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

package/src/use-settings-dialog.tsx

@@ -35,11 +35,14 @@ export interface SettingsDialogModel {
   cycleSetting: (rowKey: string) => void;
   handleSettingsKey: (name: string) => void;
   onCategorySelect: (categoryId: string) => void;
+  /** Open the settings dialog focused on the left nav, from a fresh state. */
+  openSettings: () => void;
 }
 
 const DOWN_KEYS = new Set(["j", "down"]);
 const UP_KEYS = new Set(["k", "up"]);
-const ENTER_BODY_KEYS = new Set(["l", "tab", "return"]);
+const ENTER_BODY_KEYS = new Set(["l", "right", "tab", "return"]);
+const BACK_TO_NAV_KEYS = new Set(["h", "left", "tab"]);
 const ACTIVATE_KEYS = new Set(["return", "space", "l"]);
 
 function moveNavZone(
@@ -64,7 +67,7 @@ function moveNavZone(
 function moveBodyRow(name: string, nav: SettingsNav, rowCount: number): SettingsNav | null {
   if (DOWN_KEYS.has(name)) return { ...nav, rowIndex: Math.min(rowCount - 1, nav.rowIndex + 1) };
   if (UP_KEYS.has(name)) return { ...nav, rowIndex: Math.max(0, nav.rowIndex - 1) };
-  if (name === "h" || name === "tab") return { ...nav, zone: "nav" };
+  if (BACK_TO_NAV_KEYS.has(name)) return { ...nav, zone: "nav" };
 
   return null;
 }
@@ -108,10 +111,11 @@ export function useSettingsDialog(params: {
     onRenameDisplayName,
   } = params;
 
+  // open focused on the left nav, so up/down browses categories until l/tab/enter enters the body
   const [settingsNav, setSettingsNav] = useState<SettingsNav>({
     categoryId: "general",
     rowIndex: 0,
-    zone: "body",
+    zone: "nav",
   });
   const [actionsExpandedIndex, setActionsExpandedIndex] = useState<number | null>(null);
   const [actionsExpandedField, setActionsExpandedField] = useState<"prompt" | "metadata">("prompt");
@@ -247,6 +251,12 @@ export function useSettingsDialog(params: {
     }
   };
 
+  const openSettings = (): void => {
+    setSettingsNav({ categoryId: "general", rowIndex: 0, zone: "nav" });
+    setActionsExpandedIndex(null);
+    setMenuDialog("settings");
+  };
+
   const onCategorySelect = (categoryId: string): void => {
     // ignore a select that names no real category, so the key handler never dereferences nothing
     if (!settingsCategories.some((category) => category.id === categoryId)) return;
@@ -305,5 +315,6 @@ export function useSettingsDialog(params: {
     cycleSetting,
     handleSettingsKey,
     onCategorySelect,
+    openSettings,
   };
 }

package/src/use-thread-body-editing.tsx

@@ -0,0 +1,58 @@
+/**
+ * The thread pane's inline edit mode: owns whether the native markdown editor is
+ * open over the body, the editor element itself, and the open and exit handles.
+ * Opening is gated to an editable thread (the caller passes canEdit - owner,
+ * unresolved, not a diff); exiting saves the edited body as the working copy
+ * through the controller, so leaving the editor never loses work. The header
+ * edit/normal toggle exits through requestExit; switching threads closes the
+ * editor. Rendering the editor lives here too, so the pane pulls in one concept
+ * rather than wiring the component and its handle ref by hand.
+ */
+
+import React, { useRef, useState } from "react";
+import type { Theme } from "./theme";
+import type { ReviewController } from "./thread-controller";
+import { MarkdownThreadEditor, type MarkdownEditorHandle } from "./components/MarkdownThreadEditor";
+
+export interface ThreadBodyEditing {
+  /** True while the inline markdown editor owns the thread pane and its keys. */
+  editing: boolean;
+  /** Open the editor when the active thread is editable; a no-op otherwise. */
+  openEditor: () => void;
+  /** Save the current text and close - the header edit/normal toggle's exit. */
+  requestExit: () => void;
+  /** The editor element for the thread pane, bound to the working copy and theme. */
+  renderEditor: (theme: Theme) => React.ReactNode;
+}
+
+export function useThreadBodyEditing(options: {
+  controller: ReviewController;
+  sessionId: string | undefined;
+  canEdit: boolean;
+}): ThreadBodyEditing {
+  const { controller, sessionId, canEdit } = options;
+  // key editing by thread id so a thread switch closes the editor with no effect or ref
+  const [editingSessionId, setEditingSessionId] = useState<string | null>(null);
+  const handleRef = useRef<MarkdownEditorHandle | null>(null);
+  const editing = editingSessionId !== null && editingSessionId === sessionId;
+  const exitEditor = (text: string): void => {
+    controller.saveEditedBody(text);
+    setEditingSessionId(null);
+  };
+
+  return {
+    editing,
+    openEditor: () => {
+      if (canEdit && sessionId !== undefined) setEditingSessionId(sessionId);
+    },
+    requestExit: () => handleRef.current?.requestExit(),
+    renderEditor: (theme) => (
+      <MarkdownThreadEditor
+        ref={handleRef}
+        initialText={controller.working()}
+        theme={theme}
+        onExitEditor={exitEditor}
+      />
+    ),
+  };
+}

package/src/view-plan.test.ts

@@ -9,10 +9,14 @@ import {
   renderedOffsetAtOrAfter,
   renderedOffsetAtOrBefore,
   renderedOffsetFor,
+  renderedSpanToWork,
+  renderedStyleRuns,
+  renderedText,
   safeLinkHref,
   spanFromRange,
   spanKey,
   startSpan,
+  styledRunsFor,
   workRangeForRendered,
 } from "./view-plan";
 import { cutBlock, parseBlocks, restoreBlock, restoreLine, type Annotation } from "@cueloop/schema";
@@ -273,9 +277,9 @@ describe("rendered/work offset mapping", () => {
     const rendered = renderedOffsetFor(runs, wordsAt)!;
 
     // Assert
-    const renderedText = runs.map((run) => run.text).join("");
+    const renderedString = runs.map((run) => run.text).join("");
 
-    expect(renderedText.slice(rendered, rendered + "words".length)).toBe("words");
+    expect(renderedString.slice(rendered, rendered + "words".length)).toBe("words");
     // reading a rendered selection over "words" recovers the work range
     expect(workRangeForRendered(runs, rendered, rendered + "words".length)).toEqual({
       start: wordsAt,
@@ -287,11 +291,11 @@ describe("rendered/work offset mapping", () => {
     // Arrange
     const block = buildDisplay("old words\n", "new words\n")[0]!;
     const runs = blockRuns(block, true);
-    const renderedText = runs.map((run) => run.text).join("");
+    const renderedString = runs.map((run) => run.text).join("");
 
     // Act
     // select everything rendered: the work range is the whole work text
-    const range = workRangeForRendered(runs, 0, renderedText.length)!;
+    const range = workRangeForRendered(runs, 0, renderedString.length)!;
 
     // Assert
     expect(displayText(block).slice(range.start, range.end)).toBe(displayText(block));
@@ -319,9 +323,9 @@ describe("rendered/work offset mapping", () => {
     const renderedEnd = renderedOffsetAtOrBefore(runs, spanEnd - 1)!;
 
     // Assert
-    const renderedText = runs.map((run) => run.text).join("");
+    const renderedString = runs.map((run) => run.text).join("");
 
-    expect(renderedText.slice(renderedStart, renderedEnd + 1)).toBe("very");
+    expect(renderedString.slice(renderedStart, renderedEnd + 1)).toBe("very");
     // exact hits behave like renderedOffsetFor
     expect(renderedOffsetAtOrAfter(runs, 0)).toBe(0);
     expect(renderedOffsetAtOrBefore(runs, 0)).toBe(0);
@@ -404,3 +408,49 @@ describe("cut / restore round-trip", () => {
     expect(buildDisplay(BASE, restored).every((block) => block.type === "same")).toBe(true);
   });
 });
+
+describe("rendered-text projection (markers concealed)", () => {
+  const linkedBlock = () => buildDisplay("Use the `flag` and see [docs](https://x.dev).")[0]!;
+
+  test("renderedText drops inline markers, keeping visible characters", () => {
+    expect(renderedText(linkedBlock())).toBe("Use the flag and see docs.");
+  });
+
+  test("renderedText leaves a table block's source verbatim", () => {
+    const table = buildDisplay("| a | b |\n| --- | --- |\n| 1 | 2 |")[0]!;
+
+    expect(table.kind).toBe("table");
+    expect(renderedText(table)).toBe("| a | b |\n| --- | --- |\n| 1 | 2 |");
+  });
+
+  test("renderedSpanToWork maps a rendered link label back to its work offsets", () => {
+    const display = buildDisplay("Use the `flag` and see [docs](https://x.dev).");
+    // "docs" sits at rendered offset 21 ("Use the flag and see ".length)
+    const work = renderedSpanToWork(display, 0, 0, 21, 25);
+    const workText = display[0]!.work!.text;
+
+    expect(workText.slice(work.start, work.end)).toBe("docs");
+  });
+
+  test("renderedSpanToWork maps rendered inline code back to the backtick content", () => {
+    const display = buildDisplay("Use the `flag` and see docs.");
+    // "flag" sits at rendered offset 8 ("Use the ".length)
+    const work = renderedSpanToWork(display, 0, 0, 8, 12);
+
+    expect(display[0]!.work!.text.slice(work.start, work.end)).toBe("flag");
+  });
+
+  test("styledRunsFor colors a link run and marks the covered stretch", () => {
+    const linkRow = buildDisplay("see [docs](https://x.dev) now")[0]!;
+    const roleRuns = renderedStyleRuns(linkRow);
+    // "see docs now"; mark the whole "docs" label (rendered offsets 4..8)
+    const runs = styledRunsFor(roleRuns, { start: 0, end: renderedText(linkRow).length }, [
+      { start: 4, end: 8 },
+    ]);
+    const link = runs.find((run) => run.role === "link")!;
+
+    expect(link.text).toBe("docs");
+    expect(link.marked).toBe(true);
+    expect(runs.find((run) => run.text === "see ")!.marked).toBe(false);
+  });
+});

package/src/view-plan.ts

@@ -17,7 +17,8 @@ import {
   type Block,
 } from "@cueloop/schema";
 import { wordLevelChanges } from "./diff-intraline";
-import { spanRangeInBlock, type TextSpan } from "./thread-selection";
+import { spanRangeInBlock, type CharRange, type TextSpan } from "./thread-selection";
+import type { MarkRange, VisualLine } from "./mark-runs";
 
 // ── display model ─────────────────────────────
 
@@ -37,6 +38,18 @@ export function displayText(block: DisplayBlock): string {
   return (block.work ?? block.base)!.text;
 }
 
+/**
+ * The text a block actually paints: every rendered run's text in order, with
+ * inline markers concealed. This is the coordinate space the read-only thread
+ * surface hit-tests and paints in; it differs from displayText wherever a block
+ * carries inline markup (a link, code, or emphasis) whose markers drop away.
+ */
+export function renderedText(block: DisplayBlock): string {
+  return blockRuns(block, true)
+    .map((run) => run.text)
+    .join("");
+}
+
 /** Word-overlap similarity gate: an unrelated cut + insert must not merge. */
 function similar(baseBlock: Block, workBlock: Block): boolean {
   if (baseBlock.kind !== workBlock.kind) return false;
@@ -214,15 +227,27 @@ export function marksByDisplay(
     const endEntry = workEntries[resolved.endBlockIndex];
 
     if (!startEntry || !endEntry) continue;
+    // resolveAnchor works in the block's work text; the surface paints and hit-tests in rendered
+    // text (markers concealed), so map the span onto the visible characters it covers
+    const renderedStart = renderedOffsetAtOrAfter(
+      blockRuns(startEntry.block, true),
+      resolved.start,
+    );
+    const renderedEndInclusive = renderedOffsetAtOrBefore(
+      blockRuns(endEntry.block, true),
+      Math.max(0, resolved.end - 1),
+    );
+
+    if (renderedStart === null || renderedEndInclusive === null) continue;
     const span: TextSpan = {
-      start: { blockIndex: startEntry.displayIndex, char: resolved.start },
-      end: { blockIndex: endEntry.displayIndex, char: resolved.end },
+      start: { blockIndex: startEntry.displayIndex, char: renderedStart },
+      end: { blockIndex: endEntry.displayIndex, char: renderedEndInclusive + 1 },
     };
 
     // a span paints on every block it covers; the mark carries the whole span
     for (let workIndex = resolved.blockIndex; workIndex <= resolved.endBlockIndex; workIndex++) {
       const entry = workEntries[workIndex]!;
-      const range = spanRangeInBlock(span, entry.displayIndex, entry.block.work!.text.length);
+      const range = spanRangeInBlock(span, entry.displayIndex, renderedText(entry.block).length);
 
       if (!range) continue;
       const marks = marksByIndex.get(entry.displayIndex) ?? [];
@@ -243,7 +268,11 @@ export function marksByDisplay(
 
 /** Base runs for a display block: plain text, or word-diff for mod blocks. */
 export function blockRuns(block: DisplayBlock, markup: boolean): StyleRun[] {
-  const literal = block.kind === "code" || block.kind === "hr";
+  const literal =
+    block.kind === "code" ||
+    block.kind === "hr" ||
+    block.kind === "table" ||
+    block.kind === "frontmatter";
 
   if (block.type === "mod" && markup) {
     const changes = wordLevelChanges(block.base!.text, block.work!.text);
@@ -315,6 +344,94 @@ export function inlineStyleRuns(text: string, base: number): StyleRun[] {
   return runs;
 }
 
+/** A rendered run positioned by its offset in the block's rendered (concealed) text. */
+export interface RenderedRun {
+  text: string;
+  role: RunRole;
+  /** Offset of this run in the block's rendered text. */
+  start: number;
+  href?: string;
+}
+
+/** The block's role runs positioned in rendered-text coordinates, for painting and hit-testing. */
+export function renderedStyleRuns(block: DisplayBlock): RenderedRun[] {
+  const runs: RenderedRun[] = [];
+  let rendered = 0;
+
+  for (const run of blockRuns(block, true)) {
+    const positioned: RenderedRun = { text: run.text, role: run.role, start: rendered };
+
+    if (run.href !== undefined) positioned.href = run.href;
+    runs.push(positioned);
+    rendered += run.text.length;
+  }
+
+  return runs;
+}
+
+/** A painted run of one visual line: its role, its href, and whether a mark or the caret cell covers it. */
+export interface StyledRun {
+  text: string;
+  role: RunRole;
+  marked: boolean;
+  caretOnly: boolean;
+  href?: string;
+}
+
+/**
+ * Slice a block's rendered role runs to one visual line and split them further
+ * at mark boundaries, so each painted run carries both its markdown role and
+ * whether a discussion mark or the caret cell covers it. Every coordinate here
+ * is a rendered-text offset; `markRanges` are block-level and clipped to the line.
+ */
+export function styledRunsFor(
+  roleRuns: RenderedRun[],
+  line: VisualLine,
+  markRanges: MarkRange[],
+): StyledRun[] {
+  const cuts = new Set<number>([line.start, line.end]);
+
+  for (const run of roleRuns) {
+    if (run.start > line.start && run.start < line.end) cuts.add(run.start);
+    const runEnd = run.start + run.text.length;
+
+    if (runEnd > line.start && runEnd < line.end) cuts.add(runEnd);
+  }
+  for (const range of markRanges) {
+    const start = Math.max(line.start, range.start);
+    const end = Math.min(line.end, range.end);
+
+    if (start < end) {
+      cuts.add(start);
+      cuts.add(end);
+    }
+  }
+  const edges = [...cuts].toSorted((left, right) => left - right);
+  const runs: StyledRun[] = [];
+
+  for (let index = 0; index < edges.length - 1; index++) {
+    const start = edges[index]!;
+    const end = edges[index + 1]!;
+
+    if (end <= start) continue;
+    const roleRun = roleRuns.find(
+      (candidate) => candidate.start <= start && start < candidate.start + candidate.text.length,
+    );
+    const covering = markRanges.filter((range) => range.start <= start && end <= range.end);
+    const styled: StyledRun = {
+      text: roleRun ? roleRun.text.slice(start - roleRun.start, end - roleRun.start) : "",
+      role: roleRun?.role ?? "plain",
+      marked: covering.some((range) => range.caretOnly !== true),
+      caretOnly: covering.some((range) => range.caretOnly === true),
+    };
+
+    if (roleRun?.href !== undefined) styled.href = roleRun.href;
+    runs.push(styled);
+  }
+
+  return runs.length > 0 ? runs : [{ text: "", role: "plain", marked: false, caretOnly: false }];
+}
+
 /** Split runs at mark boundaries; marks only bind to runs with offsets. */
 export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
   if (!marks.length) return runs;
@@ -455,6 +572,38 @@ export function workRangeForRendered(
   return range;
 }
 
+/**
+ * Map a rendered-text selection back to the work-text range an anchor is cut
+ * from. The read-only surface yields rendered offsets (markers concealed); an
+ * anchor's quote must come from the block's work text, so convert at the seam
+ * before makeAnchor. A selection may cross blocks: the start rendered offset
+ * lives in `displayIndex`, the end in `endDisplayIndex`.
+ */
+export function renderedSpanToWork(
+  display: DisplayBlock[],
+  displayIndex: number,
+  endDisplayIndex: number,
+  renderedStart: number,
+  renderedEnd: number,
+): CharRange {
+  const startBlock = display[displayIndex]!;
+
+  if (displayIndex === endDisplayIndex) {
+    const range = workRangeForRendered(blockRuns(startBlock, true), renderedStart, renderedEnd);
+
+    return range ?? { start: renderedStart, end: renderedEnd };
+  }
+  const startRuns = blockRuns(startBlock, true);
+  const startRange = workRangeForRendered(
+    startRuns,
+    renderedStart,
+    renderedText(startBlock).length,
+  );
+  const endRange = workRangeForRendered(blockRuns(display[endDisplayIndex]!, true), 0, renderedEnd);
+
+  return { start: startRange?.start ?? renderedStart, end: endRange?.end ?? renderedEnd };
+}
+
 /** Line delta between two revision contents, for the sheet-header summary. */
 export function revisionDelta(previousContent: string, nextContent: string) {
   const ops = lcsDiff(previousContent.split("\n"), nextContent.split("\n"));

package/src/App.share-choice.test.tsx

@@ -1,105 +0,0 @@
-/** The share shortcut opens an app-level public/private choice reachable from any view. */
-
-import { afterEach, beforeEach, describe, mock, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import React from "react";
-import { testRender } from "@opentui/react/test-utils";
-import { DaemonServer } from "@cueloop/daemon";
-import type { Thread } from "@cueloop/schema";
-import { App } from "./App";
-import type { ShareTransport } from "./thread-controller";
-import { isolateUserConfig, press, pressKey, waitForText, waitForTextGone } from "./test-support";
-
-const shareTransport: ShareTransport = {
-  publish: mock(async () => ({ line: "ssh p_share01@cueloop.dev", copied: true })),
-  pull: mock(async () => {
-    throw new Error("Unexpected share pull");
-  }),
-  push: mock(async () => {}),
-  watch: () => () => {},
-  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
-  collaboratorAnnotations: () => [],
-  mergeFromShare: () => ({ annotations: [] }),
-};
-
-const PLAN = `# Migration Plan\n\n## Context\n\nThe daemon persists sessions to disk atomically.\n`;
-
-let home: string;
-let restoreUserConfig: () => void;
-let server: DaemonServer;
-let session: Thread;
-
-beforeEach(() => {
-  home = mkdtempSync(join(tmpdir(), "cueloop-share-choice-"));
-  restoreUserConfig = isolateUserConfig(home);
-  server = new DaemonServer({ home, idleExitMs: 0 });
-  server.start();
-  session = server.core.sessionCreate({
-    workspace: { repoRoot: "/repo", branch: "main" },
-    artifact: {
-      type: "plan",
-      content: PLAN,
-      meta: { title: "Migration Plan", planPath: "plan.md" },
-    },
-  });
-});
-afterEach(() => {
-  restoreUserConfig();
-  server.stop();
-  rmSync(home, { recursive: true, force: true });
-});
-
-describe("share choice", () => {
-  test("the shortcut opens the public/private choice", async () => {
-    // Arrange
-    const setup = await testRender(
-      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
-      { width: 120, height: 32 },
-    );
-    await waitForText(setup, "cueloop");
-
-    // Act
-    await pressKey(setup, "s", { ctrl: true });
-
-    // Assert
-    await waitForText(setup, "public link");
-    await waitForText(setup, "private link");
-  });
-
-  test("the private choice opens the manage-access surface", async () => {
-    // Arrange
-    const setup = await testRender(
-      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
-      { width: 120, height: 32 },
-    );
-    await waitForText(setup, "cueloop");
-
-    // Act: open the choice, move to private, select it
-    await pressKey(setup, "s", { ctrl: true });
-    await waitForText(setup, "private link");
-    await press(setup, "down");
-    await press(setup, "enter");
-
-    // Assert
-    await waitForText(setup, "Manage access");
-  });
-
-  test("escape cancels the choice without sharing", async () => {
-    // Arrange
-    const setup = await testRender(
-      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
-      { width: 120, height: 32 },
-    );
-    await waitForText(setup, "cueloop");
-
-    // Act
-    await pressKey(setup, "s", { ctrl: true });
-    await waitForText(setup, "public link");
-    await press(setup, "escape");
-
-    // Assert
-    await waitForTextGone(setup, "public link");
-  });
-});

package/src/components/ManageAccessDialog.stories.tsx

@@ -1,36 +0,0 @@
-import React from "react";
-import { DARK } from "../theme";
-import type { Story, StoryMeta } from "./story";
-import { ManageAccessDialog } from "./ManageAccessDialog";
-
-export const meta: StoryMeta = { title: "Dialogs/ManageAccess" };
-
-export const WithHandles: Story = {
-  render: () => (
-    <ManageAccessDialog
-      isOpen
-      logins={["octocat", "hubot"]}
-      onAdd={() => {}}
-      onRemove={() => {}}
-      onCreateLink={() => {}}
-      onClose={() => {}}
-      theme={DARK}
-    />
-  ),
-  size: { width: 60, height: 18 },
-};
-
-export const Empty: Story = {
-  render: () => (
-    <ManageAccessDialog
-      isOpen
-      logins={[]}
-      onAdd={() => {}}
-      onRemove={() => {}}
-      onCreateLink={() => {}}
-      onClose={() => {}}
-      theme={DARK}
-    />
-  ),
-  size: { width: 60, height: 18 },
-};

package/src/components/ManageAccessDialog.test.tsx

@@ -1,94 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import React, { useState } from "react";
-import { testRender } from "@opentui/react/test-utils";
-import { DARK } from "../theme";
-import { clickText, locateTextInFrame, settle, typeText } from "../test-support";
-import { ManageAccessDialog } from "./ManageAccessDialog";
-
-function AccessHarness({ initial }: { initial: string[] }): React.ReactNode {
-  const [logins, setLogins] = useState<string[]>(initial);
-  const [open, setOpen] = useState(true);
-
-  return (
-    <box style={{ width: 60, height: 18 }}>
-      <ManageAccessDialog
-        isOpen={open}
-        logins={logins}
-        onAdd={(login) => setLogins((prev) => [...prev, login])}
-        onRemove={(login) => setLogins((prev) => prev.filter((entry) => entry !== login))}
-        onCreateLink={() => {}}
-        onClose={() => setOpen(false)}
-        theme={DARK}
-      />
-    </box>
-  );
-}
-
-async function renderAccess(initial: string[]): Promise<Awaited<ReturnType<typeof testRender>>> {
-  const setup = await testRender(<AccessHarness initial={initial} />, { width: 60, height: 18 });
-
-  await settle(setup);
-
-  return setup;
-}
-
-describe("ManageAccessDialog", () => {
-  test("renders the allowlist of GitHub handles", async () => {
-    const setup = await renderAccess(["octocat", "hubot"]);
-    const frame = setup.captureCharFrame();
-
-    expect(locateTextInFrame(frame, "@octocat")).not.toBeNull();
-    expect(locateTextInFrame(frame, "@hubot")).not.toBeNull();
-  });
-
-  test("clicking a row removes that handle from the allowlist", async () => {
-    const setup = await renderAccess(["octocat", "hubot"]);
-
-    await clickText(setup, "@octocat");
-
-    expect(locateTextInFrame(setup.captureCharFrame(), "@octocat")).toBeNull();
-    expect(locateTextInFrame(setup.captureCharFrame(), "@hubot")).not.toBeNull();
-  });
-
-  test("typing a handle and pressing add appends it to the allowlist", async () => {
-    const setup = await renderAccess([]);
-
-    await typeText(setup, "octocat");
-    await clickText(setup, "add");
-
-    expect(locateTextInFrame(setup.captureCharFrame(), "@octocat")).not.toBeNull();
-  });
-
-  test("clicking create link publishes the private link", async () => {
-    let created = false;
-    const setup = await testRender(
-      <box style={{ width: 60, height: 18 }}>
-        <ManageAccessDialog
-          isOpen
-          logins={["octocat"]}
-          onAdd={() => {}}
-          onRemove={() => {}}
-          onCreateLink={() => {
-            created = true;
-          }}
-          onClose={() => {}}
-          theme={DARK}
-        />
-      </box>,
-      { width: 60, height: 18 },
-    );
-
-    await settle(setup);
-    await clickText(setup, "create link");
-
-    expect(created).toBe(true);
-  });
-
-  test("clicking close dismisses the dialog", async () => {
-    const setup = await renderAccess([]);
-
-    await clickText(setup, "close");
-
-    expect(locateTextInFrame(setup.captureCharFrame(), "Manage access")).toBeNull();
-  });
-});