@cueloop/client 0.1.0-alpha.0 → 0.1.0-alpha.100

package/src/app/App.appearance.test.tsx

@@ -0,0 +1,53 @@
+/** The App renders in a light virtual terminal: passing appearance="light" threads the light branded theme through the provider without breaking the mount (the char frame is color-blind, so this covers propagation and wiring, not the pixel colors). */
+
+import { afterEach, beforeEach, describe, expect, 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 { DaemonServer } from "@cueloop/daemon";
+import type { Thread } from "@cueloop/schema";
+import { App } from "./App";
+import { isolateUserConfig, settle, waitForText, renderReadyApp } from "../testing/test-support";
+
+const PLAN = "# Sync Plan\n\n## Steps\n\n- flush the queue\n";
+
+let home: string;
+let server: DaemonServer;
+let session: Thread;
+let restoreUserConfig: () => void;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-appearance-"));
+  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: "Sync Plan", planPath: "plan.md" } },
+  });
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("appearance", () => {
+  test("renders the review on a light terminal", async () => {
+    // Arrange + Act
+    const setup = await renderReadyApp(
+      <App home={home} sessionId={session.id} appearance="light" />,
+      {
+        width: 120,
+        height: 32,
+      },
+    );
+
+    // Assert
+    await waitForText(setup, "cueloop");
+    await waitForText(setup, "Sync Plan");
+    await settle(setup);
+    expect(setup.captureCharFrame()).toContain("flush the queue");
+  });
+});

package/src/app/App.autoclose.test.tsx

@@ -0,0 +1,144 @@
+/** Post-submit completion overlay: prompt, opt-in persistence, countdown, dismissal. Countdown seconds tick on an injected ManualClock, so tests advance time instead of waiting it out. */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } 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 { ManualClock } from "@opentui/core/testing";
+import { DaemonServer } from "@cueloop/daemon";
+import type { Thread } from "@cueloop/schema";
+import { App } from "./App";
+import { isolateUserConfig, press, settle, waitForText, pressKey } from "../testing/test-support";
+
+const PLAN = "# Plan\n\nShip the thing.\n";
+
+let home: string;
+let server: DaemonServer;
+let session: Thread;
+let configPath: string;
+let restoreUserConfig: () => void;
+let clock: ManualClock;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-close-"));
+  configPath = join(home, "config.toml");
+  restoreUserConfig = isolateUserConfig(home, "config.toml");
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: PLAN, meta: { title: "Plan" } },
+  });
+  clock = new ManualClock();
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp(onExit?: (code: number) => void) {
+  const setup = await testRender(
+    <App home={home} sessionId={session.id} onExit={onExit} clock={clock} />,
+    {
+      width: 120,
+      height: 30,
+    },
+  );
+
+  await waitForText(setup, "cueloop");
+
+  return setup;
+}
+
+type Setup = Awaited<ReturnType<typeof renderApp>>;
+
+async function submitApprove(setup: Setup): Promise<void> {
+  await pressKey(setup, "RETURN", { meta: true }); // open submit (approve default: no pending items)
+  await pressKey(setup, "RETURN", { meta: true }); // confirm
+  await waitForText(setup, "review approved");
+}
+
+describe("completion overlay", () => {
+  test("submit with auto-close off counts down from 5; ⏎ exits now", async () => {
+    // Arrange
+    let exited = -1;
+    const setup = await renderApp((code) => (exited = code));
+
+    // Act
+    await submitApprove(setup);
+
+    // Assert
+    const frame = await waitForText(setup, "closing in 5s");
+
+    expect(frame).toContain("review approved");
+    expect(frame).toContain("close");
+    expect(frame).toContain("back to plan");
+
+    // Act
+    await press(setup, "enter");
+
+    // Assert
+    expect(exited).toBe(0);
+  });
+
+  test("a remembers the countdown as the persisted default", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 5s");
+
+    // Act
+    await press(setup, "a");
+
+    // Assert
+    expect(existsSync(configPath)).toBe(true);
+    expect(readFileSync(configPath, "utf8")).toContain("auto_close = 5");
+
+    // Act
+    // the countdown keeps running; each second is one manual-clock tick
+    clock.advance(1000);
+
+    // Assert
+    await waitForText(setup, "closing in 4s");
+  });
+
+  test("esc dismisses to the resolved read-only view", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 5s");
+
+    // Act
+    // a bare ESC sits in the input parser's escape-sequence disambiguation
+    // window before it is delivered - the frame wait absorbs it
+    await press(setup, "escape");
+
+    // Assert - the countdown is cancelled and we are back in the (resolved) thread view
+    const frame = await waitForText(setup, "Ship the thing");
+
+    expect(frame).not.toContain("closing in");
+  });
+
+  test("configured auto_close counts down and exits without interaction", async () => {
+    // Arrange
+    writeFileSync(configPath, "[ui]\nauto_close = 1\n");
+    let exited = -1;
+    const setup = await renderApp((code) => (exited = code));
+
+    await submitApprove(setup);
+    await waitForText(setup, "closing in 1s");
+    expect(exited).toBe(-1);
+
+    // Act
+    clock.advance(1000);
+    await settle(setup);
+
+    // Assert
+    expect(exited).toBe(0);
+  });
+});

