@ricsam/r5d-worker 0.0.97 → 0.0.100

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

@@ -954,7 +954,7 @@ function parseHydrationTransactionManifest(transactionPath) {
     throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
   }
   const candidate = parsed;
-  if (candidate.version !== 2 && candidate.version !== 3 || !Array.isArray(candidate.mounts)) {
+  if (candidate.version !== 2 && candidate.version !== 3 && candidate.version !== 4 || !Array.isArray(candidate.mounts)) {
     throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
   }
   const parseReceipt = (rawReceipt) => {
@@ -967,6 +967,25 @@ function parseHydrationTransactionManifest(transactionPath) {
   };
   const targetReceipt = parseReceipt(candidate.targetReceipt);
   const receiptBefore = parseReceipt(candidate.receiptBefore);
+  const parseScope = (rawScope, existed) => {
+    if (rawScope === void 0) return void 0;
+    if (candidate.version !== 4 || !existed || !rawScope || typeof rawScope !== "object") {
+      throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
+    }
+    const parsePaths = (rawPaths) => {
+      if (!Array.isArray(rawPaths)) throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
+      const seen = /* @__PURE__ */ new Set();
+      return rawPaths.map((rawPath) => {
+        if (typeof rawPath !== "string" || (0, import_working_tree_mirror.normalizeWorkingTreeRelativePath)(rawPath) !== rawPath || seen.has(rawPath)) {
+          throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
+        }
+        seen.add(rawPath);
+        return rawPath;
+      });
+    };
+    const { absent, trees } = rawScope;
+    return { absent: parsePaths(absent), trees: parsePaths(trees) };
+  };
   const seenIds = /* @__PURE__ */ new Set();
   const seenSnapshots = /* @__PURE__ */ new Set();
   const mounts = candidate.mounts.map((rawMount) => {
@@ -983,10 +1002,20 @@ function parseHydrationTransactionManifest(transactionPath) {
     }
     seenIds.add(mount.id);
     seenSnapshots.add(mount.snapshotName);
-    return mount;
+    const scope = parseScope(rawMount.scope, mount.existed);
+    return {
+      id: mount.id,
+      incarnationKey: mount.incarnationKey,
+      sourcePath: mount.sourcePath,
+      durabilityRootPath: mount.durabilityRootPath,
+      workspaceRelativePath: mount.workspaceRelativePath,
+      existed: mount.existed,
+      snapshotName: mount.snapshotName,
+      ...scope ? { scope } : {}
+    };
   });
   return {
-    version: 3,
+    version: candidate.version === 4 ? 4 : 3,
     targetReceipt,
     receiptBefore,
     mounts
@@ -1008,6 +1037,7 @@ function hydrationTransactionCommitted(transactionPath) {
 }
 function restoreHydrationTransaction(workspacePath, manifest) {
   const transactionPath = hydrationTransactionPath(workspacePath);
+  const durabilityScopes = /* @__PURE__ */ new Map();
   for (const mount of manifest.mounts) {
     (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
       trustedRoot: mount.durabilityRootPath,
@@ -1023,6 +1053,11 @@ function restoreHydrationTransaction(workspacePath, manifest) {
     if (!snapshotStatus.isDirectory() || snapshotStatus.isSymbolicLink()) {
       throw new Error(`Workspace hydration snapshot is not a regular directory: ${snapshotPath}`);
     }
+    if (mount.scope) {
+      const restored = (0, import_working_tree_mirror.restoreWorkingTreeMirrorScope)({ snapshotRoot: snapshotPath, targetRoot: mount.sourcePath, scope: mount.scope });
+      durabilityScopes.set(mount.id, restored.paths);
+      continue;
+    }
     (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: snapshotPath, targetRoot: mount.sourcePath, sourceMode: "all", deletionMode: "all" });
   }
   fsyncHydratedWorkspaceMounts(
@@ -1031,7 +1066,8 @@ function restoreHydrationTransaction(workspacePath, manifest) {
       hydrationIncarnationKey: mount.incarnationKey,
       sourceMode: "all",
       hydrateDeletionMode: "all"
-    }))
+    })),
+    durabilityScopes
   );
 }
 function recoverPendingHydrationTransaction(workspacePath) {
@@ -1075,57 +1111,80 @@ function beginHydrationTransaction(workspacePath, mounts, targetReceipt) {
   const transactionPath = hydrationTransactionPath(workspacePath);
   const stagingPath = import_node_path.default.join(stateDirectory, `.workspace-hydration-transaction.${process.pid}.${crypto.randomUUID()}.tmp`);
   import_node_fs.default.mkdirSync(stagingPath, { mode: 448 });
+  const durabilityScopes = /* @__PURE__ */ new Map();
   try {
     const snapshotRoot = import_node_path.default.join(stagingPath, "mounts");
     import_node_fs.default.mkdirSync(snapshotRoot, { mode: 448 });
-    const manifest = {
-      version: 3,
-      targetReceipt,
-      receiptBefore: readHydratedWorkspaceReceipt(workspacePath),
-      mounts: mounts.map((mount, index) => {
-        const sourcePath = import_node_path.default.resolve(mount.sourcePath);
-        const durabilityRootPath = import_node_path.default.resolve(mount.durabilityRootPath);
+    const receiptBefore = readHydratedWorkspaceReceipt(workspacePath);
+    const manifestMounts = mounts.map((mount, index) => {
+      const sourcePath = import_node_path.default.resolve(mount.sourcePath);
+      const durabilityRootPath = import_node_path.default.resolve(mount.durabilityRootPath);
+      (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
+        trustedRoot: durabilityRootPath,
+        candidate: sourcePath,
+        label: `Workspace hydration snapshot mount ${mount.id}`
+      });
+      const sourceStatus = lstatIfExists(sourcePath);
+      if (sourceStatus && (!sourceStatus.isDirectory() || sourceStatus.isSymbolicLink())) {
+        throw new Error(`Workspace hydration snapshot source is not a regular directory: ${sourcePath}`);
+      }
+      const snapshotName = String(index);
+      const snapshotPath = import_node_path.default.join(snapshotRoot, snapshotName);
+      import_node_fs.default.mkdirSync(snapshotPath, { mode: 448 });
+      let scope;
+      if (sourceStatus && mount.hydrateDeletionMode === "git") {
+        const outerPath = workspaceMountOuterPath(workspacePath, mount);
         (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
-          trustedRoot: durabilityRootPath,
-          candidate: sourcePath,
-          label: `Workspace hydration snapshot mount ${mount.id}`
+          trustedRoot: workspacePath,
+          candidate: outerPath,
+          label: `Workspace mount ${mount.id} outer source`
         });
-        const sourceStatus = lstatIfExists(sourcePath);
-        if (sourceStatus && (!sourceStatus.isDirectory() || sourceStatus.isSymbolicLink())) {
-          throw new Error(`Workspace hydration snapshot source is not a regular directory: ${sourcePath}`);
-        }
-        const snapshotName = String(index);
-        const snapshotPath = import_node_path.default.join(snapshotRoot, snapshotName);
-        import_node_fs.default.mkdirSync(snapshotPath, { mode: 448 });
-        if (sourceStatus) {
-          (0, import_working_tree_mirror.mirrorWorkingTree)({
-            sourceRoot: sourcePath,
-            targetRoot: snapshotPath,
-            sourceMode: "all",
-            deletionMode: "all",
-            // This tree is still private and the source authority is untouched.
-            // The single recursive barrier below makes the complete snapshot
-            // durable before its directory entry is published or hydration starts.
-            durability: "deferred_private_staging"
-          });
-        }
-        return {
-          id: mount.id,
-          incarnationKey: mount.hydrationIncarnationKey,
-          sourcePath,
-          durabilityRootPath,
-          workspaceRelativePath: mount.workspaceRelativePath,
-          existed: Boolean(sourceStatus),
-          snapshotName
-        };
-      })
+        const plan = (0, import_working_tree_mirror.planWorkingTreeMirror)({ sourceRoot: outerPath, targetRoot: sourcePath, sourceMode: "all", deletionMode: "git" });
+        scope = (0, import_working_tree_mirror.captureWorkingTreeMirrorPlan)({
+          plan,
+          targetRoot: sourcePath,
+          snapshotRoot: snapshotPath,
+          // Same private-staging deferral as the complete snapshot below.
+          durability: "deferred_private_staging"
+        });
+        durabilityScopes.set(mount.id, [...plan.desired.keys()]);
+      } else if (sourceStatus) {
+        (0, import_working_tree_mirror.mirrorWorkingTree)({
+          sourceRoot: sourcePath,
+          targetRoot: snapshotPath,
+          sourceMode: "all",
+          deletionMode: "all",
+          // This tree is still private and the source authority is untouched.
+          // The single recursive barrier below makes the complete snapshot
+          // durable before its directory entry is published or hydration starts.
+          durability: "deferred_private_staging"
+        });
+      }
+      return {
+        id: mount.id,
+        incarnationKey: mount.hydrationIncarnationKey,
+        sourcePath,
+        durabilityRootPath,
+        workspaceRelativePath: mount.workspaceRelativePath,
+        existed: Boolean(sourceStatus),
+        snapshotName,
+        ...scope ? { scope } : {}
+      };
+    });
+    const manifest = {
+      // Older workers reject version 4, so a scoped snapshot can never be
+      // replayed as a complete copy after a downgrade.
+      version: manifestMounts.some((mount) => mount.scope) ? 4 : 3,
+      targetReceipt,
+      receiptBefore,
+      mounts: manifestMounts
     };
     writePrivateFileDurably(import_node_path.default.join(stagingPath, "manifest.json"), `${JSON.stringify(manifest)}
 `);
     fsyncTree(stagingPath);
     import_node_fs.default.renameSync(stagingPath, transactionPath);
     fsyncDirectory(stateDirectory);
-    return manifest;
+    return { manifest, durabilityScopes };
   } catch (error) {
     import_node_fs.default.rmSync(stagingPath, { recursive: true, force: true });
     fsyncDirectory(stateDirectory);
@@ -1137,7 +1196,11 @@ function markHydrationTransactionDurable(workspacePath) {
   writePrivateFileDurably(import_node_path.default.join(transactionPath, "committed"), "committed\n");
   fsyncDirectory(transactionPath);
 }
-function fsyncHydratedWorkspaceMount(mount) {
+function gitVisibleDurabilityPaths(mount, sourcePath, sourceStatus) {
+  if (mount.hydrateDeletionMode !== "git" || !sourceStatus.isDirectory() || !lstatIfExists(import_node_path.default.join(sourcePath, ".git"))) return null;
+  return [...(0, import_working_tree_mirror.inspectWorkingTree)(sourcePath, "git").keys()];
+}
+function fsyncHydratedWorkspaceMount(mount, scope) {
   (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
     trustedRoot: mount.durabilityRootPath,
     candidate: mount.sourcePath,
@@ -1162,7 +1225,17 @@ function fsyncHydratedWorkspaceMount(mount) {
       import_node_fs.default.closeSync(descriptor);
     }
   };
-  if (import_node_fs.default.existsSync(mount.sourcePath)) syncEntry(mount.sourcePath, true);
+  const sourcePath = import_node_path.default.resolve(mount.sourcePath);
+  const sourceStatus = lstatIfExists(sourcePath);
+  if (sourceStatus) {
+    const paths = scope ?? gitVisibleDurabilityPaths(mount, sourcePath, sourceStatus);
+    if (paths) {
+      if (!sourceStatus.isDirectory()) throw new Error(`Workspace mount ${mount.id} source is not a regular directory: ${sourcePath}`);
+      (0, import_working_tree_mirror.fsyncWorkingTreePaths)(sourcePath, paths);
+    } else {
+      syncEntry(sourcePath, true);
+    }
+  }
   const durabilityRoot = import_node_path.default.resolve(mount.durabilityRootPath);
   let boundaryParent = import_node_path.default.dirname(import_node_path.default.resolve(mount.sourcePath));
   while (true) {
@@ -1181,8 +1254,8 @@ function fsyncHydratedWorkspaceMount(mount) {
     boundaryParent = nextParent;
   }
 }
-function fsyncHydratedWorkspaceMounts(mounts) {
-  for (const mount of mounts) fsyncHydratedWorkspaceMount(mount);
+function fsyncHydratedWorkspaceMounts(mounts, scopes = /* @__PURE__ */ new Map()) {
+  for (const mount of mounts) fsyncHydratedWorkspaceMount(mount, scopes.get(mount.id));
 }
 function workspaceIsShallow(workspacePath) {
   return gitResult(workspacePath, ["rev-parse", "--is-shallow-repository"]).stdout === "true";
@@ -1431,6 +1504,9 @@ function restoreDeferredWorkspaceMountsFromHead(workspacePath, mounts) {
     }
   }
 }
+function workspaceMountOuterPath(workspacePath, mount) {
+  return import_node_path.default.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
+}
 function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
   const hydratedMountIds = [];
   const skippedMountIds = [];
@@ -1439,7 +1515,7 @@ function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
       skippedMountIds.push(mount.id);
       continue;
     }
-    const sourceRoot = import_node_path.default.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
+    const sourceRoot = workspaceMountOuterPath(workspacePath, mount);
     (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
       trustedRoot: workspacePath,
       candidate: sourceRoot,
@@ -1525,56 +1601,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 = 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);
-    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 = {}) {
@@ -1586,7 +1673,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 = {}) {
@@ -1626,7 +1714,8 @@ async function recoverWorkspaceGitHydration(workspacePath, mounts, options = {})
     receiptMounts: configuredBasisMounts,
     requiredMounts: hydrationTargets,
     ignoreBusy: options.ignoreBusy,
-    recordCurrentHead: true
+    recordCurrentHead: true,
+    hydrationHooks: options.hydrationHooks
   });
   void hydration;
 }
@@ -1677,7 +1766,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");
@@ -1932,7 +2022,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(
@@ -2058,7 +2149,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);

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.97",
+  "version": "0.0.100",
   "type": "module"
 }