@ricsam/r5d-worker 0.0.51 → 0.0.54

package/dist/cjs/workspace-mutation-gate.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_mutation_gate_exports = {};
+__export(workspace_mutation_gate_exports, {
+  WorkspaceMutationGate: () => WorkspaceMutationGate
+});
+module.exports = __toCommonJS(workspace_mutation_gate_exports);
+class WorkspaceMutationGate {
+  activeMutations = 0;
+  syncActive = false;
+  waiters = [];
+  acquireMutation() {
+    return new Promise((resolve) => {
+      this.waiters.push({ kind: "mutation", resolve });
+      this.drain();
+    });
+  }
+  async runMutation(operation) {
+    const release = await this.acquireMutation();
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  async runSync(operation) {
+    const release = await new Promise((resolve) => {
+      this.waiters.push({ kind: "sync", resolve });
+      this.drain();
+    });
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  drain() {
+    if (this.syncActive || this.waiters.length === 0) return;
+    const first = this.waiters[0];
+    if (first?.kind === "sync") {
+      if (this.activeMutations > 0) return;
+      this.waiters.shift();
+      this.syncActive = true;
+      first.resolve(this.releaseSync());
+      return;
+    }
+    while (this.waiters[0]?.kind === "mutation") {
+      const waiter = this.waiters.shift();
+      if (!waiter || waiter.kind !== "mutation") break;
+      this.activeMutations += 1;
+      waiter.resolve(this.releaseMutation());
+    }
+  }
+  releaseMutation() {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.activeMutations -= 1;
+      this.drain();
+    };
+  }
+  releaseSync() {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.syncActive = false;
+      this.drain();
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorkspaceMutationGate
+});

package/dist/cjs/workspace-sync.cjs

@@ -30,10 +30,12 @@ var workspace_sync_exports = {};
 __export(workspace_sync_exports, {
   MAX_WORKSPACE_SYNC_DIFF_BYTES: () => MAX_WORKSPACE_SYNC_DIFF_BYTES,
   WORKSPACE_BRANCH: () => WORKSPACE_BRANCH,
+  WORKSPACE_INTENT_REF_PREFIX: () => WORKSPACE_INTENT_REF_PREFIX,
   WORKSPACE_NATIVE_PLANS_RELATIVE_PATH: () => WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
   WORKSPACE_PERIODIC_SCAN_INTERVAL_MS: () => WORKSPACE_PERIODIC_SCAN_INTERVAL_MS,
   WorkspaceSyncSingleFlight: () => WorkspaceSyncSingleFlight,
   assertCanonicalCheckoutIndexMatchesWorktree: () => assertCanonicalCheckoutIndexMatchesWorktree,
+  assertWorkspaceQuarantineRef: () => assertWorkspaceQuarantineRef,
   calculateWorkspaceDiffFingerprint: () => calculateWorkspaceDiffFingerprint,
   encodeWorkspaceBranch: () => encodeWorkspaceBranch,
   mirrorShadowWorkspaceToVisible: () => mirrorShadowWorkspaceToVisible,
@@ -49,7 +51,9 @@ var import_node_crypto = require("node:crypto");
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_managed_paths = require("./managed-paths.cjs");
+var import_workspace_mutation_gate = require("./workspace-mutation-gate.cjs");
 const WORKSPACE_BRANCH = "main";
+const WORKSPACE_INTENT_REF_PREFIX = "refs/r5d/workspace-intents/";
 const MAX_WORKSPACE_SYNC_DIFF_BYTES = 5 * 1024 * 1024;
 const WORKSPACE_PERIODIC_SCAN_INTERVAL_MS = 5e3;
 const MAX_REPORTED_WORKSPACE_PATHS = 2e3;
@@ -1119,10 +1123,27 @@ function commitMessage(input) {
     ...input.confirmedLargeDiff ? { confirmedLargeDiff: true, confirmationReason: input.confirmationReason } : {}
   });
 }
-function isNonFastForward(result) {
-  const output = `${result.stdout}
-${result.stderr}`.toLowerCase();
-  return output.includes("non-fast-forward") || output.includes("fetch first") || output.includes("[rejected]");
+function assertWorkspaceQuarantineRef(quarantineRef) {
+  const suffix = quarantineRef.slice(WORKSPACE_INTENT_REF_PREFIX.length);
+  if (!quarantineRef.startsWith(WORKSPACE_INTENT_REF_PREFIX) || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(suffix)) {
+    throw new Error(`Workspace candidate ref must be below ${WORKSPACE_INTENT_REF_PREFIX}`);
+  }
+  const result = Bun.spawnSync(["git", "check-ref-format", quarantineRef], {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`Invalid workspace candidate ref ${JSON.stringify(quarantineRef)}`);
+  }
+}
+function uploadWorkspaceCandidate(input, candidateHead) {
+  const quarantineRef = input.quarantineRef;
+  if (!quarantineRef) {
+    throw new Error("A server-issued workspace candidate ref is required before uploading a canonical workspace candidate");
+  }
+  assertWorkspaceQuarantineRef(quarantineRef);
+  return runGitResult(input, input.shadowRoot, ["push", "origin", `HEAD:${quarantineRef}`]);
 }
 function resetShadowToRemote(input, opaqueWorkspaceRoots = []) {
   runGit(input, input.shadowRoot, ["fetch", "origin", "--prune"], "fetch canonical workspace before reset");
@@ -1141,6 +1162,7 @@ function baseResult(input, startingHead) {
     workerLabel: input.workerLabel,
     trigger: input.trigger,
     startingHead,
+    expectedHead: startingHead,
     rebaseCount: 0,
     diffSizeBytes: 0,
     gitStatus: "",
@@ -1150,6 +1172,32 @@ function baseResult(input, startingHead) {
     localChangesDiscarded: false
   };
 }
+function convergeRedundantInboundCandidate(input, result) {
+  if (input.trigger.type !== "inbound_head" || !input.skipVisibleMirror || input.trigger.canonicalCheckoutOnly) return null;
+  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
+  if (!remoteHead) return null;
+  const stagedTree = runGit(input, input.shadowRoot, ["write-tree"], "write inbound workspace candidate tree");
+  const remoteTree = runGit(
+    input,
+    input.shadowRoot,
+    ["rev-parse", "--verify", `${remoteHead}^{tree}`],
+    "resolve authoritative workspace tree"
+  );
+  if (stagedTree !== remoteTree) return null;
+  const localHead = revParse(input, "HEAD");
+  runGit(input, input.shadowRoot, ["reset", "--hard", remoteHead], "converge redundant inbound workspace candidate");
+  runGit(input, input.shadowRoot, ["clean", "-fd"], "clean redundant inbound workspace candidate");
+  mirrorShadowWorkspaceToVisible(input);
+  return {
+    ...result,
+    outcome: localHead === remoteHead ? "no_change" : "updated",
+    publishedHead: remoteHead,
+    diffSizeBytes: 0,
+    gitStatus: gitStatus(input),
+    affectedProjects: [],
+    affectedPaths: []
+  };
+}
 async function synchronizeWorkspace(rawInput) {
   let input = { ...rawInput, attemptId: rawInput.attemptId ?? crypto.randomUUID() };
   try {
@@ -1183,6 +1231,8 @@ async function synchronizeWorkspace(rawInput) {
     const stagePathspecs = mirroredGitlinkProjection.opaqueRoots.flatMap((root) => [`:(exclude,literal)${root}`]);
     runGit(input, input.shadowRoot, ["add", "-A", "--", ".", ...stagePathspecs], "stage workspace changes");
     forceStageCanonicalCheckoutFiles(input, mirroredGitlinkProjection.entries, mirroredGitlinkProjection.opaqueRoots);
+    const redundantInboundCandidate = convergeRedundantInboundCandidate(input, result);
+    if (redundantInboundCandidate) return redundantInboundCandidate;
     const sampledCanonicalCheckoutTreeHash = sampleCanonicalCheckoutTree(input);
     const stagedWorkingPaths = stagedPaths(input);
     const baseRevision = candidateBaseRevision(input);
@@ -1216,7 +1266,7 @@ async function synchronizeWorkspace(rawInput) {
     if (stagedWorkingPaths.length > 0) {
       runGit(input, input.shadowRoot, ["commit", "-m", commitMessage(input)], "commit workspace changes");
     }
-    const candidateHead = revParse(input, "HEAD");
+    let candidateHead = revParse(input, "HEAD");
     if (candidateHead) assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, candidateHead);
     const hasRemoteMain = Boolean(revParse(input, `origin/${WORKSPACE_BRANCH}`));
     const hasUnpushedCommit = candidateHead ? !hasRemoteMain || !tryGit(input, input.shadowRoot, ["merge-base", "--is-ancestor", candidateHead, `origin/${WORKSPACE_BRANCH}`]) : false;
@@ -1252,58 +1302,59 @@ async function synchronizeWorkspace(rawInput) {
       };
     }
     let rebaseCount = 0;
-    for (let pushAttempt = 0; pushAttempt < 3; pushAttempt += 1) {
-      const push = runGitResult(input, input.shadowRoot, ["push", "origin", `HEAD:refs/heads/${WORKSPACE_BRANCH}`]);
-      if (push.exitCode === 0) {
-        const publishedHead = revParse(input, "HEAD") ?? candidateHead;
-        if (publishedHead) assertPublishedCanonicalCheckoutTree(input, publishedHead, sampledCanonicalCheckoutTreeHash);
-        mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots);
-        return {
-          ...observed,
-          outcome: "published",
-          candidateHead: candidateHead ?? void 0,
-          publishedHead: publishedHead ?? void 0,
-          rebaseCount,
-          gitStatus: gitStatus(input)
-        };
-      }
-      if (!isNonFastForward(push)) {
-        return {
-          ...observed,
-          outcome: "failed",
-          candidateHead: candidateHead ?? void 0,
-          rebaseCount,
-          error: push.stderr || push.stdout || "Workspace push failed",
-          gitStatus: gitStatus(input)
-        };
-      }
-      runGit(input, input.shadowRoot, ["fetch", "origin", "--prune"], "fetch workspace after push race");
+    const expectedHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
+    if (candidateHead && expectedHead && !tryGit(input, input.shadowRoot, ["merge-base", "--is-ancestor", expectedHead, candidateHead])) {
       const rebase = runGitResult(input, input.shadowRoot, ["rebase", `origin/${WORKSPACE_BRANCH}`]);
       rebaseCount += 1;
       if (rebase.exitCode !== 0) {
         const conflicted = runGitResult(input, input.shadowRoot, ["diff", "--name-only", "--diff-filter=U", "-z"]);
-        const discardedPaths = reportedPaths([.../* @__PURE__ */ new Set([...paths, ...conflicted.stdout.split("\0").filter(Boolean)])].sort());
-        const publishedHead = resetShadowToRemote(input, mirroredGitlinkProjection.opaqueRoots);
+        const conflictPaths = reportedPaths([.../* @__PURE__ */ new Set([...paths, ...conflicted.stdout.split("\0").filter(Boolean)])].sort());
+        runGit(input, input.shadowRoot, ["rebase", "--abort"], "preserve workspace candidate after rebase conflict");
         return {
           ...observed,
-          outcome: "conflict_reset",
+          outcome: "failed",
+          expectedHead,
           candidateHead: candidateHead ?? void 0,
-          publishedHead: publishedHead ?? void 0,
           rebaseCount,
-          discardedPaths,
-          localChangesDiscarded: true,
+          affectedPaths: conflictPaths,
+          error: `Workspace candidate conflicts with canonical head ${expectedHead}; local changes were preserved for reconciliation.`,
           gitStatus: gitStatus(input)
         };
       }
+      candidateHead = revParse(input, "HEAD");
       assertPublishedCanonicalCheckoutTree(input, "HEAD", sampledCanonicalCheckoutTreeHash);
       assertUnscopedCanonicalCheckoutSubtreesMatchRemote(input, "HEAD");
     }
+    if (!candidateHead) {
+      return {
+        ...observed,
+        outcome: "failed",
+        rebaseCount,
+        error: "Workspace candidate does not have a commit",
+        gitStatus: gitStatus(input)
+      };
+    }
+    const upload = uploadWorkspaceCandidate(input, candidateHead);
+    if (upload.exitCode !== 0) {
+      return {
+        ...observed,
+        outcome: "failed",
+        candidateHead,
+        quarantineRef: input.quarantineRef,
+        rebaseCount,
+        error: upload.stderr || upload.stdout || "Workspace candidate upload failed",
+        gitStatus: gitStatus(input)
+      };
+    }
+    assertPublishedCanonicalCheckoutTree(input, candidateHead, sampledCanonicalCheckoutTreeHash);
+    mirrorShadowWorkspaceToVisible(input, mirroredGitlinkProjection.opaqueRoots);
     return {
       ...observed,
-      outcome: "failed",
-      candidateHead: candidateHead ?? void 0,
+      outcome: "candidate_ready",
+      expectedHead,
+      candidateHead,
+      quarantineRef: input.quarantineRef,
       rebaseCount,
-      error: "Workspace push did not converge after three attempts",
       gitStatus: gitStatus(input)
     };
   } catch (error) {
@@ -1346,9 +1397,10 @@ function calculateWorkspaceDiffFingerprint(rawInput) {
   return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify({ stagedTree, localHead, remoteHead })).digest("hex");
 }
 class WorkspaceSyncSingleFlight {
+  mutationGate = new import_workspace_mutation_gate.WorkspaceMutationGate();
   queue = Promise.resolve();
   enqueue(task) {
-    const queued = this.queue.then(task, task);
+    const queued = this.mutationGate.runSync(task);
     this.queue = queued.then(
       () => void 0,
       () => void 0
@@ -1367,6 +1419,12 @@ class WorkspaceSyncSingleFlight {
   fingerprintPrepared(prepare) {
     return this.enqueue(() => calculateWorkspaceDiffFingerprint(prepare()));
   }
+  runMutation(operation) {
+    return this.mutationGate.runMutation(operation);
+  }
+  acquireMutation() {
+    return this.mutationGate.acquireMutation();
+  }
   afterCurrent() {
     return this.queue;
   }
@@ -1375,10 +1433,12 @@ class WorkspaceSyncSingleFlight {
 0 && (module.exports = {
   MAX_WORKSPACE_SYNC_DIFF_BYTES,
   WORKSPACE_BRANCH,
+  WORKSPACE_INTENT_REF_PREFIX,
   WORKSPACE_NATIVE_PLANS_RELATIVE_PATH,
   WORKSPACE_PERIODIC_SCAN_INTERVAL_MS,
   WorkspaceSyncSingleFlight,
   assertCanonicalCheckoutIndexMatchesWorktree,
+  assertWorkspaceQuarantineRef,
   calculateWorkspaceDiffFingerprint,
   encodeWorkspaceBranch,
   mirrorShadowWorkspaceToVisible,

package/dist/mjs/heartbeat.mjs

@@ -3,8 +3,19 @@ const WORKER_HEARTBEAT_TIMEOUT_MS = 45e3;
 function hasWorkerHeartbeatTimedOut(lastHeartbeatAt, now = Date.now(), timeoutMs = WORKER_HEARTBEAT_TIMEOUT_MS) {
   return lastHeartbeatAt !== null && now - lastHeartbeatAt >= timeoutMs;
 }
+function grantWorkerHeartbeatBusyGrace(lastHeartbeatAt, currentGrace, now = Date.now(), timeoutMs = WORKER_HEARTBEAT_TIMEOUT_MS, graceMs = WORKER_HEARTBEAT_INTERVAL_MS) {
+  if (!hasWorkerHeartbeatTimedOut(lastHeartbeatAt, now, timeoutMs)) return currentGrace;
+  if (currentGrace?.heartbeatAt === lastHeartbeatAt) return currentGrace;
+  return { heartbeatAt: lastHeartbeatAt, expiresAt: now + graceMs };
+}
+function hasWorkerHeartbeatTimedOutWithBusyGrace(lastHeartbeatAt, busyGrace, now = Date.now(), timeoutMs = WORKER_HEARTBEAT_TIMEOUT_MS) {
+  if (lastHeartbeatAt !== null && busyGrace?.heartbeatAt === lastHeartbeatAt && now < busyGrace.expiresAt) return false;
+  return hasWorkerHeartbeatTimedOut(lastHeartbeatAt, now, timeoutMs);
+}
 export {
   WORKER_HEARTBEAT_INTERVAL_MS,
   WORKER_HEARTBEAT_TIMEOUT_MS,
-  hasWorkerHeartbeatTimedOut
+  grantWorkerHeartbeatBusyGrace,
+  hasWorkerHeartbeatTimedOut,
+  hasWorkerHeartbeatTimedOutWithBusyGrace
 };