@ricsam/r5d-worker 0.0.95 → 0.0.97

package/dist/cjs/main.cjs

@@ -3824,6 +3824,7 @@ async function startWorker(options) {
         const branchKey = projectBranchKey(project.projectId, branch.branchName);
         const creatorLocalIncarnation = creatorLocalIncarnations.get(branchKey) === branch.branchId;
         const preservesCheckoutPathMove = checkoutPathMoveBranches.has(branchKey);
+        const initialPublicationSourceBranch = creatorLocalIncarnation ? branch.sourceBranchName : null;
         mounts.push({
           id: projectMountId(project.projectId, branch.branchName),
           hydrationIncarnationKey: branch.branchId,
@@ -3833,6 +3834,7 @@ async function startWorker(options) {
           sourceMode: "git",
           hydrateDeletionMode: "git",
           preserveLocalOnInitialOuterAbsence: creatorLocalIncarnation,
+          ...initialPublicationSourceBranch ? { initialPublicationSourceRelativePath: workspaceProjectRelativePath(project.projectId, initialPublicationSourceBranch) } : {},
           preserveLocalOnHydrationBasisChange: preservesCheckoutPathMove,
           busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
@@ -3847,6 +3849,7 @@ async function startWorker(options) {
           sourceMode: "all",
           hydrateDeletionMode: "all",
           preserveLocalOnInitialOuterAbsence: creatorLocalIncarnation,
+          ...initialPublicationSourceBranch ? { initialPublicationSourceRelativePath: workspacePlanRelativePath(project.projectId, initialPublicationSourceBranch) } : {},
           preserveLocalOnHydrationBasisChange: preservesCheckoutPathMove,
           busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
@@ -4446,6 +4449,12 @@ async function startWorker(options) {
       }
     });
     input.assertStillAdmitted?.();
+    if (result.initialPublicationMountIds && result.initialPublicationMountIds.length > 0) {
+      process.stderr.write(
+        `[r5d-worker] published first checkout copies above the automatic diff-size limit, measured against their source subtrees at ${result.diffSizeBytes} bytes: ${result.initialPublicationMountIds.join(", ")}
+`
+      );
+    }
     if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
       await applyObservedProjectHeadsAfterInboundWorkspace(
         observedProjectHeads,

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.95",
+  "version": "0.0.97",
   "type": "commonjs"
 }

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

@@ -1483,13 +1483,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 = import_node_path.default.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");
@@ -1505,12 +1530,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();
@@ -1686,14 +1712,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: (0, import_git_process_environment.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: (0, import_git_process_environment.workerGitProcessEnvironment)()
+    }
+  );
   const stderrPromise = new Response(subprocess.stderr).text();
   const reader = subprocess.stdout.getReader();
   let total = 0;
@@ -1713,6 +1751,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: (0, import_git_process_environment.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() : [];
@@ -1940,12 +2045,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);
@@ -2095,8 +2207,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 {
@@ -2141,7 +2270,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) {
@@ -2163,6 +2294,7 @@ async function synchronizeWorkspaceGit(input) {
         diffSizeBytes: size,
         affectedPaths: paths,
         ...completedMounts,
+        ...initialPublicationMountIds ? { initialPublicationMountIds } : {},
         ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         ...projectionWarning ? { error: projectionWarning } : {}
       };

package/dist/cjs/workspace-merge-projection.cjs

@@ -206,6 +206,14 @@ function indexMode(entry) {
 function indexInfoRecord(mode, objectId, relativePath) {
   return Buffer.concat([Buffer.from(`${mode} ${objectId}	`), Buffer.from(relativePath), Buffer.from([0])]);
 }
+function basisGitlinks(workspacePath, basis) {
+  const listed = gitResult(workspacePath, ["ls-tree", "-r", "-z", `${basis.basisHead}:${basis.workspaceRelativePath}`]);
+  if (listed.exitCode !== 0) return [];
+  return nulRecords(listed.stdout).flatMap((record) => {
+    const match = /^160000 commit ([0-9a-f]{40,64})\t(.+)$/su.exec(record.toString());
+    return match ? [{ objectId: match[1], relativePath: match[2] }] : [];
+  });
+}
 function synthesizeMountTree(input) {
   const sourceRoot = import_node_path.default.resolve(input.sourcePath);
   const entries = (0, import_working_tree_mirror.inspectWorkingTree)(sourceRoot, input.sourceMode);
@@ -220,6 +228,15 @@ function synthesizeMountTree(input) {
       const objectId = entry.kind === "file" ? hashRegularFile(input.workspacePath, sourcePath, entry) : hashSymlink(input.workspacePath, sourcePath, entry);
       records.push(indexInfoRecord(indexMode(entry), objectId, relativePath));
     }
+    if (input.gitlinkBasis && input.sourceMode === "git") {
+      for (const gitlink of basisGitlinks(input.workspacePath, input.gitlinkBasis)) {
+        const populatedPrefix = `${gitlink.relativePath}/`;
+        const populated = [...entries.keys()].some((relativePath) => relativePath.startsWith(populatedPrefix));
+        if (entries.get(gitlink.relativePath)?.kind === "directory" && !populated) {
+          records.push(indexInfoRecord("160000", gitlink.objectId, gitlink.relativePath));
+        }
+      }
+    }
     if (records.length > 0) {
       git(input.workspacePath, ["update-index", "-z", "--index-info"], "populate workspace projection index", {
         environment,
@@ -284,7 +301,8 @@ function synthesizeOursCommit(input) {
   const mountTree = synthesizeMountTree({
     workspacePath: input.workspacePath,
     sourcePath: input.mount.sourcePath,
-    sourceMode: input.mount.sourceMode
+    sourceMode: input.mount.sourceMode,
+    gitlinkBasis: { basisHead: input.basisHead, workspaceRelativePath: input.workspaceRelativePath }
   });
   const rootTree = graftMountTree({
     workspacePath: input.workspacePath,

package/dist/mjs/main.mjs

@@ -3831,6 +3831,7 @@ async function startWorker(options) {
         const branchKey = projectBranchKey(project.projectId, branch.branchName);
         const creatorLocalIncarnation = creatorLocalIncarnations.get(branchKey) === branch.branchId;
         const preservesCheckoutPathMove = checkoutPathMoveBranches.has(branchKey);
+        const initialPublicationSourceBranch = creatorLocalIncarnation ? branch.sourceBranchName : null;
         mounts.push({
           id: projectMountId(project.projectId, branch.branchName),
           hydrationIncarnationKey: branch.branchId,
@@ -3840,6 +3841,7 @@ async function startWorker(options) {
           sourceMode: "git",
           hydrateDeletionMode: "git",
           preserveLocalOnInitialOuterAbsence: creatorLocalIncarnation,
+          ...initialPublicationSourceBranch ? { initialPublicationSourceRelativePath: workspaceProjectRelativePath(project.projectId, initialPublicationSourceBranch) } : {},
           preserveLocalOnHydrationBasisChange: preservesCheckoutPathMove,
           busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
@@ -3854,6 +3856,7 @@ async function startWorker(options) {
           sourceMode: "all",
           hydrateDeletionMode: "all",
           preserveLocalOnInitialOuterAbsence: creatorLocalIncarnation,
+          ...initialPublicationSourceBranch ? { initialPublicationSourceRelativePath: workspacePlanRelativePath(project.projectId, initialPublicationSourceBranch) } : {},
           preserveLocalOnHydrationBasisChange: preservesCheckoutPathMove,
           busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
@@ -4453,6 +4456,12 @@ async function startWorker(options) {
       }
     });
     input.assertStillAdmitted?.();
+    if (result.initialPublicationMountIds && result.initialPublicationMountIds.length > 0) {
+      process.stderr.write(
+        `[r5d-worker] published first checkout copies above the automatic diff-size limit, measured against their source subtrees at ${result.diffSizeBytes} bytes: ${result.initialPublicationMountIds.join(", ")}
+`
+      );
+    }
     if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
       await applyObservedProjectHeadsAfterInboundWorkspace(
         observedProjectHeads,

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.95",
+  "version": "0.0.97",
   "type": "module"
 }

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/mjs/workspace-merge-projection.mjs

@@ -170,6 +170,14 @@ function indexMode(entry) {
 function indexInfoRecord(mode, objectId, relativePath) {
   return Buffer.concat([Buffer.from(`${mode} ${objectId}	`), Buffer.from(relativePath), Buffer.from([0])]);
 }
+function basisGitlinks(workspacePath, basis) {
+  const listed = gitResult(workspacePath, ["ls-tree", "-r", "-z", `${basis.basisHead}:${basis.workspaceRelativePath}`]);
+  if (listed.exitCode !== 0) return [];
+  return nulRecords(listed.stdout).flatMap((record) => {
+    const match = /^160000 commit ([0-9a-f]{40,64})\t(.+)$/su.exec(record.toString());
+    return match ? [{ objectId: match[1], relativePath: match[2] }] : [];
+  });
+}
 function synthesizeMountTree(input) {
   const sourceRoot = path.resolve(input.sourcePath);
   const entries = inspectWorkingTree(sourceRoot, input.sourceMode);
@@ -184,6 +192,15 @@ function synthesizeMountTree(input) {
       const objectId = entry.kind === "file" ? hashRegularFile(input.workspacePath, sourcePath, entry) : hashSymlink(input.workspacePath, sourcePath, entry);
       records.push(indexInfoRecord(indexMode(entry), objectId, relativePath));
     }
+    if (input.gitlinkBasis && input.sourceMode === "git") {
+      for (const gitlink of basisGitlinks(input.workspacePath, input.gitlinkBasis)) {
+        const populatedPrefix = `${gitlink.relativePath}/`;
+        const populated = [...entries.keys()].some((relativePath) => relativePath.startsWith(populatedPrefix));
+        if (entries.get(gitlink.relativePath)?.kind === "directory" && !populated) {
+          records.push(indexInfoRecord("160000", gitlink.objectId, gitlink.relativePath));
+        }
+      }
+    }
     if (records.length > 0) {
       git(input.workspacePath, ["update-index", "-z", "--index-info"], "populate workspace projection index", {
         environment,
@@ -248,7 +265,8 @@ function synthesizeOursCommit(input) {
   const mountTree = synthesizeMountTree({
     workspacePath: input.workspacePath,
     sourcePath: input.mount.sourcePath,
-    sourceMode: input.mount.sourceMode
+    sourceMode: input.mount.sourceMode,
+    gitlinkBasis: { basisHead: input.basisHead, workspaceRelativePath: input.workspaceRelativePath }
   });
   const rootTree = graftMountTree({
     workspacePath: input.workspacePath,

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.95",
+  "version": "0.0.97",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",