@cueloop/client 0.1.0-alpha.78 → 0.1.0-alpha.79

package/src/thread-chords.test.ts

@@ -1,202 +1,79 @@
 import { describe, expect, test } from "bun:test";
-import {
-  DEFAULT_LEADER,
-  leaderHint,
-  matchesLeader,
-  resolveLeaderCommand,
-  resolveThreadChord,
-} from "./thread-chords";
-
-const owner = { composing: false, isOwner: true, resolved: false, treeActive: false };
-
-describe("the command leader", () => {
-  test("matchesLeader recognizes the configured chord and nothing else", () => {
-    expect(matchesLeader({ ctrl: true, name: "g" }, [DEFAULT_LEADER])).toBe(true);
-    expect(matchesLeader({ ctrl: true, name: "G" }, [DEFAULT_LEADER])).toBe(true);
-    expect(matchesLeader({ name: "g" }, [DEFAULT_LEADER])).toBe(false);
-    expect(matchesLeader({ ctrl: true, name: "x" }, [DEFAULT_LEADER])).toBe(false);
-    expect(matchesLeader({ ctrl: true, meta: true, name: "g" }, [DEFAULT_LEADER])).toBe(false);
-    expect(matchesLeader({ name: "," }, [","])).toBe(true);
+import { resolveNavKey } from "./thread-chords";
+
+const owner = { isOwner: true, resolved: false, treeActive: false };
+const readOnly = { type: "status" as const, message: "observer - read-only" };
+const submitted = { type: "status" as const, message: "review submitted - read-only" };
+
+describe("resolveNavKey", () => {
+  test("the session commands: submit, edit, share", () => {
+    expect(resolveNavKey({ name: "return" }, owner)).toEqual({ type: "openSubmit" });
+    expect(resolveNavKey({ name: "enter" }, owner)).toEqual({ type: "openSubmit" });
+    expect(resolveNavKey({ name: "e" }, owner)).toEqual({ type: "edit" });
+    expect(resolveNavKey({ name: "s" }, owner)).toEqual({ type: "share" });
   });
 
-  test("leaderHint renders the glyph plus a trailing space", () => {
-    expect(leaderHint(["ctrl+g"])).toBe("⌃g ");
-    expect(leaderHint([","])).toBe(", ");
-  });
-
-  test("a key after the leader runs the same intent as its Option chord", () => {
+  test("a diff row's keys win over the shared letters, then fall through to curation", () => {
     const diff = { ...owner, isDiff: true };
 
-    expect(resolveLeaderCommand({ name: "x" }, diff)).toEqual({ type: "rejectChange" });
-    expect(resolveLeaderCommand({ name: "X" }, diff)).toEqual({ type: "rejectHunk" });
-    expect(resolveLeaderCommand({ name: "x" }, owner)).toEqual({ type: "cut" });
-    expect(resolveLeaderCommand({ name: "return" }, owner)).toEqual({ type: "openSubmit" });
-    expect(resolveLeaderCommand({ name: "x" }, { ...owner, composing: true })).toBeNull();
-  });
-});
-
-describe("resolveThreadChord", () => {
-  test("ctrl+enter opens the submit overlay for an owner with an open review", () => {
-    // Assert: the terminal-safe chord and the cmd forms all submit
-    expect(resolveThreadChord({ name: "return", ctrl: true }, owner)).toEqual({
-      type: "openSubmit",
-    });
-    expect(resolveThreadChord({ name: "return", super: true }, owner)).toEqual({
-      type: "openSubmit",
-    });
-    expect(resolveThreadChord({ name: "enter", meta: true }, owner)).toEqual({
-      type: "openSubmit",
-    });
-  });
-
-  test("session chords map to their intents", () => {
-    // Assert
-    expect(resolveThreadChord({ name: "e", ctrl: true }, owner)).toEqual({ type: "edit" });
-    expect(resolveThreadChord({ name: "s", ctrl: true }, owner)).toEqual({ type: "share" });
+    expect(resolveNavKey({ name: "x" }, diff)).toEqual({ type: "rejectChange" });
+    expect(resolveNavKey({ name: "c" }, diff)).toEqual({ type: "foldFile" });
+    expect(resolveNavKey({ name: "d" }, diff)).toEqual({ type: "toggleDiffView" });
+    expect(resolveNavKey({ name: "k" }, diff)).toEqual({ type: "walkStart" });
+    // a letter with no diff meaning still reaches the curation commands
+    expect(resolveNavKey({ name: "n" }, diff)).toEqual({ type: "nextAnnotation" });
   });
 
-  test("in a diff, option chords act on the caret's row and file; the rest still reach the rail", () => {
-    // Arrange
-    const diff = { ...owner, isDiff: true };
-
-    // Assert - the code-row primitives
-    expect(resolveThreadChord({ name: "x", meta: true }, diff)).toEqual({ type: "rejectChange" });
-    expect(resolveThreadChord({ name: "X", meta: true }, diff)).toEqual({ type: "rejectHunk" });
-    expect(resolveThreadChord({ name: "u", meta: true }, diff)).toEqual({
-      type: "restoreCuration",
-    });
-    expect(resolveThreadChord({ name: "c", meta: true }, diff)).toEqual({ type: "foldFile" });
-    expect(resolveThreadChord({ name: "d", meta: true }, diff)).toEqual({ type: "toggleDiffView" });
-    expect(resolveThreadChord({ name: "k", meta: true }, diff)).toEqual({ type: "walkStart" });
-    // the rail letters are untouched
-    expect(resolveThreadChord({ name: "n", meta: true }, diff)).toEqual({ type: "nextAnnotation" });
-    // rejecting is the owner's, and closed once resolved
-    expect(resolveThreadChord({ name: "x", meta: true }, { ...diff, isOwner: false })).toEqual({
-      type: "status",
-      message: "observer - read-only",
-    });
-    expect(resolveThreadChord({ name: "k", meta: true }, { ...diff, resolved: true })).toEqual({
-      type: "status",
-      message: "review submitted - read-only",
-    });
+  test("the discussion and curation commands", () => {
+    expect(resolveNavKey({ name: "n" }, owner)).toEqual({ type: "nextAnnotation" });
+    expect(resolveNavKey({ name: "p" }, owner)).toEqual({ type: "prevAnnotation" });
+    expect(resolveNavKey({ name: "backspace" }, owner)).toEqual({ type: "removeAnnotation" });
+    expect(resolveNavKey({ name: "r" }, owner)).toEqual({ type: "openRename" });
+    expect(resolveNavKey({ name: "x" }, owner)).toEqual({ type: "cut" });
+    expect(resolveNavKey({ name: "u" }, owner)).toEqual({ type: "restoreCuration" });
   });
 
-  test("option chords drive the rail and curation with the plan sheet's letters", () => {
-    // Assert
-    expect(resolveThreadChord({ name: "n", meta: true }, owner)).toEqual({
-      type: "nextAnnotation",
-    });
-    expect(resolveThreadChord({ name: "p", meta: true }, owner)).toEqual({
-      type: "prevAnnotation",
-    });
-    expect(resolveThreadChord({ name: "e", meta: true }, owner)).toEqual({ type: "editCard" });
-    expect(resolveThreadChord({ name: "backspace", meta: true }, owner)).toEqual({
-      type: "removeAnnotation",
-    });
-    expect(resolveThreadChord({ name: "r", meta: true }, owner)).toEqual({ type: "openRename" });
-    expect(resolveThreadChord({ name: "x", meta: true }, owner)).toEqual({ type: "cut" });
-    expect(resolveThreadChord({ name: "u", meta: true }, owner)).toEqual({
-      type: "restoreCuration",
-    });
-    expect(resolveThreadChord({ name: "x", meta: true }, { ...owner, isOwner: false })).toEqual({
-      type: "status",
-      message: "observer - read-only",
-    });
-  });
+  test("the tree commands: move on the Tree tab, go, branch, label, fork, hand off", () => {
+    const onTree = { ...owner, treeActive: true };
 
-  test("an open composer swallows every chord, so typing is never hijacked", () => {
-    // Assert
-    expect(
-      resolveThreadChord({ name: "return", ctrl: true }, { ...owner, composing: true }),
-    ).toBeNull();
-    expect(resolveThreadChord({ name: "s", ctrl: true }, { ...owner, composing: true })).toBeNull();
+    expect(resolveNavKey({ name: "n" }, onTree)).toEqual({ type: "treeMove", direction: 1 });
+    expect(resolveNavKey({ name: "p" }, onTree)).toEqual({ type: "treeMove", direction: -1 });
+    expect(resolveNavKey({ name: "g" }, owner)).toEqual({ type: "treeGo" });
+    expect(resolveNavKey({ name: "b" }, owner)).toEqual({ type: "treeBranch" });
+    expect(resolveNavKey({ name: "l" }, owner)).toEqual({ type: "treeLabel" });
+    expect(resolveNavKey({ name: "f" }, owner)).toEqual({ type: "treeFork" });
+    expect(resolveNavKey({ name: "h" }, owner)).toEqual({ type: "treeForkShare" });
   });
 
-  test("plain keys and unbound chords belong to the document grammar", () => {
-    // Assert
-    expect(resolveThreadChord({ name: "return" }, owner)).toBeNull();
-    expect(resolveThreadChord({ name: "s" }, owner)).toBeNull();
-    expect(resolveThreadChord({ name: "x", ctrl: true }, owner)).toBeNull();
+  test("a shift letter resolves as its uppercase, which no command claims, so it returns to typing", () => {
+    expect(resolveNavKey({ name: "x", shift: true }, { ...owner, isDiff: true })).toBeNull();
   });
 
-  test("a collaborator is told a primitive is read-only, and a resolved review cannot be resubmitted", () => {
-    // Assert
+  test("a collaborator is refused the owner's commands; renaming stays open", () => {
     const collaborator = { ...owner, isOwner: false };
-    const readOnly = { type: "status" as const, message: "observer - read-only" };
 
-    expect(resolveThreadChord({ name: "return", ctrl: true }, collaborator)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "e", ctrl: true }, collaborator)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "s", ctrl: true }, collaborator)).toEqual(readOnly);
-    expect(
-      resolveThreadChord({ name: "return", ctrl: true }, { ...owner, resolved: true }),
-    ).toBeNull();
+    expect(resolveNavKey({ name: "return" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "e" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "s" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "x" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "g" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "f" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "r" }, collaborator)).toEqual({ type: "openRename" });
   });
 
-  test("a resolved review refuses every change and says so; renaming an author stays open", () => {
-    // Arrange
+  test("a resolved review refuses every change and says so; a fork stays open", () => {
     const resolved = { ...owner, resolved: true };
-    const submitted = { type: "status" as const, message: "review submitted - read-only" };
 
-    // Assert
-    expect(resolveThreadChord({ name: "e", ctrl: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "e", meta: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "backspace", meta: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "x", meta: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "u", meta: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "r", meta: true }, resolved)).toEqual({ type: "openRename" });
-    expect(resolveThreadChord({ name: "s", ctrl: true }, resolved)).toEqual({ type: "share" });
+    expect(resolveNavKey({ name: "return" }, resolved)).toBeNull();
+    expect(resolveNavKey({ name: "e" }, resolved)).toEqual(submitted);
+    expect(resolveNavKey({ name: "x" }, resolved)).toEqual(submitted);
+    expect(resolveNavKey({ name: "b" }, resolved)).toEqual(submitted);
+    expect(resolveNavKey({ name: "f" }, resolved)).toEqual({ type: "treeFork" });
+    expect(resolveNavKey({ name: "s" }, resolved)).toEqual({ type: "share" });
   });
 
-  test("the tree chords: toggle, move on the Tree tab, go, branch, label, fork, hand off", () => {
-    // Arrange
-    const onTree = { ...owner, treeActive: true };
-    const readOnly = { type: "status" as const, message: "observer - read-only" };
-    const submitted = { type: "status" as const, message: "review submitted - read-only" };
-
-    // Assert: next / previous follow the tab that shows
-    expect(resolveThreadChord({ name: "t", meta: true }, owner)).toEqual({ type: "toggleTree" });
-    expect(resolveThreadChord({ name: "n", meta: true }, onTree)).toEqual({
-      type: "treeMove",
-      direction: 1,
-    });
-    expect(resolveThreadChord({ name: "p", meta: true }, onTree)).toEqual({
-      type: "treeMove",
-      direction: -1,
-    });
-    expect(resolveThreadChord({ name: "n", meta: true }, owner)).toEqual({
-      type: "nextAnnotation",
-    });
-    expect(resolveThreadChord({ name: "g", meta: true }, owner)).toEqual({ type: "treeGo" });
-    expect(resolveThreadChord({ name: "b", meta: true }, owner)).toEqual({ type: "treeBranch" });
-    expect(resolveThreadChord({ name: "l", meta: true }, owner)).toEqual({ type: "treeLabel" });
-    expect(resolveThreadChord({ name: "f", meta: true }, owner)).toEqual({ type: "treeFork" });
-    expect(resolveThreadChord({ name: "h", meta: true }, owner)).toEqual({ type: "treeForkShare" });
-    // moving the tree is the owner's; a fork is open after a verdict, a move is not
-    expect(resolveThreadChord({ name: "g", meta: true }, { ...owner, isOwner: false })).toEqual(
-      readOnly,
-    );
-    expect(resolveThreadChord({ name: "f", meta: true }, { ...owner, isOwner: false })).toEqual(
-      readOnly,
-    );
-    expect(resolveThreadChord({ name: "b", meta: true }, { ...owner, resolved: true })).toEqual(
-      submitted,
-    );
-    expect(resolveThreadChord({ name: "f", meta: true }, { ...owner, resolved: true })).toEqual({
-      type: "treeFork",
-    });
-    expect(resolveThreadChord({ name: "t", meta: true }, { ...owner, isOwner: false })).toEqual({
-      type: "toggleTree",
-    });
-  });
-
-  test("an observer cannot edit or delete cards either", () => {
-    // Arrange
-    const observer = { ...owner, isOwner: false };
-    const readOnly = { type: "status" as const, message: "observer - read-only" };
-
-    // Assert
-    expect(resolveThreadChord({ name: "e", meta: true }, observer)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "backspace", meta: true }, observer)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "r", meta: true }, observer)).toEqual({ type: "openRename" });
+  test("an unmapped key returns null, so the surface returns to typing", () => {
+    expect(resolveNavKey({ name: "z" }, owner)).toBeNull();
+    expect(resolveNavKey({ name: "j" }, owner)).toBeNull();
   });
 });

package/src/thread-chords.ts

@@ -1,186 +1,75 @@
-/**
- * The session-level chords of the thread view. Letters in the thread view
- * type a comment, so everything that acts on the session as a whole - submit,
- * share, edit, the rail - lives on ctrl chords (cmd where the terminal
- * delivers it). The guided walk is a diff-review mode and has no chord here. Pure: the view reports whether a composer is open, this maps
- * a key to an intent or to nothing.
- */
-
 import type { Intent } from "./keymap";
 
-export interface ThreadChordKey {
+export interface NavKey {
   name: string;
-  ctrl?: boolean;
-  meta?: boolean;
-  super?: boolean;
+  shift?: boolean;
 }
 
-export interface ThreadChordContext {
-  /** A composer owns the keyboard: chords never fire while one is open. */
-  composing: boolean;
-  /** Collaborators annotate only; submit, edit, and share are the owner's. */
+export interface ThreadNavContext {
   isOwner: boolean;
-  /** A resolved session has nothing left to submit. */
   resolved: boolean;
-  /** The rail shows the tree: next / previous move its selection instead of the cards. */
   treeActive: boolean;
-  /** A diff review: the block chords act on the code row under the caret (reject, fold, walk). */
   isDiff?: boolean;
 }
 
-export const DEFAULT_LEADER = "ctrl+g";
-
-export function leaderCombosFor(configured: readonly string[] | undefined): readonly string[] {
-  return configured ?? [DEFAULT_LEADER];
-}
-
-const MOD_GLYPHS = new Map<string, string>([
-  ["ctrl", "⌃"],
-  ["control", "⌃"],
-  ["meta", "⌥"],
-  ["alt", "⌥"],
-  ["option", "⌥"],
-  ["shift", "⇧"],
-  ["cmd", "⌘"],
-  ["super", "⌘"],
-]);
-
-function comboParts(combo: string) {
-  const parts = combo.split("+");
-
-  return { mods: parts.slice(0, -1).map((part) => part.toLowerCase()), name: parts.at(-1) ?? "" };
-}
-
-export function leaderHint(combos: readonly string[]): string {
-  const { mods, name } = comboParts(combos[0] ?? DEFAULT_LEADER);
-
-  return `${mods.map((mod) => MOD_GLYPHS.get(mod) ?? mod).join("")}${name} `;
-}
-
-export function matchesLeader(
-  key: { ctrl?: boolean; meta?: boolean; shift?: boolean; super?: boolean; name: string },
-  combos: readonly string[],
-): boolean {
-  return combos.some((combo) => {
-    const { mods, name } = comboParts(combo);
-
-    return (
-      key.name.toLowerCase() === name.toLowerCase() &&
-      Boolean(key.ctrl) === (mods.includes("ctrl") || mods.includes("control")) &&
-      Boolean(key.shift) === mods.includes("shift") &&
-      Boolean(key.super) === (mods.includes("cmd") || mods.includes("super")) &&
-      Boolean(key.meta) ===
-        (mods.includes("meta") || mods.includes("alt") || mods.includes("option"))
-    );
-  });
-}
-
 export interface ChordEntry {
   keys: string;
   label: string;
 }
 
-/** The diff-review chords: the leader (or Option) plus a letter, on the caret's row or file. */
-export function diffChordEntries(hint: string): ChordEntry[] {
+export function sessionCommandEntries(): ChordEntry[] {
   return [
-    { keys: `${hint}x / ${hint}X`, label: "reject the change / the hunk" },
-    { keys: `${hint}u`, label: "restore the last rejection" },
-    { keys: `${hint}c`, label: "collapse the file to its band" },
-    { keys: `${hint}d`, label: "split / stacked (when wide)" },
-    { keys: `${hint}k`, label: "start the guided walk" },
+    { keys: "⏎", label: "submit the review" },
+    { keys: "e", label: "edit in $EDITOR" },
+    { keys: "s", label: "share" },
   ];
 }
 
-/** The session chords stay on Ctrl, which terminals deliver reliably. */
-export const THREAD_CHORD_ENTRIES = [
-  { keys: "⌃enter", label: "submit the review" },
-  { keys: "⌃e", label: "edit in $EDITOR" },
-  { keys: "⌃s", label: "share" },
-  { keys: "⌃r", label: "cycle the rail" },
-] as const;
-
-/** The rail and curation chords: the leader plus the plan sheet's old letter. */
-export function railChordEntries(hint: string): ChordEntry[] {
+export function diffCommandEntries(): ChordEntry[] {
   return [
-    { keys: `${hint}n / ${hint}p`, label: "next / previous card" },
-    { keys: `${hint}e`, label: "edit the card" },
-    { keys: `${hint}⌫`, label: "delete the card" },
-    { keys: `${hint}r`, label: "rename the author" },
-    { keys: `${hint}x`, label: "cut the block" },
-    { keys: `${hint}u`, label: "restore the last cut" },
-    { keys: "⌥w / ⌥s", label: "widen / narrow the rail" },
+    { keys: "x", label: "reject the change under the caret" },
+    { keys: "u", label: "restore the last rejection" },
+    { keys: "c", label: "collapse the file to its band" },
+    { keys: "d", label: "split / stacked (when wide)" },
+    { keys: "k", label: "start the guided walk" },
   ];
 }
 
-/** The tree chords: the leader plus a letter, all on the rail's Tree tab. */
-export function treeChordEntries(hint: string): ChordEntry[] {
+export function curationCommandEntries(): ChordEntry[] {
   return [
-    { keys: `${hint}t`, label: "show / hide the tree" },
-    { keys: `${hint}n / ${hint}p`, label: "next / previous entry" },
-    { keys: `${hint}g`, label: "go to the entry" },
-    { keys: `${hint}b`, label: "branch off the tip" },
-    { keys: `${hint}l`, label: "label a checkpoint" },
-    { keys: `${hint}f`, label: "fork the path" },
-    { keys: `${hint}h`, label: "fork and hand off" },
+    { keys: "n / p", label: "next / previous card" },
+    { keys: "z", label: "fold / unfold the card" },
+    { keys: "⌫", label: "delete the card" },
+    { keys: "r", label: "rename the author" },
+    { keys: "x", label: "cut the block" },
+    { keys: "u", label: "restore the last cut" },
   ];
 }
 
-export function resolveThreadChord(
-  key: ThreadChordKey,
-  context: ThreadChordContext,
-): Intent | null {
-  if (context.composing) return null;
-  const modified = Boolean(key.ctrl || key.meta || key.super);
-
-  if (!modified) return null;
-  if (key.name === "return" || key.name === "enter") {
-    if (!context.isOwner) return READ_ONLY;
-
-    return context.resolved ? null : { type: "openSubmit" };
-  }
-  if (key.ctrl) return resolveSessionChord(key.name, context);
-  if (key.meta)
-    return (
-      (context.isDiff && resolveDiffChord(key.name, context)) || resolveRailChord(key.name, context)
-    );
-
-  return null;
+export function treeCommandEntries(): ChordEntry[] {
+  return [
+    { keys: "g", label: "go to the entry" },
+    { keys: "b", label: "branch off the tip" },
+    { keys: "l", label: "label a checkpoint" },
+    { keys: "f", label: "fork the path" },
+    { keys: "h", label: "fork and hand off" },
+  ];
 }
 
-export function resolveLeaderCommand(
-  key: ThreadChordKey,
-  context: ThreadChordContext,
-): Intent | null {
-  if (context.composing) return null;
-  if (key.name === "return" || key.name === "enter") {
-    if (!context.isOwner) return READ_ONLY;
-
-    return context.resolved ? null : { type: "openSubmit" };
-  }
-
-  return (
-    (context.isDiff && resolveDiffChord(key.name, context)) || resolveRailChord(key.name, context)
-  );
-}
+const READ_ONLY: Intent = { type: "status", message: "observer - read-only" };
+const RESOLVED: Intent = { type: "status", message: "review submitted - read-only" };
 
-export function dispatchLeaderCommand(
-  key: { name: string; shift?: boolean },
-  context: ThreadChordContext,
-  dispatch: (intent: Intent) => void,
-): void {
-  const name = key.shift ? key.name.toUpperCase() : key.name;
-  const chord = resolveLeaderCommand({ name }, context);
+function mutating(intent: Intent, context: ThreadNavContext): Intent {
+  if (!context.isOwner) return READ_ONLY;
+  if (context.resolved) return RESOLVED;
 
-  if (chord) dispatch(chord);
+  return intent;
 }
 
-/** The diff's row and file chords; null lets the rail chords answer the letter. */
-function resolveDiffChord(name: string, context: ThreadChordContext): Intent | null {
+function resolveDiffKey(name: string, context: ThreadNavContext): Intent | null {
   switch (name) {
     case "x":
       return mutating({ type: "rejectChange" }, context);
-    case "X":
-      return mutating({ type: "rejectHunk" }, context);
     case "c":
       return { type: "foldFile" };
     case "d":
@@ -192,19 +81,7 @@ function resolveDiffChord(name: string, context: ThreadChordContext): Intent | n
   }
 }
 
-/** The answers a blocked primitive gets - the same words the keymap uses. */
-const READ_ONLY: Intent = { type: "status", message: "observer - read-only" };
-const RESOLVED: Intent = { type: "status", message: "review submitted - read-only" };
-
-/** Editing, deleting, cutting, and restoring change the review: gated by role and by a verdict. */
-function mutating(intent: Intent, context: ThreadChordContext): Intent {
-  if (!context.isOwner) return READ_ONLY;
-  if (context.resolved) return RESOLVED;
-
-  return intent;
-}
-
-function resolveSessionChord(name: string, context: ThreadChordContext): Intent | null {
+function resolveSessionKey(name: string, context: ThreadNavContext): Intent | null {
   switch (name) {
     case "e":
       return mutating({ type: "edit" }, context);
@@ -215,33 +92,24 @@ function resolveSessionChord(name: string, context: ThreadChordContext): Intent
   }
 }
 
-// option arrives as meta in this terminal stack; the letters mirror the
-// plan sheet's keymap so the rail keeps its muscle memory
-function resolveRailChord(name: string, context: ThreadChordContext): Intent | null {
+function resolveCurationKey(name: string, context: ThreadNavContext): Intent | null {
   switch (name) {
     case "n":
       return context.treeActive ? { type: "treeMove", direction: 1 } : { type: "nextAnnotation" };
     case "p":
       return context.treeActive ? { type: "treeMove", direction: -1 } : { type: "prevAnnotation" };
-    case "t":
-      return { type: "toggleTree" };
-    // the tree is the owner's: a move, a branch, or a label changes what everyone sees
     case "g":
       return mutating({ type: "treeGo" }, context);
     case "b":
       return mutating({ type: "treeBranch" }, context);
     case "l":
       return mutating({ type: "treeLabel" }, context);
-    // a fork can be taken from a resolved review: only the role gates it
     case "f":
       return context.isOwner ? { type: "treeFork" } : READ_ONLY;
     case "h":
       return context.isOwner ? { type: "treeForkShare" } : READ_ONLY;
-    case "e":
-      return mutating({ type: "editCard" }, context);
     case "backspace":
       return mutating({ type: "removeAnnotation" }, context);
-    // renaming an author is a local display choice, open to every role
     case "r":
       return { type: "openRename" };
     case "x":
@@ -252,3 +120,44 @@ function resolveRailChord(name: string, context: ThreadChordContext): Intent | n
       return null;
   }
 }
+
+export interface SessionChordKey {
+  name: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+}
+
+export function resolveSessionChord(
+  key: SessionChordKey,
+  context: Pick<ThreadNavContext, "isOwner" | "resolved">,
+): Intent | null {
+  if (key.name === "return" || key.name === "enter") {
+    if (!(key.ctrl || key.meta || key.super)) return null;
+    if (!context.isOwner) return READ_ONLY;
+
+    return context.resolved ? null : { type: "openSubmit" };
+  }
+  if (!key.ctrl) return null;
+  if (key.name === "e")
+    return context.resolved ? RESOLVED : context.isOwner ? { type: "edit" } : READ_ONLY;
+  if (key.name === "s") return context.isOwner ? { type: "share" } : READ_ONLY;
+
+  return null;
+}
+
+export function resolveNavKey(key: NavKey, context: ThreadNavContext): Intent | null {
+  const name = key.shift ? key.name.toUpperCase() : key.name;
+
+  if (name === "return" || name === "enter") {
+    if (!context.isOwner) return READ_ONLY;
+
+    return context.resolved ? null : { type: "openSubmit" };
+  }
+
+  return (
+    (context.isDiff ? resolveDiffKey(name, context) : null) ??
+    resolveSessionKey(name, context) ??
+    resolveCurationKey(name, context)
+  );
+}

package/src/thread-controller.curate.test.ts

@@ -118,6 +118,7 @@ function fakeClient(initial: Thread, sink: WorkingCopySink): SessionClient {
     sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionSetShares: unimplemented("sessionSetShares"),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),

package/src/thread-controller.live-diff.test.ts

@@ -38,7 +38,9 @@ const shareTransport: ShareTransport = {
   pull: mock(async () => planSession()),
   push: mock(async () => {}),
   watch: () => () => {},
+  revoke: async () => {},
   parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  formatShareLine: (id: string) => "ssh " + id + "@cueloop.dev",
   collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
   mergeFromShare,
 };
@@ -82,6 +84,7 @@ function fakeClient(session: Thread): SessionClient {
     sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionSetShares: unimplemented("sessionSetShares"),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),