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

package/src/key-bindings.ts

@@ -10,6 +10,7 @@
 
 import { Keymap, type KeymapEvent, type KeymapHost } from "@opentui/keymap";
 import { registerDefaultKeys } from "@opentui/keymap/addons";
+import * as v from "valibot";
 import type { KeyState } from "./keymap";
 
 export interface ResolvableKey {
@@ -111,7 +112,11 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
 };
 
 /** Status-line glyphs for named keys. */
-const KEY_GLYPHS: Record<string, string> = {
+interface KeyGlyphs {
+  [key: string]: string;
+}
+
+const KEY_GLYPHS: KeyGlyphs = {
   return: "enter",
   enter: "enter",
   escape: "esc",
@@ -186,7 +191,7 @@ class HeadlessKeymapHost implements KeymapHost<object, KeymapEvent> {
  * keymap's canonical form is lowercase + the shift modifier. Non-letter
  * single characters ("$", "0") already encode their shift in the character.
  */
-function normalizedEvent(key: ResolvableKey): { name: string; shift: boolean } {
+function normalizedEvent(key: ResolvableKey) {
   if (key.name.length === 1) {
     if (/[a-zA-Z]/.test(key.name)) {
       return {
@@ -220,6 +225,10 @@ const SPAN_COMMANDS: [key: string, command: string][] = [
   ["escape", "span_cancel"],
 ];
 
+function isConditionMatcher(value: unknown): value is () => boolean {
+  return typeof value === "function";
+}
+
 export class KeyBindings {
   private readonly host = new HeadlessKeymapHost();
   private readonly keymap = new Keymap<object, KeymapEvent>(this.host);
@@ -234,7 +243,7 @@ export class KeyBindings {
     // and dispatch only see the layer that owns the current mode
     this.keymap.registerLayerFields({
       when: (value, fieldContext) => {
-        if (typeof value === "function") fieldContext.activeWhen(value as () => boolean);
+        if (isConditionMatcher(value)) fieldContext.activeWhen(value);
       },
     });
     this.registerModeLayers();
@@ -373,10 +382,10 @@ export class KeyBindings {
   /** First active key display for a command, mapped through the glyph table. */
   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;
+      const parsedCommand = v.safeParse(v.string(), activeKey.command);
+      const bindingCommand = parsedCommand.success
+        ? parsedCommand.output
+        : activeKey.bindings?.[0]?.command;
 
       if (bindingCommand !== command) continue;
 

package/src/keymap.test.ts

@@ -21,11 +21,7 @@ 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) {
   return { name, shift, meta };
 }
 
@@ -537,11 +533,13 @@ describe("review panel controls", () => {
 
 describe("duplicated-branch collapse", () => {
   test("plan and diff produce the same intents for annotation nav, delete, and submit", () => {
-    for (const patch of [
+    const patches: Partial<KeyState>[] = [
       {},
       { annotationCount: 0, hasFocusedAnnotation: false },
       { resolved: true },
-    ] as Partial<KeyState>[]) {
+    ];
+
+    for (const patch of patches) {
       for (const name of ["n", "p", "backspace", "return"]) {
         const plan = reduceKey(state(patch), key(name));
         const diff = reduceKey(state({ ...patch, view: "diff" }), key(name));

package/src/kitty-image.test.ts

@@ -54,13 +54,13 @@ describe("kitty image placement", () => {
 describe("resolveTransmitMedium", () => {
   test("defaults to base64; file transfer is opt-in and never over ssh", () => {
     // Assert
-    expect(resolveTransmitMedium({} as NodeJS.ProcessEnv)).toBe("base64");
-    expect(resolveTransmitMedium({ CUELOOP_KITTY_FILE: "1" } as NodeJS.ProcessEnv)).toBe("file");
+    expect(resolveTransmitMedium({})).toBe("base64");
+    expect(resolveTransmitMedium({ CUELOOP_KITTY_FILE: "1" })).toBe("file");
     expect(
       resolveTransmitMedium({
         CUELOOP_KITTY_FILE: "1",
         SSH_CONNECTION: "1.2.3.4 5 6 7",
-      } as NodeJS.ProcessEnv),
+      }),
     ).toBe("base64");
   });
 });

package/src/prototype-browser.ts

@@ -73,7 +73,7 @@ export function cssBoxToCell(
   box: ElementBox,
   image: { x: number; y: number; width: number; height: number },
   viewport: PrototypeViewport,
-): { column: number; row: number; columns: number; rows: number } {
+) {
   const scaleColumn = image.width / viewport.width;
   const scaleRow = image.height / viewport.height;
 
@@ -174,13 +174,13 @@ export async function launchPrototypeRenderer(options: LaunchOptions): Promise<P
         omitBackground: true,
       });
 
-      return new Uint8Array(buffer as Buffer);
+      return new Uint8Array(buffer);
     },
     async elementAt(cssX, cssY) {
-      return (await page.evaluate(elementAtScript, cssX, cssY)) as PrototypeElement | null;
+      return page.evaluate(elementAtScript, cssX, cssY);
     },
     async scrollBy(deltaY) {
-      return (await page.evaluate(scrollByScript, deltaY)) as boolean;
+      return page.evaluate(scrollByScript, deltaY);
     },
     async close() {
       await page.close().catch(() => undefined);
@@ -189,7 +189,7 @@ export async function launchPrototypeRenderer(options: LaunchOptions): Promise<P
 }
 
 /** Serialized into the page (self-contained for puppeteer): resolve the click to a component element. */
-function elementAtScript(x: number, y: number): unknown {
+function elementAtScript(x: number, y: number) {
   const SEMANTIC = new Set([
     "SECTION",
     "ARTICLE",
@@ -232,7 +232,8 @@ function elementAtScript(x: number, y: number): unknown {
       const parent: Element | null = current.parentElement;
 
       if (parent) {
-        const twins = [...parent.children].filter((child) => child.tagName === current!.tagName);
+        const currentTagName = current.tagName;
+        const twins = [...parent.children].filter((child) => child.tagName === currentTagName);
 
         if (twins.length > 1) part += ":nth-of-type(" + (twins.indexOf(current) + 1) + ")";
       }
@@ -242,15 +243,24 @@ function elementAtScript(x: number, y: number): unknown {
 
     return parts.join(" > ");
   };
+  // Prefer the nearest focusable target before falling back to its component container.
+  const focusableTarget = (start: Element | null): Element | null => {
+    for (
+      let element: Element | null = start;
+      element && element !== document.body;
+      element = element.parentElement
+    ) {
+      if (element instanceof HTMLElement && element.tabIndex >= 0) {
+        return element;
+      }
+    }
+
+    return null;
+  };
   const hit = document.elementFromPoint(x, y);
 
   if (!(hit instanceof Element)) return null;
-  // A click on an interactive control anchors to that control - a button in a
-  // grid is the target, not the grid. Everything else climbs to its component.
-  const control = hit.closest(
-    "button, a, [role='button'], input, select, textarea, label, summary",
-  );
-  const node = control ?? componentRoot(hit);
+  const node = focusableTarget(hit) ?? componentRoot(hit);
   const selector = selectorFor(node);
 
   if (!selector) return null;

package/src/serve.ts

@@ -36,7 +36,7 @@ export interface ServeOptions {
   home?: string;
   /** Silence the @opentui/ssh startup banner (tests). Default true. */
   banner?: boolean;
-  onError?: (err: unknown) => void;
+  onError?: (cause: unknown) => void;
 }
 
 export interface ServeHandle {

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

@@ -37,26 +37,41 @@ function diffSession(files?: DiffFileContents[]): ReviewSession {
   };
 }
 
+interface WorkingCopySink {
+  workingCopy?: string;
+}
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
 /** A fake client that records the working copy the controller writes. */
-function fakeClient(session: ReviewSession, sink: { workingCopy?: string }): SessionClient {
+function fakeClient(session: ReviewSession, sink: WorkingCopySink): SessionClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
     sessionSetWorkingCopy: mock(async (_id: string, content: string | undefined) => {
       sink.workingCopy = content;
 
       return { ...session, workingCopy: content };
     }),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
     close: () => {},
-  } as unknown as SessionClient;
+  };
 }
 
 const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
 
 async function connected(session: ReviewSession) {
-  const sink: { workingCopy?: string } = {};
+  const sink: WorkingCopySink = {};
   const client = fakeClient(session, sink);
   const controller = createReviewController({
     sessionId: session.id,

package/src/session-controller.share.test.ts

@@ -1,10 +1,9 @@
-import { describe, expect, mock, test } from "bun:test";
+import { describe, expect, mock, test, type Mock } from "bun:test";
 import { ManualClock } from "@opentui/core/testing";
 import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/schema";
 import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController, SHARE_POLL_MS, type ShareTransport } from "./session-controller";
 
-// Stub the ssh transport so no subprocess spawns; the controller under test
-// imports these from "./share".
 const publishShare = mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: true }));
 let remote: ReviewSession;
 const pullShare = mock(async () => remote);
@@ -12,16 +11,13 @@ const pushShare = mock(
   async (_shareId: string, _annotations: Array<Omit<Annotation, "createdAt">>) => {},
 );
 
-mock.module("./share", () => ({
-  publishShare,
-  pullShare,
-  pushShare,
-  shareIdFromLine: (line: string) => line.match(/^ssh (\S+)@/)?.[1],
-  collaboratorAnnotations: (session: ReviewSession) =>
-    session.annotations.filter((annotation) => annotation.author),
-}));
-
-const { createReviewController, SHARE_POLL_MS } = await import("./session-controller");
+const shareTransport: ShareTransport = {
+  publish: publishShare,
+  pull: pullShare,
+  push: pushShare,
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
+};
 
 function sessionFixture(overrides: Partial<ReviewSession> = {}): ReviewSession {
   return {
@@ -49,13 +45,23 @@ function annotation(id: string, author: string): Annotation {
   };
 }
 
-function fakeClient(session: ReviewSession): SessionClient {
+interface FakeSessionClient extends SessionClient {
+  sessionAnnotate: Mock<SessionClient["sessionAnnotate"]>;
+}
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+function fakeClient(session: ReviewSession): FakeSessionClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
-    sessionAnnotate: mock(async () => session),
+    sessionAnnotate: mock<SessionClient["sessionAnnotate"]>(async () => session),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetShareId: mock(
       async (_id: string, shareId: string) => ((session.shareId = shareId), session),
     ),
@@ -67,8 +73,11 @@ function fakeClient(session: ReviewSession): SessionClient {
 
       return session;
     }),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
     close: () => {},
-  } as unknown as SessionClient;
+  };
 }
 
 const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
@@ -76,12 +85,13 @@ const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
 async function connectedController(
   session: ReviewSession,
   clock?: ManualClock,
-): Promise<{ controller: ReturnType<typeof createReviewController>; client: SessionClient }> {
+): Promise<{ controller: ReturnType<typeof createReviewController>; client: FakeSessionClient }> {
   const client = fakeClient(session);
   const controller = createReviewController({
     sessionId: session.id,
     openClient: async () => client,
     clock,
+    shareTransport,
   });
 
   controller.connect();
@@ -205,7 +215,7 @@ describe("mirror on annotate", () => {
       sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:me")] }),
     );
 
-    (client.sessionAnnotate as ReturnType<typeof mock>).mockImplementationOnce(async () => {
+    client.sessionAnnotate.mockImplementationOnce(async () => {
       throw new Error("session is resolved");
     });
 

package/src/session-controller.ts

@@ -131,6 +131,22 @@ export interface ControllerSnapshot {
   walk: { index: number } | null;
 }
 
+export interface ShareTransport {
+  publish: typeof publishShare;
+  pull: typeof pullShare;
+  push: typeof pushShare;
+  parseShareId: typeof shareIdFromLine;
+  collaboratorAnnotations: typeof collaboratorAnnotations;
+}
+
+const DEFAULT_SHARE_TRANSPORT: ShareTransport = {
+  publish: publishShare,
+  pull: pullShare,
+  push: pushShare,
+  parseShareId: shareIdFromLine,
+  collaboratorAnnotations,
+};
+
 export interface ReviewControllerOptions {
   home?: string;
   sessionId?: string;
@@ -145,6 +161,7 @@ export interface ReviewControllerOptions {
    * renders a decrypted share instead.
    */
   openClient?: () => Promise<SessionClient>;
+  shareTransport?: ShareTransport;
 }
 
 export interface ReviewController {
@@ -235,6 +252,13 @@ export function createReviewController(options: ReviewControllerOptions): Review
   return new Controller(options);
 }
 
+interface DerivedSessionProjection {
+  display: DisplayBlock[];
+  rows: DiffRow[];
+  files: WalkFile[];
+  models: Map<string, FileDiffMetadata>;
+}
+
 class Controller implements ReviewController {
   readonly readOnly: boolean;
   private client: SessionClient | null = null;
@@ -254,18 +278,13 @@ class Controller implements ReviewController {
   private editor: string | undefined;
   private exporters: BundledExporter[] = [];
   private readonly clock: Clock;
+  private readonly shareTransport: ShareTransport;
   private countdown: TimerHandle | undefined;
   private sharePoll: TimerHandle | undefined;
   private shareRun: object | null = null;
   /** Projections keyed by session identity so renders reuse one computation. */
   private derivedFor: ReviewSession | null = null;
-  private derived: {
-    display: DisplayBlock[];
-    rows: DiffRow[];
-    files: WalkFile[];
-    /** Per-path parsed diff models, for hunk curation; empty when files absent. */
-    models: Map<string, FileDiffMetadata>;
-  } = {
+  private derived: DerivedSessionProjection = {
     display: [],
     rows: [],
     files: [],
@@ -277,6 +296,7 @@ class Controller implements ReviewController {
   constructor(private readonly options: ReviewControllerOptions) {
     this.readOnly = options.readOnly ?? false;
     this.clock = options.clock ?? new SystemClock();
+    this.shareTransport = options.shareTransport ?? DEFAULT_SHARE_TRANSPORT;
   }
 
   subscribe = (listener: () => void): (() => void) => {
@@ -402,16 +422,16 @@ class Controller implements ReviewController {
   private async refreshSession(id: string): Promise<void> {
     try {
       if (this.client) this.update({ session: await this.client.sessionGet(id) });
-    } catch (error) {
-      if (!this.closed) this.setStatus(error instanceof Error ? error.message : String(error));
+    } catch (cause) {
+      if (!this.closed) this.setStatus(cause instanceof Error ? cause.message : String(cause));
     }
   }
 
   private async refreshInbox(): Promise<void> {
     try {
       if (this.client) this.update({ inbox: await this.client.sessionList({ status: "pending" }) });
-    } catch (error) {
-      if (!this.closed) this.setStatus(error instanceof Error ? error.message : String(error));
+    } catch (cause) {
+      if (!this.closed) this.setStatus(cause instanceof Error ? cause.message : String(cause));
     }
   }
 
@@ -419,8 +439,8 @@ class Controller implements ReviewController {
   private apply(mutation: Promise<ReviewSession>): void {
     mutation
       .then((session) => this.update({ session }))
-      .catch((error: unknown) =>
-        this.setStatus(String(error instanceof Error ? error.message : error)),
+      .catch((cause: unknown) =>
+        this.setStatus(String(cause instanceof Error ? cause.message : cause)),
       );
   }
 
@@ -438,8 +458,8 @@ class Controller implements ReviewController {
     this.client
       ?.sessionDelete(id)
       .then(() => this.setStatus("plan deleted"))
-      .catch((error: unknown) =>
-        this.setStatus(`delete failed: ${error instanceof Error ? error.message : String(error)}`),
+      .catch((cause: unknown) =>
+        this.setStatus(`delete failed: ${cause instanceof Error ? cause.message : String(cause)}`),
       );
   }
 
@@ -775,7 +795,7 @@ class Controller implements ReviewController {
     const shareId = this.snapshot.session?.shareId;
 
     if (!shareId) return;
-    void persisted.then(() => pushShare(shareId, [annotation])).catch(() => {});
+    void persisted.then(() => this.shareTransport.push(shareId, [annotation])).catch(() => {});
   }
 
   removeAnnotation(id: string): void {
@@ -868,12 +888,12 @@ class Controller implements ReviewController {
         // a remembers the choice. A configured delay overrides; 0 closes now.
         const delay = this.autoClose;
 
-        if (delay === 0) this.finishReview();
-        else if (typeof delay === "number") this.startCounting(delay);
-        else this.startCounting(DEFAULT_AUTO_CLOSE);
+        if (delay === "off") this.startCounting(DEFAULT_AUTO_CLOSE);
+        else if (delay === 0) this.finishReview();
+        else this.startCounting(delay);
       })
-      .catch((error: unknown) =>
-        this.setStatus(String(error instanceof Error ? error.message : error)),
+      .catch((cause: unknown) =>
+        this.setStatus(String(cause instanceof Error ? cause.message : cause)),
       );
   }
 
@@ -882,17 +902,18 @@ class Controller implements ReviewController {
 
     if (!session) return;
     this.setStatus("sharing…");
-    publishShare(session)
+    this.shareTransport
+      .publish(session)
       .then(async ({ line, copied }) => {
         // Stamp the id back so a later pull knows which share to collect from.
-        const shareId = shareIdFromLine(line);
+        const shareId = this.shareTransport.parseShareId(line);
 
         if (shareId && this.client) await this.client.sessionSetShareId(session.id, shareId);
         this.setStatus("");
         this.showToast(line, copied ? "share link copied" : "share link");
       })
-      .catch((error: unknown) =>
-        this.setStatus(`share failed: ${error instanceof Error ? error.message : String(error)}`),
+      .catch((cause: unknown) =>
+        this.setStatus(`share failed: ${cause instanceof Error ? cause.message : String(cause)}`),
       );
   }
 
@@ -908,10 +929,11 @@ class Controller implements ReviewController {
     if (!session?.shareId || !this.client) return Promise.resolve();
     const client = this.client;
 
-    return pullShare(session.shareId)
+    return this.shareTransport
+      .pull(session.shareId)
       .then((remote) =>
         client.sessionMergeShared(session.id, {
-          annotations: collaboratorAnnotations(remote),
+          annotations: this.shareTransport.collaboratorAnnotations(remote),
           participants: remote.participants,
         }),
       )

package/src/share.ts

@@ -13,6 +13,8 @@ import {
   packSessionBlob,
 } from "@cueloop/daemon/share-blob";
 import type { Annotation, ReviewSession } from "@cueloop/schema";
+import { SessionRecordSchema } from "@cueloop/daemon/validate";
+import * as v from "valibot";
 import { copyToClipboard } from "./clipboard";
 
 export interface ShareTarget {
@@ -63,7 +65,7 @@ export async function pullShare(shareId: string, target: ShareTarget = {}): Prom
 
   if (code !== 0) throw new Error(`gateway pull failed: ${stderr.trim() || `ssh exited ${code}`}`);
 
-  return JSON.parse(stdout) as ReviewSession;
+  return v.parse(SessionRecordSchema, JSON.parse(stdout));
 }
 
 /** A share's collaborator notes: the ones a viewer authored (author stamped). */

package/src/test-support.ts

@@ -31,9 +31,13 @@ export function isolateUserConfig(home: string, fileName = "no-config.toml"): ()
   };
 }
 
+declare global {
+  var IS_REACT_ACT_ENVIRONMENT: boolean | undefined;
+}
+
 /** The harness drives the real event loop by design; keep React's act warning off. */
 export function allowEventLoopUpdates(): void {
-  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = false;
+  globalThis.IS_REACT_ACT_ENVIRONMENT = false;
 }
 
 /**

package/src/theme-presets.ts

@@ -148,7 +148,14 @@ export const THEME_PRESETS: Record<ThemeName, Theme> = {
 };
 
 /** Cycle order for the Settings theme row; the registry's insertion order, branded default first. */
-export const THEME_NAMES: ThemeName[] = Object.keys(THEME_PRESETS) as ThemeName[];
+export const THEME_NAMES: ThemeName[] = [
+  "cueloop",
+  "rose-pine-moon",
+  "catppuccin-mocha",
+  "tokyo-night",
+  "gruvbox-dark",
+  "nord",
+];
 
 /** Human labels for the Settings cycle row, keyed by the persisted name. */
 export const THEME_LABELS: Record<ThemeName, string> = {
@@ -169,7 +176,7 @@ export const THEME_LABELS: Record<ThemeName, string> = {
 export function themeForName(name: string, appearance: Appearance = "dark"): Theme {
   if (name === "cueloop") return brandedTheme(appearance);
 
-  return THEME_PRESETS[name as ThemeName] ?? brandedTheme(appearance);
+  return isThemeName(name) ? THEME_PRESETS[name] : brandedTheme(appearance);
 }
 
 /** A preset with the user's `[theme]` per-token overrides layered on top - the live-switch equivalent of config load. */

package/src/view-diff.ts

@@ -73,10 +73,7 @@ function fileLabel(file: FileDiffMetadata): string {
 }
 
 /** Quote-primary anchor for a diff row: neighbors as context selectors. */
-export function diffRowAnchor(
-  rows: DiffRow[],
-  rowIndex: number,
-): { quote: string; prefix: string; suffix: string } {
+export function diffRowAnchor(rows: DiffRow[], rowIndex: number) {
   const row = rows[rowIndex]!;
   const prev = rows[rowIndex - 1];
   const next = rows[rowIndex + 1];

package/src/view-plan.ts

@@ -285,12 +285,14 @@ export function inlineStyleRuns(text: string, base: number): StyleRun[] {
 
   for (const run of inlineRuns(text)) {
     if (run.role === "marker" || run.start === null) continue;
-    runs.push({
+    const styleRun: StyleRun = {
       text: run.text,
       role: run.role === "text" ? "plain" : run.role,
       start: base + run.start,
-      ...(run.href !== undefined ? { href: run.href } : {}),
-    });
+    };
+
+    if (run.href !== undefined) styleRun.href = run.href;
+    runs.push(styleRun);
   }
 
   return runs;
@@ -437,10 +439,7 @@ export function workRangeForRendered(
 }
 
 /** Line delta between two revision contents, for the sheet-header summary. */
-export function revisionDelta(
-  previousContent: string,
-  nextContent: string,
-): { added: number; removed: number } {
+export function revisionDelta(previousContent: string, nextContent: string) {
   const ops = lcsDiff(previousContent.split("\n"), nextContent.split("\n"));
   let added = 0;
   let removed = 0;