package/src/app/App.deleted-scroll.test.tsx

@@ -0,0 +1,187 @@
+/** Keyboard scrolling in a changed-file tab uses caret navigation, even when the file was deleted. */
+
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { ScrollBoxRenderable, type Renderable } from "@opentui/core";
+import { DaemonServer } from "@cueloop/daemon";
+import { App } from "./App";
+import { annotationPaletteFor } from "../annotations/annotation-palette";
+import { DARK } from "../appearance/theme";
+import {
+  isolateUserConfig,
+  locateText,
+  press,
+  renderReadyApp,
+  settle,
+  waitForText,
+} from "../testing/test-support";
+
+function findScrollbox(node: Renderable): ScrollBoxRenderable | null {
+  if (node.id === "diff-scroll" && node instanceof ScrollBoxRenderable) return node;
+
+  for (const child of node.getChildren()) {
+    const found = findScrollbox(child);
+
+    if (found) return found;
+  }
+
+  return null;
+}
+
+function hex(color: { toInts(): [number, number, number, number] }): string {
+  const [red, green, blue] = color.toInts();
+
+  return "#" + [red, green, blue].map((part) => part.toString(16).padStart(2, "0")).join("");
+}
+
+test("deleted file caret scrolls one row and stays at the file boundaries", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-scroll-home-"));
+  const repo = mkdtempSync(join(tmpdir(), "cueloop-scroll-repo-"));
+  const restoreConfig = isolateUserConfig(home);
+  const server = new DaemonServer({ home, idleExitMs: 0 });
+  let setup: Awaited<ReturnType<typeof renderReadyApp>> | undefined;
+
+  try {
+    const file = join(repo, "long.md");
+    const lines = Array.from({ length: 180 }, (_, index) =>
+      index === 113
+        ? "[nodejs/node#36005](https://github.com/nodejs/node/issues/36005)."
+        : `row ${String(index).padStart(3, "0")} ${"a paragraph with wrapped text and a link [source](https://example.test/page) ".repeat((index % 3) + 1)}`,
+    );
+    const git = (args: string[]) => Bun.spawnSync(["git", "-C", repo, ...args]);
+
+    writeFileSync(file, lines.join("\n") + "\n");
+    git(["init", "-q"]);
+    git(["config", "user.email", "fixture@example.com"]);
+    git(["config", "user.name", "Fixture"]);
+    git(["add", "-A"]);
+    git(["commit", "-q", "-m", "seed"]);
+    unlinkSync(file);
+    server.start();
+    setup = await renderReadyApp(<App home={home} sessionId={undefined} cwd={repo} />, {
+      width: 180,
+      height: 48,
+    });
+    await waitForText(setup, "long.md");
+    const treeFile = locateText(setup, "long.md");
+
+    await setup.mockMouse.click(treeFile.column, treeFile.row);
+    await waitForText(setup, "row 00");
+    const box = findScrollbox(setup.renderer.root);
+
+    if (!box) throw new Error("file diff scrollbox missing");
+    for (let offset = 0; offset < 1000; offset += 20) {
+      box.scrollTo({ x: 0, y: offset });
+      await settle(setup);
+      if (setup.captureCharFrame().includes("row 130")) break;
+    }
+    const target = locateText(setup, "row 130");
+
+    await setup.mockMouse.click(target.column, target.row);
+    await press(setup, "escape");
+
+    const steps: number[] = [];
+    const caretCell = annotationPaletteFor(DARK).caretCell;
+    const frameTrace: Array<{ markers: number[]; caret: number }> = [];
+    const captureFrame = () => {
+      const lines = setup!.captureCharFrame().split("\n");
+      const markers = lines.flatMap((line, row) => (line.includes("▎") ? [row] : []));
+      const caret = setup!
+        .captureSpans()
+        .lines.findIndex((line) => line.spans.some((span) => hex(span.bg) === caretCell));
+
+      frameTrace.push({ markers, caret });
+    };
+
+    setup.renderer.on("frame", captureFrame);
+
+    for (let index = 0; index < 12; index++) {
+      const before = box.scrollTop;
+
+      await press(setup, "down");
+      steps.push(box.scrollTop - before);
+      const caretRow = setup
+        .captureSpans()
+        .lines.findIndex((line) => line.spans.some((span) => hex(span.bg) === caretCell));
+      const markerRows = setup
+        .captureCharFrame()
+        .split("\n")
+        .flatMap((line, row) => (line.includes("▎") ? [row] : []));
+
+      expect(caretRow).toBeGreaterThanOrEqual(0);
+      expect(markerRows).toEqual([caretRow]);
+    }
+
+    expect(Math.max(...steps)).toBeLessThanOrEqual(1);
+    expect(Math.min(...steps)).toBeGreaterThanOrEqual(0);
+    let anchored = false;
+
+    for (let index = 0; index < 80; index++) {
+      await press(setup, "up");
+      const marker = setup
+        .captureCharFrame()
+        .split("\n")
+        .findIndex((line) => line.includes("▎"));
+
+      if (marker === box.viewport.screenY) anchored = true;
+      if (anchored && box.scrollTop > 0) expect(marker).toBe(box.viewport.screenY);
+    }
+    expect(anchored).toBe(true);
+    box.scrollTo({ x: 0, y: 100000 });
+    await settle(setup);
+    const last = locateText(setup, "row 179");
+
+    await setup.mockMouse.click(last.column, last.row);
+    await press(setup, "escape");
+    let lastMarker = -1;
+
+    for (let index = 0; index < 12; index++) {
+      const traceStart = frameTrace.length;
+      const before = box.scrollTop;
+
+      await press(setup, "down");
+      const states = frameTrace.slice(traceStart);
+
+      expect(box.scrollTop).toBe(before);
+      expect(states.length).toBeGreaterThan(0);
+      for (const state of states) {
+        expect(state.markers).toEqual([state.caret]);
+        expect(state.caret).toBeGreaterThanOrEqual(lastMarker);
+        lastMarker = state.caret;
+      }
+    }
+    box.scrollTo({ x: 0, y: 0 });
+    await settle(setup);
+    const first = locateText(setup, "row 000");
+
+    await setup.mockMouse.click(first.column, first.row);
+    await press(setup, "escape");
+    let firstMarker = Number.POSITIVE_INFINITY;
+
+    for (let index = 0; index < 12; index++) {
+      const traceStart = frameTrace.length;
+      const before = box.scrollTop;
+
+      await press(setup, "up");
+      const states = frameTrace.slice(traceStart);
+
+      expect(box.scrollTop).toBe(before);
+      expect(states.length).toBeGreaterThan(0);
+      for (const state of states) {
+        expect(state.markers).toEqual([state.caret]);
+        expect(state.caret).toBeLessThanOrEqual(firstMarker);
+        firstMarker = state.caret;
+      }
+    }
+    setup.renderer.off("frame", captureFrame);
+  } finally {
+    setup?.renderer.destroy();
+    server.stop();
+    restoreConfig();
+    rmSync(home, { recursive: true, force: true });
+    rmSync(repo, { recursive: true, force: true });
+  }
+}, 30000);

