@ricsam/r5d-worker 0.0.136 → 0.0.137

package/dist/cjs/workspace-hydration-ledger.cjs

@@ -18,34 +18,49 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var workspace_hydration_ledger_exports = {};
 __export(workspace_hydration_ledger_exports, {
+  WorkspaceHydrationLedger: () => WorkspaceHydrationLedger,
   WorkspaceHydrationPreBlobLedger: () => WorkspaceHydrationPreBlobLedger
 });
 module.exports = __toCommonJS(workspace_hydration_ledger_exports);
-class WorkspaceHydrationPreBlobLedger {
+class WorkspaceHydrationLedger {
   mounts = /* @__PURE__ */ new Map();
   static key(mount) {
     return `${mount.hydrationIncarnationKey}\0${mount.id}`;
   }
-  /** Blob ids by mount-relative path for the mount, or an empty map. */
+  /** Entries by mount-relative path for the mount, or an empty map. */
+  entries(mount) {
+    return this.mounts.get(WorkspaceHydrationLedger.key(mount)) ?? /* @__PURE__ */ new Map();
+  }
+  /** Blob ids by mount-relative path for the mount (the §3.3 detector's input), or an empty map. */
   preBlobs(mount) {
-    return this.mounts.get(WorkspaceHydrationPreBlobLedger.key(mount)) ?? /* @__PURE__ */ new Map();
+    return new Map([...this.entries(mount)].map(([relativePath, entry]) => [relativePath, entry.preBlob]));
   }
-  /** Record the pre-hydration blob of every path a merge hydration replaced; earlier entries for other paths are kept. */
-  record(mount, preBlobs) {
-    const entries = preBlobs instanceof Map ? [...preBlobs] : Object.entries(preBlobs);
-    if (entries.length === 0) return;
-    const key = WorkspaceHydrationPreBlobLedger.key(mount);
+  /**
+   * Record what a merge hydration replaced; earlier entries for other paths
+   * are kept. A path that already carries a live entry keeps its `preBlob`
+   * while the new hydration also ran across a live process: the process's
+   * read predates both hydrations, so what it read is still the first blob.
+   */
+  record(mount, entries, options = {}) {
+    const incoming = entries instanceof Map ? [...entries] : Object.entries(entries);
+    if (incoming.length === 0) return;
+    const replace = new Set(options.replacePreBlobFor ?? []);
+    const key = WorkspaceHydrationLedger.key(mount);
     const current = this.mounts.get(key) ?? /* @__PURE__ */ new Map();
-    for (const [relativePath, blob] of entries) current.set(relativePath, blob);
+    for (const [relativePath, entry] of incoming) {
+      const previous = current.get(relativePath);
+      const preBlob = previous && previous.processLiveAcrossHydration && entry.processLiveAcrossHydration && !replace.has(relativePath) ? previous.preBlob : entry.preBlob;
+      current.set(relativePath, { ...entry, preBlob });
+    }
     this.mounts.set(key, current);
   }
   /** Forget the mount: its checkout was rewritten by something this ledger did not observe. */
   clearMount(mount) {
-    this.mounts.delete(WorkspaceHydrationPreBlobLedger.key(mount));
+    this.mounts.delete(WorkspaceHydrationLedger.key(mount));
   }
   /** Forget paths whose checkout content moved on from the hydrated bytes: a later return to the old bytes is a deliberate edit. */
   forget(mount, paths) {
-    const key = WorkspaceHydrationPreBlobLedger.key(mount);
+    const key = WorkspaceHydrationLedger.key(mount);
     const current = this.mounts.get(key);
     if (!current) return;
     for (const relativePath of paths) current.delete(relativePath);
@@ -60,7 +75,9 @@ class WorkspaceHydrationPreBlobLedger {
     return total;
   }
 }
+const WorkspaceHydrationPreBlobLedger = WorkspaceHydrationLedger;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  WorkspaceHydrationLedger,
   WorkspaceHydrationPreBlobLedger
 });

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

@@ -120,6 +120,8 @@ function decideWorkspaceHydrationMerge(input) {
   const overrides = /* @__PURE__ */ new Map();
   const expectations = /* @__PURE__ */ new Map();
   const preBlobs = /* @__PURE__ */ new Map();
+  const postBlobs = /* @__PURE__ */ new Map();
+  const blobsToStore = /* @__PURE__ */ new Map();
   const mergedPaths = [];
   const keptPaths = /* @__PURE__ */ new Set();
   const desiredForIndex = new Map(desired);
@@ -172,13 +174,17 @@ function decideWorkspaceHydrationMerge(input) {
             remove.add(relativePath);
             expectations.set(relativePath, oursStat);
           }
-          if (change.base && isBlobMode(change.base.mode)) preBlobs.set(relativePath, change.base.objectId);
+          if (change.base && isBlobMode(change.base.mode)) {
+            preBlobs.set(relativePath, change.base.objectId);
+            postBlobs.set(relativePath, null);
+          }
           continue;
         }
         write.add(relativePath);
         expectations.set(relativePath, oursStat ?? currentTargetStat(targetRoot, relativePath));
         if (change.base && isBlobMode(change.base.mode) && change.base.objectId !== change.theirs.objectId) {
           preBlobs.set(relativePath, change.base.objectId);
+          postBlobs.set(relativePath, isBlobMode(change.theirs.mode) ? change.theirs.objectId : null);
         }
         continue;
       }
