@ricsam/r5d-worker 0.0.94 → 0.0.96

package/dist/mjs/project-worktrees.mjs

@@ -4,6 +4,12 @@ import os from "node:os";
 import path from "node:path";
 import { gitCredentialUsernameConfigKey, gitTransportSecurityArgs, workerGitProcessEnvironment } from "./git-process-environment.mjs";
 import { validateManagedBranchName } from "./managed-paths.mjs";
+import {
+  canonicalizeLocalProjectMirrorRefs,
+  hashProjectMirrorRefs,
+  PROJECT_MIRROR_REF_PREFIX,
+  PROJECT_SERVER_SYNCED_REF_PREFIX
+} from "./project-mirror-refs-token.mjs";
 import { mirrorWorkingTree } from "./working-tree-mirror.mjs";
 const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
 const PROJECT_WORKTREE_SNAPSHOT_MANIFEST = "transaction.json";
@@ -1241,6 +1247,7 @@ ${deleted.stdout}`)) {
       `Delete hidden project mirror for ${input.branchName}: ${deleted.stderr || deleted.stdout || `git exited ${deleted.exitCode}`}`
     );
   }
+  await gitResultAsync(input.gitDirectory, ["update-ref", "-d", `refs/r5d/mirror/${input.branchName}`]);
 }
 async function pushProjectMirrorHeads(input) {
   const results = [];
@@ -1298,6 +1305,7 @@ async function pushProjectMirrorHeads(input) {
     if (pushed.exitCode !== 0) {
       throw new Error(`Push hidden project mirror for ${branchName}: ${pushed.stderr || pushed.stdout || `git exited ${pushed.exitCode}`}`);
     }
+    await gitAsync(checkoutPath, ["update-ref", `refs/r5d/mirror/${branchName}`, head], `record pushed mirror tip ${branchName}`);
     results.push({ branchName, head, pushed: true });
   }
   return results;
@@ -1310,21 +1318,23 @@ function assertProjectMirrorHeadsPushed(results) {
 }
 async function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  const fetch = await gitResultAsync(
-    primaryPath,
-    [
-      ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-      "fetch",
-      "--no-recurse-submodules",
-      "--prune",
-      input.mirrorUrl,
-      "+refs/heads/*:refs/r5d/mirror/*",
-      "+refs/r5d/server-synced/*:refs/r5d/server-synced/*"
-    ],
-    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
-  );
-  if (fetch.exitCode !== 0)
-    throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
+  if (input.refreshRemote !== false) {
+    const fetch = await gitResultAsync(
+      primaryPath,
+      [
+        ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
+        "fetch",
+        "--no-recurse-submodules",
+        "--prune",
+        input.mirrorUrl,
+        "+refs/heads/*:refs/r5d/mirror/*",
+        "+refs/r5d/server-synced/*:refs/r5d/server-synced/*"
+      ],
+      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+    );
+    if (fetch.exitCode !== 0)
+      throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
+  }
   const observations = [];
   for (const branchName of [...input.branchNames].sort()) {
     const checkoutPath = branchPath(input.projectRoot, branchName);
@@ -1370,6 +1380,24 @@ async function observeProjectMirrorHeads(input) {
   }
   return observations;
 }
+async function computeLocalProjectMirrorRefsToken(input) {
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  const rows = await gitAsync(
+    primaryPath,
+    ["for-each-ref", "--format=%(objectname) %(refname)", PROJECT_MIRROR_REF_PREFIX, PROJECT_SERVER_SYNCED_REF_PREFIX],
+    "list cached project mirror refs"
+  );
+  const refs = rows.split(/\r?\n/).filter(Boolean).map((row) => {
+    const separator = row.indexOf(" ");
+    const objectName = separator < 0 ? "" : row.slice(0, separator);
+    const refname = separator < 0 ? "" : row.slice(separator + 1);
+    if (!/^[0-9a-f]{40,64}$/.test(objectName) || refname.length === 0) {
+      throw new Error(`Invalid cached mirror ref listing row: ${row}`);
+    }
+    return { refname, objectName };
+  });
+  return hashProjectMirrorRefs(canonicalizeLocalProjectMirrorRefs(refs));
+}
 async function applyObservedProjectMirrorHeads(input) {
   const results = [];
   for (const observation of [...input.observations].sort((left, right) => left.branchName.localeCompare(right.branchName))) {
@@ -1451,6 +1479,7 @@ export {
   ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads,
   assertProjectMirrorHeadsPushed,
+  computeLocalProjectMirrorRefsToken,
   createLinkedProjectBranch,
   createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch,

package/dist/mjs/workspace-git-sync.mjs

@@ -1438,13 +1438,38 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
   }
   return { hydratedMountIds: hydratedMountIds.sort(), skippedMountIds: skippedMountIds.sort() };
 }
+async function selectMountsWithUnchangedOuterSubtree(workspacePath, receipt, head, mounts) {
+  const candidates = mounts.flatMap((mount) => {
+    const basisHead = workspaceHydrationReceiptMountBasisHead(receipt, mount);
+    return basisHead && basisHead !== head ? [{ mount, basisHead }] : [];
+  });
+  if (candidates.length === 0) return /* @__PURE__ */ new Set();
+  const objects = await resolveGitObjectIdsAsync(
+    workspacePath,
+    candidates.flatMap(({ mount, basisHead }) => [
+      workspaceTreeObjectName(basisHead, mount.workspaceRelativePath),
+      workspaceTreeObjectName(head, mount.workspaceRelativePath)
+    ])
+  );
+  const unchanged = /* @__PURE__ */ new Set();
+  for (const { mount, basisHead } of candidates) {
+    const before = objects.get(workspaceTreeObjectName(basisHead, mount.workspaceRelativePath)) ?? null;
+    const after = objects.get(workspaceTreeObjectName(head, mount.workspaceRelativePath)) ?? null;
+    if (before === after) unchanged.add(mount.id);
+  }
+  return unchanged;
+}
 async function hydrateWorkspaceGitMountsTransactionally(input) {
   const workspacePath = path.resolve(input.workspacePath);
   const durabilityMounts = input.durabilityMounts ?? input.mounts;
   const receiptMounts = input.receiptMounts ?? durabilityMounts;
   const requiredMounts = input.requiredMounts ?? input.mounts;
+  const carryMounts = input.carryMounts ?? [];
+  if (carryMounts.length > 0 && !input.recordCurrentHead) {
+    throw new Error("Workspace hydration can only carry unchanged mounts while recording the current head");
+  }
   const candidateMounts = [
-    ...new Map([...input.mounts, ...durabilityMounts, ...requiredMounts].map((mount) => [mount.id, mount])).values()
+    ...new Map([...input.mounts, ...durabilityMounts, ...requiredMounts, ...carryMounts].map((mount) => [mount.id, mount])).values()
   ];
   if (input.recordCurrentHead && !await workspaceCheckoutDurabilityIsCurrentAsync(workspacePath)) {
     throw new Error("Workspace checkout is not durably materialized at its current HEAD");
@@ -1460,12 +1485,13 @@ async function hydrateWorkspaceGitMountsTransactionally(input) {
       ({ id }) => !busyMountIds.has(id) && (requestedIds.has(id) || !requiredIds.has(id))
     );
     const unavailableRequiredIds = requiredMounts.filter(({ id }) => busyMountIds.has(id) || !requestedIds.has(id)).map(({ id }) => id);
+    const carriedMounts = carryMounts.filter(({ id }) => !busyMountIds.has(id));
     return {
       busyMountIds,
       hydrationMounts: hydrationMounts2,
       advancedDurabilityMounts: advancedDurabilityMounts2,
       skippedMountIds: [.../* @__PURE__ */ new Set([...busyMountIds, ...unavailableRequiredIds])].sort(),
-      targetReceipt: targetHead ? receiptWithMountsAtHead(receiptBeforeTransaction, targetHead, advancedDurabilityMounts2, receiptMounts) : null
+      targetReceipt: targetHead ? receiptWithMountsAtHead(receiptBeforeTransaction, targetHead, [...advancedDurabilityMounts2, ...carriedMounts], receiptMounts) : null
     };
   };
   const noopCandidate = computeSelection();
@@ -1641,14 +1667,26 @@ async function changedPaths(workspacePath, baseRevision, headRevision) {
   const base = baseRevision ?? emptyTreeHash(workspacePath);
   return (await gitAsync(workspacePath, ["diff", "--name-only", "--no-renames", "-z", base, headRevision], "inspect workspace commit paths")).split("\0").filter(Boolean).sort();
 }
-async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit) {
+async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit, pathspecs = []) {
   const base = baseRevision ?? emptyTreeHash(workspacePath);
-  const subprocess = Bun.spawn(["git", ...NON_RECURSIVE_GIT_CONFIG, "diff", "--binary", "--no-ext-diff", base, headRevision], {
-    cwd: workspacePath,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
+  const subprocess = Bun.spawn(
+    [
+      "git",
+      ...NON_RECURSIVE_GIT_CONFIG,
+      "diff",
+      "--binary",
+      "--no-ext-diff",
+      base,
+      headRevision,
+      ...pathspecs.length > 0 ? ["--", ...pathspecs] : []
+    ],
+    {
+      cwd: workspacePath,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: workerGitProcessEnvironment()
+    }
+  );
   const stderrPromise = new Response(subprocess.stderr).text();
   const reader = subprocess.stdout.getReader();
   let total = 0;
@@ -1668,6 +1706,73 @@ async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit) {
   if (exitCode !== 0) throw new Error(`Measure workspace diff: ${stderr || `git exited ${exitCode}`}`);
   return total;
 }
+async function resolveGitObjectIdsAsync(workspacePath, names) {
+  const resolved = /* @__PURE__ */ new Map();
+  const unique = [...new Set(names)];
+  if (unique.length === 0) return resolved;
+  const subprocess = Bun.spawn(gitCommandArgs(["cat-file", "--batch-check"]), {
+    cwd: workspacePath,
+    stdin: Buffer.from(`${unique.join("\n")}
+`),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: workerGitProcessEnvironment()
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(subprocess.stdout).text(),
+    new Response(subprocess.stderr).text(),
+    subprocess.exited
+  ]);
+  if (exitCode !== 0) throw new Error(`Resolve workspace objects: ${stderr.trim() || `git exited ${exitCode}`}`);
+  const lines = stdout.split("\n").filter((line) => line.length > 0);
+  if (lines.length !== unique.length) {
+    throw new Error(`Resolve workspace objects: expected ${unique.length} results, received ${lines.length}`);
+  }
+  unique.forEach((name, index) => {
+    const match = /^([0-9a-f]{40,64}) \S+ \d+$/.exec(lines[index]);
+    resolved.set(name, match ? match[1] : null);
+  });
+  return resolved;
+}
+function workspaceTreeObjectName(revision, workspaceRelativePath) {
+  return `${revision}:${normalizedWorkspaceMountPath(workspaceRelativePath)}`;
+}
+async function measureInitialPublicationDiffSize(input) {
+  const candidates = input.mounts.filter(
+    (mount) => typeof mount.initialPublicationSourceRelativePath === "string"
+  );
+  if (candidates.length === 0) return null;
+  const revisions = [input.localHead, ...input.remoteHead ? [input.remoteHead] : []];
+  const objects = await resolveGitObjectIdsAsync(
+    input.workspacePath,
+    candidates.flatMap(
+      (mount) => revisions.flatMap((revision) => [
+        workspaceTreeObjectName(revision, mount.workspaceRelativePath),
+        workspaceTreeObjectName(revision, mount.initialPublicationSourceRelativePath)
+      ])
+    )
+  );
+  const lookup = (revision, workspaceRelativePath) => revision ? objects.get(workspaceTreeObjectName(revision, workspaceRelativePath)) ?? null : null;
+  const initialPublications = candidates.flatMap((mount) => {
+    const published = lookup(input.localHead, mount.workspaceRelativePath);
+    if (!published || lookup(input.remoteHead, mount.workspaceRelativePath)) return [];
+    const source = lookup(input.localHead, mount.initialPublicationSourceRelativePath) ?? lookup(input.remoteHead, mount.initialPublicationSourceRelativePath);
+    return [{ mount, published, source }];
+  });
+  if (initialPublications.length === 0) return null;
+  let size = await input.measure(
+    input.workspacePath,
+    input.remoteHead,
+    input.localHead,
+    input.limit,
+    initialPublications.map(({ mount }) => `:(exclude,literal)${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`)
+  );
+  for (const { published, source } of initialPublications) {
+    if (size > input.limit) break;
+    size += await input.measure(input.workspacePath, source, published, input.limit - size);
+  }
+  return { size, mountIds: initialPublications.map(({ mount }) => mount.id).sort() };
+}
 function conflictPaths(workspacePath) {
   const result = gitResult(workspacePath, ["diff", "--name-only", "--diff-filter=U", "-z"]);
   return result.exitCode === 0 ? result.stdout.split("\0").filter(Boolean).sort() : [];
@@ -1895,12 +2000,19 @@ async function synchronizeWorkspaceGit(input) {
     const uncoveredCompletionBasisMounts = completionReceiptMounts.filter(
       (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
     );
+    const unchangedMountIds = currentHeadBeforeHydration ? await selectMountsWithUnchangedOuterSubtree(
+      workspacePath,
+      currentReceiptBeforeHydration,
+      currentHeadBeforeHydration,
+      uncoveredCompletionMounts
+    ) : /* @__PURE__ */ new Set();
     const hydration = await hydrateWorkspaceGitMountsTransactionally({
       workspacePath,
-      mounts: uncoveredCompletionMounts,
-      durabilityMounts: uncoveredCompletionBasisMounts,
+      mounts: uncoveredCompletionMounts.filter(({ id }) => !unchangedMountIds.has(id)),
+      durabilityMounts: uncoveredCompletionBasisMounts.filter(({ id }) => !unchangedMountIds.has(id)),
+      carryMounts: uncoveredCompletionMounts.filter(({ id }) => unchangedMountIds.has(id)),
       receiptMounts: completionReceiptMounts,
-      requiredMounts: uncoveredRequiredLiveMounts,
+      requiredMounts: uncoveredRequiredLiveMounts.filter(({ id }) => !unchangedMountIds.has(id)),
       recordCurrentHead: true
     });
     for (const id of hydration.skippedMountIds) cycleSkippedMountIds.add(id);
@@ -2050,8 +2162,25 @@ async function synchronizeWorkspaceGit(input) {
       };
     }
     const paths = await changedPaths(workspacePath, remoteHead, localHead);
-    const size = paths.length > 0 ? await (input.measureDiffSize ?? diffSizeBytes)(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
+    const measureDiffSize = input.measureDiffSize ?? diffSizeBytes;
+    let size = paths.length > 0 ? await measureDiffSize(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
     input.assertStillAdmitted?.();
+    let initialPublicationMountIds;
+    if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
+      const initialPublication = await measureInitialPublicationDiffSize({
+        workspacePath,
+        remoteHead,
+        localHead,
+        mounts: input.mounts,
+        limit: maxDiffBytes,
+        measure: measureDiffSize
+      });
+      input.assertStillAdmitted?.();
+      if (initialPublication && initialPublication.size <= maxDiffBytes) {
+        size = initialPublication.size;
+        initialPublicationMountIds = initialPublication.mountIds;
+      }
+    }
     if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
       const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones]);
       return {
@@ -2096,7 +2225,9 @@ async function synchronizeWorkspaceGit(input) {
       "push",
       "--no-recurse-submodules"
     ];
-    if (input.allowLargeDiff) pushArgs.push(`--push-option=${WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION}`);
+    if (input.allowLargeDiff || initialPublicationMountIds) {
+      pushArgs.push(`--push-option=${WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION}`);
+    }
     pushArgs.push("origin", `HEAD:refs/heads/${WORKSPACE_GIT_BRANCH}`);
     const push = await gitResultAsync(workspacePath, pushArgs);
     if (push.exitCode === 0) {
@@ -2118,6 +2249,7 @@ async function synchronizeWorkspaceGit(input) {
         diffSizeBytes: size,
         affectedPaths: paths,
         ...completedMounts,
+        ...initialPublicationMountIds ? { initialPublicationMountIds } : {},
         ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         ...projectionWarning ? { error: projectionWarning } : {}
       };

package/dist/types/main.d.ts

@@ -125,6 +125,15 @@ type WorkerServerMessage = {
     confirmationReason?: string;
     resetToCanonical?: boolean;
     requiredAncestorHeads?: string[];
+} | {
+    /**
+     * Content-derived tokens naming each canonical project repository's
+     * observable ref state, keyed by project id. Replace-all: projects
+     * absent from a message have no advertised token and observation falls
+     * back to fetching. See `project-mirror-fetch-policy.ts`.
+     */
+    type: "project_mirror_refs_tokens";
+    tokens: Record<string, string>;
 } | {
     type: "create_project_branch";
     requestId: string;

package/dist/types/project-mirror-fetch-policy.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Decides whether a periodic observation must fetch a project's hidden mirror
+ * or may reuse the locally cached mirror refs. The server advertises a
+ * content-derived token per project (hash of the exact ref namespaces the
+ * observation fetch would transfer); when the advertised token equals the
+ * token the local refs already cover, the fetch would be a no-op.
+ *
+ * Skipping is fail-open: any missing or mismatched information fetches. The
+ * backstop bounds the damage of a server-side token bug (for example a token
+ * computed against the wrong repository path) to one interval; every
+ * git-transport writer is observed by the server's on-disk recompute, so the
+ * backstop is insurance against bugs, not against known unobserved writers.
+ */
+export declare const PROJECT_MIRROR_FETCH_BACKSTOP_MS: number;
+export type ProjectMirrorFetchDecision = {
+    fetch: true;
+    reason: "skipping_disabled" | "no_advertised_token" | "never_fetched" | "token_changed" | "backstop_elapsed";
+} | {
+    fetch: false;
+    reason: "token_match";
+};
+export declare function projectMirrorFetchDecision(input: {
+    advertisedToken: string | undefined;
+    fetchedToken: string | undefined;
+    lastFetchAtMs: number | undefined;
+    nowMs: number;
+    skippingEnabled: boolean;
+    backstopMs?: number;
+}): ProjectMirrorFetchDecision;

package/dist/types/project-mirror-refs-token.d.ts

@@ -0,0 +1,19 @@
+export declare const PROJECT_MIRROR_REF_PREFIX = "refs/r5d/mirror/";
+export declare const PROJECT_SERVER_SYNCED_REF_PREFIX = "refs/r5d/server-synced/";
+export type ProjectMirrorRef = {
+    refname: string;
+    objectName: string;
+};
+/**
+ * Hash a ref listing into a mirror-refs token. Both sides sort here rather
+ * than trusting git's listing order: renaming `refs/r5d/mirror/*` back to
+ * `refs/heads/*` changes sort neighborhoods.
+ */
+export declare function hashProjectMirrorRefs(refs: readonly ProjectMirrorRef[]): string;
+/**
+ * Rename locally fetched mirror refs into the namespaces the server hashes.
+ * Rows outside the two observed namespaces are dropped; the caller lists only
+ * those namespaces, so a dropped row means an unexpected listing, and dropping
+ * it can only make tokens differ — which fails open into a fetch.
+ */
+export declare function canonicalizeLocalProjectMirrorRefs(refs: readonly ProjectMirrorRef[]): ProjectMirrorRef[];

package/dist/types/project-worktrees.d.ts

@@ -212,11 +212,32 @@ export type ProjectMirrorHeadObservation = {
  * Fetch and pin the exact hidden-mirror tips that may be applied after a
  * causally later outer-workspace fetch and hydration. Observation deliberately
  * does not mutate a live branch or its index.
+ *
+ * With `refreshRemote: false` the network fetch is skipped and the tips come
+ * from the locally cached `refs/r5d/mirror/*` / `refs/r5d/server-synced/*`
+ * refs of an earlier fetch. That is safe in the stale direction (a newer
+ * mirror tip waits for a later cycle, exactly like a tip that lands mid-cycle
+ * today) and in the fresh direction (hidden-mirror publication is tree-first,
+ * so any locally cached tip's covering outer tree was published before the
+ * fetch that cached it, hence before this cycle's outer fetch).
  */
 export declare function observeProjectMirrorHeads(input: Omit<ProjectMirrorHeadUpdateInput, "branchMutationAllowed"> & {
     allowNonFastForward: boolean;
     branchIds?: ReadonlyMap<string, string>;
+    refreshRemote?: boolean;
 }): Promise<ProjectMirrorHeadObservation[]>;
+/**
+ * Compute the mirror-refs token for the locally cached mirror state — the
+ * token the server will advertise once it hashes the same refs. After a
+ * successful lease push (which updates `refs/r5d/mirror/*` above), this
+ * matches the server's next advertisement unless something else also moved
+ * the canonical repository, in which case the mismatch fails open into a
+ * fetch. Formula twin: `server/git/project-mirror-refs-token.ts`.
+ */
+export declare function computeLocalProjectMirrorRefsToken(input: {
+    projectRoot: string;
+    primaryBranchName: string;
+}): Promise<string>;
 /** Apply only previously observed object ids; this function never refetches. */
 export declare function applyObservedProjectMirrorHeads(input: {
     projectRoot: string;

package/dist/types/workspace-git-sync.d.ts

@@ -26,6 +26,13 @@ export type WorkspaceGitMount = {
      * This is transient and must clear after that move is published.
      */
     preserveLocalOnHydrationBasisChange?: boolean;
+    /**
+     * Workspace-relative path of the subtree this creator-local mount was copied
+     * from (its source branch checkout). While the mount's own outer subtree is
+     * still unpublished, the automatic diff-size guard measures it against that
+     * source subtree instead of counting the whole copied tree as new content.
+     */
+    initialPublicationSourceRelativePath?: string;
     /** Remove the outer-workspace subtree when the mounted source was intentionally deleted. */
     deleteWhenSourceMissing?: boolean;
     busy?: () => boolean;
@@ -51,10 +58,16 @@ export type WorkspaceGitSyncResult = {
     remoteHead: string | null;
     publishedHead: string | null;
     rebaseCount: number;
+    /**
+     * Bytes the automatic publication guard evaluated. A creator-local branch's
+     * first publication counts only its divergence from the source subtree.
+     */
     diffSizeBytes: number;
     affectedPaths: string[];
     activeMountIds: string[];
     skippedMountIds: string[];
+    /** Creator-local mounts whose first outer publication was measured against their source subtree. */
+    initialPublicationMountIds?: string[];
     conflictPaths?: string[];
     conflictSnapshotRefs?: {
         local: string;
@@ -152,7 +165,7 @@ export declare function resetWorkspaceGit(input: {
     activeMountIds: string[];
     skippedMountIds: string[];
 }>;
-declare function diffSizeBytes(workspacePath: string, baseRevision: string | null, headRevision: string, limit: number): Promise<number>;
+declare function diffSizeBytes(workspacePath: string, baseRevision: string | null, headRevision: string, limit: number, pathspecs?: readonly string[]): Promise<number>;
 export declare function synchronizeWorkspaceGit(input: {
     attemptId?: string;
     workerLabel: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",