@frockbot/computer-core 0.3.17 → 0.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/computer-core",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,7 +12,7 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/kernel-contracts": "0.3.17",
+    "@frockbot/kernel-contracts": "0.3.18",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/core.ts

@@ -895,6 +895,29 @@ function guardedHandle(
             guardedOperation(assertCurrent, () =>
               sync.reconcile(reason, options),
             ),
+          // Forwarded when the provider offers it. Dropping it here is how a
+          // publish's required `dist/` pull was "refused: this Computer cannot
+          // reconcile a single durable root" on production (Bob, 2026-09-04)
+          // while the provider underneath could — and once ordinary sync
+          // stopped carrying `dist/`, that refusal was the whole failure.
+          ...(sync.reconcileRoot
+            ? {
+                reconcileRoot: (
+                  root: Parameters<
+                    NonNullable<ComputerSyncV1["reconcileRoot"]>
+                  >[0],
+                  reason: Parameters<
+                    NonNullable<ComputerSyncV1["reconcileRoot"]>
+                  >[1],
+                  options?: Parameters<
+                    NonNullable<ComputerSyncV1["reconcileRoot"]>
+                  >[2],
+                ) =>
+                  guardedOperation(assertCurrent, () =>
+                    sync.reconcileRoot!(root, reason, options),
+                  ),
+              }
+            : {}),
           signal: (options) =>
             guardedOperation(assertCurrent, () => sync.signal(options)),
         }

package/src/index.test.ts

@@ -230,6 +230,71 @@ describe("ComputerRegistry", () => {
     await root.fiber.dispose();
   });
 
+  test("keeps a provider's single-root reconciliation on the guarded handle", async () => {
+    // Bob on production (2026-09-04): the provider could reconcile one root,
+    // the guarded handle dropped that method, and the publish that needed
+    // `dist/` pulled explicitly was refused as "cannot reconcile a single
+    // durable root" while ordinary sync no longer carried build output.
+    const root = new Context();
+    await root.plugin(ComputerRegistry);
+    const calls: string[] = [];
+    const syncing: ComputerProvider = {
+      id: "sprites",
+      open: async (identity, tenant, assignment) => ({
+        assignment,
+        identity,
+        tenant,
+        sync: {
+          reconcile: async (reason) => {
+            calls.push(`reconcile:${reason}`);
+            return { status: "ok" } as never;
+          },
+          reconcileRoot: async (declared, reason, options) => {
+            calls.push(
+              `root:${reason}:${declared.kind}:${(options?.requiredPaths ?? []).join(",")}`,
+            );
+            return { status: "ok" } as never;
+          },
+          signal: async () => undefined,
+        },
+        close: () => Promise.resolve(),
+      }),
+    };
+    root.computers.register(syncing);
+    const identity = { userId: "user-1" };
+    root.computers.assign(identity, "sprites");
+    const computer = await root.computers.open(identity, { botId: "bot-1" });
+
+    expect(computer.sync?.reconcileRoot).toBeDefined();
+    await computer.sync?.reconcileRoot?.(
+      {
+        kind: "package-declared",
+        userId: "user-1",
+        packageId: "applets",
+        rootId: "source",
+      },
+      "publish",
+      { requiredPaths: ["a.b/dist/server.js"] },
+    );
+    expect(calls).toEqual(["root:publish:package-declared:a.b/dist/server.js"]);
+
+    // Still guarded: a stale handle refuses it like every other operation.
+    root.computers.register({ ...syncing, id: "local" });
+    root.computers.assign(identity, "local");
+    await expect(
+      computer.sync?.reconcileRoot?.(
+        {
+          kind: "package-declared",
+          userId: "user-1",
+          packageId: "applets",
+          rootId: "source",
+        },
+        "publish",
+      ),
+    ).rejects.toMatchObject({ code: "stale-assignment" });
+    await root.fiber.dispose();
+  });
+
   test("fails clearly when a User has no Computer assignment", async () => {
     const root = new Context();
     await root.plugin(ComputerRegistry);