@cueloop/client 0.1.0-alpha.59 → 0.1.0-alpha.60

package/src/key-bindings.ts

@@ -161,6 +161,7 @@ class HeadlessKeymapHost implements KeymapHost<object, KeymapEvent> {
   }
   onKeyPress(listener: (event: KeymapEvent) => void): () => void {
     this.pressListeners.add(listener);
+
     return () => this.pressListeners.delete(listener);
   }
   onKeyRelease(): () => void {
@@ -193,14 +194,17 @@ function normalizedEvent(key: ResolvableKey): { name: string; shift: boolean } {
         shift: key.shift || key.name !== key.name.toLowerCase(),
       };
     }
+
     return { name: key.name, shift: false };
   }
+
   return { name: key.name, shift: key.shift };
 }
 
 /** Config combos write shifted letters as uppercase; the parser wants shift+. */
 function bindingKeyFor(combo: string): string {
   if (combo.length === 1 && /[A-Z]/.test(combo)) return `shift+${combo.toLowerCase()}`;
+
   return combo;
 }
 
@@ -242,6 +246,7 @@ export class KeyBindings {
     this.unregisterGrammarLayer?.();
     const bindings: { key: string; cmd: string }[] = [];
     const commandNames = new Set<string>();
+
     for (const [action, combos] of Object.entries(keys)) {
       commandNames.add(action);
       for (const combo of combos) bindings.push({ key: bindingKeyFor(combo), cmd: action });
@@ -257,6 +262,7 @@ export class KeyBindings {
         name,
         run: () => {
           this.resolvedCommand = name;
+
           return true;
         },
       })),
@@ -268,9 +274,11 @@ export class KeyBindings {
       name,
       run: () => {
         this.resolvedCommand = name;
+
         return true;
       },
     });
