@ricsam/r5d-worker 0.0.99 → 0.0.101

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

@@ -128,6 +128,22 @@ async function gitAsync(cwd, args, action) {
   if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
   return result.stdout;
 }
+async function gitOutputAsync(cwd, args, action, input) {
+  const subprocess = Bun.spawn(gitCommandArgs(args), {
+    cwd,
+    stdin: input ?? "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: (0, import_git_process_environment.workerGitProcessEnvironment)()
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(subprocess.stdout).arrayBuffer(),
+    new Response(subprocess.stderr).text(),
+    subprocess.exited
+  ]);
+  if (exitCode !== 0) throw new Error(`${action}: ${stderr.trim() || `git exited ${exitCode}`}`);
+  return Buffer.from(stdout);
+}
 async function tryGitAsync(cwd, args) {
   return (await gitResultAsync(cwd, args)).exitCode === 0;
 }
@@ -1139,7 +1155,13 @@ function beginHydrationTransaction(workspacePath, mounts, targetReceipt) {
           candidate: outerPath,
           label: `Workspace mount ${mount.id} outer source`
         });
-        const plan = (0, import_working_tree_mirror.planWorkingTreeMirror)({ sourceRoot: outerPath, targetRoot: sourcePath, sourceMode: "all", deletionMode: "git" });
+        const plan = (0, import_working_tree_mirror.planWorkingTreeMirror)({
+          sourceRoot: outerPath,
+          targetRoot: sourcePath,
+          sourceMode: "all",
+          deletionMode: "git",
+          sourceGitlinks: outerSubtreeGitlinks(workspacePath, mount)
+        });
         scope = (0, import_working_tree_mirror.captureWorkingTreeMirrorPlan)({
           plan,
           targetRoot: sourcePath,
@@ -1450,6 +1472,7 @@ function activeMounts(mounts) {
   return { active, tombstones, skipped };
 }
 function mirrorMountsToWorkspace(workspacePath, mounts) {
+  const projected = [];
   for (const mount of mounts) {
     (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
       trustedRoot: mount.durabilityRootPath,
@@ -1461,13 +1484,61 @@ function mirrorMountsToWorkspace(workspacePath, mounts) {
       candidate: import_node_path.default.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/")),
       label: `Workspace mount ${mount.id} outer target`
     });
-    (0, import_working_tree_mirror.mirrorWorkingTree)({
+    const mirrored = (0, import_working_tree_mirror.mirrorWorkingTree)({
       sourceRoot: mount.sourcePath,
       targetRoot: import_node_path.default.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/")),
       sourceMode: mount.sourceMode,
       deletionMode: "all"
     });
+    projected.push({ mount, gitlinks: mirrored.gitlinks });
+  }
+  return projected;
+}
+async function stageWorkspaceGitlinks(workspacePath, projected) {
+  if (projected.length === 0) return;
+  const mountPaths = projected.map(({ mount }) => normalizedWorkspaceMountPath(mount.workspaceRelativePath));
+  const desired = /* @__PURE__ */ new Map();
+  projected.forEach(({ gitlinks }, index) => {
+    for (const gitlink of gitlinks) desired.set(`${mountPaths[index]}/${gitlink.relativePath}`, gitlink.objectId);
+  });
+  const desiredRoots = new Set(desired.keys());
+  const listed = await gitOutputAsync(
+    workspacePath,
+    ["ls-files", "-z", "--stage", "--", ...mountPaths.map((mountPath) => `:(literal)${mountPath}`)],
+    "inspect staged workspace mount entries"
+  );
+  const feed = [];
+  const current = /* @__PURE__ */ new Map();
+  const drop = (objectId, relativePath) => {
+    feed.push(Buffer.concat([Buffer.from(`0 ${"0".repeat(objectId.length)}	`), Buffer.from(relativePath), Buffer.from([0])]));
+  };
+  for (const record of listed.toString().split("\0")) {
+    const match = /^([0-7]{6}) ([0-9a-f]{40,64}) [0-3]\t(.+)$/su.exec(record);
+    if (!match) continue;
+    const mode = match[1];
+    const objectId = match[2];
+    const relativePath = match[3];
+    if (mode === "160000") {
+      current.set(relativePath, objectId);
+      if (!desired.has(relativePath)) drop(objectId, relativePath);
+      continue;
+    }
+    if (desired.has(relativePath) || hasAncestorIn(relativePath, desiredRoots)) drop(objectId, relativePath);
   }
+  for (const [relativePath, objectId] of desired) {
+    if (current.get(relativePath) === objectId) continue;
+    feed.push(Buffer.concat([Buffer.from(`160000 ${objectId}	`), Buffer.from(relativePath), Buffer.from([0])]));
+  }
+  if (feed.length === 0) return;
+  await gitOutputAsync(workspacePath, ["update-index", "-z", "--index-info"], "stage workspace gitlinks", Buffer.concat(feed));
+}
+function hasAncestorIn(relativePath, ancestors) {
+  let parent = import_node_path.default.posix.dirname(relativePath);
+  while (parent !== ".") {
+    if (ancestors.has(parent)) return true;
+    parent = import_node_path.default.posix.dirname(parent);
+  }
+  return false;
 }
 function removeWorkspaceMounts(workspacePath, mounts) {
   for (const mount of mounts) {
@@ -1507,6 +1578,24 @@ function restoreDeferredWorkspaceMountsFromHead(workspacePath, mounts) {
 function workspaceMountOuterPath(workspacePath, mount) {
   return import_node_path.default.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
 }
+function outerSubtreeGitlinks(workspacePath, mount) {
+  const gitlinks = /* @__PURE__ */ new Map();
+  const head = revParse(workspacePath, "HEAD");
+  if (!head) return gitlinks;
+  const subtree = `${head}:${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`;
+  const listed = Bun.spawnSync(gitCommandArgs(["ls-tree", "-r", "-z", subtree]), {
+    cwd: workspacePath,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: (0, import_git_process_environment.workerGitProcessEnvironment)()
+  });
+  if (listed.exitCode !== 0) return gitlinks;
+  for (const record of Buffer.from(listed.stdout).toString().split("\0")) {
+    const match = /^160000 commit ([0-9a-f]{40,64})\t(.+)$/su.exec(record);
+    if (match) gitlinks.set(match[2], match[1]);
+  }
+  return gitlinks;
+}
 function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
   const hydratedMountIds = [];
   const skippedMountIds = [];
@@ -1550,6 +1639,9 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
       sourceRoot,
       targetRoot: mount.sourcePath,
       sourceMode: "all",
+      // The outer worktree shows a submodule as an empty directory; the tree
+      // carries its pointer, which a Git checkout applies to its index (D4).
+      sourceGitlinks: outerSubtreeGitlinks(workspacePath, mount),
       // A missing checkout has no Git index to define git-only deletions. Its
       // newly created directory is empty, so all-mode is equivalent and lets
       // bootstrap hydration preserve the fetched tree before Git initializes.
@@ -1565,7 +1657,7 @@ async function selectMountsWithUnchangedOuterSubtree(workspacePath, receipt, hea
     return basisHead && basisHead !== head ? [{ mount, basisHead }] : [];
   });
   if (candidates.length === 0) return /* @__PURE__ */ new Set();
-  const objects = await resolveGitObjectIdsAsync(
+  const objects = await resolveGitObjectsAsync(
     workspacePath,
     candidates.flatMap(({ mount, basisHead }) => [
       workspaceTreeObjectName(basisHead, mount.workspaceRelativePath),
@@ -1574,8 +1666,8 @@ async function selectMountsWithUnchangedOuterSubtree(workspacePath, receipt, hea
   );
   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;
+    const before = objects.get(workspaceTreeObjectName(basisHead, mount.workspaceRelativePath))?.objectId ?? null;
+    const after = objects.get(workspaceTreeObjectName(head, mount.workspaceRelativePath))?.objectId ?? null;
     if (before === after) unchanged.add(mount.id);
   }
   return unchanged;
@@ -1601,56 +1693,67 @@ async function hydrateWorkspaceGitMountsTransactionally(input) {
     const busyMountIds = new Set(input.ignoreBusy ? [] : candidateMounts.filter((mount) => mount.busy?.()).map(({ id }) => id));
     const requestedIds = new Set(input.mounts.map(({ id }) => id));
     const requiredIds = new Set(requiredMounts.map(({ id }) => id));
-    const hydrationMounts2 = input.mounts.filter(({ id }) => !busyMountIds.has(id));
-    const advancedDurabilityMounts2 = durabilityMounts.filter(
+    const hydrationMounts = input.mounts.filter(({ id }) => !busyMountIds.has(id));
+    const advancedDurabilityMounts = durabilityMounts.filter(
       ({ 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,
+      hydrationMounts,
+      advancedDurabilityMounts,
       skippedMountIds: [.../* @__PURE__ */ new Set([...busyMountIds, ...unavailableRequiredIds])].sort(),
-      targetReceipt: targetHead ? receiptWithMountsAtHead(receiptBeforeTransaction, targetHead, [...advancedDurabilityMounts2, ...carriedMounts], receiptMounts) : null
+      targetReceipt: targetHead ? receiptWithMountsAtHead(receiptBeforeTransaction, targetHead, [...advancedDurabilityMounts, ...carriedMounts], receiptMounts) : null
     };
   };
   const noopCandidate = computeSelection();
   if (noopCandidate.hydrationMounts.length === 0 && noopCandidate.advancedDurabilityMounts.length === 0 && noopCandidate.targetReceipt && lstatIfExists(hydrationTransactionPath(workspacePath)) === null && workspaceHydrationReceiptsEqual(receiptBeforeTransaction, noopCandidate.targetReceipt) && hydratedWorkspaceReceiptFileIsV3(workspacePath) && await workspaceBasisRefsAreCurrentAsync(workspacePath, noopCandidate.targetReceipt)) {
     return { hydratedMountIds: [], skippedMountIds: noopCandidate.skippedMountIds };
   }
-  const selection = computeSelection();
-  const { hydrationMounts, advancedDurabilityMounts, targetReceipt } = selection;
-  const { manifest, durabilityScopes } = beginHydrationTransaction(workspacePath, hydrationMounts, targetReceipt);
+  const hooks = input.hydrationHooks;
+  const context = {
+    transactionId: crypto.randomUUID(),
+    workspacePath,
+    mountIds: [...new Set([...noopCandidate.hydrationMounts, ...noopCandidate.advancedDurabilityMounts].map(({ id }) => id))].sort()
+  };
+  if (hooks) await hooks.beforeTransaction(context);
   try {
-    const hydration = hydrateWorkspaceGitMountsRaw(workspacePath, hydrationMounts, { ignoreBusy: true });
-    const expectedHydratedIds = hydrationMounts.map(({ id }) => id).sort();
-    if (hydration.skippedMountIds.length > 0 || hydration.hydratedMountIds.length !== expectedHydratedIds.length || hydration.hydratedMountIds.some((id, index) => id !== expectedHydratedIds[index])) {
-      throw new Error("Workspace hydration did not include every required mount");
-    }
-    fsyncHydratedWorkspaceMounts(advancedDurabilityMounts, durabilityScopes);
-    markHydrationTransactionDurable(workspacePath);
-    if (targetReceipt) updateHydratedWorkspaceReceipt(workspacePath, targetReceipt);
-    removeHydrationTransaction(workspacePath);
-    return {
-      hydratedMountIds: hydration.hydratedMountIds,
-      skippedMountIds: selection.skippedMountIds
-    };
-  } catch (error) {
-    const transactionPath = hydrationTransactionPath(workspacePath);
-    if (lstatIfExists(transactionPath) && hydrationTransactionCommitted(transactionPath)) {
-      throw error;
-    }
+    const selection = computeSelection();
+    const { hydrationMounts, advancedDurabilityMounts, targetReceipt } = selection;
+    const { manifest, durabilityScopes } = beginHydrationTransaction(workspacePath, hydrationMounts, targetReceipt);
     try {
-      restoreHydrationTransaction(workspacePath, manifest);
+      const hydration = hydrateWorkspaceGitMountsRaw(workspacePath, hydrationMounts, { ignoreBusy: true });
+      const expectedHydratedIds = hydrationMounts.map(({ id }) => id).sort();
+      if (hydration.skippedMountIds.length > 0 || hydration.hydratedMountIds.length !== expectedHydratedIds.length || hydration.hydratedMountIds.some((id, index) => id !== expectedHydratedIds[index])) {
+        throw new Error("Workspace hydration did not include every required mount");
+      }
+      fsyncHydratedWorkspaceMounts(advancedDurabilityMounts, durabilityScopes);
+      markHydrationTransactionDurable(workspacePath);
+      if (targetReceipt) updateHydratedWorkspaceReceipt(workspacePath, targetReceipt);
       removeHydrationTransaction(workspacePath);
-    } catch (restoreError) {
-      throw new AggregateError(
-        [error, restoreError],
-        `Workspace hydration failed and its durable snapshot could not be restored: ${error instanceof Error ? error.message : String(error)}`
-      );
+      return {
+        hydratedMountIds: hydration.hydratedMountIds,
+        skippedMountIds: selection.skippedMountIds
+      };
+    } catch (error) {
+      const transactionPath = hydrationTransactionPath(workspacePath);
+      if (lstatIfExists(transactionPath) && hydrationTransactionCommitted(transactionPath)) {
+        throw error;
+      }
+      try {
+        restoreHydrationTransaction(workspacePath, manifest);
+        removeHydrationTransaction(workspacePath);
+      } catch (restoreError) {
+        throw new AggregateError(
+          [error, restoreError],
+          `Workspace hydration failed and its durable snapshot could not be restored: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      throw error;
     }
-    throw error;
+  } finally {
+    hooks?.afterTransaction(context);
   }
 }
 async function hydrateWorkspaceGitMounts(workspacePath, mounts, options = {}) {
@@ -1662,7 +1765,8 @@ async function hydrateWorkspaceGitMounts(workspacePath, mounts, options = {}) {
   return hydrateWorkspaceGitMountsTransactionally({
     workspacePath,
     mounts,
-    ignoreBusy: options.ignoreBusy
+    ignoreBusy: options.ignoreBusy,
+    hydrationHooks: options.hydrationHooks
   });
 }
 async function recoverWorkspaceGitHydration(workspacePath, mounts, options = {}) {
@@ -1702,7 +1806,8 @@ async function recoverWorkspaceGitHydration(workspacePath, mounts, options = {})
     receiptMounts: configuredBasisMounts,
     requiredMounts: hydrationTargets,
     ignoreBusy: options.ignoreBusy,
-    recordCurrentHead: true
+    recordCurrentHead: true,
+    hydrationHooks: options.hydrationHooks
   });
   void hydration;
 }
@@ -1753,7 +1858,8 @@ async function resetWorkspaceGit(input) {
     durabilityMounts: [...requiredLiveMounts, ...selected.tombstones, ...durablyAbsentMounts],
     receiptMounts: input.mounts,
     requiredMounts: requiredLiveMounts,
-    recordCurrentHead: true
+    recordCurrentHead: true,
+    hydrationHooks: input.hydrationHooks
   });
   const requiredLiveIds = requiredLiveMounts.map(({ id }) => id).sort();
   const resetHead = revParse(workspacePath, "HEAD");
@@ -1827,7 +1933,7 @@ async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit, p
   if (exitCode !== 0) throw new Error(`Measure workspace diff: ${stderr || `git exited ${exitCode}`}`);
   return total;
 }
-async function resolveGitObjectIdsAsync(workspacePath, names) {
+async function resolveGitObjectsAsync(workspacePath, names) {
   const resolved = /* @__PURE__ */ new Map();
   const unique = [...new Set(names)];
   if (unique.length === 0) return resolved;
@@ -1850,21 +1956,43 @@ async function resolveGitObjectIdsAsync(workspacePath, names) {
     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);
+    const match = /^([0-9a-f]{40,64}) (\S+) \d+$/.exec(lines[index]);
+    resolved.set(name, match ? { objectId: match[1], type: match[2] } : null);
   });
   return resolved;
 }
 function workspaceTreeObjectName(revision, workspaceRelativePath) {
   return `${revision}:${normalizedWorkspaceMountPath(workspaceRelativePath)}`;
 }
+async function pathsReplacedByGitlinks(workspacePath, baseRevision, headRevision) {
+  const base = baseRevision ?? emptyTreeHash(workspacePath);
+  const raw = await gitOutputAsync(
+    workspacePath,
+    ["diff", "--raw", "--no-renames", "-z", base, headRevision],
+    "inspect workspace gitlink changes"
+  );
+  const records = raw.toString().split("\0");
+  const addedGitlinks = [];
+  for (let index = 0; index + 1 < records.length; index += 2) {
+    if (/^:[0-7]{6} 160000 \S+ \S+ A$/u.test(records[index])) addedGitlinks.push(records[index + 1]);
+  }
+  if (addedGitlinks.length === 0) return [];
+  const objects = await resolveGitObjectsAsync(
+    workspacePath,
+    addedGitlinks.map((relativePath) => `${base}:${relativePath}`)
+  );
+  return addedGitlinks.filter((relativePath) => objects.get(`${base}:${relativePath}`)?.type === "tree").sort();
+}
+function gitlinkMigrationPathspecs(paths) {
+  return paths.map((relativePath) => `:(exclude,literal)${relativePath}`);
+}
 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(
+  const objects = await resolveGitObjectsAsync(
     input.workspacePath,
     candidates.flatMap(
       (mount) => revisions.flatMap((revision) => [
@@ -1873,7 +2001,7 @@ async function measureInitialPublicationDiffSize(input) {
       ])
     )
   );
-  const lookup = (revision, workspaceRelativePath) => revision ? objects.get(workspaceTreeObjectName(revision, workspaceRelativePath)) ?? null : null;
+  const lookup = (revision, workspaceRelativePath) => revision ? objects.get(workspaceTreeObjectName(revision, workspaceRelativePath))?.objectId ?? null : null;
   const initialPublications = candidates.flatMap((mount) => {
     const published = lookup(input.localHead, mount.workspaceRelativePath);
     if (!published || lookup(input.remoteHead, mount.workspaceRelativePath)) return [];
@@ -1881,16 +2009,14 @@ async function measureInitialPublicationDiffSize(input) {
     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)}`)
-  );
+  let size = await input.measure(input.workspacePath, input.remoteHead, input.localHead, input.limit, [
+    ...initialPublications.map(({ mount }) => `:(exclude,literal)${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`),
+    ...input.excludePathspecs ?? []
+  ]);
   for (const { published, source } of initialPublications) {
     if (size > input.limit) break;
-    size += await input.measure(input.workspacePath, source, published, input.limit - size);
+    const migrations = source ? await pathsReplacedByGitlinks(input.workspacePath, source, published) : [];
+    size += await input.measure(input.workspacePath, source, published, input.limit - size, gitlinkMigrationPathspecs(migrations));
   }
   return { size, mountIds: initialPublications.map(({ mount }) => mount.id).sort() };
 }
@@ -2008,7 +2134,8 @@ async function synchronizeWorkspaceGit(input) {
   await recoverWorkspaceGitHydration(workspacePath, input.mounts, {
     ...deferredMountIds.size > 0 ? { deferMountIds: deferredMountIds } : {},
     preserveResolutionInProgress,
-    preserveStaleBases: true
+    preserveStaleBases: true,
+    hydrationHooks: input.hydrationHooks
   });
   const selected = activeMounts(input.mounts);
   const projectionMutationTokens = new Map(
@@ -2134,7 +2261,8 @@ async function synchronizeWorkspaceGit(input) {
       carryMounts: uncoveredCompletionMounts.filter(({ id }) => unchangedMountIds.has(id)),
       receiptMounts: completionReceiptMounts,
       requiredMounts: uncoveredRequiredLiveMounts.filter(({ id }) => !unchangedMountIds.has(id)),
-      recordCurrentHead: true
+      recordCurrentHead: true,
+      hydrationHooks: input.hydrationHooks
     });
     for (const id of hydration.skippedMountIds) cycleSkippedMountIds.add(id);
     refreshCycleSkippedMounts(completionReceiptMounts);
@@ -2152,10 +2280,12 @@ async function synchronizeWorkspaceGit(input) {
     return classifyMounts([...selected.active, ...selected.tombstones], hydration.skippedMountIds);
   };
   let newlyStagedPaths = [];
+  const projectedGitlinks = [];
   const stageAndCommitWorkspace = async () => {
     if (workspaceResolutionInProgress(workspacePath) || await workspaceHasUnmergedEntries(workspacePath)) {
       throw new Error("Outer workspace clone has an unfinished merge/rebase; finish or abort it before synchronizing");
     }
+    await stageWorkspaceGitlinks(workspacePath, projectedGitlinks);
     await gitAsync(workspacePath, ["add", "-A", "--", "."], "stage workspace working trees");
     newlyStagedPaths = await stagedPaths(workspacePath);
     if (newlyStagedPaths.length > 0) {
@@ -2185,7 +2315,7 @@ async function synchronizeWorkspaceGit(input) {
           cycleSkippedMountIds.add(mount.id);
           continue;
         }
-        mirrorMountsToWorkspace(workspacePath, [mount]);
+        projectedGitlinks.push(...mirrorMountsToWorkspace(workspacePath, [mount]));
         projectedFastMounts.push(mount);
         await yieldToWorkerEventLoop();
       }
@@ -2284,7 +2414,9 @@ async function synchronizeWorkspaceGit(input) {
     }
     const paths = await changedPaths(workspacePath, remoteHead, localHead);
     const measureDiffSize = input.measureDiffSize ?? diffSizeBytes;
-    let size = paths.length > 0 ? await measureDiffSize(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
+    const gitlinkMigrations = paths.length > 0 ? await pathsReplacedByGitlinks(workspacePath, remoteHead, localHead) : [];
+    const gitlinkMigrationExcludes = gitlinkMigrationPathspecs(gitlinkMigrations);
+    let size = paths.length > 0 ? await measureDiffSize(workspacePath, remoteHead, localHead, maxDiffBytes, gitlinkMigrationExcludes) : 0;
     input.assertStillAdmitted?.();
     let initialPublicationMountIds;
     if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
@@ -2294,7 +2426,8 @@ async function synchronizeWorkspaceGit(input) {
         localHead,
         mounts: input.mounts,
         limit: maxDiffBytes,
-        measure: measureDiffSize
+        measure: measureDiffSize,
+        excludePathspecs: gitlinkMigrationExcludes
       });
       input.assertStillAdmitted?.();
       if (initialPublication && initialPublication.size <= maxDiffBytes) {
@@ -2302,6 +2435,11 @@ async function synchronizeWorkspaceGit(input) {
         initialPublicationMountIds = initialPublication.mountIds;
       }
     }
+    let gitlinkMigrationConfirmed = false;
+    if (gitlinkMigrations.length > 0 && size <= maxDiffBytes && !input.allowLargeDiff) {
+      gitlinkMigrationConfirmed = await measureDiffSize(workspacePath, remoteHead, localHead, maxDiffBytes) > maxDiffBytes;
+      input.assertStillAdmitted?.();
+    }
     if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
       const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones]);
       return {
@@ -2346,7 +2484,7 @@ async function synchronizeWorkspaceGit(input) {
       "push",
       "--no-recurse-submodules"
     ];
-    if (input.allowLargeDiff || initialPublicationMountIds) {
+    if (input.allowLargeDiff || initialPublicationMountIds || gitlinkMigrationConfirmed) {
       pushArgs.push(`--push-option=${WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION}`);
     }
     pushArgs.push("origin", `HEAD:refs/heads/${WORKSPACE_GIT_BRANCH}`);

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

@@ -206,14 +206,6 @@ 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);
@@ -224,19 +216,14 @@ function synthesizeMountTree(input) {
     const records = [];
     for (const [relativePath, entry] of [...entries.entries()].sort(([left], [right]) => left.localeCompare(right))) {
       if (entry.kind === "directory") continue;
+      if (entry.kind === "gitlink") {
+        records.push(indexInfoRecord("160000", entry.objectId, relativePath));
+        continue;
+      }
       const sourcePath = sourceEntryPath(sourceRoot, relativePath);
       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,
@@ -301,8 +288,7 @@ function synthesizeOursCommit(input) {
   const mountTree = synthesizeMountTree({
     workspacePath: input.workspacePath,
     sourcePath: input.mount.sourcePath,
-    sourceMode: input.mount.sourceMode,
-    gitlinkBasis: { basisHead: input.basisHead, workspaceRelativePath: input.workspaceRelativePath }
+    sourceMode: input.mount.sourceMode
   });
   const rootTree = graftMountTree({
     workspacePath: input.workspacePath,

package/dist/mjs/main.mjs

@@ -104,9 +104,35 @@ function workerServerHeartbeatAction(input) {
   if (input.watchdogSweepDelayed || input.probeElapsedMs === void 0) return "start_probe";
   return input.probeElapsedMs >= input.timeoutMs ? "terminate" : "wait";
 }
+const WORKSPACE_HYDRATION_LEASE_OPERATION_PREFIX = "hydration:";
+function createWorkspaceHydrationLeaseHooks(send, options = {}) {
+  const yieldToEventLoop = options.yieldToEventLoop ?? (() => new Promise((resolve) => setImmediate(resolve)));
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const now = options.now ?? (() => performance.now());
+  const operationId = (context) => `${WORKSPACE_HYDRATION_LEASE_OPERATION_PREFIX}${context.transactionId}`;
+  const startedAtMs = /* @__PURE__ */ new Map();
+  return {
+    async beforeTransaction(context) {
+      send({ type: "heartbeat_lease", operationId: operationId(context), kind: "hydration", active: true });
+      startedAtMs.set(context.transactionId, now());
+      log(`[r5d-worker] hydrating ${context.mountIds.length} workspace mount(s) under hydration lease ${context.transactionId}`);
+      await yieldToEventLoop();
+    },
+    afterTransaction(context) {
+      const startedAt = startedAtMs.get(context.transactionId);
+      startedAtMs.delete(context.transactionId);
+      send({ type: "heartbeat_lease", operationId: operationId(context), kind: "hydration", active: false });
+      log(
+        `[r5d-worker] released hydration lease ${context.transactionId} after ${startedAt === void 0 ? "?" : Math.round(now() - startedAt)}ms`
+      );
+    }
+  };
+}
 const workerLifecycleTestHarness = {
   boundedWorkerLifecycleProgress,
-  workerServerHeartbeatAction
+  workerServerHeartbeatAction,
+  createWorkspaceHydrationLeaseHooks
 };
 class ProjectWorkspaceConfigurationDeferredError extends Error {
 }
@@ -4377,6 +4403,7 @@ async function startWorker(options) {
       error: error instanceof Error ? error.message : String(error)
     };
   };
+  const workspaceHydrationTransactionHooks = createWorkspaceHydrationLeaseHooks((message) => sendWorkerMessageFromCurrentSource(ws, message));
   const performWorkspaceSync = async (input) => {
     if (!workspaceRemoteUrl || !workspaceCredentialHelper || !workspaceCredentialUsername || !workspaceGitIdentity) {
       throw new Error("Worker workspace configuration has not been received");
@@ -4399,7 +4426,8 @@ async function startWorker(options) {
         credentialHelper: workspaceCredentialHelper,
         credentialUsername: workspaceCredentialUsername,
         gitIdentity: workspaceGitIdentity,
-        mounts: configuredMounts
+        mounts: configuredMounts,
+        hydrationHooks: workspaceHydrationTransactionHooks
       });
       await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads2, reset.activeMountIds, true);
       return {
@@ -4453,7 +4481,8 @@ async function startWorker(options) {
       assertStillAdmitted: input.assertStillAdmitted,
       afterWorkspacePublished: outerRemediation ? void 0 : async ({ activeMountIds, publishedHead }) => {
         await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, expectedMirrorHeads, inboundMoveMountIds);
-      }
+      },
+      hydrationHooks: workspaceHydrationTransactionHooks
     });
     input.assertStillAdmitted?.();
     if (result.initialPublicationMountIds && result.initialPublicationMountIds.length > 0) {
@@ -5047,7 +5076,10 @@ async function startWorker(options) {
           sourcePath: recoverySourceOverrides.get(mount.id) ?? mount.sourcePath,
           busy: mount.busyForRecovery ?? mount.busy
         }));
-        await recoverWorkspaceGitHydration(workspaceShadowRoot, recoveryMounts, { preserveStaleBases: true });
+        await recoverWorkspaceGitHydration(workspaceShadowRoot, recoveryMounts, {
+          preserveStaleBases: true,
+          hydrationHooks: workspaceHydrationTransactionHooks
+        });
         for (const project of message.projects) {
           for (const { branchName } of project.preserveOnlyBranches) {
             if (stillPendingCreatedBranches.has(pendingCreatedBranchKey(project.projectId, branchName))) {
@@ -5091,7 +5123,7 @@ async function startWorker(options) {
           // layouts can be marked ready. No process can resolve an unready
           // target, and preserving the fetched outer tree here prevents clean
           // checkout initialization from erasing synchronized dirt.
-          { ignoreBusy: true }
+          { ignoreBusy: true, hydrationHooks: workspaceHydrationTransactionHooks }
         );
         await ensureConfiguredProjects((progress) => {
           sendLifecycleProgress({ phase: "configuring", operationId: configurationOperationId, ...progress });

package/dist/mjs/package.json

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