@frockbot/architecture-checks 0.0.0 → 0.1.1

package/package.json

@@ -1,14 +1,41 @@
 {
   "name": "@frockbot/architecture-checks",
-  "version": "0.0.0",
-  "description": "Placeholder reserving this name for trusted publishing. Superseded by the first release.",
-  "license": "UNLICENSED",
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "description": "Automated checks for the constitutional rules that can be enforced mechanically.",
+  "scripts": {
+    "test": "bun test src",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@frockbot/computer-core": "0.1.1",
+    "@frockbot/connection-core": "0.1.1",
+    "@frockbot/kernel-agent-loop": "0.1.1",
+    "@frockbot/kernel-composition": "0.1.1",
+    "@frockbot/kernel-contracts": "0.1.1",
+    "@frockbot/kernel-do": "0.1.1",
+    "@frockbot/plugin-authoring": "0.1.1",
+    "@frockbot/plugin-computer": "0.1.1",
+    "@frockbot/plugin-memory": "0.1.1",
+    "@frockbot/plugin-models": "0.1.1",
+    "@frockbot/plugin-prompt": "0.1.1",
+    "@frockbot/plugin-provider-foundation": "0.1.1",
+    "@frockbot/plugin-provider-ollama-cloud": "0.1.1",
+    "@frockbot/plugin-skills": "0.1.1",
+    "@frockbot/plugin-tools": "0.1.1",
+    "cordis": "4.0.0-rc.8"
+  },
+  "devDependencies": {
+    "@types/bun": "1.4.0",
+    "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/timoconnellaus/frockbot.git",
     "directory": "packages/architecture-checks"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/computer-host-boundaries.test.ts

@@ -0,0 +1,125 @@
+// ADR 0004 — "the Fly Sprites SDK is loaded in exactly one place". The SDK's
+// HTTP exec protocol depends on response chunk boundaries workerd does not
+// preserve, so it may only run in the Node container app; every other package
+// reaches the Computer through the `COMPUTER_HOST` service binding. The rule is
+// a source-graph fact, so `scripts/check-computer-host-imports.ts` enforces it
+// and this file proves both that the tree obeys it and that the linter bites.
+import { afterAll, describe, expect, test } from "bun:test";
+import {
+  copyFileSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+// Spelled in halves so this file's own fixtures are not a violation of the
+// rule it proves.
+const SDK = ["@fly", "sprites"].join("/");
+
+const repoRoot = resolve(import.meta.dirname, "..", "..", "..");
+const checkScript = join(repoRoot, "scripts", "check-computer-host-imports.ts");
+
+function runCheck(cwd: string): { output: string; exitCode: number | null } {
+  const check = Bun.spawnSync({
+    cmd: ["bun", "scripts/check-computer-host-imports.ts"],
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return {
+    output: `${check.stdout.toString()}${check.stderr.toString()}`,
+    exitCode: check.exitCode,
+  };
+}
+
+const fixtures: string[] = [];
+
+// A miniature repo with the linter copied in, so a violation can be staged
+// without writing one into this tree.
+function fixtureRepo(files: Record<string, string>): string {
+  const root = mkdtempSync(join(tmpdir(), "computer-host-lint-"));
+  fixtures.push(root);
+  mkdirSync(join(root, "scripts"), { recursive: true });
+  copyFileSync(
+    checkScript,
+    join(root, "scripts", "check-computer-host-imports.ts"),
+  );
+  writeFileSync(
+    join(root, "package.json"),
+    JSON.stringify({ name: "fixture" }),
+  );
+  for (const [path, contents] of Object.entries(files)) {
+    const target = join(root, path);
+    mkdirSync(resolve(target, ".."), { recursive: true });
+    writeFileSync(target, contents);
+  }
+  return root;
+}
+
+afterAll(() => {
+  for (const root of fixtures) rmSync(root, { recursive: true, force: true });
+});
+
+describe("computer host boundaries", () => {
+  test("the Fly Sprites SDK is imported only by the Computer host", () => {
+    const { output, exitCode } = runCheck(repoRoot);
+    expect(output).toContain("Computer host import contract passed");
+    expect(exitCode).toBe(0);
+  });
+
+  test("the check refuses a static import outside the Computer host", () => {
+    const root = fixtureRepo({
+      "packages/example/package.json": JSON.stringify({ name: "example" }),
+      "packages/example/src/index.ts": `import { SpritesClient } from "${SDK}";\n`,
+    });
+    const { output, exitCode } = runCheck(root);
+    expect(exitCode).toBe(1);
+    expect(output).toContain("packages/example/src/index.ts:1");
+    expect(output).toContain(SDK);
+  });
+
+  test("the check refuses a dynamic import and a Vue single-file component", () => {
+    const root = fixtureRepo({
+      "packages/example/package.json": JSON.stringify({ name: "example" }),
+      "packages/example/src/lazy.ts": `export const sdk = () => import("${SDK}/exec");\n`,
+      "packages/example/src/Panel.vue": `<script setup lang="ts">\nimport { SpritesClient } from "${SDK}";\n</script>\n`,
+    });
+    const { output, exitCode } = runCheck(root);
+    expect(exitCode).toBe(1);
+    expect(output).toContain("packages/example/src/lazy.ts");
+    expect(output).toContain("packages/example/src/Panel.vue");
+  });
+
+  test("the check refuses a manifest that declares the SDK outside the host", () => {
+    const root = fixtureRepo({
+      "apps/cloudflare/package.json": JSON.stringify({
+        name: "cloudflare",
+        devDependencies: { [SDK]: "0.1.0" },
+      }),
+    });
+    const { output, exitCode } = runCheck(root);
+    expect(exitCode).toBe(1);
+    expect(output).toContain("apps/cloudflare/package.json");
+    expect(output).toContain("devDependencies");
+  });
+
+  test("the Computer host itself may import the SDK and declare it", () => {
+    const root = fixtureRepo({
+      "apps/computer-host/package.json": JSON.stringify({
+        name: "computer-host",
+        dependencies: { [SDK]: "0.1.0" },
+      }),
+      "apps/computer-host/container/server.ts": `import { SpritesClient } from "${SDK}";\n`,
+      "apps/computer-host/container/package.json": JSON.stringify({
+        name: "container",
+        dependencies: { [SDK]: "0.1.0" },
+      }),
+    });
+    const { output, exitCode } = runCheck(root);
+    expect(output).toContain("Computer host import contract passed");
+    expect(exitCode).toBe(0);
+  });
+});

package/src/desktop-provider-boundaries.test.ts

@@ -0,0 +1,157 @@
+// Constitutional check — "Provider types stay in their adapter".
+//
+// The registered machine's agent is the first Package that can run a shell
+// command on somebody's laptop, and the rule that keeps that honest is where
+// the two dangerous imports may appear:
+//
+//   * `electron` — the widest authority FrockBot has — only inside the Electron
+//     main process and its preload, which is `apps/desktop/src` (and the
+//     Electron proof-of-concept app that exists to exercise it).
+//   * `child_process` — only in the Electron main process, where a
+//     `trusted-main` desktop Contribution reaches it through a capability, and
+//     in the end-to-end harness that starts the dev server.
+//
+// No Package under `packages/` may import either. That is what makes
+// `@frockbot/plugin-user-machine`'s agent loop testable in CI: it cannot
+// silently acquire a process to spawn, so every decision it makes has to be
+// expressible over an injected seam.
+//
+// Like the other authority checks, the rule is a pure function of a scan so a
+// violation can be staged without writing one into this tree.
+
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const repoRoot = resolve(import.meta.dirname, "..", "..", "..");
+
+/** Spelled in halves so this file is not itself a violation of its own rule. */
+const ELECTRON = ["elec", "tron"].join("");
+const CHILD_PROCESS = ["child", "_process"].join("");
+
+interface ScannedSource {
+  /** Repo-relative path. */
+  path: string;
+  /** Every module specifier the file imports or requires. */
+  specifiers: string[];
+}
+
+const SPECIFIER = /(?:from|import|require\()\s*["']([^"']+)["']/g;
+
+function scanSources(): ScannedSource[] {
+  return [
+    ...new Bun.Glob("{packages,apps,applications}/**/*.{ts,vue}").scanSync({
+      cwd: repoRoot,
+    }),
+  ]
+    .filter((path) => !path.includes("node_modules/"))
+    .filter((path) => !path.includes("/dist/"))
+    .filter((path) => !path.includes("/out/"))
+    .sort()
+    .map((path) => {
+      const source = readFileSync(resolve(repoRoot, path), "utf8");
+      return {
+        path,
+        specifiers: [...source.matchAll(SPECIFIER)].map((match) => match[1]!),
+      };
+    });
+}
+
+/** Where each dangerous import is permitted, and nowhere else. */
+const ALLOWED = {
+  electron: [/^apps\/desktop\/src\//, /^apps\/cordis-poc\/src\//],
+  childProcess: [
+    /^apps\/desktop\/src\/main\//,
+    // The Playwright harness starts `wrangler dev`; it is a test runner, not a
+    // Package, and it never ships.
+    /^apps\/cloudflare\/e2e\//,
+  ],
+} as const;
+
+export function desktopProviderOffenders(
+  sources: readonly ScannedSource[],
+): string[] {
+  const offenders: string[] = [];
+  for (const { path, specifiers } of sources) {
+    for (const specifier of specifiers) {
+      const electron =
+        specifier === ELECTRON || specifier.startsWith(`${ELECTRON}/`);
+      const child =
+        specifier === CHILD_PROCESS || specifier === `node:${CHILD_PROCESS}`;
+      if (!electron && !child) continue;
+      const allowed = electron ? ALLOWED.electron : ALLOWED.childProcess;
+      if (allowed.some((pattern) => pattern.test(path))) continue;
+      offenders.push(`${path}: ${specifier}`);
+    }
+  }
+  return offenders;
+}
+
+describe("desktop provider boundaries", () => {
+  test("Electron and child_process are imported only where they may be", () => {
+    expect(desktopProviderOffenders(scanSources())).toEqual([]);
+  });
+
+  test("no Package under packages/ reaches either of them", () => {
+    const offenders = scanSources()
+      .filter((source) => source.path.startsWith("packages/"))
+      .flatMap((source) =>
+        source.specifiers
+          .filter(
+            (specifier) =>
+              specifier === ELECTRON ||
+              specifier.startsWith(`${ELECTRON}/`) ||
+              specifier === CHILD_PROCESS ||
+              specifier === `node:${CHILD_PROCESS}`,
+          )
+          .map((specifier) => `${source.path}: ${specifier}`),
+      );
+    expect(offenders).toEqual([]);
+  });
+
+  test("the rule bites on a staged violation", () => {
+    expect(
+      desktopProviderOffenders([
+        {
+          path: "packages/plugin-user-machine/src/desktop.ts",
+          specifiers: [`node:${CHILD_PROCESS}`, "@frockbot/desktop-core"],
+        },
+        {
+          path: "packages/plugin-user-machine/src/device.ts",
+          specifiers: [ELECTRON],
+        },
+        {
+          path: "apps/cloudflare/src/index.ts",
+          specifiers: [`${ELECTRON}/main`],
+        },
+        // Permitted, and must stay permitted.
+        {
+          path: "apps/desktop/src/main/machine-host.ts",
+          specifiers: [`node:${CHILD_PROCESS}`],
+        },
+        {
+          path: "apps/desktop/src/preload/index.ts",
+          specifiers: [ELECTRON],
+        },
+      ]),
+    ).toEqual([
+      `packages/plugin-user-machine/src/desktop.ts: node:${CHILD_PROCESS}`,
+      `packages/plugin-user-machine/src/device.ts: ${ELECTRON}`,
+      `apps/cloudflare/src/index.ts: ${ELECTRON}/main`,
+    ]);
+  });
+
+  test("a lookalike specifier is not the real thing", () => {
+    expect(
+      desktopProviderOffenders([
+        {
+          path: "apps/cloudflare/src/index.ts",
+          specifiers: [
+            `@better-auth/${ELECTRON}/client`,
+            `${CHILD_PROCESS}-promise`,
+          ],
+        },
+      ]),
+    ).toEqual([]);
+  });
+});

package/src/kernel-boundaries.test.ts

@@ -0,0 +1,139 @@
+// Constitutional checks that are pure source-graph facts: what the kernel may
+// import, what a client bundle or protocol may carry, and what core runtime
+// code may depend on. Each rule is one named test so `docs/architecture-checks.md`
+// can point at it.
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const repoRoot = resolve(import.meta.dirname, "..", "..", "..");
+
+function sourceFiles(...patterns: string[]): string[] {
+  const files: string[] = [];
+  for (const pattern of patterns) {
+    files.push(
+      ...new Bun.Glob(pattern).scanSync({
+        cwd: repoRoot,
+        onlyFiles: true,
+      }),
+    );
+  }
+  return files
+    .filter((path) => !path.includes("node_modules/"))
+    .filter((path) => !path.includes("/dist/"))
+    .sort();
+}
+
+function read(path: string): string {
+  return readFileSync(join(repoRoot, path), "utf8");
+}
+
+describe("kernel boundaries", () => {
+  // Constitution — Minimal kernel: "The kernel imports no Package and contains
+  // no product policy."
+  test("the kernel imports no Package", async () => {
+    const check = Bun.spawnSync({
+      cmd: ["bun", "scripts/check-kernel-imports.ts"],
+      cwd: repoRoot,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const output = `${check.stdout.toString()}${check.stderr.toString()}`;
+    expect(output).toContain("Kernel import contract passed");
+    expect(check.exitCode).toBe(0);
+    await Promise.resolve();
+  });
+
+  // Constitution — Architecture checks: "two provider Packages satisfy the
+  // model interface with no kernel diff". The behavioural half is in
+  // model-interface.test.ts; this is the source half.
+  test("no kernel source names a model provider Package", () => {
+    const providerTerms = [
+      "provider-foundation",
+      "provider-ollama-cloud",
+      "openai-compatible",
+      "ollama.com",
+    ];
+    const offenders: string[] = [];
+    for (const path of sourceFiles("packages/kernel-*/src/**/*.ts")) {
+      if (path.endsWith(".test.ts")) continue;
+      const source = read(path);
+      for (const term of providerTerms) {
+        if (source.includes(term)) offenders.push(`${path}: ${term}`);
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+
+  // Constitution — Explicit seams: "Core and runtime modules are independent of
+  // Electron and client-framework authority."
+  test("core runtime code has no Electron dependency", () => {
+    const offenders: string[] = [];
+    for (const path of sourceFiles(
+      "packages/kernel-*/src/**/*.ts",
+      "packages/client-core/src/**/*.ts",
+      "packages/configuration-core/src/**/*.ts",
+      "packages/connection-core/src/**/*.ts",
+      "packages/computer-core/src/**/*.ts",
+      "packages/protocol/src/**/*.ts",
+      "packages/plugin-shell/src/backend*.ts",
+      "packages/plugin-settings/src/backend*.ts",
+      "applications/foundation/src/runtime.ts",
+      "applications/foundation/src/user.ts",
+      "apps/cloudflare/src/**/*.ts",
+    )) {
+      if (/from\s+"electron(\/|")/.test(read(path))) offenders.push(path);
+    }
+    expect(offenders).toEqual([]);
+
+    const manifests = [
+      "packages/kernel-contracts",
+      "packages/kernel-agent-loop",
+      "packages/kernel-composition",
+      "packages/kernel-do",
+      "packages/client-core",
+      "packages/protocol",
+      "packages/plugin-shell",
+      "applications/foundation",
+      "apps/cloudflare",
+    ];
+    for (const manifest of manifests) {
+      const declared = read(`${manifest}/package.json`);
+      expect({ manifest, electron: declared.includes('"electron"') }).toEqual({
+        manifest,
+        electron: false,
+      });
+    }
+  });
+
+  // Constitution — Plugin-owned integrations: "Secrets remain server-side and
+  // cross interfaces only as opaque references when necessary."
+  test("client bundles and protocols contain no secrets", () => {
+    const secretNames = [
+      "CREDENTIAL_KEYRING",
+      "BETTER_AUTH_SECRET",
+      "GOOGLE_CLIENT_SECRET",
+      "SPRITES_TOKEN",
+      "OLLAMA_API_KEY",
+    ];
+    const offenders: string[] = [];
+    for (const path of sourceFiles(
+      "packages/*/src/client/**/*.{ts,vue}",
+      "packages/client-core/src/**/*.ts",
+      "packages/client-ui/src/**/*.{ts,vue}",
+      "packages/protocol/src/**/*.ts",
+      "packages/webui-shell/src/**/*.{ts,vue}",
+    )) {
+      if (path.endsWith(".test.ts")) continue;
+      const source = read(path);
+      for (const name of secretNames) {
+        if (source.includes(name)) offenders.push(`${path}: ${name}`);
+      }
+      // A client may name a credential slot, never carry its plaintext.
+      if (/plaintextCredential|apiKeyPlaintext|credentialSecret/.test(source)) {
+        offenders.push(`${path}: plaintext credential field`);
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+});

package/src/memory-boundaries.test.ts

@@ -0,0 +1,208 @@
+// Constitution — Architecture checks: "Memory is readable and writable with no
+// Computer interface call".
+//
+// The Computer is assigned and its tools are mounted, so the Turn *could*
+// reach it. Every entry point of the provider-neutral Computer interface
+// records itself, and a whole Memory cycle — write, read, inject, forget —
+// runs through the Memory Package. The check is that not one of those
+// recordings happens.
+import { describe, expect, test } from "bun:test";
+import {
+  ComputerRegistry,
+  type ComputerProvider,
+} from "@frockbot/computer-core";
+import { AgentRegistry } from "@frockbot/kernel-agent-loop/agent";
+import { AgentLoop } from "@frockbot/kernel-agent-loop";
+import {
+  SessionStore,
+  type LlmProvider,
+  type NormalizedModelRequest,
+} from "@frockbot/kernel-contracts";
+import { createComputerAgentPlugin } from "@frockbot/plugin-computer/agent";
+import {
+  botMemoryRootV1,
+  createMemoryRuntimePlugin,
+  createTestMemoryFilesV1,
+  MemoryStore,
+  userMemoryRootV1,
+} from "@frockbot/plugin-memory";
+import { LlmRegistry } from "@frockbot/plugin-models";
+import { SystemPromptRegistry } from "@frockbot/plugin-prompt";
+import { ToolRegistry } from "@frockbot/plugin-tools";
+import { Context, type Plugin } from "cordis";
+
+const COMPOSITION = {
+  generationId: "1970-01-01T00:00:00.000Z:0123456789abcdef",
+  artifactSetHash: "a".repeat(64),
+};
+
+describe("Memory boundaries", () => {
+  test("Memory is readable and writable with no Computer interface call", async () => {
+    const computerCalls: string[] = [];
+    const provider: ComputerProvider = {
+      id: "recording",
+      open: (identity, tenant, assignment) => {
+        computerCalls.push(`open:${identity.userId}:${tenant.botId}`);
+        return Promise.resolve({
+          assignment,
+          identity,
+          tenant,
+          exec: {
+            execute: () => {
+              computerCalls.push("exec");
+              return Promise.resolve({
+                exitCode: 0,
+                stdout: new Uint8Array(),
+                stderr: new Uint8Array(),
+                outputTruncated: false,
+              });
+            },
+          },
+          browser: {
+            perform: () => {
+              computerCalls.push("browser");
+              return Promise.resolve({ accessibilitySnapshot: "" });
+            },
+          },
+          close: () => Promise.resolve(),
+        });
+      },
+    };
+
+    const owner = { userId: "user-1", botId: "bot-1" };
+    const files = createTestMemoryFilesV1({ userId: owner.userId });
+    const store = new MemoryStore({ files, owner });
+    const writer = {
+      kind: "bot" as const,
+      botId: owner.botId,
+      sessionId: "user-1:bot-1",
+      turnId: "turn-0",
+      runId: "run-0",
+    };
+
+    // WRITE — the Bot's own root and its shard of the shared User root.
+    expect(
+      (
+        await store.write({
+          root: botMemoryRootV1(owner),
+          tier: "profile",
+          fact: "Tim prefers blunt answers.",
+          writer,
+        })
+      ).status,
+    ).toBe("ok");
+    expect(
+      (
+        await store.write({
+          root: userMemoryRootV1(owner),
+          tier: "log",
+          fact: "The gym build starts in spring.",
+          writer,
+        })
+      ).status,
+    ).toBe("ok");
+
+    // READ — both tiers, merged.
+    expect((await store.read(botMemoryRootV1(owner))).profile).toHaveLength(1);
+    expect((await store.read(userMemoryRootV1(owner))).recent).toHaveLength(1);
+
+    const requests: NormalizedModelRequest[] = [];
+    const model: LlmProvider = {
+      id: "memory-reader",
+      async *stream(request) {
+        requests.push(request);
+        yield { type: "text-delta", text: "read" };
+        yield { type: "finish", reason: "completed" };
+      },
+    };
+
+    const root = new Context();
+    await root.plugin(SessionStore, {});
+    await root.plugin(SystemPromptRegistry);
+    await root.plugin(LlmRegistry);
+    await root.plugin(ToolRegistry);
+    await root.plugin(ComputerRegistry);
+    await root.plugin(AgentRegistry);
+    const providerPlugin: Plugin.Function = (ctx) => {
+      const disposeModel = ctx.llm.register(model);
+      const disposeComputer = ctx.computers.register(provider);
+      return () => {
+        disposeComputer();
+        disposeModel();
+      };
+    };
+    providerPlugin.inject = ["llm", "computers"];
+    await root.plugin(providerPlugin);
+    await root.plugin(
+      createComputerAgentPlugin({
+        userId: owner.userId,
+        defaultProviderId: "recording",
+      }),
+    );
+    await root.plugin(
+      createMemoryRuntimePlugin({
+        owner,
+        store,
+        writer: { sessionId: "user-1:bot-1", turnId: "turn-1", runId: "run-1" },
+      }),
+    );
+    await root.plugin(AgentLoop, { maxSteps: 2, composition: COMPOSITION });
+
+    // The Computer tools really are mounted: this Turn simply never uses them.
+    expect(
+      root.tools.schemas({ turnType: "chat" }).map((schema) => schema.name),
+    ).toContain("computer_exec");
+    expect(
+      root.tools.schemas({ turnType: "chat" }).map((schema) => schema.name),
+    ).toEqual(
+      expect.arrayContaining([
+        "memory_write",
+        "memory_forget",
+        "memory_search",
+        "memory_rebuild_index",
+      ]),
+    );
+
+    const handle = await root.agents.create({
+      botId: owner.botId,
+      sessionId: "user-1:bot-1",
+      provider: model.id,
+      model: "test-model",
+      admitEffect: () => Promise.resolve(true),
+    });
+    handle.agent.send("What do you remember?");
+    await handle.agent.whenIdle();
+
+    // INJECT — both tiers reached the model request, in GrokBot's shape.
+    const system = requests.at(0)?.system ?? "";
+    expect(system).toContain("User memory:");
+    expect(system).toContain("Memory:");
+    expect(system).toContain("Tim prefers blunt answers.");
+    expect(system).toContain("[via bot-1] The gym build starts in spring.");
+
+    // …and it is recorded in durable state, generations included.
+    const injected = handle.agent.session.events.find(
+      (event) => event.type === "memory/injected",
+    );
+    if (injected?.type !== "memory/injected") throw new Error("unreachable");
+    expect(injected.facts.map((fact) => fact.text).sort()).toEqual([
+      "The gym build starts in spring.",
+      "Tim prefers blunt answers.",
+    ]);
+    expect(injected.sources.every((source) => source.generationId)).toBe(true);
+
+    // FORGET — the last leg of the cycle, still with no Computer.
+    expect(
+      (
+        await store.forget({
+          root: botMemoryRootV1(owner),
+          fact: "Tim prefers blunt answers.",
+          writer,
+        })
+      ).status,
+    ).toBe("ok");
+
+    expect(computerCalls).toEqual([]);
+    await root.fiber.dispose();
+  });
+});