@ricsam/r5d-worker 0.0.82 → 0.0.86

package/dist/cjs/package.json

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

package/dist/cjs/workspace-automatic-sync-policy.cjs

@@ -23,7 +23,9 @@ __export(workspace_automatic_sync_policy_exports, {
   pendingCreatedBranchAutomaticSyncDeferral: () => pendingCreatedBranchAutomaticSyncDeferral,
   pendingCreatedBranchKey: () => pendingCreatedBranchKey,
   projectBranchHasActiveWorkspaceTarget: () => projectBranchHasActiveWorkspaceTarget,
-  shouldDeferAutomaticWorkspaceSyncForPendingBranch: () => shouldDeferAutomaticWorkspaceSyncForPendingBranch
+  projectBranchMountBusyDuringExclusiveSync: () => projectBranchMountBusyDuringExclusiveSync,
+  shouldDeferAutomaticWorkspaceSyncForPendingBranch: () => shouldDeferAutomaticWorkspaceSyncForPendingBranch,
+  workspacePlansMountBusyDuringExclusiveSync: () => workspacePlansMountBusyDuringExclusiveSync
 });
 module.exports = __toCommonJS(workspace_automatic_sync_policy_exports);
 const PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS = 12e4;
@@ -43,6 +45,12 @@ function projectBranchHasActiveWorkspaceTarget(projectId, branchName, activeTarg
   }
   return false;
 }
+function projectBranchMountBusyDuringExclusiveSync(input) {
+  return input.executionDisabled || input.worktreeOperationInProgress || input.retainedCanonicalProcessGroup || projectBranchHasActiveWorkspaceTarget(input.projectId, input.branchName, input.activeTargets);
+}
+function workspacePlansMountBusyDuringExclusiveSync(activeTargets, retainedCanonicalProcessGroup = false) {
+  return retainedCanonicalProcessGroup || hasActiveVisibleProjectsWorkspaceTarget(activeTargets);
+}
 function shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches, activeTargets) {
   if (pendingCreatedBranches.length === 0) return false;
   const targets = [...activeTargets];
@@ -65,5 +73,7 @@ function pendingCreatedBranchAutomaticSyncDeferral(pendingCreatedBranches, activ
   pendingCreatedBranchAutomaticSyncDeferral,
   pendingCreatedBranchKey,
   projectBranchHasActiveWorkspaceTarget,
-  shouldDeferAutomaticWorkspaceSyncForPendingBranch
+  projectBranchMountBusyDuringExclusiveSync,
+  shouldDeferAutomaticWorkspaceSyncForPendingBranch,
+  workspacePlansMountBusyDuringExclusiveSync
 });

package/dist/cjs/workspace-command-sync-policy.cjs

@@ -20,6 +20,7 @@ var workspace_command_sync_policy_exports = {};
 __export(workspace_command_sync_policy_exports, {
   acquireWorkspaceCommandMutation: () => acquireWorkspaceCommandMutation,
   reserveWorkspaceCommandAfterCurrentSync: () => reserveWorkspaceCommandAfterCurrentSync,
+  runReservedWorkspaceCommand: () => runReservedWorkspaceCommand,
   runWorkspaceCommand: () => runWorkspaceCommand,
   shouldSerializeWorkspaceCommand: () => shouldSerializeWorkspaceCommand
 });
