@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/read-copy-composer.test.ts

@@ -0,0 +1,388 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, test } from "vitest";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { commitFiles } from "@fungi.computer/agar/git-commit";
+import {
+  countingGit,
+  ReadCopyBudgetExceeded,
+} from "@fungi.computer/agar/read-copy";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+import { gitStore, readCopyFrame } from "../backend/git.js";
+import { BonsaiState, ensureBonsaiTables } from "../backend/state.js";
+import { appBackend } from "../backend/methods.js";
+import { observePush } from "../backend/service.js";
+import { getRepoDetail } from "../backend/repository-copy.js";
+import {
+  listFilesCopy,
+  listTreeCopy,
+  readFileCopy,
+} from "../backend/files-copy.js";
+import {
+  readGraph,
+  readCommits,
+  readCommitDetail,
+} from "../backend/graph-commit-copies.js";
+import { commitDetail, graph, type JsonValue } from "../shared/contract.js";
+import { copyRebuildPage, fileList } from "@fungi.computer/agar/roles/files";
+
+const actor = {
+  actor: { kind: "member" as const, memberId: "owner" },
+  computerId: null,
+};
+const author = { name: "Morel", email: "morel@test.invalid" };
+const text = (value: string) => new TextEncoder().encode(value);
+
+async function fixture() {
+  const provider = realGit();
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const state = new BonsaiState(owner.sql, owner.transactionSync);
+  await provider.git.create("pond");
+  state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const written = await commitFiles(provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: null,
+    changes: [{ path: "README.md", content: text("Pond\n") }],
+    message: "Plant pond",
+    author,
+  });
+  if (written.kind !== "committed") throw new Error("Fixture commit failed");
+  const lifetime = new AbortController();
+  const counted = countingGit(provider.git, {
+    limit: 10000,
+    signal: lifetime.signal,
+  });
+  const runtime = {
+    state,
+    store: gitStore(counted.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  await getRepoDetail(runtime, "pond");
+  await readCopyFrame(runtime.store, async (store) => {
+    const bounded = { ...runtime, store };
+    await listFilesCopy(bounded, { repo: "pond", ref: "main" });
+    await listTreeCopy(bounded, { repo: "pond", ref: "main", path: "" });
+    await readFileCopy(bounded, {
+      repo: "pond",
+      ref: "main",
+      path: "README.md",
+    });
+    await readGraph(bounded, "pond");
+    await readCommits(bounded, { repo: "pond", ref: "main" });
+    await readCommitDetail(bounded, { repo: "pond", hash: written.commit });
+  });
+  const reopen = () => ({
+    ...runtime,
+    state: new BonsaiState(owner.sql, owner.transactionSync),
+  });
+  const call = (method: string, input: JsonValue, bonsai = runtime) =>
+    appBackend.call(method, input, { bonsai }, actor);
+  return {
+    provider,
+    counted,
+    runtime,
+    hash: written.commit,
+    reopen,
+    call,
+    close() {
+      lifetime.abort();
+      database.close();
+      provider.close();
+    },
+  };
+}
+
+const mutableReads = [
+  ["files.list", { repo: "pond", ref: "main" }],
+  ["files.tree", { repo: "pond", ref: "main", path: "" }],
+  ["files.read", { repo: "pond", ref: "main", path: "README.md" }],
+  ["graph.get", { repo: "pond" }],
+  ["commits.list", { repo: "pond", ref: "main" }],
+] satisfies [string, JsonValue][];
+
+test("public Files and Graph/Commits methods use ready copies after SQLite reconstruction with zero Git", async () => {
+  const f = await fixture();
+  try {
+    const runtime = f.reopen();
+    const before = f.counted.total();
+    for (const [method, input] of mutableReads) {
+      expect(await f.call(method, input, runtime)).not.toMatchObject({
+        kind: "rebuilding",
+      });
+    }
+    expect(
+      await f.call("commits.get", { repo: "pond", hash: f.hash }, runtime),
+    ).toMatchObject({ commit: { hash: f.hash } });
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("a push exhausting before metadata blocks every later mutable view after reopen and foreground pages recover it", async () => {
+  const f = await fixture();
+  try {
+    const written = await commitFiles(f.provider.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: f.hash,
+      changes: [
+        { path: "README.md", content: text("New pond\n") },
+        ...Array.from({ length: 60 }, (_, i) => ({
+          path: `dir${String(i)}/fish.txt`,
+          content: text(`Fish ${String(i)}\n`),
+        })),
+      ],
+      message: "Grow pond",
+      author,
+    });
+    if (written.kind !== "committed")
+      throw new Error("Large fixture commit failed");
+    const before = f.counted.total();
+    await expect(
+      observePush(f.runtime, {
+        repository: "pond",
+        writer: { kind: "actor", actor: actor.actor },
+        eventId: "grow-pond",
+        updates: [
+          { ref: "refs/heads/main", before: f.hash, after: written.commit },
+        ],
+      }),
+    ).rejects.toBeInstanceOf(ReadCopyBudgetExceeded);
+    expect(f.counted.total() - before).toBeLessThanOrEqual(40);
+    const runtime = f.reopen();
+    // Retain the OLD ready metadata to prove the pending gate, not just a missing row.
+    expect(runtime.state.repositoryCopies.read("pond")).toMatchObject({
+      kind: "ready",
+      head: f.hash,
+    });
+    const blockedAt = f.counted.total();
+    for (const [method, input] of mutableReads)
+      expect(await f.call(method, input, runtime)).toEqual({
+        kind: "rebuilding",
+      });
+    expect(f.counted.total() - blockedAt).toBe(0);
+    expect(
+      await f.call("commits.get", { repo: "pond", hash: f.hash }, runtime),
+    ).toMatchObject({ commit: { hash: f.hash } });
+    let cursor: string | null = null;
+    let done = false;
+    let pages = 0;
+    while (!done && pages < 30) {
+      const start = f.counted.total();
+      const page = copyRebuildPage.parse(
+        await f.call("rebuildCopies", { cursor }, runtime),
+      );
+      expect(f.counted.total() - start).toBeLessThanOrEqual(40);
+      cursor = page.cursor;
+      done = page.done;
+      pages++;
+    }
+    expect(done).toBe(true);
+    expect(runtime.state.repositoryRefStatus("pond").pending).toBe(false);
+    const readyAt = f.counted.total();
+    expect(
+      fileList.parse(
+        await f.call("files.list", { repo: "pond", ref: "main" }, runtime),
+      ).commit.hash,
+    ).toBe(written.commit);
+    expect(
+      await f.call(
+        "files.read",
+        { repo: "pond", ref: "main", path: "README.md" },
+        runtime,
+      ),
+    ).toMatchObject({ text: "New pond\n" });
+    expect(
+      await f.call(
+        "files.tree",
+        { repo: "pond", ref: "main", path: "" },
+        runtime,
+      ),
+    ).toMatchObject({ commit: { hash: written.commit } });
+    expect(
+      graph.parse(await f.call("graph.get", { repo: "pond" }, runtime)).lanes[0]
+        ?.head,
+    ).toBe(written.commit);
+    expect(
+      await f.call("commits.list", { repo: "pond", ref: "main" }, runtime),
+    ).toMatchObject({
+      commits: [
+        { commit: { hash: written.commit } },
+        { commit: { hash: f.hash } },
+      ],
+    });
+    expect(
+      await f.call(
+        "commits.get",
+        { repo: "pond", hash: written.commit },
+        runtime,
+      ),
+    ).toMatchObject({ commit: { hash: written.commit } });
+    expect(f.counted.total() - readyAt).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("a cold public Commit detail exhausting its frame returns rebuilding without a partial result", async () => {
+  const f = await fixture();
+  try {
+    const written = await commitFiles(f.provider.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: f.hash,
+      changes: Array.from({ length: 60 }, (_, i) => ({
+        path: `fish-${String(i)}.txt`,
+        content: text(`Fish ${String(i)}\n`),
+      })),
+      message: "More fish",
+      author,
+    });
+    if (written.kind !== "committed")
+      throw new Error("Large fixture commit failed");
+    const before = f.counted.total();
+    expect(
+      await f.call("commits.get", { repo: "pond", hash: written.commit }),
+    ).toEqual({ kind: "rebuilding" });
+    expect(f.counted.total() - before).toBeLessThanOrEqual(40);
+  } finally {
+    f.close();
+  }
+});
+
+/** A fresh repository whose first push is a whole App tree: too large for one
+ * frame to observe, and too large for one commit diff row to hold every text. */
+async function wholeTreeRepository() {
+  const provider = realGit();
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const state = new BonsaiState(owner.sql, owner.transactionSync);
+  await provider.git.create("app");
+  state.registerRepo({
+    name: "app",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const page = "x".repeat(13_000);
+  const written = await commitFiles(provider.git, {
+    repository: "app",
+    branch: "main",
+    expectedHead: null,
+    changes: Array.from({ length: 64 }, (_, i) => ({
+      path: `pkg${String(i % 16)}/src/file${String(i)}.ts`,
+      content: text(`// ${String(i)}\n${page}\n`),
+    })),
+    message: "Whole App",
+    author,
+  });
+  if (written.kind !== "committed") throw new Error("Whole tree commit failed");
+  // A provider that answers after a delay, as a remote one does: every read
+  // a frame launches is still in flight when its budget runs out.
+  const later = <T>(value: () => Promise<T>) =>
+    new Promise<T>((resolve, reject) => {
+      setTimeout(() => {
+        value().then(resolve, reject);
+      }, 2);
+    });
+  const remote: typeof provider.git = {
+    ...provider.git,
+    readTree: (...args) => later(() => provider.git.readTree(...args)),
+    readBlob: (...args) => later(() => provider.git.readBlob(...args)),
+    readCommit: (...args) => later(() => provider.git.readCommit(...args)),
+  };
+  const runtime = {
+    state,
+    store: gitStore(remote),
+    events: { emit: () => Promise.resolve() },
+  };
+  const call = (method: string, input: JsonValue) =>
+    appBackend.call(method, input, { bonsai: runtime }, actor);
+  return {
+    provider,
+    runtime,
+    head: written.commit,
+    call,
+    close() {
+      database.close();
+      provider.close();
+    },
+  };
+}
+
+const zero = "0".repeat(40);
+
+test("a fresh repository's whole-tree first push recovers through foreground pages", async () => {
+  // Each page reads Git, which the host grants only to a method declaring it.
+  expect(appBackend.methods.rebuildCopies?.policy.requires).toContain(
+    "git.repository",
+  );
+  const f = await wholeTreeRepository();
+  try {
+    await expect(
+      observePush(f.runtime, {
+        repository: "app",
+        writer: { kind: "actor", actor: actor.actor },
+        eventId: "whole-tree",
+        updates: [{ ref: "refs/heads/main", before: zero, after: f.head }],
+      }),
+    ).rejects.toBeInstanceOf(ReadCopyBudgetExceeded);
+    let cursor: string | null = null;
+    let done = false;
+    for (let pages = 0; !done && pages < 60; pages++) {
+      const page = copyRebuildPage.parse(
+        await f.call("rebuildCopies", { cursor }),
+      );
+      cursor = page.cursor;
+      done = page.done;
+    }
+    expect(done).toBe(true);
+    // The root commit's diff fits its copy row: texts that would not fit are
+    // listed as too large to show, with their line counts.
+    const detail = commitDetail.parse(
+      await f.call("commits.get", { repo: "app", hash: f.head }),
+    );
+    expect(detail.diff.files.some((file) => file.truncated)).toBe(true);
+    expect(detail.diff.files.some((file) => file.newText !== null)).toBe(true);
+  } finally {
+    f.close();
+  }
+});
+
+test("a new branch's push diffs against the default head within one frame", async () => {
+  const f = await wholeTreeRepository();
+  try {
+    await getRepoDetail(f.runtime, "app");
+    const edited = await commitFiles(f.provider.git, {
+      repository: "app",
+      branch: "edit",
+      expectedHead: null,
+      startFrom: "main",
+      changes: [{ path: "pkg0/src/file0.ts", content: text("// edited\n") }],
+      message: "Edit one file",
+      author,
+    });
+    if (edited.kind !== "committed") throw new Error("Edit commit failed");
+    await observePush(f.runtime, {
+      repository: "app",
+      writer: { kind: "actor", actor: actor.actor },
+      eventId: "new-branch",
+      updates: [{ ref: "refs/heads/edit", before: zero, after: edited.commit }],
+    });
+    const detail = await getRepoDetail(f.runtime, "app");
+    expect(detail.refs).toContainEqual(
+      expect.objectContaining({ name: "refs/heads/edit", hash: edited.commit }),
+    );
+  } finally {
+    f.close();
+  }
+});

package/test/read-copy-lifetimes.test.ts

@@ -0,0 +1,214 @@
+import { DatabaseSync } from "node:sqlite";
+import { rmSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { expect, it } from "vitest";
+import { commitFiles } from "@fungi.computer/agar/git-commit";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+import { observePush } from "../backend/service.js";
+import { commitDetail, jsonValue, type JsonValue } from "../shared/contract.js";
+import { commitPage } from "@fungi.computer/agar/roles/files";
+import { appBackend } from "../backend/methods.js";
+import { gitStore } from "../backend/git.js";
+import { getRepoDetail } from "../backend/repository-copy.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import { invalidateFilesCopies } from "../backend/files-copy.js";
+import { invalidateGraphCommitCopies } from "../backend/graph-commit-copies.js";
+
+const caller = {
+  actor: { kind: "member" as const, memberId: "Levi" },
+  computerId: null,
+  role: "owner" as const,
+};
+const author = { name: "Morel", email: "morel@test.invalid" };
+
+async function fixture() {
+  const provider = realGit();
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const controller = new AbortController();
+  const binding = {
+    ...provider.git,
+    delete: async (name: string) => {
+      if ((await provider.git.info(name)) === null) return false;
+      rmSync(fileURLToPath(await provider.git.cloneUrl(name)), {
+        recursive: true,
+      });
+      return true;
+    },
+  };
+  const counted = countingGit(binding, {
+    limit: 10_000,
+    signal: controller.signal,
+  });
+  const bonsai = {
+    state: new BonsaiState(owner.sql, owner.transactionSync),
+    store: gitStore(counted.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  const registration = {
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  };
+  await provider.git.create("pond");
+  bonsai.state.registerRepo(registration);
+  const result = await commitFiles(provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: null,
+    author,
+    message: "Add fish",
+    changes: [
+      { path: "notes.txt", content: new TextEncoder().encode("Fish\n") },
+    ],
+  });
+  if (result.kind !== "committed") throw new Error("Fixture did not commit");
+  await getRepoDetail(bonsai, "pond");
+  const reopen = () => ({
+    ...bonsai,
+    state: new BonsaiState(owner.sql, owner.transactionSync),
+  });
+  return {
+    bonsai,
+    provider,
+    counted,
+    hash: result.commit,
+    reopen,
+    async recreate() {
+      invalidateFilesCopies(bonsai, "pond");
+      invalidateGraphCommitCopies(bonsai, "pond");
+      bonsai.state.removeRepo("pond");
+      await counted.git.delete("pond");
+      bonsai.state.completeRepoDeletion("pond");
+      await provider.git.create("pond");
+      bonsai.state.registerRepo(registration);
+      const runtime = reopen();
+      await getRepoDetail(runtime, "pond");
+      return runtime;
+    },
+    close() {
+      controller.abort();
+      database.close();
+      provider.close();
+    },
+  };
+}
+
+for (const method of [
+  "files.list",
+  "files.tree",
+  "files.read",
+  "commits.get",
+  "commits.list",
+] as const) {
+  it(`${method} does not serve an old saved OID after deletion and same-name recreation across SQLite reopen`, async () => {
+    const f = await fixture();
+    try {
+      const input =
+        method === "commits.get"
+          ? { repo: "pond", hash: f.hash }
+          : method === "files.list" || method === "commits.list"
+            ? { repo: "pond", ref: f.hash }
+            : {
+                repo: "pond",
+                ref: f.hash,
+                path: method === "files.read" ? "notes.txt" : "",
+              };
+      const first = await appBackend.call(
+        method,
+        input,
+        { bonsai: f.bonsai },
+        caller,
+      );
+      const before = f.counted.total();
+      expect(
+        await appBackend.call(method, input, { bonsai: f.reopen() }, caller),
+      ).toEqual(first);
+      expect(f.counted.total() - before).toBe(0);
+      const recreated = await f.recreate();
+      if (method === "commits.list")
+        await expect(
+          appBackend.call(method, input, { bonsai: recreated }, caller),
+        ).resolves.toEqual({ ref: f.hash, commits: [] });
+      else
+        await expect(
+          appBackend.call(method, input, { bonsai: recreated }, caller),
+        ).rejects.toMatchObject({ code: "not_found" });
+    } finally {
+      f.close();
+    }
+  });
+}
+
+it("keeps saved immutable views warm with zero Git after a normal push and SQLite reopen", async () => {
+  const f = await fixture();
+  try {
+    const reads = [
+      ["files.list", { repo: "pond", ref: f.hash }],
+      ["files.tree", { repo: "pond", ref: f.hash, path: "" }],
+      ["files.read", { repo: "pond", ref: f.hash, path: "notes.txt" }],
+      ["commits.get", { repo: "pond", hash: f.hash }],
+      ["commits.list", { repo: "pond", ref: f.hash }],
+    ] satisfies [string, JsonValue][];
+    const content = (method: string, value: JsonValue) => {
+      if (method === "commits.get") {
+        const detail = commitDetail.parse(value);
+        return { commit: detail.commit, diff: detail.diff };
+      }
+      if (method === "commits.list")
+        return commitPage.parse(value).commits.map((item) => item.commit);
+      return value;
+    };
+    const saved = [];
+    for (const [method, input] of reads)
+      saved.push(
+        content(
+          method,
+          jsonValue.parse(
+            await appBackend.call(method, input, { bonsai: f.bonsai }, caller),
+          ),
+        ),
+      );
+    const result = await commitFiles(f.provider.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: f.hash,
+      author,
+      message: "Add more fish",
+      changes: [
+        { path: "notes.txt", content: new TextEncoder().encode("More fish\n") },
+      ],
+    });
+    if (result.kind !== "committed")
+      throw new Error("Push fixture did not commit");
+    await observePush(f.bonsai, {
+      repository: "pond",
+      writer: { kind: "actor", actor: caller.actor },
+      eventId: "lifetime-push",
+      updates: [
+        { ref: "refs/heads/main", before: f.hash, after: result.commit },
+      ],
+    });
+    const reopened = f.reopen();
+    expect(reopened.state.repositoryGeneration("pond")).toBe(1);
+    const before = f.counted.total();
+    const restored = [];
+    for (const [method, input] of reads)
+      restored.push(
+        content(
+          method,
+          jsonValue.parse(
+            await appBackend.call(method, input, { bonsai: reopened }, caller),
+          ),
+        ),
+      );
+    expect(restored).toEqual(saved);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});

package/test/read-copy-rpc.config.jsonc

@@ -0,0 +1,12 @@
+{
+  "name": "bonsai-read-copy-rpc-proof",
+  "compatibility_date": "2026-09-04",
+  "compatibility_flags": ["nodejs_compat"],
+  "services": [
+    {
+      "binding": "GIT",
+      "service": "bonsai-read-copy-rpc-proof",
+      "entrypoint": "GitRpc",
+    },
+  ],
+}

package/test/read-copy-rpc.native.mjs

@@ -0,0 +1,47 @@
+/** countingGit must accept native RPC methods without dispatching Function.bind remotely. */
+import assert from "node:assert/strict";
+import { URL } from "node:url";
+import { log } from "node:console";
+import { unstable_dev } from "wrangler";
+import * as z from "zod";
+const repository = z.strictObject({
+  name: z.string(),
+  defaultBranch: z.string(),
+  lastPushAt: z.string().nullable(),
+  source: z.string().nullable(),
+});
+const result = z.strictObject({
+  direct: repository,
+  wrapped: repository,
+  total: z.literal(1),
+  counts: z.strictObject({ info: z.literal(1) }),
+  exhausted: z.literal(true),
+  aborted: z.literal(true),
+});
+const worker = await unstable_dev(
+  new URL("./read-copy-rpc.worker.ts", import.meta.url).pathname,
+  {
+    config: new URL("./read-copy-rpc.config.jsonc", import.meta.url).pathname,
+    local: true,
+    ip: "127.0.0.1",
+    port: 0,
+    logLevel: "none",
+    experimental: {
+      disableExperimentalWarning: true,
+      disableDevRegistry: true,
+    },
+  },
+);
+try {
+  const response = await worker.fetch();
+  assert.equal(
+    response.status,
+    200,
+    "countingGit must wrap the real native GIT RPC binding",
+  );
+  const value = result.parse(await response.json());
+  assert.deepEqual(value.direct, value.wrapped);
+  log("PASS: native GIT RPC counting preserves dispatch, budget and abort");
+} finally {
+  await worker.stop();
+}