@cueloop/client 0.1.0-alpha.32 → 0.1.0-alpha.34

package/src/key-bindings.test.ts

@@ -4,7 +4,9 @@ import { describe, expect, test } from "bun:test";
 import { DEFAULT_KEYS } from "./config";
 import { KeyBindings } from "./key-bindings";
 
-function bindings(context: { overlay?: "none" | "walk" | "compose" | "submit"; spanMode?: boolean } = {}): KeyBindings {
+function bindings(
+  context: { overlay?: "none" | "walk" | "compose" | "submit"; spanMode?: boolean } = {},
+): KeyBindings {
   const resolver = new KeyBindings(DEFAULT_KEYS);
   resolver.setContext({ overlay: context.overlay ?? "none", spanMode: context.spanMode ?? false });
   return resolver;
@@ -19,7 +21,7 @@ describe("grammar-layer resolution", () => {
     ["g", true, "bottom"],
     ["v", false, "span"],
     ["c", false, "comment"],
-    ["s", false, "suggest"],
+    ["s", false, undefined],
     ["x", false, "cut"],
     ["e", false, "edit"],
     ["n", false, "next_annotation"],
@@ -86,26 +88,32 @@ describe("mode layers own their keys", () => {
 describe("getActiveKeys-generated status hints", () => {
   test("normal mode hint matches the locked string", () => {
     expect(bindings().statusHint("normal")).toBe(
-      "j/k move · v span · drag selects · c comment · s suggest · x cut · e edit · n/p annotations · ⏎ submit · q quit",
+      "j/k move · v span · drag selects · c comment · x cut · e edit · n/p annotations · enter submit · q quit",
     );
   });
 
   test("card-selected hint keeps the locked Cut label", () => {
-    expect(bindings().statusHint("card")).toBe("card · e edit · x Cut · n/p cards · esc deselect · ⏎ submit");
+    expect(bindings().statusHint("card")).toBe(
+      "card · e edit · x Cut · n/p cards · esc deselect · enter submit",
+    );
   });
 
   test("span hint", () => {
     expect(bindings({ spanMode: true }).statusHint("span")).toBe(
-      "span · l/h grow/shrink · w/b slide · $ end · c comment · s suggest · esc",
+      "span · l/h grow/shrink · w/b slide · $ end · c comment · esc",
     );
   });
 
   test("compose hint", () => {
-    expect(bindings({ overlay: "compose" }).statusHint("compose")).toBe("typing · ⏎ save · esc cancel");
+    expect(bindings({ overlay: "compose" }).statusHint("compose")).toBe(
+      "typing · enter save · esc cancel",
+    );
   });
 
   test("submit hint", () => {
-    expect(bindings({ overlay: "submit" }).statusHint("submit")).toBe("verdict ←/→ · ⏎ submit · esc cancel");
+    expect(bindings({ overlay: "submit" }).statusHint("submit")).toBe(
+      "verdict ←/→ · enter submit · esc cancel",
+    );
   });
 
   test("walk hint", () => {
@@ -115,7 +123,9 @@ describe("getActiveKeys-generated status hints", () => {
   });
 
   test("read-only hint", () => {
-    expect(bindings().statusHint("read-only")).toBe("observer - read-only · j/k move · n/p annotations · q quit");
+    expect(bindings().statusHint("read-only")).toBe(
+      "observer - read-only · j/k move · n/p annotations · q quit",
+    );
   });
 
   test("collaborator hint annotates but shows no plan edit or submit", () => {
@@ -123,7 +133,7 @@ describe("getActiveKeys-generated status hints", () => {
     const hint = bindings().statusHint("collaborator");
 
     // Assert
-    expect(hint).toBe("j/k move · v span · drag selects · c comment · s suggest · n/p annotations · q quit");
+    expect(hint).toBe("j/k move · v span · drag selects · c comment · n/p annotations · q quit");
     expect(hint).not.toContain("cut");
     expect(hint).not.toContain("edit");
     expect(hint).not.toContain("submit");

package/src/key-bindings.ts

@@ -24,11 +24,26 @@ export interface KeyLayerContext {
 }
 
 /** Hint templates keyed by the same view states the status line shows. */
-export type HintMode = "normal" | "collaborator" | "card" | "span" | "compose" | "submit" | "walk" | "read-only";
+export type HintMode =
+  | "normal"
+  | "collaborator"
+  | "card"
+  | "span"
+  | "compose"
+  | "submit"
+  | "walk"
+  | "read-only";
 
-type HintEntry =
-  | { text: string }
-  | { commands: string[]; label: string; labelFirst?: boolean };
+export interface CheatsheetEntry {
+  keys: string;
+  label: string;
+}
+export interface CheatsheetSection {
+  title: string;
+  entries: CheatsheetEntry[];
+}
+
+type HintEntry = { text: string } | { commands: string[]; label: string; labelFirst?: boolean };
 
 const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
   normal: [
@@ -36,7 +51,6 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
     { commands: ["span"], label: "span" },
     { text: "drag selects" },
     { commands: ["comment"], label: "comment" },
-    { commands: ["suggest"], label: "suggest" },
     { commands: ["cut"], label: "cut" },
     { commands: ["edit"], label: "edit" },
     { commands: ["next_annotation", "prev_annotation"], label: "annotations" },
@@ -49,7 +63,6 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
     { commands: ["span"], label: "span" },
     { text: "drag selects" },
     { commands: ["comment"], label: "comment" },
-    { commands: ["suggest"], label: "suggest" },
     { commands: ["next_annotation", "prev_annotation"], label: "annotations" },
     { commands: ["quit"], label: "quit" },
   ],
@@ -67,7 +80,6 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
     { commands: ["span_slide_forward", "span_slide_back"], label: "slide" },
     { commands: ["span_to_end"], label: "end" },
     { commands: ["span_comment"], label: "comment" },
-    { commands: ["span_suggest"], label: "suggest" },
     { commands: ["span_cancel"], label: "" },
   ],
   compose: [
@@ -97,8 +109,8 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
 
 /** Status-line glyphs for named keys. */
 const KEY_GLYPHS: Record<string, string> = {
-  return: "⏎",
-  enter: "⏎",
+  return: "enter",
+  enter: "enter",
   escape: "esc",
   left: "←",
   right: "→",
@@ -173,7 +185,10 @@ class HeadlessKeymapHost implements KeymapHost<object, KeymapEvent> {
 function normalizedEvent(key: ResolvableKey): { name: string; shift: boolean } {
   if (key.name.length === 1) {
     if (/[a-zA-Z]/.test(key.name)) {
-      return { name: key.name.toLowerCase(), shift: key.shift || key.name !== key.name.toLowerCase() };
+      return {
+        name: key.name.toLowerCase(),
+        shift: key.shift || key.name !== key.name.toLowerCase(),
+      };
     }
     return { name: key.name, shift: false };
   }
@@ -195,7 +210,6 @@ const SPAN_COMMANDS: [key: string, command: string][] = [
   ["$", "span_to_end"],
   ["0", "span_to_start"],
   ["c", "span_comment"],
-  ["s", "span_suggest"],
   ["escape", "span_cancel"],
 ];
 
@@ -272,7 +286,13 @@ export class KeyBindings {
         { key: "enter", cmd: "walk_submit" },
         { key: "q", cmd: "quit" },
       ],
-      commands: [record("walk_next"), record("walk_prev"), record("walk_leave"), record("walk_submit"), record("quit")],
+      commands: [
+        record("walk_next"),
+        record("walk_prev"),
+        record("walk_leave"),
+        record("walk_submit"),
+        record("quit"),
+      ],
     });
     this.keymap.registerLayer({
       priority: 20,
@@ -303,7 +323,9 @@ export class KeyBindings {
     });
     this.keymap.registerLayer({
       priority: 20,
-      when: () => this.context.overlay === "completion-prompt" || this.context.overlay === "completion-counting",
+      when: () =>
+        this.context.overlay === "completion-prompt" ||
+        this.context.overlay === "completion-counting",
       bindings: [
         { key: "return", cmd: "finish_review" },
         { key: "enter", cmd: "finish_review" },
@@ -311,7 +333,11 @@ export class KeyBindings {
         { key: "a", cmd: "opt_in_auto_close" },
         { key: "escape", cmd: "dismiss_completion" },
       ],
-      commands: [record("finish_review"), record("opt_in_auto_close"), record("dismiss_completion")],
+      commands: [
+        record("finish_review"),
+        record("opt_in_auto_close"),
+        record("dismiss_completion"),
+      ],
     });
   }
 
@@ -335,7 +361,9 @@ export class KeyBindings {
   private keyDisplayFor(command: string): string | null {
     for (const activeKey of this.keymap.getActiveKeys({ includeBindings: true })) {
       const bindingCommand =
-        typeof activeKey.command === "string" ? activeKey.command : activeKey.bindings?.[0]?.command;
+        typeof activeKey.command === "string"
+          ? activeKey.command
+          : activeKey.bindings?.[0]?.command;
       if (bindingCommand !== command) continue;
       return KEY_GLYPHS[activeKey.stroke.name] ?? activeKey.display;
     }
@@ -356,8 +384,41 @@ export class KeyBindings {
       if (!displays.length) continue;
       const keyPart = displays.join("/");
       if (!entry.label) fragments.push(keyPart);
-      else fragments.push(entry.labelFirst ? `${entry.label} ${keyPart}` : `${keyPart} ${entry.label}`);
+      else
+        fragments.push(
+          entry.labelFirst ? `${entry.label} ${keyPart}` : `${keyPart} ${entry.label}`,
+        );
     }
     return fragments.join(" · ");
   }
+
+  /**
+   * The full keybinding cheatsheet, grouped by mode. Each section sets the
+   * layer context so getActiveKeys resolves that mode's real bindings, then
+   * restores it - a rebound key shows its live binding here too.
+   */
+  cheatsheet(): CheatsheetSection[] {
+    const saved = this.context;
+    const build = (context: KeyLayerContext, mode: HintMode, title: string): CheatsheetSection => {
+      this.context = context;
+      const entries: CheatsheetEntry[] = [];
+      for (const entry of HINT_TEMPLATES[mode]) {
+        if ("text" in entry || !entry.label) continue;
+        const keys = entry.commands
+          .map((command) => this.keyDisplayFor(command))
+          .filter((display): display is string => display !== null)
+          .join(" / ");
+        if (keys) entries.push({ keys, label: entry.label });
+      }
+      return { title, entries };
+    };
+    const sections = [
+      build({ overlay: "none", spanMode: false }, "normal", "Review"),
+      build({ overlay: "none", spanMode: true }, "span", "Selection"),
+      build({ overlay: "submit", spanMode: false }, "submit", "Submit"),
+      build({ overlay: "walk", spanMode: false }, "walk", "Walk"),
+    ];
+    this.context = saved;
+    return sections.filter((section) => section.entries.length > 0);
+  }
 }

package/src/keymap.test.ts

@@ -21,7 +21,11 @@ function state(patch: Partial<KeyState> = {}): KeyState {
   };
 }
 
-function key(name: string, shift = false, meta = false): { name: string; shift: boolean; meta: boolean } {
+function key(
+  name: string,
+  shift = false,
+  meta = false,
+): { name: string; shift: boolean; meta: boolean } {
   return { name, shift, meta };
 }
 
@@ -133,7 +137,9 @@ describe("collaborator (share) capabilities", () => {
     const collab = state({ canEditPlan: false, canSubmitVerdict: false });
 
     // Act / Assert
-    expect(reduceKey(collab, key("c"), "comment")).toEqual([{ type: "openCompose", kind: "comment", from: "cursor" }]);
+    expect(reduceKey(collab, key("c"), "comment")).toEqual([
+      { type: "openCompose", kind: "comment", from: "cursor" },
+    ]);
   });
 
   test("can edit their own card: edit with a focused annotation rewrites it", () => {
@@ -158,7 +164,9 @@ describe("collaborator (share) capabilities", () => {
     const collab = state({ canSubmitVerdict: false });
 
     // Act / Assert
-    expect(reduceKey(collab, key("x"), "submit")).toEqual([{ type: "status", message: "shared view - your notes save as you go; q to leave" }]);
+    expect(reduceKey(collab, key("x"), "submit")).toEqual([
+      { type: "status", message: "shared view - your notes save as you go; q to leave" },
+    ]);
   });
 
   test("cannot re-share: only the owner shares", () => {
@@ -166,7 +174,9 @@ describe("collaborator (share) capabilities", () => {
     const collab = state({ canShare: false });
 
     // Act / Assert
-    expect(reduceKey(collab, key("S", true), "share")).toEqual([{ type: "status", message: "only the plan owner can share" }]);
+    expect(reduceKey(collab, key("S", true), "share")).toEqual([
+      { type: "status", message: "only the plan owner can share" },
+    ]);
   });
 });
 
@@ -178,7 +188,9 @@ describe("share", () => {
 
   test("an observer cannot share", () => {
     // Act / Assert
-    expect(reduceKey(state({ readOnly: true }), key("S", true), "share")).toEqual([{ type: "status", message: "observer - read-only" }]);
+    expect(reduceKey(state({ readOnly: true }), key("S", true), "share")).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
   });
 });
 
@@ -194,7 +206,6 @@ describe("plan normal mode", () => {
     ["g", true, [{ type: "move", to: "bottom" }]],
     ["v", false, [{ type: "startSpan" }]],
     ["c", false, [{ type: "openCompose", kind: "comment", from: "cursor" }]],
-    ["s", false, [{ type: "openCompose", kind: "suggestion", from: "cursor" }]],
     // the default state has a selected card, so Cut and edit act on the card
     ["x", false, [{ type: "removeAnnotation" }]],
     ["e", false, [{ type: "editCard" }]],
@@ -217,20 +228,35 @@ describe("plan normal mode", () => {
     const resolvedState = state({ resolved: true });
 
     // Assert
-    for (const name of ["c", "s", "x", "e"]) {
-      expect(reduceKey(resolvedState, key(name))).toEqual([{ type: "status", message: "review submitted - read-only" }]);
+    for (const name of ["c", "x", "e"]) {
+      expect(reduceKey(resolvedState, key(name))).toEqual([
+        { type: "status", message: "review submitted - read-only" },
+      ]);
     }
     expect(reduceKey(resolvedState, key("return"))).toEqual([]);
     expect(reduceKey(resolvedState, key("backspace"))).toEqual([]);
   });
 
+  test("u restores a rail removal (a cut block); a share viewer's is silent", () => {
+    // Assert - the undo intent leaves the target to the dispatcher
+    expect(reduceKey(state(), key("u"))).toEqual([{ type: "restoreCuration" }]);
+    expect(reduceKey(state({ resolved: true }), key("u"))).toEqual([
+      { type: "status", message: "review submitted - read-only" },
+    ]);
+    expect(reduceKey(state({ canEditPlan: false }), key("u"))).toEqual([]);
+    expect(reduceKey(state({ readOnly: true }), key("u"))).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
+  });
+
   test("cut text cannot host a comment or a span", () => {
     // Arrange
     const cut = state({ cursorAnnotatable: false });
 
     // Assert
-    expect(reduceKey(cut, key("c"))).toEqual([{ type: "status", message: "text is cut - restore it first" }]);
-    expect(reduceKey(cut, key("s"))).toEqual([{ type: "status", message: "text is cut - restore it first" }]);
+    expect(reduceKey(cut, key("c"))).toEqual([
+      { type: "status", message: "text is cut - restore it first" },
+    ]);
     expect(reduceKey(cut, key("v"))).toEqual([]);
   });
 
@@ -265,7 +291,8 @@ describe("span mode", () => {
     ["$", [{ type: "spanKey", name: "$" }]],
     ["0", [{ type: "spanKey", name: "0" }]],
     ["c", [{ type: "openCompose", kind: "comment", from: "span" }]],
-    ["s", [{ type: "openCompose", kind: "suggestion", from: "span" }]],
+    ["x", [{ type: "spanCut" }]],
+    ["a", [{ type: "openSpanActions" }]],
     ["escape", [{ type: "closeOverlay" }]],
     ["q", [{ type: "exit" }]],
     ["j", []],
@@ -275,6 +302,73 @@ describe("span mode", () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);
     });
   }
+
+  test("an observer's span-mode mutations answer read-only", () => {
+    // Arrange
+    const observer = state({ spanMode: true, readOnly: true });
+
+    // Assert
+    expect(reduceKey(observer, key("x"))).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
+    expect(reduceKey(observer, key("a"))).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
+    expect(reduceKey(observer, key("c"))).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
+  });
+
+  test("span-mode cut is owner-only, like the normal plan cut", () => {
+    // Arrange
+    const collaborator = state({ spanMode: true, canEditPlan: false });
+
+    // Assert
+    expect(reduceKey(collaborator, key("x"))).toEqual([]);
+  });
+
+  test("all span-mode mutations are blocked once the review is resolved", () => {
+    // Arrange
+    const resolved = state({ spanMode: true, resolved: true });
+    const readOnlyStatus: Intent[] = [{ type: "status", message: "review submitted - read-only" }];
+
+    // Assert - comment, cut, and quick-actions all answer read-only
+    expect(reduceKey(resolved, key("x"))).toEqual(readOnlyStatus);
+    expect(reduceKey(resolved, key("c"))).toEqual(readOnlyStatus);
+    expect(reduceKey(resolved, key("a"))).toEqual(readOnlyStatus);
+  });
+
+  test("span-mode cut gates for an observer even when cut is rebound off x", () => {
+    // Arrange - the span sub-grammar hardwires x, so the read-only gate must catch it by name
+    const rebound = { ...DEFAULT_KEYS, cut: ["d"] };
+    const observer = state({ spanMode: true, readOnly: true, keys: rebound });
+
+    // Assert
+    expect(reduceKey(observer, key("x"))).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
+  });
+});
+
+describe("span actions overlay", () => {
+  // Arrange
+  const keyState = state({ overlay: "spanActions" });
+  const table: [string, Intent[]][] = [
+    ["j", [{ type: "moveSpanAction", direction: 1 }]],
+    ["down", [{ type: "moveSpanAction", direction: 1 }]],
+    ["k", [{ type: "moveSpanAction", direction: -1 }]],
+    ["up", [{ type: "moveSpanAction", direction: -1 }]],
+    ["return", [{ type: "pickSpanAction" }]],
+    ["enter", [{ type: "pickSpanAction" }]],
+    ["escape", [{ type: "closeSpanActions" }]],
+    ["c", []],
+    ["q", []],
+  ];
+  for (const [name, expected] of table) {
+    test(`${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(keyState, key(name))).toEqual(expected);
+    });
+  }
 });
 
 describe("diff mode", () => {
@@ -290,9 +384,8 @@ describe("diff mode", () => {
     ["backspace", [{ type: "removeAnnotation" }]],
     ["return", [{ type: "openSubmit" }]],
     ["v", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
-    ["x", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
+    ["x", [{ type: "rejectChange" }]],
     ["e", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
-    ["s", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
     ["q", [{ type: "exit" }]],
   ];
   for (const [name, expected] of table) {
@@ -301,6 +394,40 @@ describe("diff mode", () => {
     });
   }
 
+  test("shift+x rejects the whole hunk under the cursor", () => {
+    // Assert
+    expect(reduceKey(keyState, key("x", true))).toEqual([{ type: "rejectHunk" }]);
+  });
+
+  test("curation is owner-only and locked once resolved", () => {
+    // Assert - a resolved diff answers before curating
+    expect(reduceKey(state({ view: "diff", resolved: true }), key("x"))).toEqual([
+      { type: "status", message: "review submitted - read-only" },
+    ]);
+    // a collaborator (canEditPlan false) cannot curate hunks
+    expect(reduceKey(state({ view: "diff", canEditPlan: false }), key("x"))).toEqual([
+      { type: "status", message: "only the diff owner can curate hunks" },
+    ]);
+    // an observer's mutating attempt is stopped by the read-only gate
+    expect(reduceKey(state({ view: "diff", readOnly: true }), key("x"))).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
+  });
+
+  test("u restores a curated-out item, owner-only and locked once resolved", () => {
+    // Assert - the undo intent leaves the target to the dispatcher
+    expect(reduceKey(keyState, key("u"))).toEqual([{ type: "restoreCuration" }]);
+    expect(reduceKey(state({ view: "diff", resolved: true }), key("u"))).toEqual([
+      { type: "status", message: "review submitted - read-only" },
+    ]);
+    expect(reduceKey(state({ view: "diff", canEditPlan: false }), key("u"))).toEqual([
+      { type: "status", message: "only the diff owner can curate hunks" },
+    ]);
+    expect(reduceKey(state({ view: "diff", readOnly: true }), key("u"))).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
+  });
+
   test("comment guards: resolved first, then non-code rows", () => {
     // Assert
     expect(reduceKey(state({ view: "diff", resolved: true }), key("c"))).toEqual([
@@ -322,7 +449,9 @@ describe("guided walk", () => {
     expect(reduceKey(state({ view: "diff", readOnly: true }), key("w"))).toEqual([
       { type: "status", message: "observer - read-only" },
     ]);
-    expect(reduceKey(state(), key("w"))).toEqual([{ type: "status", message: "the guided walk is a diff-review mode" }]);
+    expect(reduceKey(state(), key("w"))).toEqual([
+      { type: "status", message: "the guided walk is a diff-review mode" },
+    ]);
   });
 
   // Arrange
@@ -348,7 +477,10 @@ describe("guided walk", () => {
     const atEnd = state({ view: "diff", overlay: "walk", walkAtEnd: true });
 
     // Assert
-    expect(reduceKey(atEnd, key("return"))).toEqual([{ type: "walkLeave" }, { type: "openSubmit" }]);
+    expect(reduceKey(atEnd, key("return"))).toEqual([
+      { type: "walkLeave" },
+      { type: "openSubmit" },
+    ]);
     expect(reduceKey(atEnd, key("enter"))).toEqual([{ type: "walkLeave" }, { type: "openSubmit" }]);
   });
 });
@@ -378,7 +510,9 @@ describe("review panel controls", () => {
 
   test("span mode still owns b as a span verb, not a panel cycle", () => {
     // Assert
-    expect(reduceKey(state({ spanMode: true }), key("b"))).toEqual([{ type: "spanKey", name: "b" }]);
+    expect(reduceKey(state({ spanMode: true }), key("b"))).toEqual([
+      { type: "spanKey", name: "b" },
+    ]);
   });
 
   test("the walk overlay keeps the brackets for stepping", () => {
@@ -411,8 +545,10 @@ describe("read-only filter", () => {
   test("every mutating key answers observer - read-only, in plan and diff", () => {
     for (const view of ["plan", "diff"] as const) {
       const keyState = state({ view, readOnly: true });
-      for (const name of ["c", "s", "x", "e", "backspace", "return", "enter"]) {
-        expect(reduceKey(keyState, key(name))).toEqual([{ type: "status", message: "observer - read-only" }]);
+      for (const name of ["c", "x", "e", "backspace", "return", "enter"]) {
+        expect(reduceKey(keyState, key(name))).toEqual([
+          { type: "status", message: "observer - read-only" },
+        ]);
       }
     }
   });
@@ -427,21 +563,24 @@ describe("read-only filter", () => {
     expect(reduceKey(keyState, key("q"))).toEqual([{ type: "exit" }]);
   });
 
-  test("span-mode c/s are gated by key name even under a rebound keymap", () => {
+  test("span-mode c is gated by key name even under a rebound keymap", () => {
     // Arrange
-    const rebound = { ...DEFAULT_KEYS, comment: ["m"], suggest: ["t"] };
+    const rebound = { ...DEFAULT_KEYS, comment: ["m"] };
     const keyState = state({ spanMode: true, readOnly: true, keys: rebound });
 
     // Assert
-    expect(reduceKey(keyState, key("c"))).toEqual([{ type: "status", message: "observer - read-only" }]);
-    expect(reduceKey(keyState, key("s"))).toEqual([{ type: "status", message: "observer - read-only" }]);
+    expect(reduceKey(keyState, key("c"))).toEqual([
+      { type: "status", message: "observer - read-only" },
+    ]);
   });
 });
 
 describe("inbox delete", () => {
   test("d on a session requests delete", () => {
     // Arrange / Act / Assert
-    expect(reduceKey(state({ view: "inbox" }), key("d"))).toEqual([{ type: "requestDeleteSession" }]);
+    expect(reduceKey(state({ view: "inbox" }), key("d"))).toEqual([
+      { type: "requestDeleteSession" },
+    ]);
   });
 });
 
@@ -465,13 +604,19 @@ describe("confirm overlay", () => {
 describe("rename grammar", () => {
   test("r on a focused note opens rename", () => {
     // Arrange / Act / Assert
-    expect(reduceKey(state({ hasFocusedAnnotation: true }), key("r"))).toEqual([{ type: "openRename" }]);
+    expect(reduceKey(state({ hasFocusedAnnotation: true }), key("r"))).toEqual([
+      { type: "openRename" },
+    ]);
   });
 
   test("prompt overlay routes ⏎ to confirm and esc to cancel", () => {
     // Arrange / Act / Assert
-    expect(reduceKey(state({ overlay: "prompt" }), key("return"))).toEqual([{ type: "confirmDialog" }]);
-    expect(reduceKey(state({ overlay: "prompt" }), key("escape"))).toEqual([{ type: "closeOverlay" }]);
+    expect(reduceKey(state({ overlay: "prompt" }), key("return"))).toEqual([
+      { type: "confirmDialog" },
+    ]);
+    expect(reduceKey(state({ overlay: "prompt" }), key("escape"))).toEqual([
+      { type: "closeOverlay" },
+    ]);
     expect(reduceKey(state({ overlay: "prompt" }), key("a"))).toEqual([]);
   });
 });