@ricsam/r5d-worker 0.0.97 → 0.0.100

package/dist/cjs/main.cjs

@@ -97,9 +97,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 {
 }
@@ -4370,6 +4396,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");
@@ -4392,7 +4419,8 @@ async function startWorker(options) {
         credentialHelper: workspaceCredentialHelper,
         credentialUsername: workspaceCredentialUsername,
         gitIdentity: workspaceGitIdentity,
-        mounts: configuredMounts
+        mounts: configuredMounts,
+        hydrationHooks: workspaceHydrationTransactionHooks
       });
       await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads2, reset.activeMountIds, true);
       return {
@@ -4446,7 +4474,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) {
@@ -5040,7 +5069,10 @@ async function startWorker(options) {
           sourcePath: recoverySourceOverrides.get(mount.id) ?? mount.sourcePath,
           busy: mount.busyForRecovery ?? mount.busy
         }));
-        await (0, import_workspace_git_sync.recoverWorkspaceGitHydration)(workspaceShadowRoot, recoveryMounts, { preserveStaleBases: true });
+        await (0, import_workspace_git_sync.recoverWorkspaceGitHydration)(workspaceShadowRoot, recoveryMounts, {
+          preserveStaleBases: true,
+          hydrationHooks: workspaceHydrationTransactionHooks
+        });
         for (const project of message.projects) {
           for (const { branchName } of project.preserveOnlyBranches) {
             if (stillPendingCreatedBranches.has((0, import_workspace_automatic_sync_policy.pendingCreatedBranchKey)(project.projectId, branchName))) {
@@ -5084,7 +5116,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/cjs/package.json

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

package/dist/cjs/working-tree-mirror.cjs

@@ -29,8 +29,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var working_tree_mirror_exports = {};
 __export(working_tree_mirror_exports, {
   assertWorkingTreeHasNoPortableGitMetadataAliases: () => assertWorkingTreeHasNoPortableGitMetadataAliases,
+  captureWorkingTreeMirrorPlan: () => captureWorkingTreeMirrorPlan,
+  fsyncWorkingTreePaths: () => fsyncWorkingTreePaths,
   inspectWorkingTree: () => inspectWorkingTree,
-  mirrorWorkingTree: () => mirrorWorkingTree
+  mirrorWorkingTree: () => mirrorWorkingTree,
+  normalizeWorkingTreeRelativePath: () => normalizeWorkingTreeRelativePath,
+  planWorkingTreeMirror: () => planWorkingTreeMirror,
+  restoreWorkingTreeMirrorScope: () => restoreWorkingTreeMirrorScope
 });
 module.exports = __toCommonJS(working_tree_mirror_exports);
 var import_node_fs = __toESM(require("node:fs"), 1);
@@ -186,14 +191,55 @@ function addParentDirectories(entries, root) {
     }
   }
 }
-function inspectWorkingTree(root, mode) {
+function gitlinkPaths(root) {
+  const result = Bun.spawnSync(
+    [
+      "git",
+      "-c",
+      "submodule.recurse=false",
+      "-c",
+      "fetch.recurseSubmodules=false",
+      "-c",
+      "push.recurseSubmodules=false",
+      "ls-files",
+      "-z",
+      "--stage",
+      "--",
+      "."
+    ],
+    {
+      cwd: root,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: (0, import_git_process_environment.workerGitProcessEnvironment)()
+    }
+  );
+  if (result.exitCode !== 0) {
+    throw new Error(`Inspect Git index gitlinks: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
+  }
+  const gitlinks = /* @__PURE__ */ new Set();
+  for (const record of result.stdout.toString().split("\0")) {
+    const match = /^160000 [0-9a-f]+ [0-3]\t(.+)$/su.exec(record);
+    if (!match) continue;
+    const normalized = normalizeRelativePath(match[1]);
+    if (normalized) gitlinks.add(normalized);
+  }
+  return gitlinks;
+}
+function directoryIsEmpty(root, relativePath) {
+  const inspected = inspectRelativePathWithoutFollowingAncestors(root, relativePath);
+  return inspected.kind === "entry" && inspected.stat.isDirectory() && import_node_fs.default.readdirSync(inspected.absolutePath).length === 0;
+}
+function inspectWorkingTree(root, mode, options = {}) {
   const entries = /* @__PURE__ */ new Map();
   root = import_node_path.default.resolve(root);
   if (!inspectDirectoryRoot(root, { allowMissing: true, label: "Working-tree root" })) return entries;
   if (mode === "all") {
     for (const child of import_node_fs.default.readdirSync(root).sort()) addEntry(entries, root, child, true);
   } else {
+    const omittedGitlinks = options.omitUnpopulatedGitlinks ? gitlinkPaths(root) : null;
     for (const relativePath of gitEligibleRoots(root)) {
+      if (omittedGitlinks?.has(relativePath) && directoryIsEmpty(root, relativePath)) continue;
       addEntry(entries, root, relativePath, true);
     }
   }
@@ -367,7 +413,9 @@ function mirrorWorkingTree(input) {
   }
   inspectDirectoryRoot(targetRoot, { allowMissing: false, label: "Working-tree target root" });
   const desired = inspectWorkingTree(sourceRoot, input.sourceMode);
-  const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all");
+  const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all", {
+    omitUnpopulatedGitlinks: input.deletionMode === "git"
+  });
   for (const relativePath of [...existing.keys()].sort((left, right) => right.split("/").length - left.split("/").length)) {
     if (!desired.has(relativePath)) removeEntry(targetRoot, relativePath);
   }
@@ -378,9 +426,213 @@ function mirrorWorkingTree(input) {
   }
   return { paths: [...desired.keys()].filter((relativePath) => desired.get(relativePath)?.kind !== "directory").sort() };
 }
+function normalizeWorkingTreeRelativePath(value) {
+  return normalizeRelativePath(value);
+}
+const MIRROR_TEMPORARY_FILE_PATTERN = /^\.r5d-working-tree-mirror-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp$/u;
+function relativeDepth(relativePath) {
+  return relativePath.split("/").length;
+}
+function shallowestFirst(left, right) {
+  return relativeDepth(left) - relativeDepth(right) || left.localeCompare(right);
+}
+function deepestFirst(left, right) {
+  return relativeDepth(right) - relativeDepth(left) || left.localeCompare(right);
+}
+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 treeEntryFromStat(stat, absolutePath) {
+  if (stat.isSymbolicLink()) return { kind: "symlink", mode: stat.mode, target: import_node_fs.default.readlinkSync(absolutePath) };
+  if (stat.isFile()) return { kind: "file", mode: stat.mode, size: stat.size };
+  if (stat.isDirectory()) return { kind: "directory", mode: stat.mode };
+  return null;
+}
+function fsyncPath(targetPath, flags) {
+  const descriptor = import_node_fs.default.openSync(targetPath, flags);
+  try {
+    import_node_fs.default.fsyncSync(descriptor);
+  } finally {
+    import_node_fs.default.closeSync(descriptor);
+  }
+}
+function planWorkingTreeMirror(input) {
+  const sourceRoot = import_node_path.default.resolve(input.sourceRoot);
+  const targetRoot = import_node_path.default.resolve(input.targetRoot);
+  const desired = inspectWorkingTree(sourceRoot, input.sourceMode);
+  const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all", {
+    omitUnpopulatedGitlinks: input.deletionMode === "git"
+  });
+  const replaced = /* @__PURE__ */ new Map();
+  const absent = [];
+  for (const [relativePath, entry] of existing) {
+    if (!desired.has(relativePath)) replaced.set(relativePath, entry);
+  }
+  for (const [relativePath, entry] of desired) {
+    const target = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (target.kind !== "entry") {
+      absent.push(relativePath);
+      continue;
+    }
+    const { absolutePath, stat } = target;
+    if (entry.kind === "directory") {
+      if (stat.isDirectory()) continue;
+    } else if (entry.kind === "symlink") {
+      if (stat.isSymbolicLink() && import_node_fs.default.readlinkSync(absolutePath) === entry.target) continue;
+    } else if (stat.isFile() && filesEqual(import_node_path.default.join(sourceRoot, ...relativePath.split("/")), absolutePath, entry)) {
+      continue;
+    }
+    const current = treeEntryFromStat(stat, absolutePath);
+    if (current) replaced.set(relativePath, current);
+    else absent.push(relativePath);
+  }
+  const replacedDirectories = new Set(
+    [...replaced].filter(([, entry]) => entry.kind === "directory").map(([relativePath]) => relativePath)
+  );
+  for (const relativePath of [...replaced.keys()]) {
+    if (hasAncestorIn(relativePath, replacedDirectories)) replaced.delete(relativePath);
+  }
+  return {
+    desired,
+    replaced,
+    absent: absent.filter((relativePath) => !hasAncestorIn(relativePath, replacedDirectories)).sort(shallowestFirst)
+  };
+}
+function captureWorkingTreeMirrorPlan(input) {
+  const targetRoot = import_node_path.default.resolve(input.targetRoot);
+  const snapshotRoot = import_node_path.default.resolve(input.snapshotRoot);
+  const durability = input.durability ?? "per_entry";
+  inspectDirectoryRoot(targetRoot, { allowMissing: false, label: "Working-tree target root" });
+  if (!inspectDirectoryRoot(snapshotRoot, { allowMissing: true, label: "Working-tree snapshot root" })) {
+    import_node_fs.default.mkdirSync(snapshotRoot, { recursive: true });
+  }
+  const trees = [];
+  for (const [relativePath, entry] of [...input.plan.replaced.entries()].sort(([left], [right]) => shallowestFirst(left, right))) {
+    if (entry.kind !== "directory") {
+      copyEntry(targetRoot, snapshotRoot, relativePath, entry, durability);
+      continue;
+    }
+    const source = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (source.kind !== "entry" || !source.stat.isDirectory()) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${import_node_path.default.join(targetRoot, ...relativePath.split("/"))}`);
+    }
+    ensureDirectory(snapshotRoot, relativePath, entry.mode);
+    mirrorWorkingTree({
+      sourceRoot: source.absolutePath,
+      targetRoot: import_node_path.default.join(snapshotRoot, ...relativePath.split("/")),
+      sourceMode: "all",
+      deletionMode: "all",
+      durability
+    });
+    trees.push(relativePath);
+  }
+  return { absent: [...input.plan.absent].sort(shallowestFirst), trees: trees.sort(shallowestFirst) };
+}
+function restoreWorkingTreeMirrorScope(input) {
+  const snapshotRoot = import_node_path.default.resolve(input.snapshotRoot);
+  const targetRoot = import_node_path.default.resolve(input.targetRoot);
+  inspectDirectoryRoot(snapshotRoot, { allowMissing: false, label: "Working-tree snapshot root" });
+  if (!inspectDirectoryRoot(targetRoot, { allowMissing: true, label: "Working-tree target root" })) {
+    import_node_fs.default.mkdirSync(targetRoot, { recursive: true });
+  }
+  const normalize = (relativePath) => {
+    const normalized = normalizeRelativePath(relativePath);
+    if (!normalized) throw new Error(`Invalid working-tree scope path: ${relativePath}`);
+    return normalized;
+  };
+  const absent = input.scope.absent.map(normalize);
+  const trees = new Set(input.scope.trees.map(normalize));
+  const captured = inspectWorkingTree(snapshotRoot, "all");
+  for (const tree of trees) {
+    if (captured.get(tree)?.kind !== "directory") {
+      throw new Error(`Working-tree snapshot does not hold the captured directory: ${tree}`);
+    }
+  }
+  const touched = /* @__PURE__ */ new Set();
+  for (const relativePath of [...absent].sort(deepestFirst)) {
+    const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (inspected.kind === "entry") import_node_fs.default.rmSync(inspected.absolutePath, { recursive: true, force: true });
+    touched.add(relativePath);
+  }
+  const writtenDirectories = /* @__PURE__ */ new Set();
+  for (const relativePath of absent) writtenDirectories.add(import_node_path.default.posix.dirname(relativePath));
+  for (const [relativePath, entry] of captured) {
+    if (entry.kind !== "directory" && !hasAncestorIn(relativePath, trees)) writtenDirectories.add(import_node_path.default.posix.dirname(relativePath));
+  }
+  for (const directory of writtenDirectories) {
+    let absoluteDirectory = targetRoot;
+    if (directory !== ".") {
+      const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, directory);
+      if (inspected.kind !== "entry" || !inspected.stat.isDirectory()) continue;
+      absoluteDirectory = inspected.absolutePath;
+    }
+    for (const name of import_node_fs.default.readdirSync(absoluteDirectory)) {
+      if (!MIRROR_TEMPORARY_FILE_PATTERN.test(name)) continue;
+      const temporaryPath = import_node_path.default.join(absoluteDirectory, name);
+      if (!import_node_fs.default.lstatSync(temporaryPath).isFile()) continue;
+      import_node_fs.default.rmSync(temporaryPath, { force: true });
+      touched.add(directory === "." ? name : import_node_path.default.posix.join(directory, name));
+    }
+  }
+  for (const [relativePath, entry] of [...captured.entries()].sort(([left], [right]) => shallowestFirst(left, right))) {
+    touched.add(relativePath);
+    if (hasAncestorIn(relativePath, trees)) continue;
+    if (!trees.has(relativePath)) {
+      copyEntry(snapshotRoot, targetRoot, relativePath, entry, "per_entry");
+      continue;
+    }
+    const current = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (current.kind === "blocked") {
+      throw new Error(`Refusing to restore a working-tree directory through a symlink or non-directory: ${current.blockingPath}`);
+    }
+    if (current.kind === "entry" && !current.stat.isDirectory()) {
+      import_node_fs.default.rmSync(current.absolutePath, { recursive: true, force: true });
+    }
+    ensureDirectory(targetRoot, relativePath, entry.mode);
+    mirrorWorkingTree({
+      sourceRoot: import_node_path.default.join(snapshotRoot, ...relativePath.split("/")),
+      targetRoot: import_node_path.default.join(targetRoot, ...relativePath.split("/")),
+      sourceMode: "all",
+      deletionMode: "all"
+    });
+  }
+  return { paths: [...touched].sort(shallowestFirst) };
+}
+function fsyncWorkingTreePaths(root, relativePaths) {
+  root = import_node_path.default.resolve(root);
+  inspectDirectoryRoot(root, { allowMissing: false, label: "Working-tree root" });
+  const directories = /* @__PURE__ */ new Set(["."]);
+  for (const relativePath of relativePaths) {
+    const normalized = normalizeRelativePath(relativePath);
+    if (!normalized) throw new Error(`Invalid working-tree path: ${relativePath}`);
+    directories.add(import_node_path.default.posix.dirname(normalized));
+    const inspected = inspectRelativePathWithoutFollowingAncestors(root, normalized);
+    if (inspected.kind !== "entry") continue;
+    if (inspected.stat.isDirectory()) directories.add(normalized);
+    else if (inspected.stat.isFile()) fsyncPath(inspected.absolutePath, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
+  }
+  for (const directory of directories) {
+    if (directory === ".") {
+      fsyncPath(root, import_node_fs.default.constants.O_RDONLY);
+      continue;
+    }
+    const inspected = inspectRelativePathWithoutFollowingAncestors(root, directory);
+    if (inspected.kind === "entry" && inspected.stat.isDirectory()) fsyncPath(inspected.absolutePath, import_node_fs.default.constants.O_RDONLY);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   assertWorkingTreeHasNoPortableGitMetadataAliases,
+  captureWorkingTreeMirrorPlan,
+  fsyncWorkingTreePaths,
   inspectWorkingTree,
-  mirrorWorkingTree
+  mirrorWorkingTree,
+  normalizeWorkingTreeRelativePath,
+  planWorkingTreeMirror,
+  restoreWorkingTreeMirrorScope
 });