+
     this.keymap.registerLayer({
       priority: 10,
       when: () => this.context.overlay === "none" && this.context.spanMode,
@@ -355,8 +363,10 @@ export class KeyBindings {
    */
   resolveAction(key: ResolvableKey): string | undefined {
     const normalized = normalizedEvent(key);
+
     this.resolvedCommand = undefined;
     this.host.emitKeyPress(makeKeymapEvent(normalized.name, normalized.shift));
+
     return this.resolvedCommand;
   }
 
@@ -367,15 +377,19 @@ export class KeyBindings {
         typeof activeKey.command === "string"
           ? activeKey.command
           : activeKey.bindings?.[0]?.command;
+
       if (bindingCommand !== command) continue;
+
       return KEY_GLYPHS[activeKey.stroke.name] ?? activeKey.display;
     }
+
     return null;
   }
 
   /** The status-line hint for a view state, generated from the active keys. */
   statusHint(mode: HintMode): string {
     const fragments: string[] = [];
+
     for (const entry of HINT_TEMPLATES[mode]) {
       if ("text" in entry) {
         fragments.push(entry.text);
@@ -384,14 +398,17 @@ export class KeyBindings {
       const displays = entry.commands
         .map((command) => this.keyDisplayFor(command))
         .filter((display): display is string => display !== null);
+
       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}`,
         );
     }
+
     return fragments.join(" · ");
   }
 
@@ -405,14 +422,17 @@ export class KeyBindings {
     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 = [
@@ -424,7 +444,9 @@ export class KeyBindings {
       // so it is listed statically rather than resolved from the active keys.
       { title: "Agent terminal", entries: [{ keys: AGENT_DETACH_HINT, label: "detach" }] },
     ];
+
     this.context = saved;
+
     return sections.filter((section) => section.entries.length > 0);
   }
 }

package/src/keymap.test.ts

@@ -41,6 +41,7 @@ describe("compose overlay", () => {
     ["j", []],
     ["q", []],
   ];
+
   for (const [name, expected] of table) {
     test(`${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);
@@ -69,6 +70,7 @@ describe("submit overlay", () => {
     ["j", []],
     ["q", []],
   ];
+
   for (const [name, expected] of table) {
     test(`${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);
@@ -92,6 +94,7 @@ describe("completion overlay", () => {
     [counting, "a", [{ type: "optInAutoClose" }]],
     [counting, "escape", [{ type: "dismissCompletion" }]],
   ];
+
   for (const [overlayState, name, expected] of table) {
     test(`${overlayState.overlay} ${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(overlayState, key(name))).toEqual(expected);
@@ -113,6 +116,7 @@ describe("inbox mode", () => {
     ["c", []],
     ["escape", []],
   ];
+
   for (const [name, expected] of table) {
     test(`${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);
@@ -217,6 +221,7 @@ describe("plan normal mode", () => {
     ["escape", false, [{ type: "deselect" }]],
     ["z", false, []],
   ];
+
   for (const [name, shift, expected] of table) {
     test(`${shift ? "shift+" : ""}${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(keyState, key(name, shift))).toEqual(expected);
@@ -297,6 +302,7 @@ describe("span mode", () => {
     ["q", [{ type: "exit" }]],
     ["j", []],
   ];
+
   for (const [name, expected] of table) {
     test(`${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);
@@ -364,6 +370,7 @@ describe("span actions overlay", () => {
     ["c", []],
     ["q", []],
   ];
+
   for (const [name, expected] of table) {
     test(`${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);
@@ -388,6 +395,7 @@ describe("diff mode", () => {
     ["e", [{ type: "status", message: "plan-only verb - diff review uses c on a line" }]],
     ["q", [{ type: "exit" }]],
   ];
+
   for (const [name, expected] of table) {
     test(`${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);
@@ -466,6 +474,7 @@ describe("guided walk", () => {
     ["j", []],
     ["c", []],
   ];
+
   for (const [name, expected] of table) {
     test(`walking ${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(walking, key(name))).toEqual(expected);
@@ -491,6 +500,7 @@ describe("review panel controls", () => {
     ["]", [{ type: "resizeReviewPanel", direction: 1 }]],
     ["[", [{ type: "resizeReviewPanel", direction: -1 }]],
   ];
+
   for (const view of ["plan", "diff"] as const) {
     for (const [name, expected] of table) {
       test(`${view} ${name} -> ${JSON.stringify(expected)}`, () => {
@@ -535,6 +545,7 @@ describe("duplicated-branch collapse", () => {
       for (const name of ["n", "p", "backspace", "return"]) {
         const plan = reduceKey(state(patch), key(name));
         const diff = reduceKey(state({ ...patch, view: "diff" }), key(name));
+
         expect(diff).toEqual(plan);
       }
     }
@@ -545,6 +556,7 @@ 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", "x", "e", "backspace", "return", "enter"]) {
         expect(reduceKey(keyState, key(name))).toEqual([
           { type: "status", message: "observer - read-only" },
@@ -594,6 +606,7 @@ describe("confirm overlay", () => {
     ["j", []],
     ["d", []],
   ];
+
   for (const [name, expected] of table) {
     test(`${name} -> ${JSON.stringify(expected)}`, () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);

package/src/keymap.ts

@@ -123,19 +123,23 @@ function status(message: string): Intent[] {
 export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: string): Intent[] {
   const name = key.name;
   const overlayGrammar = overlayGrammars[state.overlay];
+
   if (overlayGrammar) return overlayGrammar(state, key);
   const action = resolvedAction ?? actionFor(state.keys, name, key.shift);
+
   if (action === "quit") return [{ type: "exit" }];
   // the ONE read-only rule: any mutating attempt answers instead of acting
   // (span-mode c, x, and a are hardwired keys, so they gate by name as well)
   const mutating =
     MUTATING_ACTIONS.has(action ?? "") ||
     (state.spanMode && (name === "c" || name === "x" || name === "a"));
+
   if (state.readOnly && mutating) return status("observer - read-only");
 
   // share is a session-level verb: it works from any view, owner only
   if (action === "share") {
     if (state.canShare === false) return status("only the plan owner can share");
+
     return [{ type: "share" }];
   }
 
@@ -146,8 +150,10 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
   // the review panel rides both plan and diff reviews; collapsing and resizing
   // are view state, so the read-only gate above lets them through
   const reviewPanel = reviewPanelGrammar(action);
+
   if (reviewPanel) return reviewPanel;
   if (state.view === "diff") return diffGrammar(state, action);
+
   return planGrammar(state, action, name);
 }
 
@@ -166,60 +172,74 @@ const overlayGrammars: Partial<Record<KeyState["overlay"], OverlayGrammar>> = {
 
 function composeOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   const name = key.name;
+
   if (name === "escape") return [{ type: "closeOverlay" }];
   if (name === "return" || name === "enter") {
     // In the composer, ⌥/Alt+⏎ (meta) and shift+⏎ insert a newline - the
     // focused textarea owns that; only a bare ⏎ saves. The submit overlay
     // keeps its plain ⏎ submit.
     if (key.shift || key.meta) return [];
+
     return [{ type: "saveCompose" }];
   }
+
   return [];
 }
 
 function submitOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   const name = key.name;
+
   if (name === "escape") return [{ type: "closeOverlay" }];
   if (name === "return" || name === "enter") return [{ type: "submitVerdict" }];
   if (name === "left" || name === "right") {
     return [{ type: "cycleVerdict", direction: name === "left" ? -1 : 1 }];
   }
+
   return [];
 }
 
 function confirmOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   const name = key.name;
+
   if (name === "return" || name === "enter") return [{ type: "confirmDialog" }];
   if (name === "escape") return [{ type: "closeOverlay" }];
+
   return [];
 }
 
 function promptOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   const name = key.name;
+
   if (name === "return" || name === "enter") return [{ type: "confirmDialog" }];
   if (name === "escape") return [{ type: "closeOverlay" }];
+
   return [];
 }
 
 function spanActionsOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   const name = key.name;
+
   if (name === "j" || name === "down") return [{ type: "moveSpanAction", direction: 1 }];
   if (name === "k" || name === "up") return [{ type: "moveSpanAction", direction: -1 }];
   if (name === "return" || name === "enter") return [{ type: "pickSpanAction" }];
   if (name === "escape") return [{ type: "closeSpanActions" }];
+
   return [];
 }
 
 function completionOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   const name = key.name;
+
   if (name === "return" || name === "enter" || name === "q") return [{ type: "finishReview" }];
   if (name === "a") return [{ type: "optInAutoClose" }];
   if (name === "escape") return [{ type: "dismissCompletion" }];
+
   return [];
 }
 
 function walkOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   const name = key.name;
+
   if (name === "]") return [{ type: "walkForward" }];
   if (name === "[") return [{ type: "walkBack" }];
   if (name === "escape") return [{ type: "walkLeave" }];
@@ -227,6 +247,7 @@ function walkOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
     return [{ type: "walkLeave" }, { type: "openSubmit" }];
   }
   if (name === "q") return [{ type: "exit" }];
+
   return [];
 }
 
@@ -235,6 +256,7 @@ function reviewPanelGrammar(action: string | undefined): Intent[] | null {
   if (action === "review_cycle") return [{ type: "cycleReviewPanel" }];
   if (action === "review_wider") return [{ type: "resizeReviewPanel", direction: 1 }];
   if (action === "review_narrower") return [{ type: "resizeReviewPanel", direction: -1 }];
+
   return null;
 }
 
@@ -244,20 +266,24 @@ function inboxGrammar(state: KeyState, name: string): Intent[] {
   if (name === "k" || name === "up") return [{ type: "inboxMove", to: "up" }];
   if (name === "return" || name === "enter") return [{ type: "openSession" }];
   if (name === "d") return [{ type: "requestDeleteSession" }];
+
   return [];
 }
 
 function diffGrammar(state: KeyState, action: string | undefined): Intent[] {
   const navigation = navigationIntent(action);
+
   if (navigation) return navigation;
   if (action === "walk") {
     // marking viewed writes the session record, so a resolved review answers
     if (state.resolved) return status("review submitted - read-only");
+
     return [{ type: "walkStart" }];
   }
   if (action === "comment") {
     if (state.resolved) return status("review submitted - read-only");
     if (!state.cursorAnnotatable) return status("move to a code line to comment");
+
     return [{ type: "openCompose", kind: "comment", from: "cursor" }];
   }
   // cut rejects the change under the cursor, reject_hunk the whole hunk; both
@@ -265,19 +291,23 @@ function diffGrammar(state: KeyState, action: string | undefined): Intent[] {
   if (action === "cut" || action === "reject_hunk") {
     if (state.resolved) return status("review submitted - read-only");
     if (state.canEditPlan === false) return status("only the diff owner can curate hunks");
+
     return [{ type: action === "reject_hunk" ? "rejectHunk" : "rejectChange" }];
   }
   // restore un-does a curated-out rejection from the rail; same owner gate as reject
   if (action === "restore_curation") {
     if (state.resolved) return status("review submitted - read-only");
     if (state.canEditPlan === false) return status("only the diff owner can curate hunks");
+
     return [{ type: "restoreCuration" }];
   }
   const shared = annotationCluster(state, action);
+
   if (shared) return shared;
   if (action === "span" || action === "edit") {
     return status("plan-only verb - diff review uses c on a line");
   }
+
   return [];
 }
 
@@ -293,13 +323,16 @@ function spanGrammar(state: KeyState, name: string): Intent[] {
     // partial-span cut is not in the working-copy model, so cut removes the
     // whole block the span sits in; owner-only, like plan cut
     if (state.canEditPlan === false) return [];
+
     return [{ type: "spanCut" }];
   }
+
   return [];
 }
 
 function planGrammar(state: KeyState, action: string | undefined, name: string): Intent[] {
   const navigation = navigationIntent(action);
+
   if (navigation) return navigation;
   if (action === "walk") return status("the guided walk is a diff-review mode");
   if (name === "escape") return [{ type: "deselect" }];
@@ -307,12 +340,14 @@ function planGrammar(state: KeyState, action: string | undefined, name: string):
   if (action === "comment") {
     if (state.resolved) return status("review submitted - read-only");
     if (!state.cursorAnnotatable) return status("text is cut - restore it first");
+
     return [{ type: "openCompose", kind: "comment", from: "cursor" }];
   }
   // restore un-does a rail removal (a cut block); a plan edit, so owner-only
   if (action === "restore_curation") {
     if (state.resolved) return status("review submitted - read-only");
     if (state.canEditPlan === false) return [];
+
     return [{ type: "restoreCuration" }];
   }
   if (action === "cut" || action === "edit") {
@@ -324,8 +359,10 @@ function planGrammar(state: KeyState, action: string | undefined, name: string):
     // editing the plan itself is the owner's verb; a share viewer only annotates,
     // and has no edit affordance, so the key is silent rather than a nag
     if (state.canEditPlan === false) return [];
+
     return [{ type: action }];
   }
+
   return annotationCluster(state, action) ?? [];
 }
 
@@ -334,6 +371,7 @@ function navigationIntent(action: string | undefined): Intent[] | null {
   if (action === "down" || action === "up" || action === "top" || action === "bottom") {
     return [{ type: "move", to: action }];
   }
+
   return null;
 }
 
@@ -341,21 +379,26 @@ function navigationIntent(action: string | undefined): Intent[] | null {
 function annotationCluster(state: KeyState, action: string | undefined): Intent[] | null {
   if (action === "next_annotation" || action === "prev_annotation") {
     if (!state.annotationCount) return status("no annotations");
+
     return [{ type: action === "next_annotation" ? "nextAnnotation" : "prevAnnotation" }];
   }
   if (action === "delete_annotation") {
     if (state.resolved || !state.hasFocusedAnnotation) return [];
+
     return [{ type: "removeAnnotation" }];
   }
   if (action === "rename") {
     if (!state.hasFocusedAnnotation) return status("select a collaborator's note to rename them");
+
     return [{ type: "openRename" }];
   }
   if (action === "submit") {
     // a collaborator's notes union back as they go; there is no verdict to submit
     if (state.canSubmitVerdict === false)
       return status("shared view - your notes save as you go; q to leave");
+
     return state.resolved ? [] : [{ type: "openSubmit" }];
   }
+
   return null;
 }

package/src/kitty-image.ts

@@ -49,12 +49,14 @@ let privateTempDir: string | null = null;
  */
 export function resolveTransmitMedium(env: NodeJS.ProcessEnv = process.env): TransmitMedium {
   if (env.CUELOOP_KITTY_FILE === "1" && !env.SSH_CONNECTION && !env.SSH_TTY) return "file";
+
   return "base64";
 }
 
 /** Save the cursor, run the placement at the region's corner, restore it. */
 function atRegion(region: CellRegion, body: string): string {
   const moveToCorner = `\x1b[${region.row + 1};${region.column + 1}H`;
+
   return `\x1b7${moveToCorner}${body}\x1b8`;
 }
 
@@ -71,7 +73,9 @@ function placementKeys(imageId: number, region: CellRegion): string {
 function writeTempPng(png: Uint8Array): string {
   if (!privateTempDir) privateTempDir = mkdtempSync(join(tmpdir(), "cueloop-prototype-"));
   const path = join(privateTempDir, `${tempFileCounter++}.png`);
+
   writeFileSync(path, png, { flag: "wx" });
+
   return path;
 }
 
@@ -79,20 +83,24 @@ function base64Transmit(png: Uint8Array, region: CellRegion, imageId: number): s
   const base64 = Buffer.from(png).toString("base64");
   const controlKeys = `a=T,f=100,${placementKeys(imageId, region)}`;
   let sequence = "";
+
   for (let offset = 0; offset < base64.length; offset += CHUNK_BYTES) {
     const chunk = base64.slice(offset, offset + CHUNK_BYTES);
     const isMore = offset + CHUNK_BYTES < base64.length ? 1 : 0;
+
     sequence +=
       offset === 0
         ? graphicsCommand(`${controlKeys},m=${isMore}`, chunk)
         : graphicsCommand(`m=${isMore}`, chunk);
   }
+
   return sequence;
 }
 
 function fileTransmit(png: Uint8Array, region: CellRegion, imageId: number): string {
   const path = writeTempPng(png);
   const payload = Buffer.from(path).toString("base64");
+
   return graphicsCommand(`a=T,f=100,t=t,${placementKeys(imageId, region)}`, payload);
 }
 
@@ -114,6 +122,7 @@ export function transmitKittyImage(
   if (region.columns < 1 || region.rows < 1) return;
   const body =
     medium === "file" ? fileTransmit(png, region, imageId) : base64Transmit(png, region, imageId);
+
   write(SYNCHRONIZED_UPDATE_START + atRegion(region, body) + SYNCHRONIZED_UPDATE_END);
 }
 

package/src/prototype-browser.test.ts

@@ -49,6 +49,7 @@ describe("cssBoxToCell", () => {
   test("a zero-size rect still reserves at least one cell", () => {
     // Assert
     const cell = cssBoxToCell({ x: 0, y: 0, width: 0, height: 0 }, IMAGE, VIEWPORT);
+
     expect(cell.columns).toBe(1);
     expect(cell.rows).toBe(1);
   });

package/src/prototype-browser.ts

@@ -52,6 +52,7 @@ export function imageCellToCss(
 ): { x: number; y: number } | null {
   const columnInImage = event.x - image.x;
   const rowInImage = event.y - image.y;
+
   if (
     columnInImage < 0 ||
     rowInImage < 0 ||
@@ -60,6 +61,7 @@ export function imageCellToCss(
   ) {
     return null;
   }
+
   return {
     x: ((columnInImage + 0.5) / image.width) * viewport.width,
     y: ((rowInImage + 0.5) / image.height) * viewport.height,
@@ -74,6 +76,7 @@ export function cssBoxToCell(
 ): { column: number; row: number; columns: number; rows: number } {
   const scaleColumn = image.width / viewport.width;
   const scaleRow = image.height / viewport.height;
+
   return {
     column: image.x + Math.floor(box.x * scaleColumn),
     row: image.y + Math.floor(box.y * scaleRow),
@@ -107,6 +110,7 @@ async function warmBrowser(executablePath: string | undefined): Promise<Puppetee
   // disconnected Chromium is dropped so the next open relaunches instead of
   // calling newPage on a dead process forever
   const cached = sharedBrowser ? await sharedBrowser.catch(() => null) : null;
+
   if (cached && cached.connected) return cached;
   const puppeteer = (await import("puppeteer-core")).default;
   const launched = puppeteer.launch({
@@ -114,14 +118,17 @@ async function warmBrowser(executablePath: string | undefined): Promise<Puppetee
     headless: true,
     args: ["--no-sandbox", "--hide-scrollbars", "--force-color-profile=srgb"],
   });
+
   sharedBrowser = launched;
   const browser = await launched.catch((error) => {
     if (sharedBrowser === launched) sharedBrowser = null;
     throw error;
   });
+
   browser.once("disconnected", () => {
     if (sharedBrowser === launched) sharedBrowser = null;
   });
+
   return browser;
 }
 
@@ -131,6 +138,7 @@ export async function launchPrototypeRenderer(options: LaunchOptions): Promise<P
   // close only the page on teardown, never the shared browser, so the next open
   // reuses the warm Chromium
   const page = await browser.newPage();
+
   try {
     await page.setViewport({
       width: options.viewport.width,
@@ -165,6 +173,7 @@ export async function launchPrototypeRenderer(options: LaunchOptions): Promise<P
         encoding: "binary",
         omitBackground: true,
       });
+
       return new Uint8Array(buffer as Buffer);
     },
     async elementAt(cssX, cssY) {
@@ -198,6 +207,7 @@ function elementAtScript(x: number, y: number): unknown {
   const componentRoot = (start: Element): Element => {
     let namedFallback: Element | null = null;
     let current: Element | null = start;
+
     while (current && current !== document.body) {
       if (isNamed(current)) {
         if (current.childElementCount > 1) return current;
@@ -205,28 +215,35 @@ function elementAtScript(x: number, y: number): unknown {
       }
       current = current.parentElement;
     }
+
     return namedFallback ?? start;
   };
   const selectorFor = (start: Element): string => {
     const parts: string[] = [];
     let current: Element | null = start;
+
     while (current && current.nodeType === 1 && current !== document.documentElement) {
       let part = current.tagName.toLowerCase();
+
       if (current.id) {
         parts.unshift(part + "#" + CSS.escape(current.id));
         break;
       }
       const parent: Element | null = current.parentElement;
+
       if (parent) {
         const twins = [...parent.children].filter((child) => child.tagName === current!.tagName);
+
         if (twins.length > 1) part += ":nth-of-type(" + (twins.indexOf(current) + 1) + ")";
       }
       parts.unshift(part);
       current = current.parentElement;
     }
+
     return parts.join(" > ");
   };
   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.
@@ -235,6 +252,7 @@ function elementAtScript(x: number, y: number): unknown {
   );
   const node = control ?? componentRoot(hit);
   const selector = selectorFor(node);
+
   if (!selector) return null;
   const text = (node.textContent || "").replace(/\s+/g, " ").trim();
   const tag = node.tagName.toLowerCase();
@@ -246,12 +264,15 @@ function elementAtScript(x: number, y: number): unknown {
         ? tag + "." + node.classList[0]
         : tag;
   const rect = node.getBoundingClientRect();
+
   return { selector, quote, box: { x: rect.x, y: rect.y, width: rect.width, height: rect.height } };
 }
 
 function scrollByScript(deltaY: number): boolean {
   const before = window.scrollY;
+
   window.scrollBy(0, deltaY);
+
   return window.scrollY !== before;
 }
 
@@ -263,5 +284,6 @@ function chromeExecutable(): string {
   if (process.platform === "win32") {
     return "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe";
   }
+
   return "/usr/bin/google-chrome";
 }