@@ -292,7 +298,14 @@ function decideWorkspaceHydrationMerge(input) {
         overrides.set(relativePath, { content: merged.content, mode });
         write.add(relativePath);
         expectations.set(relativePath, candidate.oursStat);
-        if (!contentUnchanged) preBlobs.set(relativePath, hashOf(oursBytes));
+        if (!contentUnchanged) {
+          const preBlob = hashOf(oursBytes);
+          const postBlob = hashOf(merged.content);
+          preBlobs.set(relativePath, preBlob);
+          postBlobs.set(relativePath, postBlob);
+          blobsToStore.set(preBlob, oursBytes);
+          blobsToStore.set(postBlob, merged.content);
+        }
         mergedPaths.push(relativePath);
       }
     }
@@ -366,6 +379,8 @@ function decideWorkspaceHydrationMerge(input) {
     overrides,
     expectations,
     preBlobs,
+    postBlobs,
+    blobsToStore,
     mergedPaths: mergedPaths.sort(),
     keptPaths: [...keptPaths].sort()
   };

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

@@ -251,9 +251,12 @@ function synthesizeMountTree(input) {
     removeTemporaryIndex(indexPath);
   }
 }
-function staleRewritePaths(input) {
-  const entries = Object.entries(input.staleRewriteBlobs ?? {});
-  if (entries.length === 0) return { stale: [], cleared: [] };
+function ledgerStatMatches(recorded, projected) {
+  return recorded !== null && projected?.kind === "file" && projected.ino === recorded.ino && projected.size === recorded.size && projected.mode === recorded.mode && projected.mtimeMs === recorded.mtimeMs && projected.ctimeMs === recorded.ctimeMs;
+}
+function classifyHydrationLedger(input) {
+  const entries = Object.entries(input.hydrationLedger ?? {});
+  if (entries.length === 0) return { stale: [], merge: [], cleared: [] };
   const probed = gitText(input.workspacePath, ["cat-file", "--batch-check"], "resolve workspace projection basis subtree", {
     stdin: Buffer.from(`${input.basisHead}:${input.workspaceRelativePath}
 `)
@@ -274,21 +277,116 @@ function staleRewritePaths(input) {
     for (let index = 0; index + 1 < records.length; index += 2) changed.add(records[index + 1].toString());
   }
   const stale = [];
+  const merge = [];
   const cleared = [];
-  for (const [relativePath, blob] of entries) {
+  for (const [relativePath, entry] of entries) {
     const synthesized = input.blobs.get(relativePath);
     if (synthesized === void 0) {
+      if (entry.postBlob === null) continue;
+      cleared.push(relativePath);
+      continue;
+    }
+    if (ledgerStatMatches(entry.stat, input.projectedFiles[relativePath]) || synthesized === entry.postBlob) continue;
+    if (!changed.has(relativePath)) {
       cleared.push(relativePath);
       continue;
     }
-    if (synthesized === blob) {
-      if (changed.has(relativePath)) stale.push(relativePath);
-      else cleared.push(relativePath);
+    if (entry.processLiveAcrossHydration) {
+      merge.push({ relativePath, preBlob: entry.preBlob, postBlob: entry.postBlob });
       continue;
     }
-    if (changed.has(relativePath)) cleared.push(relativePath);
+    if (synthesized === entry.preBlob) {
+      stale.push(relativePath);
+      continue;
+    }
+    cleared.push(relativePath);
+  }
+  if (merge.length > 0) {
+    const ids = [...new Set(merge.flatMap(({ preBlob, postBlob }) => postBlob ? [preBlob, postBlob] : [preBlob]))];
+    const checked = gitText(input.workspacePath, ["cat-file", "--batch-check"], "verify hydration ledger blobs", {
+      stdin: Buffer.from(`${ids.join("\n")}
+`)
+    });
+    const missing = new Set(
+      checked.split("\n").filter((line) => / missing$/u.test(line)).map((line) => line.split(" ")[0])
+    );
+    if (missing.size > 0) {
+      for (let index = merge.length - 1; index >= 0; index -= 1) {
+        const { relativePath, preBlob, postBlob } = merge[index];
+        if (missing.has(preBlob) || postBlob !== null && missing.has(postBlob)) {
+          merge.splice(index, 1);
+          cleared.push(relativePath);
+        }
+      }
+    }
+  }
+  return { stale: stale.sort(), merge: merge.sort((left, right) => left.relativePath.localeCompare(right.relativePath)), cleared: cleared.sort() };
+}
+function hydrationLedgerMergeBase(input) {
+  if (input.merges.length === 0) return input.basisHead;
+  return commitWithLedgerPaths({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    parent: input.basisHead,
+    paths: input.merges.map(({ relativePath, preBlob }) => ({ relativePath, blob: preBlob })),
+    message: JSON.stringify({
+      type: "workspace_hydration_ledger_basis",
+      mountId: input.mountId,
+      attemptId: input.attemptId,
+      paths: input.merges.map(({ relativePath }) => relativePath)
+    }),
+    action: "hydration ledger merge base"
+  });
+}
+function hydrationLedgerTheirs(input) {
+  const paths = input.merges.flatMap(({ relativePath, postBlob }) => postBlob ? [{ relativePath, blob: postBlob }] : []);
+  if (paths.length === 0) return input.currentHead;
+  return commitWithLedgerPaths({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    parent: input.currentHead,
+    paths,
+    message: JSON.stringify({
+      type: "workspace_hydration_ledger_theirs",
+      mountId: input.mountId,
+      attemptId: input.attemptId,
+      paths: paths.map(({ relativePath }) => relativePath)
+    }),
+    action: "hydration ledger theirs"
+  });
+}
+function commitWithLedgerPaths(input) {
+  const indexPath = temporaryIndexPath(input.workspacePath);
+  const environment = temporaryIndexEnvironment(indexPath);
+  try {
+    git(input.workspacePath, ["read-tree", input.parent], `read workspace tree for the ${input.action}`, { environment });
+    const paths = input.paths.map(({ relativePath }) => `${input.workspaceRelativePath}/${relativePath}`);
+    const listed = git(
+      input.workspacePath,
+      ["ls-files", "-z", "--stage", "--", ...paths.map((entry) => `:(literal)${entry}`)],
+      `inspect modes for the ${input.action}`,
+      { environment }
+    );
+    const modes = /* @__PURE__ */ new Map();
+    for (const record of nulRecords(listed)) {
+      const match = /^([0-7]{6}) [0-9a-f]{40,64} [0-3]\t(.+)$/su.exec(record.toString());
+      if (match) modes.set(match[2], match[1]);
+    }
+    const records = input.paths.map(
+      ({ relativePath, blob }, index) => indexInfoRecord(modes.get(paths[index]) ?? "100644", requireObjectId(blob, `hydration ledger blob for ${relativePath}`), paths[index])
+    );
+    git(input.workspacePath, ["update-index", "-z", "--index-info"], `rewrite paths for the ${input.action}`, {
+      environment,
+      stdin: Buffer.concat(records)
+    });
+    const tree = requireObjectId(gitText(input.workspacePath, ["write-tree"], `write the ${input.action}`, { environment }), `${input.action} tree`);
+    return requireObjectId(
+      gitText(input.workspacePath, ["commit-tree", tree, "-p", input.parent, "-m", input.message], `commit the ${input.action}`),
+      `${input.action} commit`
+    );
+  } finally {
+    removeTemporaryIndex(indexPath);
   }
-  return { stale: stale.sort(), cleared: cleared.sort() };
 }
 function nulRecords(content) {
   const records = [];
@@ -322,12 +420,14 @@ function graftMountTree(input) {
         stdin: removedPaths
       });
     }
-    git(
-      input.workspacePath,
-      ["read-tree", "-i", `--prefix=${input.workspaceRelativePath}/`, input.mountTree],
-      "graft workspace projection mount tree",
-      { environment }
-    );
+    if (input.mountTree !== null) {
+      git(
+        input.workspacePath,
+        ["read-tree", "-i", `--prefix=${input.workspaceRelativePath}/`, input.mountTree],
+        "graft workspace projection mount tree",
+        { environment }
+      );
+    }
     return requireObjectId(
       gitText(input.workspacePath, ["write-tree"], "write grafted workspace projection tree", { environment }),
       "Grafted workspace projection tree"
@@ -336,25 +436,41 @@ function graftMountTree(input) {
     removeTemporaryIndex(indexPath);
   }
 }
+function mountSubtreeObjectId(workspacePath, revision, workspaceRelativePath, label) {
+  const spec = `${revision}:${workspaceRelativePath}`;
+  if (gitResult(workspacePath, ["cat-file", "-e", spec]).exitCode !== 0) return null;
+  const type = gitText(workspacePath, ["cat-file", "-t", spec], `inspect ${label}`);
+  if (type !== "tree") throw new Error(`${label} is not a directory at ${workspaceRelativePath}`);
+  return requireObjectId(gitText(workspacePath, ["rev-parse", spec], `resolve ${label}`), label);
+}
 function synthesizeOursCommit(input) {
   const synthesized = synthesizeMountTree({
     workspacePath: input.workspacePath,
     sourcePath: input.mount.sourcePath,
     sourceMode: input.mount.sourceMode
   });
-  const detected = staleRewritePaths({
+  const classified = classifyHydrationLedger({
     workspacePath: input.workspacePath,
     workspaceRelativePath: input.workspaceRelativePath,
     basisHead: input.basisHead,
     mountTree: synthesized.tree,
     blobs: synthesized.blobs,
-    staleRewriteBlobs: input.staleRewriteBlobs
+    projectedFiles: synthesized.projectedFiles,
+    hydrationLedger: input.hydrationLedger
   });
-  if (detected.stale.length > 0) return { staleRewritePaths: detected.stale, staleRewriteCleared: detected.cleared };
-  const rootTree = graftMountTree({
+  if (classified.stale.length > 0) return { staleRewritePaths: classified.stale, staleRewriteCleared: classified.cleared };
+  const mergeBase = hydrationLedgerMergeBase({
     workspacePath: input.workspacePath,
     workspaceRelativePath: input.workspaceRelativePath,
     basisHead: input.basisHead,
+    merges: classified.merge,
+    mountId: input.mount.id,
+    attemptId: input.attemptId
+  });
+  const rootTree = graftMountTree({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    basisHead: mergeBase,
     mountTree: synthesized.tree
   });
   const message = JSON.stringify({
@@ -365,12 +481,18 @@ function synthesizeOursCommit(input) {
   const oursCommit = requireObjectId(
     gitText(
       input.workspacePath,
-      ["commit-tree", rootTree, "-p", input.basisHead, "-m", message],
+      ["commit-tree", rootTree, "-p", mergeBase, "-m", message],
       `commit synthesized workspace projection for mount ${input.mount.id}`
     ),
     `Synthesized workspace projection commit for mount ${input.mount.id}`
   );
-  return { oursCommit, projectedFiles: synthesized.projectedFiles, staleRewriteCleared: detected.cleared };
+  return {
+    oursCommit,
+    mergeBase,
+    projectedFiles: synthesized.projectedFiles,
+    staleRewriteCleared: classified.cleared,
+    ledgerMerges: classified.merge
+  };
 }
 function mergeWorkspaceProjectionMount(input) {
   const support = workspaceMergeProjectionSupport();
@@ -385,31 +507,69 @@ function mergeWorkspaceProjectionMount(input) {
     workspaceRelativePath,
     basisHead,
     attemptId: input.attemptId,
-    ...input.staleRewriteBlobs ? { staleRewriteBlobs: input.staleRewriteBlobs } : {}
+    ...input.hydrationLedger ? { hydrationLedger: input.hydrationLedger } : {}
   });
   if ("staleRewritePaths" in synthesized) {
     return { kind: "stale_rewrite", paths: synthesized.staleRewritePaths, staleRewriteCleared: synthesized.staleRewriteCleared };
   }
-  const { oursCommit, projectedFiles, staleRewriteCleared } = synthesized;
+  const { oursCommit, mergeBase, projectedFiles, staleRewriteCleared, ledgerMerges } = synthesized;
+  const ledgerMergedPaths = ledgerMerges.map(({ relativePath }) => relativePath);
+  const theirsHead = hydrationLedgerTheirs({
+    workspacePath,
+    workspaceRelativePath,
+    currentHead,
+    merges: ledgerMerges,
+    mountId: input.mount.id,
+    attemptId: input.attemptId
+  });
   const readAtMs = Date.now();
+  const inboundMountTree = mountSubtreeObjectId(
+    workspacePath,
+    theirsHead,
+    workspaceRelativePath,
+    `current workspace head subtree for mount ${input.mount.id}`
+  );
+  const inboundCommit = requireObjectId(
+    gitText(
+      workspacePath,
+      [
+        "commit-tree",
+        graftMountTree({ workspacePath, workspaceRelativePath, basisHead: mergeBase, mountTree: inboundMountTree }),
+        "-p",
+        mergeBase,
+        "-m",
+        JSON.stringify({ type: "workspace_projection_inbound", mountId: input.mount.id, attemptId: input.attemptId })
+      ],
+      `commit inbound workspace projection for mount ${input.mount.id}`
+    ),
+    `Inbound workspace projection commit for mount ${input.mount.id}`
+  );
   const merged = gitResult(workspacePath, [
     "merge-tree",
     "--write-tree",
-    `--merge-base=${basisHead}`,
+    `--merge-base=${mergeBase}`,
     "--name-only",
     "-z",
     "--no-messages",
     oursCommit,
-    currentHead
+    inboundCommit
   ]);
   if (merged.exitCode !== 0 && merged.exitCode !== 1) {
     const detail = merged.stderr.toString().trim() || merged.stdout.toString().trim() || `git exited ${merged.exitCode}`;
     throw new Error(`Merge workspace projection for mount ${input.mount.id}: ${detail}`);
   }
   const records = nulRecords(merged.stdout);
-  const resultTree = records.shift()?.toString() ?? "";
-  requireObjectId(resultTree, `Merged workspace projection tree for mount ${input.mount.id}`);
-  if (merged.exitCode === 0) return { kind: "clean", resultTree, oursCommit, projectedFiles, readAtMs, staleRewriteCleared };
+  const mergedTree = records.shift()?.toString() ?? "";
+  requireObjectId(mergedTree, `Merged workspace projection tree for mount ${input.mount.id}`);
+  if (merged.exitCode === 0) {
+    const resultTree = graftMountTree({
+      workspacePath,
+      workspaceRelativePath,
+      basisHead: currentHead,
+      mountTree: mountSubtreeObjectId(workspacePath, mergedTree, workspaceRelativePath, `merged subtree for mount ${input.mount.id}`)
+    });
+    return { kind: "clean", resultTree, oursCommit, projectedFiles, readAtMs, staleRewriteCleared, ledgerMergedPaths };
+  }
   const conflictPaths = records.map((record) => record.toString()).sort();
   return {
     kind: "conflict",
@@ -418,7 +578,8 @@ function mergeWorkspaceProjectionMount(input) {
     error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`,
     projectedFiles,
     readAtMs,
-    staleRewriteCleared
+    staleRewriteCleared,
+    ledgerMergedPaths
   };
 }
 function materializeWorkspaceProjectionTree(input) {

package/dist/mjs/main.mjs

@@ -4330,6 +4330,8 @@ async function startWorker(options, projectRuntime = {
     });
   };
   const projectBranchMountBusy = (projectId, branchName, branchPath) => !readyProjectIds.has(projectId) || projectBranchMountActivityBusy(projectId, branchName, branchPath);
+  const projectBranchMountFenced = (projectId, branchName, branchPath) => !readyProjectIds.has(projectId) || projectConfigById.get(projectId)?.executionDisabled === true || hasProjectWorktree(branchPath) && projectWorktreeOperationInProgress(branchPath) || canonicalWorkspaceMutationIsActive(activeWorkspaceMutationTargets());
+  const projectBranchMountProcessLive = (projectId, branchName) => projectBranchHasActiveWorkspaceTarget(projectId, branchName, activeWorkspaceMutationTargets());
   const inventoryConfiguredProjectCheckouts = () => {
     const inventory = { projects: [], missingCheckouts: [] };
     for (const project of projectConfigById.values()) {
@@ -4415,7 +4417,11 @@ async function startWorker(options, projectRuntime = {
               ].filter((id) => typeof id === "string")
             )
           ].join(", ") || "no live declared holder",
-          busy: () => projectBranchMountBusy(project.projectId, branch.branchName, branchPath),
+          // A running job no longer pins its checkout: merge hydration folds
+          // inbound changes into it. The plan mount below keeps the old fence
+          // because its all-mode hydration is a plain mirror.
+          busy: () => projectBranchMountFenced(project.projectId, branch.branchName, branchPath),
+          processLive: () => projectBranchMountProcessLive(project.projectId, branch.branchName),
           mutationToken: () => projectWorkspaceMutationToken(project.projectId, branch.branchName),
           busyForRecovery: () => projectBranchMountExclusiveSyncBusy(project.projectId, branch.branchName, branchPath)
         });

package/dist/mjs/package.json

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