@@ -46,6 +47,25 @@ function shouldSerializeWorkspaceCommand(target) {
 function runWorkspaceCommand(target, coordinator, operation) {
   return shouldSerializeWorkspaceCommand(target) ? coordinator.runMutation(operation) : Promise.resolve().then(operation);
 }
+async function runReservedWorkspaceCommand(target, coordinator, operation, releaseReservation) {
+  let released = false;
+  const releaseOnce = () => {
+    if (released) return;
+    released = true;
+    releaseReservation();
+  };
+  try {
+    return await runWorkspaceCommand(target, coordinator, async () => {
+      try {
+        return await operation();
+      } finally {
+        releaseOnce();
+      }
+    });
+  } finally {
+    releaseOnce();
+  }
+}
 function acquireWorkspaceCommandMutation(target, coordinator) {
   return shouldSerializeWorkspaceCommand(target) ? coordinator.acquireMutation() : Promise.resolve(void 0);
 }
@@ -53,6 +73,7 @@ function acquireWorkspaceCommandMutation(target, coordinator) {
 0 && (module.exports = {
   acquireWorkspaceCommandMutation,
   reserveWorkspaceCommandAfterCurrentSync,
+  runReservedWorkspaceCommand,
   runWorkspaceCommand,
   shouldSerializeWorkspaceCommand
 });

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

@@ -34,12 +34,15 @@ __export(workspace_git_sync_exports, {
   WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION: () => WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION,
   WORKSPACE_GIT_HYDRATED_RECEIPT: () => WORKSPACE_GIT_HYDRATED_RECEIPT,
   WORKSPACE_GIT_HYDRATION_TRANSACTION: () => WORKSPACE_GIT_HYDRATION_TRANSACTION,
+  WorkspaceRemediationAncestryError: () => WorkspaceRemediationAncestryError,
+  configureExistingWorkspaceGitForRemediation: () => configureExistingWorkspaceGitForRemediation,
   ensureWorkspaceGitClone: () => ensureWorkspaceGitClone,
   hydrateWorkspaceGitMounts: () => hydrateWorkspaceGitMounts,
   recoverWorkspaceGitHydration: () => recoverWorkspaceGitHydration,
   resetWorkspaceGit: () => resetWorkspaceGit,
   synchronizeWorkspaceGit: () => synchronizeWorkspaceGit,
   workspaceGitHydrationIsCurrent: () => workspaceGitHydrationIsCurrent,
+  workspaceGitMountsForRemediation: () => workspaceGitMountsForRemediation,
   workspaceGitSyncTestHarness: () => workspaceGitSyncTestHarness
 });
 module.exports = __toCommonJS(workspace_git_sync_exports);
@@ -56,6 +59,15 @@ const WORKSPACE_GIT_INTEGRATED_REF = "refs/r5d/workspace-local/integrated";
 const WORKSPACE_GIT_HYDRATED_RECEIPT = "r5d/workspace-hydrated-head";
 const WORKSPACE_GIT_HYDRATION_TRANSACTION = "r5d/workspace-hydration-transaction";
 const WORKSPACE_GIT_CHECKOUT_DURABILITY = "r5d/workspace-checkout-durability";
+function workspaceGitMountsForRemediation(mounts) {
+  return mounts.map((mount) => ({ ...mount, busy: mount.busyForRecovery ?? mount.busy }));
+}
+class WorkspaceRemediationAncestryError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorkspaceRemediationAncestryError";
+  }
+}
 const NON_RECURSIVE_GIT_CONFIG = [
   "-c",
   "submodule.recurse=false",
@@ -95,6 +107,29 @@ function revParse(workspacePath, revision) {
   const result = gitResult(workspacePath, ["rev-parse", "--verify", revision]);
   return result.exitCode === 0 ? result.stdout : null;
 }
+function requiredWorkspaceAncestorHeads(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length === 0 || value.some((head) => typeof head !== "string" || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(head)) || new Set(value).size !== value.length) {
+    throw new WorkspaceRemediationAncestryError("Workspace remediation ancestor requirements are invalid");
+  }
+  return [...value];
+}
+function assertWorkspaceRemediationAncestry(input) {
+  if (input.requiredAncestorHeads.length === 0) return;
+  if (!input.currentHead) throw new WorkspaceRemediationAncestryError("Workspace remediation has no resolved HEAD to verify");
+  for (const requiredHead of input.requiredAncestorHeads) {
+    if (!tryGit(input.workspacePath, ["cat-file", "-e", `${requiredHead}^{commit}`]) || !tryGit(input.workspacePath, ["merge-base", "--is-ancestor", requiredHead, input.currentHead])) {
+      throw new WorkspaceRemediationAncestryError(
+        `Workspace remediation HEAD does not descend from required conflict commit ${requiredHead}`
+      );
+    }
+  }
+  if (!input.remoteHead || !tryGit(input.workspacePath, ["cat-file", "-e", `${input.remoteHead}^{commit}`]) || !tryGit(input.workspacePath, ["merge-base", "--is-ancestor", input.remoteHead, input.currentHead])) {
+    throw new WorkspaceRemediationAncestryError(
+      "Fetched workspace head is not an ancestor of the resolved remediation HEAD; merge it explicitly before synchronizing"
+    );
+  }
+}
 function updateIntegratedWorkspaceHead(workspacePath, head) {
   git(workspacePath, ["update-ref", WORKSPACE_GIT_INTEGRATED_REF, head], "record integrated workspace head");
 }