package/src/app/App.diff.test.tsx

@@ -0,0 +1,313 @@
+/** Diff-review flow in the virtual terminal: the diff sheet annotates like the thread view. */
+
+import { afterEach, beforeEach, describe, expect, 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 { DaemonServer } from "@cueloop/daemon";
+import type { Thread } from "@cueloop/schema";
+import { App } from "./App";
+import { pullRequestReviewLayout } from "./launch-layout";
+import { DARK } from "../appearance/theme";
+import {
+  clickText,
+  dragText,
+  isolateUserConfig,
+  navCommand,
+  press,
+  pressKey,
+  renderReadyApp,
+  typeText,
+  waitForState,
+  waitForText,
+} from "../testing/test-support";
+
+const PATCH = `diff --git a/src/store.ts b/src/store.ts
+index 111..222 100644
+--- a/src/store.ts
++++ b/src/store.ts
+@@ -1,4 +1,4 @@
+ export class Store {
+-  private items = [];
++  private items = new Map();
+ }
+`;
+
+let home: string;
+let restoreUserConfig: () => void;
+let server: DaemonServer;
+let session: Thread;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-diff-"));
+  restoreUserConfig = isolateUserConfig(home);
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: PATCH, meta: { title: "working tree" } },
+  });
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp(sessionId = session.id) {
+  const setup = await renderReadyApp(<App home={home} sessionId={sessionId} />, {
+    width: 120,
+    height: 30,
+  });
+
+  await waitForText(setup, "new Map()");
+
+  return setup;
+}
+
+describe("diff review", () => {
+  test("a submitted JJ review uses the existing refresh action and shows its source", async () => {
+    const jjReview = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "jj" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: { title: "JJ change", vcs: "jj", vcsChangeId: "abcdefghijklmnopqrstuvwxyzaaaaaa" },
+      },
+    });
+    const setup = await renderReadyApp(<App home={home} sessionId={jjReview.id} />, {
+      width: 120,
+      height: 30,
+    });
+
+    await waitForText(setup, "new Map()");
+    expect(setup.captureCharFrame()).toContain("vcs: jj");
+    expect(setup.captureCharFrame()).toContain("refresh");
+  });
+
+  test("pull request review shows its brief beside Changes and signals a moved head", async () => {
+    const pullRequest = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "detached" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: {
+          title: "Fix store",
+          pr: "org/repo#42",
+          prBrief: "# Fix store\n\n## PR description\n\nUse a map.",
+          prHeadSha: "head-1",
+          prRefreshHeadSha: "head-2",
+        },
+      },
+    });
+    const setup = await renderReadyApp(
+      <App home={home} sessionId={pullRequest.id} layout={pullRequestReviewLayout()} />,
+      { width: 160, height: 30 },
+    );
+
+    await waitForText(setup, "Use a map.");
+    await waitForText(setup, "new Map()");
+    await waitForText(setup, "refresh");
+    const refreshSpan = setup
+      .captureSpans()
+      .lines.flatMap((line) => line.spans)
+      .find((span) => span.text.includes("refresh"));
+    const refreshColor = refreshSpan?.fg
+      .toInts()
+      .slice(0, 3)
+      .map((part) => part.toString(16).padStart(2, "0"))
+      .join("");
+
+    expect(`#${refreshColor}`).toBe(DARK.warning);
+  });
+
+  test("a resolved pull request review does not offer refresh", async () => {
+    const pullRequest = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "detached" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: {
+          title: "Fix store",
+          pr: "org/repo#42",
+          prHeadSha: "head-1",
+          prRefreshHeadSha: "head-2",
+        },
+      },
+    });
+
+    server.core.sessionSendMessage(pullRequest.id, "approved", "Ready to merge.");
+    const setup = await renderReadyApp(
+      <App home={home} sessionId={pullRequest.id} layout={pullRequestReviewLayout()} />,
+      { width: 160, height: 30 },
+    );
+
+    await waitForText(setup, "new Map()");
+    expect(setup.captureCharFrame()).not.toContain("refresh");
+  });
+
+  test("renders file header, hunks, and signed lines", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Assert
+    const frame = setup.captureCharFrame();
+
+    expect(frame).toContain("src/store.ts");
+    expect(frame).toContain("@@ -1,4 +1,4 @@");
+    expect(frame).toMatch(/- {2,}private items = \[\];/);
+    expect(frame).toMatch(/\+ {2,}private items = new Map\(\);/);
+  });
+
+  test("a drag marks the code, typing comments on it, and the comment lands in feedback", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Act - mark "new Map()" on the added line and just start typing, as in the thread view
+    await dragText(setup, "new Map()", "new Map()", "new Map()".length);
+    await typeText(setup, "Map needs an eviction story.");
+    await waitForText(setup, "● Map needs an eviction story.");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - the discussion card hangs under the line; the anchor is the marked words
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    await waitForText(setup, "● Map needs an eviction story.");
+    expect(server.core.sessionGet(session.id).annotations[0]!.anchor.quote).toBe("new Map()");
+
+    // Act - submit with the session chord (cmd+enter, no composer open), cycle to request changes
+    await pressKey(setup, "RETURN", { meta: true });
+    await waitForText(setup, "[approve]");
+    await press(setup, "right");
+    await waitForText(setup, "[changes]");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert
+    await waitForText(setup, "feedback sent");
+    const resolved = server.core.sessionGet(session.id);
+
+    expect(resolved.message!.body).toContain("new Map()");
+    expect(resolved.message!.body).toContain("Map needs an eviction story.");
+  });
+
+  test("pasting an image into a diff comment drops in an [Image #n] placeholder", async () => {
+    // Arrange - mark the added line and open the inline comment composer
+    const setup = await renderApp();
+
+    await dragText(setup, "new Map()", "new Map()", "new Map()".length);
+    await typeText(setup, "see ");
+
+    // Act - a burst of control bytes stands in for the binary an image paste delivers
+    await setup.mockInput.pasteBracketedText("
");
+
+    // Assert - the same placeholder the summary composer shows
+    await waitForText(setup, "see [Image #1]");
+  });
+
+  test("a comment reopens with its mark painted on the code", async () => {
+    // Arrange - a stored comment anchored to the added line's words
+    server.core.sessionAnnotate(session.id, {
+      id: "a_existing",
+      kind: "comment",
+      anchor: { quote: "new Map()", prefix: "  private items = ", suffix: ";" },
+      body: "Existing note.",
+    });
+
+    // Act
+    const setup = await renderApp();
+
+    // Assert
+    await waitForText(setup, "● Existing note.");
+  });
+
+  test("option+c folds the caret's file to its band; its title restores the body", async () => {
+    // Arrange - the caret opens on the file's first code line
+    const setup = await renderApp();
+
+    // Act
+    await navCommand(setup, "c");
+
+    // Assert - the body is gone but the band (with its counts) remains
+    await waitForState(setup, () => !setup.captureCharFrame().includes("new Map()"));
+    const collapsed = setup.captureCharFrame();
+
+    expect(collapsed).toContain("src/store.ts");
+    expect(collapsed).toContain("+1");
+
+    // Act - the title unfolds it again
+    await clickText(setup, "src/store.ts");
+
+    // Assert
+    await waitForText(setup, "new Map()");
+  });
+
+  test("curation needs full file contents; a legacy diff answers", async () => {
+    // Arrange - the session carries no artifact.files
+    const setup = await renderApp();
+
+    // Act
+    await navCommand(setup, "x");
+
+    // Assert
+    await waitForText(setup, "hunk curation needs full file contents");
+  });
+
+  test("rejecting the only change empties the curated working copy", async () => {
+    // Arrange - a diff session that carries full file contents
+    const withFiles = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: { title: "working tree" },
+        files: [
+          {
+            path: "src/store.ts",
+            oldContents: "export class Store {\n  private items = [];\n}\n",
+            newContents: "export class Store {\n  private items = new Map();\n}\n",
+            status: "modified",
+          },
+        ],
+      },
+    });
+    const setup = await renderApp(withFiles.id);
+
+    // Act - place the caret on the added line and reject its change
+    await clickText(setup, "new Map()");
+    await navCommand(setup, "x");
+
+    // Assert - the single change is gone, so the curated working copy is empty
+    await waitForState(setup, () => server.core.sessionGet(withFiles.id).workingCopy === "");
+    const stored = server.core.sessionGet(withFiles.id);
+
+    expect(stored.workingCopy).toBe("");
+    expect(setup.captureCharFrame()).not.toContain("change rejected");
+  });
+
+  test("a diff opens with the Changes column listing every changed file", async () => {
+    // Arrange - two changed files; config.ts is not in the patch text, so it can
+    // only appear here by way of the Changes column reading artifact.files
+    const withFiles = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: { title: "working tree" },
+        files: [
+          { path: "src/store.ts", oldContents: "a", newContents: "b", status: "modified" },
+          { path: "src/config.ts", oldContents: "", newContents: "c", status: "added" },
+        ],
+      },
+    });
+    const setup = await renderReadyApp(<App home={home} sessionId={withFiles.id} />, {
+      width: 120,
+      height: 30,
+    });
+
+    await waitForText(setup, "cueloop");
+
+    // Assert - the context default opens the column for a diff, so both files show
+    await waitForText(setup, "config.ts");
+    expect(setup.captureCharFrame()).toContain("store.ts");
+  });
+});