@frockbot/computer-core 0.3.16 → 0.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/computer-core",
-  "version": "0.3.16",
+  "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.16",
+    "@frockbot/kernel-contracts": "0.3.18",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/core.ts

@@ -663,7 +663,7 @@ export type ComputerSyncReasonV1 = "open" | "signal" | "turn-end" | "publish";
  * answers `unavailable` and a Turn continues.
  */
 export interface ComputerSyncSummaryV1 {
-  status: "ok" | "unavailable" | "refused" | "skipped";
+  status: "ok" | "degraded" | "unavailable" | "refused" | "skipped";
   /** Human-readable reason, empty when the run had nothing to say. */
   detail: string;
   pulled: number;
@@ -671,6 +671,10 @@ export interface ComputerSyncSummaryV1 {
   restored: number;
   removed: number;
   adopted: number;
+  /** Reproducible directories and durable entries excluded by policy. */
+  ignored: number;
+  /** Manifest entries left out after the scan reached its hard bound. */
+  omitted: number;
   conflicts: number;
   failures: number;
 }
@@ -687,6 +691,8 @@ export function computerSyncSummaryV1(
     restored: 0,
     removed: 0,
     adopted: 0,
+    ignored: 0,
+    omitted: 0,
     conflicts: 0,
     failures: 0,
   };
@@ -720,7 +726,7 @@ export interface ComputerSyncV1 {
   reconcileRoot?(
     root: WorkspaceRootV1,
     reason: ComputerSyncReasonV1,
-    options?: ComputerOperationOptions,
+    options?: ComputerRootSyncOptionsV1,
   ): Promise<ComputerSyncSummaryV1>;
   /**
    * The Computer-side watcher's change signal, or `undefined` when it cannot
@@ -730,6 +736,18 @@ export interface ComputerSyncV1 {
   signal(options?: ComputerOperationOptions): Promise<string | undefined>;
 }
 
+/** Options for the one-root reconciliation used by artifact publishers. */
+export interface ComputerRootSyncOptionsV1 extends ComputerOperationOptions {
+  /**
+   * Exact root-relative files that are required even when they live below a
+   * reproducible directory the ordinary Workspace sync excludes.
+   *
+   * This is a path selection, not a Package exception: the Computer provider
+   * does not learn which caller or Package needs the bytes.
+   */
+  requiredPaths?: readonly string[];
+}
+
 /**
  * What a host supplies so a Computer Package can build the sync: the
  * object-storage side of the durable roots, and the Durable Object records the
@@ -877,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);