@@ -964,6 +999,15 @@ function configureWorkspaceRepository(input) {
   );
   git(input.workspacePath, ["config", "--local", "core.fsyncMethod", "fsync"], "configure workspace fsync method");
 }
+function configureExistingWorkspaceGitForRemediation(input) {
+  const workspacePath = import_node_path.default.resolve(input.workspacePath);
+  const workspaceStatus = lstatIfExists(workspacePath);
+  const gitStatus = lstatIfExists(import_node_path.default.join(workspacePath, ".git"));
+  if (!workspaceStatus?.isDirectory() || workspaceStatus.isSymbolicLink() || !gitStatus?.isDirectory() || gitStatus.isSymbolicLink()) {
+    throw new Error("Active workspace remediation requires a regular existing canonical synchronization checkout");
+  }
+  configureWorkspaceRepository({ ...input, workspacePath });
+}
 function fetchWorkspaceHead(workspacePath, remoteUrl, credentialHelper, credentialUsername) {
   const result = gitResult(workspacePath, [
     ...(0, import_git_process_environment.gitTransportSecurityArgs)(remoteUrl, credentialHelper, credentialUsername),
@@ -1302,6 +1346,9 @@ function resetWorkspaceGit(input) {
     const outerPath = import_node_path.default.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
     return import_node_fs.default.existsSync(outerPath);
   });
+  const bootstrapMountIds = new Set(bootstrapMounts.map(({ id }) => id));
+  const durablyAbsentMounts = selected.skipped.filter((mount) => !bootstrapMountIds.has(mount.id) && mount.sourceMode === "all");
+  const uncoveredSkippedMounts = selected.skipped.filter((mount) => !bootstrapMountIds.has(mount.id) && mount.sourceMode !== "all");
   const hydrationMounts = [...selected.active, ...bootstrapMounts];
   const requiredLiveMounts = [
     ...new Map([...requiredLiveMountsBeforeHydration, ...bootstrapMounts].map((mount) => [mount.id, mount])).values()
@@ -1309,7 +1356,7 @@ function resetWorkspaceGit(input) {
   const hydration = hydrateWorkspaceGitMountsTransactionally({
     workspacePath,
     mounts: hydrationMounts,
-    durabilityMounts: [...requiredLiveMounts, ...selected.tombstones],
+    durabilityMounts: [...requiredLiveMounts, ...selected.tombstones, ...durablyAbsentMounts],
     receiptMounts: input.mounts,
     requiredMounts: requiredLiveMounts,
     recordCurrentHead: true
@@ -1325,7 +1372,7 @@ function resetWorkspaceGit(input) {
     remoteHead,
     discardedPaths,
     activeMountIds: hydration.hydratedMountIds,
-    skippedMountIds: [.../* @__PURE__ */ new Set([...selected.skipped.map(({ id }) => id), ...hydration.skippedMountIds])].sort()
+    skippedMountIds: [.../* @__PURE__ */ new Set([...uncoveredSkippedMounts.map(({ id }) => id), ...hydration.skippedMountIds])].sort()
   };
 }
 function stagedPaths(workspacePath) {
@@ -1465,8 +1512,16 @@ async function synchronizeWorkspaceGit(input) {
   const maxDiffBytes = input.maxDiffBytes ?? MAX_WORKSPACE_GIT_DIFF_BYTES;
   const maxPushAttempts = Math.max(1, input.maxPushAttempts ?? 4);
   validateMounts(workspacePath, input.mounts);
+  const requiredAncestorHeads = requiredWorkspaceAncestorHeads(input.requiredAncestorHeads);
   const preserveResolutionInProgress = input.skipMountMirror === true;
   const initial = ensureWorkspaceGitClone({ ...input, workspacePath, preserveResolutionInProgress });
+  assertWorkspaceRemediationAncestry({
+    workspacePath,
+    currentHead: initial.localHead,
+    remoteHead: initial.remoteHead,
+    requiredAncestorHeads
+  });
+  const verifiedAncestorHeads = requiredAncestorHeads.length > 0 ? requiredAncestorHeads : void 0;
   const startingHead = initial.localHead;
   const receiptBeforeInitialHydration = readHydratedWorkspaceReceipt(workspacePath);
   const deferredMountIds = /* @__PURE__ */ new Set();
@@ -1558,6 +1613,7 @@ async function synchronizeWorkspaceGit(input) {
           conflictPaths: merged.conflictPaths,
           conflictSnapshotRefs: refs,
           conflictKind: "projection_merge",
+          ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
           error: merged.error
         };
       }
@@ -1681,6 +1737,12 @@ async function synchronizeWorkspaceGit(input) {
   let rebaseCount = 0;
   let updated = false;
   for (let pushAttempt = 0; pushAttempt < maxPushAttempts; pushAttempt += 1) {
+    assertWorkspaceRemediationAncestry({
+      workspacePath,
+      currentHead: revParse(workspacePath, "HEAD"),
+      remoteHead,
+      requiredAncestorHeads
+    });
     const reconciled = synchronizeWithFetchedHead({ workspacePath, remoteHead, attemptId });
     if (reconciled.kind === "conflict") {
       const localHead2 = revParse(workspacePath, "HEAD");
@@ -1698,6 +1760,7 @@ async function synchronizeWorkspaceGit(input) {
         conflictPaths: reconciled.conflictPaths,
         conflictSnapshotRefs: reconciled.refs,
         conflictKind: "integration_rebase",
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         error: reconciled.error
       };
     }
@@ -1717,11 +1780,13 @@ async function synchronizeWorkspaceGit(input) {
         diffSizeBytes: 0,
         affectedPaths: [],
         ...classifiedMounts,
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         ...projectionWarning ? { error: projectionWarning } : {}
       };
     }
     const paths = changedPaths(workspacePath, remoteHead, localHead);
-    const size = paths.length > 0 ? await diffSizeBytes(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
+    const size = paths.length > 0 ? await (input.measureDiffSize ?? diffSizeBytes)(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
+    input.assertStillAdmitted?.();
     if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
       const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones]);
       return {
@@ -1734,15 +1799,18 @@ async function synchronizeWorkspaceGit(input) {
         diffSizeBytes: size,
         affectedPaths: paths,
         ...classifiedMounts,
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         error: `Workspace diff exceeds the ${maxDiffBytes}-byte automatic publication limit`
       };
     }
     if (localHead === remoteHead) {
+      assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
       const completedMounts = completedMountSelection(Boolean(input.skipMountMirror));
       await input.afterWorkspacePublished?.({
         publishedHead: localHead,
         activeMountIds: completedMounts.activeMountIds
       });
+      input.assertStillAdmitted?.();
       return {
         outcome: updated ? "updated" : "no_change",
         startingHead,
@@ -1753,9 +1821,11 @@ async function synchronizeWorkspaceGit(input) {
         diffSizeBytes: size,
         affectedPaths: paths,
         ...completedMounts,
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         ...projectionWarning ? { error: projectionWarning } : {}
       };
     }
+    assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
     const pushArgs = [
       ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.remoteUrl, input.credentialHelper, input.credentialUsername),
       "push",
@@ -1765,12 +1835,14 @@ async function synchronizeWorkspaceGit(input) {
     pushArgs.push("origin", `HEAD:refs/heads/${WORKSPACE_GIT_BRANCH}`);
     const push = gitResult(workspacePath, pushArgs);
     if (push.exitCode === 0) {
+      assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
       updateIntegratedWorkspaceHead(workspacePath, localHead);
       const completedMounts = completedMountSelection(Boolean(input.skipMountMirror));
       await input.afterWorkspacePublished?.({
         publishedHead: localHead,
         activeMountIds: completedMounts.activeMountIds
       });
+      input.assertStillAdmitted?.();
       return {
         outcome: "pushed",
         startingHead,
@@ -1781,6 +1853,7 @@ async function synchronizeWorkspaceGit(input) {
         diffSizeBytes: size,
         affectedPaths: paths,
         ...completedMounts,
+        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
         ...projectionWarning ? { error: projectionWarning } : {}
       };
     }
@@ -1807,11 +1880,14 @@ const workspaceGitSyncTestHarness = {
   WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION,
   WORKSPACE_GIT_HYDRATED_RECEIPT,
   WORKSPACE_GIT_HYDRATION_TRANSACTION,
+  WorkspaceRemediationAncestryError,
+  configureExistingWorkspaceGitForRemediation,
   ensureWorkspaceGitClone,
   hydrateWorkspaceGitMounts,
   recoverWorkspaceGitHydration,
   resetWorkspaceGit,
   synchronizeWorkspaceGit,
   workspaceGitHydrationIsCurrent,
+  workspaceGitMountsForRemediation,
   workspaceGitSyncTestHarness
 });