@ricsam/r5d-worker 0.0.137 → 0.0.138

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

@@ -1,3553 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { gitCredentialUsernameConfigKey, gitTransportSecurityArgs, workerGitProcessEnvironment } from "./git-process-environment.mjs";
-import {
-  materializeWorkspaceProjectionTree,
-  workspaceMergeProjectionSupport
-} from "./workspace-merge-projection.mjs";
-import { workspaceFilesystemExecutor } from "./workspace-filesystem-executor.mjs";
-import { gitBlobHash, gitObjectHashAlgorithmFor } from "./git-blob-hash.mjs";
-import {
-  applyWorkingTreeMirror,
-  captureWorkingTreeMirrorPlan,
-  fsyncWorkingTreePaths,
-  inspectWorkingTree,
-  inspectWorkingTreePath,
-  projectedFileEntry,
-  projectedFileEntryMatches,
-  mirrorWorkingTree,
-  normalizeWorkingTreeRelativePath,
-  planPreparedWorkingTreeMirror,
-  planWorkingTreeMirror,
-  prepareWorkingTreeMirror,
-  restoreWorkingTreeMirrorScope,
-  rollbackWorkingTreeMirrorJournal,
-  workingTreeDisplacedRetentionDirectory,
-  WorkingTreeTargetChangedError
-} from "./working-tree-mirror.mjs";
-import {
-  decideWorkspaceHydrationMerge,
-  readHydrationBinaryPaths,
-  describeHydrationSkipPaths,
-  parseWorkspaceSubtreeChanges
-} from "./workspace-hydration-merge.mjs";
-import { WorkspaceHydrationLedger } from "./workspace-hydration-ledger.mjs";
-import { assertManagedDirectoryPath } from "./workspace-mount-boundary.mjs";
-const WORKSPACE_GIT_BRANCH = "main";
-const MAX_WORKSPACE_GIT_DIFF_BYTES = 5 * 1024 * 1024;
-const WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION = "r5d-confirm-large-diff-v1";
-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_HYDRATION_RECOVERIES = "r5d/workspace-hydration-recoveries";
-const WORKSPACE_GIT_HYDRATION_PRESERVED_BASES = "r5d/workspace-hydration-preserved-bases";
-const WORKSPACE_GIT_CHECKOUT_DURABILITY = "r5d/workspace-checkout-durability";
-const WORKSPACE_MERGE_HYDRATION_SWITCH = "R5D_MERGE_HYDRATION";
-function workspaceMergeHydrationEnabled() {
-  return process.env[WORKSPACE_MERGE_HYDRATION_SWITCH] !== "0";
-}
-const WORKSPACE_PROCESS_BUSY_FENCE_SWITCH = "R5D_PROCESS_BUSY_FENCE";
-function workspaceProcessBusyFenceEnabled() {
-  return process.env[WORKSPACE_PROCESS_BUSY_FENCE_SWITCH] === "1";
-}
-function mountBusy(mount) {
-  if (mount.busy !== void 0 && mount.busy()) return true;
-  return workspaceProcessBusyFenceEnabled() && mount.processLive?.() === true;
-}
-const hydrationPreBlobLedgers = /* @__PURE__ */ new Map();
-function hydrationPreBlobLedger(workspacePath) {
-  const key = path.resolve(workspacePath);
-  let ledger = hydrationPreBlobLedgers.get(key);
-  if (!ledger) {
-    ledger = new WorkspaceHydrationLedger();
-    hydrationPreBlobLedgers.set(key, ledger);
-  }
-  return ledger;
-}
-class WorkspaceHydrationRecoveryRequiredError extends Error {
-  constructor(hydrationRecovery, options) {
-    super(
-      `Interrupted guarded workspace hydration ${hydrationRecovery.transactionId} requires explicit preservation recovery; visible files and the prior receipt are preserved, and snapshots remain at ${hydrationRecovery.transactionPath} (mounts: ${hydrationRecovery.mounts.map(({ id }) => id).join(", ")})${hydrationRecovery.mounts.some(({ retainedPaths }) => retainedPaths?.length) ? `; displaced entries retained at ${hydrationRecovery.mounts.flatMap(({ retainedPaths }) => retainedPaths ?? []).join(", ")}` : ""}`,
-      options
-    );
-    this.hydrationRecovery = hydrationRecovery;
-    this.name = "WorkspaceHydrationRecoveryRequiredError";
-  }
-  hydrationRecovery;
-  code = "hydration_recovery_required";
-}
-const HYDRATION_TRANSACTION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-function workspaceGitMountData(mount) {
-  return {
-    id: mount.id,
-    hydrationIncarnationKey: mount.hydrationIncarnationKey,
-    sourcePath: mount.sourcePath,
-    durabilityRootPath: mount.durabilityRootPath,
-    workspaceRelativePath: mount.workspaceRelativePath,
-    sourceMode: mount.sourceMode,
-    hydrateDeletionMode: mount.hydrateDeletionMode,
-    ...mount.preserveLocalOnInitialOuterAbsence === void 0 ? {} : { preserveLocalOnInitialOuterAbsence: mount.preserveLocalOnInitialOuterAbsence },
-    ...mount.preserveLocalOnHydrationBasisChange === void 0 ? {} : { preserveLocalOnHydrationBasisChange: mount.preserveLocalOnHydrationBasisChange },
-    ...mount.initialPublicationSourceRelativePath === void 0 ? {} : { initialPublicationSourceRelativePath: mount.initialPublicationSourceRelativePath },
-    ...mount.deleteWhenSourceMissing === void 0 ? {} : { deleteWhenSourceMissing: mount.deleteWhenSourceMissing },
-    ...mount.lastProjectedMutationToken === void 0 ? {} : { lastProjectedMutationToken: mount.lastProjectedMutationToken }
-  };
-}
-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",
-  "-c",
-  "fetch.recurseSubmodules=false",
-  "-c",
-  "push.recurseSubmodules=false"
-];
-function gitCommandArgs(args) {
-  return ["git", ...NON_RECURSIVE_GIT_CONFIG, ...args];
-}
-function workspaceCloneCommandArgs(args, remoteUrl, credentialHelper, credentialUsername) {
-  return gitCommandArgs([...gitTransportSecurityArgs(remoteUrl, credentialHelper, credentialUsername), ...args]);
-}
-function gitResult(cwd, args) {
-  const result = Bun.spawnSync(gitCommandArgs(args), {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  return {
-    exitCode: result.exitCode,
-    stdout: result.stdout.toString().trim(),
-    stderr: result.stderr.toString().trim()
-  };
-}
-function git(cwd, args, action) {
-  const result = gitResult(cwd, args);
-  if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
-  return result.stdout;
-}
-function tryGit(cwd, args) {
-  return gitResult(cwd, args).exitCode === 0;
-}
-function revParse(workspacePath, revision) {
-  const result = gitResult(workspacePath, ["rev-parse", "--verify", revision]);
-  return result.exitCode === 0 ? result.stdout : null;
-}
-async function gitResultAsync(cwd, args) {
-  const subprocess = Bun.spawn(gitCommandArgs(args), {
-    cwd,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(subprocess.stdout).text(),
-    new Response(subprocess.stderr).text(),
-    subprocess.exited
-  ]);
-  return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
-}
-async function gitAsync(cwd, args, action) {
-  const result = await gitResultAsync(cwd, args);
-  if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
-  return result.stdout;
-}
-async function gitOutputAsync(cwd, args, action, input) {
-  const subprocess = Bun.spawn(gitCommandArgs(args), {
-    cwd,
-    stdin: input ?? "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(subprocess.stdout).arrayBuffer(),
-    new Response(subprocess.stderr).text(),
-    subprocess.exited
-  ]);
-  if (exitCode !== 0) throw new Error(`${action}: ${stderr.trim() || `git exited ${exitCode}`}`);
-  return Buffer.from(stdout);
-}
-async function tryGitAsync(cwd, args) {
-  return (await gitResultAsync(cwd, args)).exitCode === 0;
-}
-async function revParseAsync(workspacePath, revision) {
-  const result = await gitResultAsync(workspacePath, ["rev-parse", "--verify", revision]);
-  return result.exitCode === 0 ? result.stdout : null;
-}
-function workspaceCommitsExist(workspacePath, heads) {
-  const uniqueHeads = [...new Set(heads)];
-  if (uniqueHeads.length === 0) return true;
-  const batch = Bun.spawnSync(gitCommandArgs(["cat-file", "--batch-check"]), {
-    cwd: workspacePath,
-    stdin: Buffer.from(uniqueHeads.map((head) => `${head}^{commit}
-`).join("")),
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  if (batch.exitCode !== 0) return false;
-  const lines = batch.stdout.toString().split("\n").filter(Boolean);
-  return lines.length === uniqueHeads.length && lines.every((line) => !line.endsWith(" missing"));
-}
-async function workspaceCommitsExistAsync(workspacePath, heads) {
-  const uniqueHeads = [...new Set(heads)];
-  if (uniqueHeads.length === 0) return true;
-  const subprocess = Bun.spawn(gitCommandArgs(["cat-file", "--batch-check"]), {
-    cwd: workspacePath,
-    stdin: Buffer.from(uniqueHeads.map((head) => `${head}^{commit}
-`).join("")),
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  const [stdout, , exitCode] = await Promise.all([
-    new Response(subprocess.stdout).text(),
-    new Response(subprocess.stderr).text(),
-    subprocess.exited
-  ]);
-  if (exitCode !== 0) return false;
-  const lines = stdout.split("\n").filter(Boolean);
-  return lines.length === uniqueHeads.length && lines.every((line) => !line.endsWith(" missing"));
-}
-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"
-    );
-  }
-}
-async function updateIntegratedWorkspaceHead(workspacePath, head) {
-  await gitAsync(workspacePath, ["update-ref", WORKSPACE_GIT_INTEGRATED_REF, head], "record integrated workspace head");
-}
-function fsyncDirectory(directoryPath) {
-  const descriptor = fs.openSync(directoryPath, fs.constants.O_RDONLY);
-  try {
-    fs.fsyncSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function lstatIfExists(targetPath) {
-  try {
-    return fs.lstatSync(targetPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-function hydratedWorkspaceReceiptPath(workspacePath) {
-  return path.join(workspacePath, ".git", ...WORKSPACE_GIT_HYDRATED_RECEIPT.split("/"));
-}
-function workspaceCheckoutDurabilityPath(workspacePath) {
-  return path.join(workspacePath, ".git", ...WORKSPACE_GIT_CHECKOUT_DURABILITY.split("/"));
-}
-function normalizedWorkspaceMountPath(workspaceRelativePath) {
-  return workspaceRelativePath.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-}
-function workspaceHydrationMountBasis(mount) {
-  return {
-    id: mount.id,
-    incarnationKey: mount.hydrationIncarnationKey,
-    sourcePath: path.resolve(mount.sourcePath),
-    durabilityRootPath: path.resolve(mount.durabilityRootPath),
-    workspaceRelativePath: normalizedWorkspaceMountPath(mount.workspaceRelativePath),
-    sourceMode: mount.sourceMode,
-    hydrateDeletionMode: mount.hydrateDeletionMode,
-    preserveLocalOnInitialOuterAbsence: mount.preserveLocalOnInitialOuterAbsence === true,
-    preserveLocalOnHydrationBasisChange: mount.preserveLocalOnHydrationBasisChange === true,
-    deleteWhenSourceMissing: mount.deleteWhenSourceMissing === true
-  };
-}
-function compareWorkspaceHydrationMountBasis(left, right) {
-  return left.id.localeCompare(right.id);
-}
-function workspaceHydrationReceipt(head, mounts) {
-  const bases = mounts.map((mount) => ({ ...workspaceHydrationMountBasis(mount), head })).sort(compareWorkspaceHydrationMountBasis);
-  const ids = /* @__PURE__ */ new Set();
-  for (const basis of bases) {
-    if (ids.has(basis.id)) throw new Error(`Workspace hydration receipt mount id must be unique: ${basis.id}`);
-    ids.add(basis.id);
-  }
-  return { version: 3, mounts: bases };
-}
-function receiptWithMountsAtHead(previous, head, mounts, allConfiguredMounts) {
-  const advanceIds = new Set(mounts.map(({ id }) => id));
-  const previousById = new Map(previous?.mounts.map((entry) => [entry.id, entry]) ?? []);
-  const entries = allConfiguredMounts.flatMap((mount) => {
-    const basis = workspaceHydrationMountBasis(mount);
-    if (advanceIds.has(mount.id)) return [{ ...basis, head }];
-    const carried = previousById.get(mount.id);
-    if (!carried) return [];
-    return [carried];
-  });
-  entries.sort(compareWorkspaceHydrationMountBasis);
-  const ids = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    if (ids.has(entry.id)) throw new Error(`Workspace hydration receipt mount id must be unique: ${entry.id}`);
-    ids.add(entry.id);
-  }
-  return { version: 3, mounts: entries };
-}
-function workspaceHydrationReceiptsEqual(left, right) {
-  if (JSON.stringify(left) !== JSON.stringify(right)) return false;
-  const effectiveLegacyHead = (receipt) => receipt?.mounts.length === 0 ? receipt.legacyHead ?? null : null;
-  return effectiveLegacyHead(left) === effectiveLegacyHead(right);
-}
-function workspaceHydrationReceiptCoversMount(receipt, head, mount) {
-  if (!receipt) return false;
-  const expected = workspaceHydrationMountBasis(mount);
-  const actual = receipt.mounts.find(({ id }) => id === expected.id);
-  if (!actual || actual.head !== head) return false;
-  const { head: _head, ...actualBasis } = actual;
-  return JSON.stringify(actualBasis) === JSON.stringify(expected);
-}
-function workspaceHydrationReceiptMountBasisHead(receipt, mount) {
-  if (!receipt) return null;
-  const expected = workspaceHydrationMountBasis(mount);
-  const actual = receipt.mounts.find(({ id }) => id === expected.id);
-  if (!actual) return null;
-  const { head, ...actualBasis } = actual;
-  return JSON.stringify(actualBasis) === JSON.stringify(expected) ? head : null;
-}
-function workspaceHydrationReceiptMatchesMounts(receipt, head, mounts) {
-  return workspaceHydrationReceiptsEqual(receipt, workspaceHydrationReceipt(head, mounts));
-}
-function configuredWorkspaceHydrationBasisMounts(workspacePath, mounts, deferMountIds) {
-  const resolvedWorkspacePath = path.resolve(workspacePath);
-  return mounts.filter((mount) => {
-    if (deferMountIds?.has(mount.id)) return false;
-    if (mount.deleteWhenSourceMissing) return !fs.existsSync(mount.sourcePath);
-    const outerPath = path.join(resolvedWorkspacePath, ...normalizedWorkspaceMountPath(mount.workspaceRelativePath).split("/"));
-    return fs.existsSync(mount.sourcePath) || fs.existsSync(outerPath) || mount.sourceMode === "all";
-  });
-}
-function parseWorkspaceHydrationReceiptContentUnverified(receiptPath, content) {
-  const legacyHead = content.endsWith("\n") ? content.slice(0, -1) : "";
-  if (/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(legacyHead) && content === `${legacyHead}
-`) {
-    const receipt2 = { version: 3, mounts: [] };
-    Object.defineProperty(receipt2, "legacyHead", { value: legacyHead, enumerable: false });
-    return { receipt: receipt2, headsToVerify: [legacyHead] };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    throw new Error(`Workspace hydration receipt contains an invalid object id or mount basis: ${receiptPath}`);
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error(`Workspace hydration receipt contains an invalid object id or mount basis: ${receiptPath}`);
-  }
-  const candidate = parsed;
-  const liftedV2Head = candidate.version === 2 && typeof candidate.head === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(candidate.head) ? candidate.head : null;
-  if (candidate.version !== 3 && liftedV2Head === null) {
-    throw new Error(`Workspace hydration receipt contains an invalid object id or mount basis: ${receiptPath}`);
-  }
-  if (!Array.isArray(candidate.mounts)) {
-    throw new Error(`Workspace hydration receipt contains an invalid mount basis: ${receiptPath}`);
-  }
-  const seenIds = /* @__PURE__ */ new Set();
-  const mounts = candidate.mounts.map((rawMount) => {
-    if (!rawMount || typeof rawMount !== "object") {
-      throw new Error(`Workspace hydration receipt contains an invalid mount basis: ${receiptPath}`);
-    }
-    const mount = rawMount;
-    const normalizedRelativePath = typeof mount.workspaceRelativePath === "string" ? normalizedWorkspaceMountPath(mount.workspaceRelativePath) : "";
-    const durabilityRelative = typeof mount.sourcePath === "string" && typeof mount.durabilityRootPath === "string" ? path.relative(mount.durabilityRootPath, mount.sourcePath) : "..";
-    if (typeof mount.id !== "string" || !mount.id || seenIds.has(mount.id) || typeof mount.incarnationKey !== "string" || !mount.incarnationKey || mount.incarnationKey.includes("\0") || typeof mount.sourcePath !== "string" || path.resolve(mount.sourcePath) !== mount.sourcePath || typeof mount.durabilityRootPath !== "string" || path.resolve(mount.durabilityRootPath) !== mount.durabilityRootPath || !durabilityRelative || durabilityRelative === ".." || durabilityRelative.startsWith(`..${path.sep}`) || path.isAbsolute(durabilityRelative) || typeof mount.workspaceRelativePath !== "string" || mount.workspaceRelativePath !== normalizedRelativePath || !normalizedRelativePath || normalizedRelativePath === "." || normalizedRelativePath.split("/").some((segment) => segment === ".." || segment === ".git") || mount.sourceMode !== "all" && mount.sourceMode !== "git" || mount.hydrateDeletionMode !== "all" && mount.hydrateDeletionMode !== "git" || typeof mount.preserveLocalOnInitialOuterAbsence !== "boolean" || typeof mount.preserveLocalOnHydrationBasisChange !== "boolean" || typeof mount.deleteWhenSourceMissing !== "boolean" || candidate.version === 3 && (typeof mount.head !== "string" || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(mount.head))) {
-      throw new Error(`Workspace hydration receipt contains an invalid mount basis: ${receiptPath}`);
-    }
-    seenIds.add(mount.id);
-    return {
-      id: mount.id,
-      incarnationKey: mount.incarnationKey,
-      sourcePath: mount.sourcePath,
-      durabilityRootPath: mount.durabilityRootPath,
-      workspaceRelativePath: mount.workspaceRelativePath,
-      sourceMode: mount.sourceMode,
-      hydrateDeletionMode: mount.hydrateDeletionMode,
-      preserveLocalOnInitialOuterAbsence: mount.preserveLocalOnInitialOuterAbsence,
-      preserveLocalOnHydrationBasisChange: mount.preserveLocalOnHydrationBasisChange,
-      deleteWhenSourceMissing: mount.deleteWhenSourceMissing,
-      head: candidate.version === 3 ? mount.head : liftedV2Head
-    };
-  });
-  const sortedMounts = mounts.sort(compareWorkspaceHydrationMountBasis);
-  if (liftedV2Head) {
-    const legacyReceipt = {
-      version: 2,
-      head: liftedV2Head,
-      mounts: sortedMounts.map(({ head: _head, ...basis }) => basis)
-    };
-    if (content !== `${JSON.stringify(legacyReceipt)}
-`) {
-      throw new Error(`Workspace hydration receipt contains a noncanonical mount basis: ${receiptPath}`);
-    }
-  }
-  const receipt = {
-    version: 3,
-    mounts: sortedMounts
-  };
-  if (liftedV2Head) Object.defineProperty(receipt, "legacyHead", { value: liftedV2Head, enumerable: false });
-  if (candidate.version === 3 && content !== `${JSON.stringify(receipt)}
-`) {
-    throw new Error(`Workspace hydration receipt contains a noncanonical mount basis: ${receiptPath}`);
-  }
-  const receiptHeads = new Set(receipt.mounts.map((mount) => mount.head));
-  if (liftedV2Head) receiptHeads.add(liftedV2Head);
-  return { receipt, headsToVerify: [...receiptHeads] };
-}
-function parseWorkspaceHydrationReceiptContent(workspacePath, receiptPath, content) {
-  const { receipt, headsToVerify } = parseWorkspaceHydrationReceiptContentUnverified(receiptPath, content);
-  if (!workspaceCommitsExist(workspacePath, headsToVerify)) {
-    throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${receiptPath}`);
-  }
-  return receipt;
-}
-function readHydratedWorkspaceReceiptUnverified(workspacePath) {
-  const receiptPath = hydratedWorkspaceReceiptPath(workspacePath);
-  const status = lstatIfExists(receiptPath);
-  if (!status) return null;
-  if (!status.isFile() || status.isSymbolicLink()) {
-    throw new Error(`Workspace hydration receipt is not a regular file: ${receiptPath}`);
-  }
-  const content = fs.readFileSync(receiptPath, "utf8");
-  return { ...parseWorkspaceHydrationReceiptContentUnverified(receiptPath, content), receiptPath };
-}
-function readHydratedWorkspaceReceipt(workspacePath) {
-  const unverified = readHydratedWorkspaceReceiptUnverified(workspacePath);
-  if (!unverified) return null;
-  if (!workspaceCommitsExist(workspacePath, unverified.headsToVerify)) {
-    throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${unverified.receiptPath}`);
-  }
-  return unverified.receipt;
-}
-async function readHydratedWorkspaceReceiptUnverifiedAsync(workspacePath) {
-  const receiptPath = hydratedWorkspaceReceiptPath(workspacePath);
-  let status;
-  try {
-    status = await fs.promises.lstat(receiptPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-  if (!status.isFile() || status.isSymbolicLink()) {
-    throw new Error(`Workspace hydration receipt is not a regular file: ${receiptPath}`);
-  }
-  const content = await fs.promises.readFile(receiptPath, "utf8");
-  return { ...parseWorkspaceHydrationReceiptContentUnverified(receiptPath, content), receiptPath };
-}
-async function readHydratedWorkspaceReceiptAsync(workspacePath) {
-  const unverified = await readHydratedWorkspaceReceiptUnverifiedAsync(workspacePath);
-  if (!unverified) return null;
-  if (!await workspaceCommitsExistAsync(workspacePath, unverified.headsToVerify)) {
-    throw new Error(`Workspace hydration receipt does not resolve to a local commit: ${unverified.receiptPath}`);
-  }
-  return unverified.receipt;
-}
-async function hydratedWorkspaceReceiptFileIsV3(workspacePath) {
-  const receiptPath = hydratedWorkspaceReceiptPath(workspacePath);
-  try {
-    const status = await fs.promises.lstat(receiptPath);
-    if (!status.isFile() || status.isSymbolicLink()) return false;
-    return JSON.parse(await fs.promises.readFile(receiptPath, "utf8")).version === 3;
-  } catch {
-    return false;
-  }
-}
-function workspaceGitHydrationIsCurrent(workspacePath, mounts) {
-  return workspaceGitHydrationHolds(workspacePath, mounts, false);
-}
-function workspaceGitHydrationIsRecoverable(workspacePath, mounts) {
-  return workspaceGitHydrationHolds(workspacePath, mounts, true);
-}
-function workspaceGitHydrationHolds(workspacePath, mounts, tolerateIdleRecordedBasis) {
-  const resolvedWorkspacePath = path.resolve(workspacePath);
-  if (!fs.existsSync(path.join(resolvedWorkspacePath, ".git"))) return true;
-  if (mounts) validateMounts(resolvedWorkspacePath, mounts);
-  const head = revParse(resolvedWorkspacePath, "HEAD");
-  if (!workspaceCheckoutDurabilityIsCurrent(resolvedWorkspacePath)) return false;
-  if (tolerateIdleRecordedBasis && lstatIfExists(hydrationTransactionPath(resolvedWorkspacePath)) !== null) return false;
-  const receipt = readHydratedWorkspaceReceipt(resolvedWorkspacePath);
-  if (!workspaceBasisRefsAreCurrent(resolvedWorkspacePath, receipt ?? { version: 3, mounts: [] })) return false;
-  if (head === null) return true;
-  if (!receipt) return false;
-  return mounts ? configuredWorkspaceHydrationBasisMounts(resolvedWorkspacePath, mounts).every(
-    (mount) => workspaceHydrationReceiptCoversMount(receipt, head, mount) || Boolean((tolerateIdleRecordedBasis || mountBusy(mount)) && workspaceHydrationReceiptMountBasisHead(receipt, mount))
-  ) : Boolean(receipt && receipt.mounts.every((mount) => tolerateIdleRecordedBasis || mount.head === head));
-}
-const WORKSPACE_GIT_BASIS_REF_PREFIX = "refs/r5d/workspace-basis/";
-const WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX = "refs/r5d/workspace-basis-staging/";
-function workspaceBasisRefName(mountId) {
-  const sanitized = Buffer.from(mountId, "utf8").toString("base64url");
-  if (!sanitized) throw new Error(`Cannot derive a workspace basis ref for mount id: ${mountId}`);
-  return `${WORKSPACE_GIT_BASIS_REF_PREFIX}${sanitized}`;
-}
-function listWorkspaceRefs(workspacePath, prefix) {
-  return git(workspacePath, ["for-each-ref", "--format=%(refname)", prefix], `list ${prefix} refs`).split("\n").filter(Boolean).sort();
-}
-function desiredWorkspaceBasisRefs(receipt) {
-  const desired = /* @__PURE__ */ new Map();
-  for (const mount of receipt.mounts) {
-    const ref = workspaceBasisRefName(mount.id);
-    if (desired.has(ref)) throw new Error(`Workspace hydration mount ids collide at basis ref ${ref}`);
-    desired.set(ref, mount.head);
-  }
-  return desired;
-}
-function workspaceBasisRefsMatch(workspacePath, receipt) {
-  const desired = desiredWorkspaceBasisRefs(receipt);
-  const actual = git(
-    workspacePath,
-    ["for-each-ref", "--format=%(refname) %(objectname)", WORKSPACE_GIT_BASIS_REF_PREFIX],
-    `list ${WORKSPACE_GIT_BASIS_REF_PREFIX} refs`
-  ).split("\n").filter(Boolean);
-  if (actual.length !== desired.size) return false;
-  return actual.every((line) => {
-    const separator = line.lastIndexOf(" ");
-    if (separator <= 0) return false;
-    return desired.get(line.slice(0, separator)) === line.slice(separator + 1);
-  });
-}
-function workspaceBasisRefsAreCurrent(workspacePath, receipt) {
-  return workspaceBasisRefsMatch(workspacePath, receipt) && listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX).length === 0;
-}
-async function workspaceBasisRefsAreCurrentAsync(workspacePath, receipt) {
-  const desired = desiredWorkspaceBasisRefs(receipt);
-  const listing = await gitAsync(
-    workspacePath,
-    ["for-each-ref", "--format=%(refname) %(objectname)", WORKSPACE_GIT_BASIS_REF_PREFIX, WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX],
-    "list workspace hydration basis refs"
-  );
-  const stable = /* @__PURE__ */ new Map();
-  for (const line of listing.split("\n").filter(Boolean)) {
-    const separator = line.lastIndexOf(" ");
-    if (separator <= 0) return false;
-    const ref = line.slice(0, separator);
-    if (ref.startsWith(WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX)) return false;
-    stable.set(ref, line.slice(separator + 1));
-  }
-  if (stable.size !== desired.size) return false;
-  return [...stable].every(([ref, head]) => desired.get(ref) === head);
-}
-function repairWorkspaceBasisRefs(workspacePath, receipt) {
-  const effectiveReceipt = receipt ?? { version: 3, mounts: [] };
-  if (!workspaceBasisRefsAreCurrent(workspacePath, effectiveReceipt)) updateWorkspaceBasisRefs(workspacePath, effectiveReceipt);
-}
-function runWorkspaceRefUpdateBatch(workspacePath, instructions, action) {
-  if (instructions.length === 0) return;
-  const updated = Bun.spawnSync(gitCommandArgs(["update-ref", "--stdin"]), {
-    cwd: workspacePath,
-    stdin: Buffer.from([...instructions, ""].join("\n")),
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  if (updated.exitCode !== 0) {
-    throw new Error(`${action}: ${updated.stderr.toString().trim() || `git exited ${updated.exitCode}`}`);
-  }
-}
-function workspaceBasisRefTransaction(receipt, stableRefs) {
-  const desired = desiredWorkspaceBasisRefs(receipt);
-  const transaction = ["start"];
-  for (const [ref, head] of [...desired].sort(([left], [right]) => left.localeCompare(right))) transaction.push(`update ${ref} ${head}`);
-  for (const ref of stableRefs) {
-    if (!desired.has(ref)) transaction.push(`delete ${ref}`);
-  }
-  transaction.push("prepare", "commit");
-  return transaction;
-}
-function updateWorkspaceBasisRefs(workspacePath, receipt) {
-  runWorkspaceRefUpdateBatch(
-    workspacePath,
-    workspaceBasisRefTransaction(receipt, listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_REF_PREFIX)),
-    "Synchronize workspace hydration basis refs"
-  );
-  runWorkspaceRefUpdateBatch(
-    workspacePath,
-    listWorkspaceRefs(workspacePath, WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX).map((ref) => `delete ${ref}`),
-    "remove staged workspace hydration basis refs"
-  );
-}
-function assertCanonicalHydrationReceiptHeads(receipt) {
-  for (const mount of receipt.mounts) {
-    if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(mount.head)) {
-      throw new Error(`Cannot record invalid workspace hydration object id: ${mount.head}`);
-    }
-  }
-}
-function throwMissingHydrationReceiptCommit(workspacePath, receipt) {
-  const missing = receipt.mounts.find(({ head }) => !tryGit(workspacePath, ["cat-file", "-e", `${head}^{commit}`]));
-  throw new Error(`Cannot record workspace hydration receipt for a missing commit: ${missing?.head ?? "unknown"}`);
-}
-function updateHydratedWorkspaceReceipt(workspacePath, receipt) {
-  assertCanonicalHydrationReceiptHeads(receipt);
-  if (!workspaceCommitsExist(
-    workspacePath,
-    receipt.mounts.map(({ head }) => head)
-  )) {
-    throwMissingHydrationReceiptCommit(workspacePath, receipt);
-  }
-  readHydratedWorkspaceReceipt(workspacePath);
-  writeHydratedWorkspaceReceiptCore(workspacePath, receipt);
-}
-function prepareHydratedWorkspaceReceiptWrite(workspacePath) {
-  const gitDirectory = path.join(workspacePath, ".git");
-  const gitDirectoryStatus = fs.lstatSync(gitDirectory);
-  if (!gitDirectoryStatus.isDirectory() || gitDirectoryStatus.isSymbolicLink()) {
-    throw new Error(`Workspace Git directory is not a regular directory: ${gitDirectory}`);
-  }
-  const receiptPath = hydratedWorkspaceReceiptPath(workspacePath);
-  const receiptDirectory = path.dirname(receiptPath);
-  const existingReceiptDirectory = lstatIfExists(receiptDirectory);
-  if (!existingReceiptDirectory) {
-    fs.mkdirSync(receiptDirectory, { recursive: false, mode: 448 });
-    fsyncDirectory(gitDirectory);
-  }
-  const receiptDirectoryStatus = fs.lstatSync(receiptDirectory);
-  if (!receiptDirectoryStatus.isDirectory() || receiptDirectoryStatus.isSymbolicLink()) {
-    throw new Error(`Workspace hydration receipt directory is not a regular directory: ${receiptDirectory}`);
-  }
-  return { receiptPath, receiptDirectory };
-}
-function stagedWorkspaceBasisRefInstructions(receipt, stagingPrefix) {
-  desiredWorkspaceBasisRefs(receipt);
-  return receipt.mounts.map(
-    (mount) => `update ${stagingPrefix}${workspaceBasisRefName(mount.id).slice(WORKSPACE_GIT_BASIS_REF_PREFIX.length)} ${mount.head}`
-  );
-}
-function publishHydratedWorkspaceReceiptFile(workspacePath, receipt, paths) {
-  const temporaryPath = path.join(paths.receiptDirectory, `.workspace-hydrated-head.${process.pid}.${crypto.randomUUID()}.tmp`);
-  let descriptor;
-  try {
-    descriptor = fs.openSync(temporaryPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
-    fs.writeFileSync(descriptor, `${JSON.stringify(receipt)}
-`, "utf8");
-    fs.fsyncSync(descriptor);
-    fs.closeSync(descriptor);
-    descriptor = void 0;
-    fs.renameSync(temporaryPath, paths.receiptPath);
-    fsyncDirectory(paths.receiptDirectory);
-  } catch (error) {
-    if (descriptor !== void 0) fs.closeSync(descriptor);
-    fs.rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-}
-function writeHydratedWorkspaceReceiptCore(workspacePath, receipt) {
-  const paths = prepareHydratedWorkspaceReceiptWrite(workspacePath);
-  const stagingPrefix = `${WORKSPACE_GIT_BASIS_STAGING_REF_PREFIX}${crypto.randomUUID()}/`;
-  runWorkspaceRefUpdateBatch(
-    workspacePath,
-    stagedWorkspaceBasisRefInstructions(receipt, stagingPrefix),
-    "stage workspace hydration basis refs"
-  );
-  publishHydratedWorkspaceReceiptFile(workspacePath, receipt, paths);
-  updateWorkspaceBasisRefs(workspacePath, receipt);
-}
-function hydrationTransactionPath(workspacePath) {
-  return path.join(workspacePath, ".git", ...WORKSPACE_GIT_HYDRATION_TRANSACTION.split("/"));
-}
-function workspacePrivateStateDirectory(workspacePath) {
-  const gitDirectory = path.join(workspacePath, ".git");
-  const gitDirectoryStatus = fs.lstatSync(gitDirectory);
-  if (!gitDirectoryStatus.isDirectory() || gitDirectoryStatus.isSymbolicLink()) {
-    throw new Error(`Workspace Git directory is not a regular directory: ${gitDirectory}`);
-  }
-  const stateDirectory = path.dirname(hydrationTransactionPath(workspacePath));
-  const existing = lstatIfExists(stateDirectory);
-  if (!existing) {
-    fs.mkdirSync(stateDirectory, { recursive: false, mode: 448 });
-    fsyncDirectory(gitDirectory);
-  } else if (!existing.isDirectory() || existing.isSymbolicLink()) {
-    throw new Error(`Workspace Git private state is not a regular directory: ${stateDirectory}`);
-  }
-  return stateDirectory;
-}
-function writePrivateFileDurably(filePath, content) {
-  const descriptor = fs.openSync(
-    filePath,
-    fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW,
-    384
-  );
-  try {
-    fs.writeFileSync(descriptor, content, "utf8");
-    fs.fsyncSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function fsyncTree(rootPath) {
-  const syncEntry = (entryPath) => {
-    const status = fs.lstatSync(entryPath);
-    if (status.isSymbolicLink()) return;
-    if (status.isDirectory()) {
-      for (const name of fs.readdirSync(entryPath)) syncEntry(path.join(entryPath, name));
-      fsyncDirectory(entryPath);
-      return;
-    }
-    if (!status.isFile()) return;
-    const descriptor = fs.openSync(entryPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-    try {
-      fs.fsyncSync(descriptor);
-    } finally {
-      fs.closeSync(descriptor);
-    }
-  };
-  syncEntry(rootPath);
-}
-function parseWorkspaceCheckoutDurabilityRecordUnverified(recordPath, content) {
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    throw new Error(`Workspace checkout durability record is invalid: ${recordPath}`);
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error(`Workspace checkout durability record is invalid: ${recordPath}`);
-  }
-  const candidate = parsed;
-  if (candidate.version !== 1 || candidate.state !== "durable" && candidate.state !== "transition" || candidate.head !== null && (typeof candidate.head !== "string" || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(candidate.head))) {
-    throw new Error(`Workspace checkout durability record is invalid: ${recordPath}`);
-  }
-  const record = {
-    version: 1,
-    state: candidate.state,
-    head: candidate.head
-  };
-  if (content !== `${JSON.stringify(record)}
-`) {
-    throw new Error(`Workspace checkout durability record is noncanonical: ${recordPath}`);
-  }
-  return record;
-}
-function readWorkspaceCheckoutDurabilityRecordUnverified(workspacePath) {
-  const recordPath = workspaceCheckoutDurabilityPath(workspacePath);
-  const status = lstatIfExists(recordPath);
-  if (!status) return null;
-  if (!status.isFile() || status.isSymbolicLink()) {
-    throw new Error(`Workspace checkout durability record is not a regular file: ${recordPath}`);
-  }
-  return { record: parseWorkspaceCheckoutDurabilityRecordUnverified(recordPath, fs.readFileSync(recordPath, "utf8")), recordPath };
-}
-function readWorkspaceCheckoutDurabilityRecord(workspacePath) {
-  const unverified = readWorkspaceCheckoutDurabilityRecordUnverified(workspacePath);
-  if (!unverified) return null;
-  if (unverified.record.head && !tryGit(workspacePath, ["cat-file", "-e", `${unverified.record.head}^{commit}`])) {
-    throw new Error(`Workspace checkout durability record names a missing commit: ${unverified.recordPath}`);
-  }
-  return unverified.record;
-}
-async function readWorkspaceCheckoutDurabilityRecordAsync(workspacePath) {
-  const recordPath = workspaceCheckoutDurabilityPath(workspacePath);
-  let status;
-  try {
-    status = await fs.promises.lstat(recordPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-  if (!status.isFile() || status.isSymbolicLink()) {
-    throw new Error(`Workspace checkout durability record is not a regular file: ${recordPath}`);
-  }
-  const unverified = {
-    record: parseWorkspaceCheckoutDurabilityRecordUnverified(recordPath, await fs.promises.readFile(recordPath, "utf8")),
-    recordPath
-  };
-  if (unverified.record.head && !await tryGitAsync(workspacePath, ["cat-file", "-e", `${unverified.record.head}^{commit}`])) {
-    throw new Error(`Workspace checkout durability record names a missing commit: ${unverified.recordPath}`);
-  }
-  return unverified.record;
-}
-function writeWorkspaceCheckoutDurabilityRecordFile(workspacePath, record) {
-  const stateDirectory = workspacePrivateStateDirectory(workspacePath);
-  const recordPath = workspaceCheckoutDurabilityPath(workspacePath);
-  const temporaryPath = path.join(stateDirectory, `.workspace-checkout-durability.${process.pid}.${crypto.randomUUID()}.tmp`);
-  try {
-    writePrivateFileDurably(temporaryPath, `${JSON.stringify(record)}
-`);
-    fs.renameSync(temporaryPath, recordPath);
-    fsyncDirectory(stateDirectory);
-  } catch (error) {
-    fs.rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-}
-function updateWorkspaceCheckoutDurabilityRecord(workspacePath, record) {
-  if (record.head && !tryGit(workspacePath, ["cat-file", "-e", `${record.head}^{commit}`])) {
-    throw new Error(`Cannot record workspace checkout durability for a missing commit: ${record.head}`);
-  }
-  readWorkspaceCheckoutDurabilityRecord(workspacePath);
-  writeWorkspaceCheckoutDurabilityRecordFile(workspacePath, record);
-}
-function fsyncWorkspaceCheckoutTree(workspacePath) {
-  const status = fs.lstatSync(workspacePath);
-  if (!status.isDirectory() || status.isSymbolicLink()) {
-    throw new Error(`Workspace clone root is not a regular directory: ${workspacePath}`);
-  }
-  for (const name of fs.readdirSync(workspacePath)) {
-    if (name === ".git") continue;
-    fsyncTree(path.join(workspacePath, name));
-  }
-  fsyncDirectory(workspacePath);
-}
-function workspaceRebaseInProgress(workspacePath) {
-  const gitDirectory = path.join(workspacePath, ".git");
-  return fs.existsSync(path.join(gitDirectory, "rebase-merge")) || fs.existsSync(path.join(gitDirectory, "rebase-apply"));
-}
-function workspaceResolutionInProgress(workspacePath) {
-  return workspaceRebaseInProgress(workspacePath) || fs.existsSync(path.join(workspacePath, ".git", "MERGE_HEAD"));
-}
-async function workspaceHasUnmergedEntries(workspacePath) {
-  const result = await gitResultAsync(workspacePath, ["ls-files", "-u", "-z"]);
-  if (result.exitCode !== 0) {
-    throw new Error(`Inspect unfinished workspace merge: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
-  }
-  return result.stdout.length > 0;
-}
-function clearWorkspaceCheckoutTree(workspacePath) {
-  for (const name of fs.readdirSync(workspacePath)) {
-    if (name === ".git") continue;
-    fs.rmSync(path.join(workspacePath, name), { recursive: true, force: true });
-  }
-  fsyncDirectory(workspacePath);
-}
-function recoverWorkspaceCheckoutDurability(workspacePath, preserveResolutionInProgress = false) {
-  workspacePath = path.resolve(workspacePath);
-  const record = readWorkspaceCheckoutDurabilityRecord(workspacePath);
-  const observedHead = revParse(workspacePath, "HEAD");
-  if (record?.state === "durable" && record.head === observedHead) return;
-  if (preserveResolutionInProgress && workspaceResolutionInProgress(workspacePath)) {
-    throw new Error("Workspace resolution is in progress; finish or abort it before synchronizing");
-  }
-  let targetHead = record?.state === "transition" ? record.head : observedHead;
-  if (record?.state === "transition" && observedHead && observedHead !== record.head) {
-    const hydrationReceipt = readHydratedWorkspaceReceipt(workspacePath);
-    if (hydrationReceipt?.legacyHead === observedHead || hydrationReceipt?.mounts.some((mount) => mount.head === observedHead)) {
-      targetHead = observedHead;
-    }
-  }
-  if (workspaceRebaseInProgress(workspacePath)) {
-    const abort = gitResult(workspacePath, ["rebase", "--abort"]);
-    if (abort.exitCode !== 0) {
-      throw new Error(`Abort interrupted workspace rebase: ${abort.stderr || abort.stdout || `git exited ${abort.exitCode}`}`);
-    }
-    if (record?.state !== "transition") targetHead = revParse(workspacePath, "HEAD");
-  }
-  clearWorkspaceCheckoutTree(workspacePath);
-  if (targetHead) {
-    git(workspacePath, ["reset", "--hard", targetHead], "reconstruct durable workspace checkout");
-    if (revParse(workspacePath, "HEAD") !== targetHead) {
-      throw new Error(`Workspace checkout reconstruction did not restore ${targetHead}`);
-    }
-  } else {
-    git(workspacePath, ["symbolic-ref", "HEAD", `refs/heads/${WORKSPACE_GIT_BRANCH}`], "restore unborn workspace HEAD");
-    git(workspacePath, ["update-ref", "-d", `refs/heads/${WORKSPACE_GIT_BRANCH}`], "remove interrupted workspace branch ref");
-    git(workspacePath, ["read-tree", "--empty"], "reconstruct unborn workspace checkout");
-    if (revParse(workspacePath, "HEAD") !== null) {
-      throw new Error("Workspace checkout reconstruction did not restore its unborn HEAD");
-    }
-  }
-  fsyncWorkspaceCheckoutTree(workspacePath);
-  updateWorkspaceCheckoutDurabilityRecord(workspacePath, { version: 1, state: "durable", head: targetHead });
-}
-function workspaceCheckoutDurabilityIsCurrent(workspacePath) {
-  const record = readWorkspaceCheckoutDurabilityRecord(workspacePath);
-  return Boolean(record?.state === "durable" && record.head === revParse(workspacePath, "HEAD"));
-}
-async function workspaceCheckoutDurabilityIsCurrentAsync(workspacePath) {
-  const record = await readWorkspaceCheckoutDurabilityRecordAsync(workspacePath);
-  return Boolean(record?.state === "durable" && record.head === await revParseAsync(workspacePath, "HEAD"));
-}
-function runCheckoutTransitionBeginJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  recoverWorkspaceCheckoutDurability(workspacePath);
-  const head = revParse(workspacePath, "HEAD");
-  updateWorkspaceCheckoutDurabilityRecord(workspacePath, { version: 1, state: "transition", head });
-  return null;
-}
-function runCheckoutTransitionCompleteJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  fsyncWorkspaceCheckoutTree(workspacePath);
-  updateWorkspaceCheckoutDurabilityRecord(workspacePath, { version: 1, state: "durable", head: revParse(workspacePath, "HEAD") });
-  return null;
-}
-function runCheckoutDurabilityRecoveryJob(input) {
-  recoverWorkspaceCheckoutDurability(path.resolve(input.workspacePath), input.preserveResolutionInProgress);
-  return null;
-}
-function runOuterCheckoutFsyncJob(input) {
-  fsyncWorkspaceCheckoutTree(path.resolve(input.workspacePath));
-  return null;
-}
-async function beginWorkspaceCheckoutTransition(workspacePath) {
-  await workspaceFilesystemExecutor().run("checkout_transition_begin", { workspacePath });
-}
-async function completeWorkspaceCheckoutTransition(workspacePath) {
-  await workspaceFilesystemExecutor().run("checkout_transition_complete", { workspacePath });
-}
-async function throwAfterWorkspaceCheckoutRecovery(workspacePath, error) {
-  try {
-    await workspaceFilesystemExecutor().run("checkout_durability_recovery", { workspacePath, preserveResolutionInProgress: false });
-  } catch (recoveryError) {
-    throw new AggregateError(
-      [error, recoveryError],
-      `Workspace checkout mutation failed and its durable head could not be restored: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  throw error;
-}
-async function runWorkspaceCheckoutTransition(workspacePath, mutate) {
-  await beginWorkspaceCheckoutTransition(workspacePath);
-  try {
-    await mutate();
-    await completeWorkspaceCheckoutTransition(workspacePath);
-  } catch (error) {
-    await throwAfterWorkspaceCheckoutRecovery(workspacePath, error);
-  }
-}
-function parseHydrationTransactionManifest(transactionPath, workspacePath = path.resolve(transactionPath, "..", "..", ".."), options = {}) {
-  const manifestPath = path.join(transactionPath, "manifest.json");
-  const status = fs.lstatSync(manifestPath);
-  if (!status.isFile() || status.isSymbolicLink()) {
-    throw new Error(`Workspace hydration transaction manifest is not a regular file: ${manifestPath}`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-  } catch (error) {
-    throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`, { cause: error });
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
-  }
-  const candidate = parsed;
-  if (candidate.version !== 2 && candidate.version !== 3 && candidate.version !== 4 && candidate.version !== 5 || !Array.isArray(candidate.mounts) || candidate.preservedMounts !== void 0 && (candidate.version !== 5 || !Array.isArray(candidate.preservedMounts))) {
-    throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
-  }
-  if (candidate.version === 5 && (typeof candidate.transactionId !== "string" || !HYDRATION_TRANSACTION_ID.test(candidate.transactionId))) {
-    throw new Error(`Workspace hydration transaction identity is invalid: ${manifestPath}`);
-  }
-  const parseReceipt = (rawReceipt) => {
-    if (rawReceipt === null) return null;
-    if (!rawReceipt || typeof rawReceipt !== "object") {
-      throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
-    }
-    const content = `${JSON.stringify(rawReceipt)}
-`;
-    return options.verifyReceiptCommits === false ? parseWorkspaceHydrationReceiptContentUnverified(manifestPath, content).receipt : parseWorkspaceHydrationReceiptContent(workspacePath, manifestPath, content);
-  };
-  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 && candidate.version !== 5 || !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" || 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 parsedMounts = [...candidate.mounts, ...candidate.preservedMounts ?? []].map((rawMount) => {
-    if (!rawMount || typeof rawMount !== "object") {
-      throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
-    }
-    const mount = rawMount;
-    if (typeof mount.id !== "string" || !mount.id || typeof mount.incarnationKey !== "string" || !mount.incarnationKey || mount.incarnationKey.includes("\0") || typeof mount.sourcePath !== "string" || path.resolve(mount.sourcePath) !== mount.sourcePath || typeof mount.durabilityRootPath !== "string" || path.resolve(mount.durabilityRootPath) !== mount.durabilityRootPath || typeof mount.workspaceRelativePath !== "string" || typeof mount.existed !== "boolean" || typeof mount.snapshotName !== "string" || !/^[0-9]+$/.test(mount.snapshotName) || seenIds.has(mount.id) || seenSnapshots.has(mount.snapshotName)) {
-      throw new Error(`Workspace hydration transaction manifest is invalid: ${manifestPath}`);
-    }
-    const relative = path.relative(mount.durabilityRootPath, mount.sourcePath);
-    if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-      throw new Error(`Workspace hydration transaction source escapes its durability root: ${mount.sourcePath}`);
-    }
-    seenIds.add(mount.id);
-    seenSnapshots.add(mount.snapshotName);
-    const scope = parseScope(rawMount.scope, mount.existed);
-    if (candidate.version === 5 && mount.recovery !== "snapshot" && mount.recovery !== "guarded" || candidate.version !== 5 && mount.recovery !== void 0 || mount.recovery === "guarded" && (!mount.existed || !scope)) {
-      throw new Error(`Workspace hydration recovery policy is invalid: ${manifestPath}`);
-    }
-    return {
-      id: mount.id,
-      incarnationKey: mount.incarnationKey,
-      sourcePath: mount.sourcePath,
-      durabilityRootPath: mount.durabilityRootPath,
-      workspaceRelativePath: mount.workspaceRelativePath,
-      existed: mount.existed,
-      snapshotName: mount.snapshotName,
-      ...scope ? { scope } : {},
-      ...candidate.version === 5 ? { recovery: mount.recovery } : {}
-    };
-  });
-  return {
-    version: candidate.version === 5 ? 5 : candidate.version === 4 ? 4 : 3,
-    ...candidate.version === 5 ? { transactionId: candidate.transactionId } : {},
-    targetReceipt,
-    receiptBefore,
-    mounts: parsedMounts.slice(0, candidate.mounts.length),
-    ...candidate.preservedMounts !== void 0 ? { preservedMounts: parsedMounts.slice(candidate.mounts.length) } : {}
-  };
-}
-function hydrationEvidenceMounts(manifest) {
-  return [...manifest.mounts, ...manifest.preservedMounts ?? []];
-}
-function removeHydrationTransaction(workspacePath) {
-  const transactionPath = hydrationTransactionPath(workspacePath);
-  fs.rmSync(transactionPath, { recursive: true, force: true });
-  fsyncDirectory(path.dirname(transactionPath));
-}
-function hydrationTransactionCommitted(transactionPath) {
-  const markerPath = path.join(transactionPath, "committed");
-  const markerStatus = lstatIfExists(markerPath);
-  if (!markerStatus) return false;
-  if (!markerStatus.isFile() || markerStatus.isSymbolicLink() || fs.readFileSync(markerPath, "utf8") !== "committed\n") {
-    throw new Error(`Workspace hydration transaction commit marker is invalid: ${markerPath}`);
-  }
-  return true;
-}
-function hydrationRetainedEvidence(mount) {
-  if (!lstatIfExists(mount.sourcePath)) return null;
-  assertManagedDirectoryPath({
-    trustedRoot: mount.durabilityRootPath,
-    candidate: mount.sourcePath,
-    label: `Hydration evidence mount ${mount.id}`
-  });
-  const dotGit = path.join(mount.sourcePath, ".git");
-  if (lstatIfExists(dotGit)?.isSymbolicLink()) throw new Error(`Hydration evidence Git directory is a symlink: ${dotGit}`);
-  const directory = workingTreeDisplacedRetentionDirectory(mount.sourcePath);
-  if (!directory) return null;
-  assertManagedDirectoryPath({
-    trustedRoot: mount.durabilityRootPath,
-    candidate: directory,
-    label: `Hydration retained evidence ${mount.id}`
-  });
-  if (!lstatIfExists(directory)) return null;
-  return {
-    directory,
-    paths: fs.readdirSync(directory).sort().map((name) => path.join(directory, name))
-  };
-}
-function fsyncHydrationRetainedEvidence(mount) {
-  const evidence = hydrationRetainedEvidence(mount);
-  if (!evidence || evidence.paths.length === 0) return;
-  fsyncTree(evidence.directory);
-  for (let directory = path.dirname(evidence.directory); ; directory = path.dirname(directory)) {
-    fsyncDirectory(directory);
-    if (directory === path.resolve(mount.durabilityRootPath)) break;
-  }
-}
-function readHydrationArchivedEvidence(transactionPath, manifest) {
-  const recordPath = path.join(transactionPath, "retained-evidence.json");
-  const status = lstatIfExists(recordPath);
-  if (!status) return [];
-  if (!status.isFile() || status.isSymbolicLink()) throw new Error(`Invalid hydration retained-evidence record: ${recordPath}`);
-  const record = JSON.parse(fs.readFileSync(recordPath, "utf8"));
-  if (record.version !== 1 || !Array.isArray(record.entries)) throw new Error(`Invalid hydration retained-evidence record: ${recordPath}`);
-  const seen = /* @__PURE__ */ new Set();
-  return record.entries.map((raw) => {
-    if (!raw || typeof raw !== "object") throw new Error(`Invalid hydration retained-evidence entry: ${recordPath}`);
-    const entry = raw;
-    const mount = hydrationEvidenceMounts(manifest).find(({ id }) => id === entry.mountId);
-    const parts = typeof entry.archiveRelativePath === "string" ? entry.archiveRelativePath.split("/") : [];
-    const sourceRelative = typeof entry.sourcePath === "string" && mount ? path.relative(mount.durabilityRootPath, entry.sourcePath) : "";
-    if (!mount || typeof entry.sourcePath !== "string" || path.resolve(entry.sourcePath) !== entry.sourcePath || !sourceRelative || sourceRelative === ".." || sourceRelative.startsWith(`..${path.sep}`) || path.isAbsolute(sourceRelative) || parts.length !== 4 || parts[0] !== "displaced" || !HYDRATION_TRANSACTION_ID.test(parts[1]) || parts[2] !== mount.snapshotName || !parts[3] || parts[3] === "." || parts[3] === ".." || parts[3].includes("\\") || seen.has(entry.archiveRelativePath)) {
-      throw new Error(`Invalid hydration retained-evidence entry: ${recordPath}`);
-    }
-    const archivedPath = path.join(transactionPath, ...parts);
-    assertManagedDirectoryPath({
-      trustedRoot: transactionPath,
-      candidate: path.dirname(archivedPath),
-      label: "Archived hydration evidence"
-    });
-    if (!lstatIfExists(archivedPath)) throw new Error(`Archived hydration evidence is missing: ${archivedPath}`);
-    seen.add(entry.archiveRelativePath);
-    return { mountId: entry.mountId, sourcePath: entry.sourcePath, archiveRelativePath: entry.archiveRelativePath };
-  });
-}
-function captureHydrationRetainedEvidence(transactionPath, manifest) {
-  const entries = readHydrationArchivedEvidence(transactionPath, manifest);
-  const captureId = crypto.randomUUID();
-  let captured = false;
-  for (const mount of hydrationEvidenceMounts(manifest)) {
-    const evidence = hydrationRetainedEvidence(mount);
-    if (!evidence || evidence.paths.length === 0) continue;
-    fsyncHydrationRetainedEvidence(mount);
-    const relativeDirectory = `displaced/${captureId}/${mount.snapshotName}`;
-    const destinationDirectory = path.join(transactionPath, relativeDirectory);
-    assertManagedDirectoryPath({ trustedRoot: transactionPath, candidate: destinationDirectory, label: "Hydration evidence capture" });
-    fs.mkdirSync(destinationDirectory, { recursive: true, mode: 448 });
-    for (const sourcePath of evidence.paths) {
-      const archiveRelativePath = `${relativeDirectory}/${path.basename(sourcePath)}`;
-      fs.cpSync(sourcePath, path.join(transactionPath, archiveRelativePath), {
-        recursive: true,
-        dereference: false,
-        verbatimSymlinks: true,
-        errorOnExist: true,
-        force: false,
-        preserveTimestamps: true
-      });
-      entries.push({ mountId: mount.id, sourcePath, archiveRelativePath });
-      captured = true;
-    }
-  }
-  if (captured) {
-    fsyncTree(path.join(transactionPath, "displaced"));
-    const temporaryPath = path.join(transactionPath, `.retained-evidence.${crypto.randomUUID()}.tmp`);
-    writePrivateFileDurably(temporaryPath, `${JSON.stringify({ version: 1, entries })}
-`);
-    fs.renameSync(temporaryPath, path.join(transactionPath, "retained-evidence.json"));
-    fsyncDirectory(transactionPath);
-  }
-  return entries;
-}
-function hydrationRecoveryRequiredError(workspacePath, manifest, cause) {
-  if (manifest.version !== 5 || !manifest.transactionId) throw new Error("Guarded hydration lacks a durable transaction identity");
-  return new WorkspaceHydrationRecoveryRequiredError(
-    {
-      transactionId: manifest.transactionId,
-      transactionPath: hydrationTransactionPath(workspacePath),
-      mounts: hydrationEvidenceMounts(manifest).map(({ id, incarnationKey, sourcePath, durabilityRootPath, workspaceRelativePath }) => {
-        const retainedPaths = hydrationRetainedEvidence({ id, sourcePath, durabilityRootPath })?.paths;
-        return {
-          id,
-          incarnationKey,
-          sourcePath,
-          durabilityRootPath,
-          workspaceRelativePath,
-          ...retainedPaths?.length ? { retainedPaths } : {}
-        };
-      }),
-      receiptBefore: manifest.receiptBefore
-    },
-    cause === void 0 ? void 0 : { cause }
-  );
-}
-function runHydrationRecoveryInspectJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  const workspaceStatus = lstatIfExists(workspacePath);
-  if (!workspaceStatus) return null;
-  if (!workspaceStatus.isDirectory() || workspaceStatus.isSymbolicLink())
-    throw new Error(`Invalid workspace hydration root: ${workspacePath}`);
-  const transactionPath = hydrationTransactionPath(workspacePath);
-  assertManagedDirectoryPath({
-    trustedRoot: workspacePath,
-    candidate: transactionPath,
-    label: "Workspace hydration transaction inspection"
-  });
-  const status = lstatIfExists(transactionPath);
-  if (!status) return null;
-  if (!status.isDirectory() || status.isSymbolicLink()) throw new Error(`Invalid workspace hydration transaction: ${transactionPath}`);
-  const manifest = parseHydrationTransactionManifest(transactionPath);
-  if (hydrationTransactionCommitted(transactionPath) || !manifest.mounts.some(({ recovery }) => recovery === "guarded")) return null;
-  return hydrationRecoveryRequiredError(workspacePath, manifest).hydrationRecovery;
-}
-function readPreservedHydrationBases(workspacePath) {
-  const recordPath = path.join(workspacePath, ".git", ...WORKSPACE_GIT_HYDRATION_PRESERVED_BASES.split("/"));
-  const status = lstatIfExists(recordPath);
-  if (!status) return null;
-  if (!status.isFile() || status.isSymbolicLink()) throw new Error(`Preserved hydration bases are not a regular file: ${recordPath}`);
-  return parseWorkspaceHydrationReceiptContentUnverified(recordPath, fs.readFileSync(recordPath, "utf8")).receipt;
-}
-async function readPreservedHydrationBasesAsync(workspacePath) {
-  const recordPath = path.join(workspacePath, ".git", ...WORKSPACE_GIT_HYDRATION_PRESERVED_BASES.split("/"));
-  let status;
-  try {
-    status = await fs.promises.lstat(recordPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-  if (!status.isFile() || status.isSymbolicLink()) throw new Error(`Preserved hydration bases are not a regular file: ${recordPath}`);
-  return parseWorkspaceHydrationReceiptContentUnverified(recordPath, await fs.promises.readFile(recordPath, "utf8")).receipt;
-}
-function preserveHydrationBases(workspacePath, manifest) {
-  const current = readHydratedWorkspaceReceipt(workspacePath);
-  if (!workspaceHydrationReceiptsEqual(current, manifest.receiptBefore)) {
-    throw new Error(`Hydration receipt changed before preservation of transaction ${manifest.transactionId}`);
-  }
-  const previous = readPreservedHydrationBases(workspacePath);
-  const affectedIds = new Set(hydrationEvidenceMounts(manifest).map(({ id }) => id));
-  const mounts = (current?.mounts ?? []).filter(
-    (entry) => affectedIds.has(entry.id) || previous?.mounts.some(
-      (preserved) => workspaceHydrationReceiptsEqual({ version: 3, mounts: [entry] }, { version: 3, mounts: [preserved] })
-    )
-  );
-  const recordPath = path.join(workspacePath, ".git", ...WORKSPACE_GIT_HYDRATION_PRESERVED_BASES.split("/"));
-  const temporaryPath = `${recordPath}.${crypto.randomUUID()}.tmp`;
-  writePrivateFileDurably(temporaryPath, `${JSON.stringify({ version: 3, mounts })}
-`);
-  fs.renameSync(temporaryPath, recordPath);
-  fsyncDirectory(path.dirname(recordPath));
-}
-function runHydrationPreserveInterruptedJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  if (!HYDRATION_TRANSACTION_ID.test(input.expectedTransactionId)) throw new Error("Invalid hydration recovery transaction identity");
-  const stateDirectory = workspacePrivateStateDirectory(workspacePath);
-  const transactionPath = hydrationTransactionPath(workspacePath);
-  const archivesPath = path.join(workspacePath, ".git", ...WORKSPACE_GIT_HYDRATION_RECOVERIES.split("/"));
-  const archivePath = path.join(archivesPath, input.expectedTransactionId);
-  assertManagedDirectoryPath({ trustedRoot: stateDirectory, candidate: archivesPath, label: "Workspace hydration archives" });
-  const pending = lstatIfExists(transactionPath);
-  if (!pending) {
-    assertManagedDirectoryPath({ trustedRoot: stateDirectory, candidate: archivePath, label: "Workspace hydration archive" });
-    if (!lstatIfExists(archivePath))
-      throw new Error(`No pending or preserved hydration transaction matches ${input.expectedTransactionId}`);
-    const archived = parseHydrationTransactionManifest(archivePath, workspacePath, { verifyReceiptCommits: false });
-    const markerPath2 = path.join(archivePath, "preserved.json");
-    const markerStatus = fs.lstatSync(markerPath2);
-    if (!markerStatus.isFile() || markerStatus.isSymbolicLink()) throw new Error(`Invalid hydration preservation record: ${markerPath2}`);
-    const marker = JSON.parse(fs.readFileSync(markerPath2, "utf8"));
-    if (archived.version !== 5 || archived.transactionId !== input.expectedTransactionId || marker.version !== 1 || marker.transactionId !== archived.transactionId) {
-      throw new Error(`Hydration archive identity does not match ${input.expectedTransactionId}`);
-    }
-    const retainedEntries2 = readHydrationArchivedEvidence(archivePath, archived).map(({ mountId, sourcePath, archiveRelativePath }) => ({
-      mountId,
-      sourcePath,
-      archivePath: path.join(archivePath, archiveRelativePath)
-    }));
-    fsyncDirectory(archivePath);
-    fsyncDirectory(archivesPath);
-    fsyncDirectory(stateDirectory);
-    return {
-      transactionId: archived.transactionId,
-      archivePath,
-      receiptBefore: archived.receiptBefore,
-      preservedMountIds: hydrationEvidenceMounts(archived).map(({ id }) => id).sort(),
-      alreadyPreserved: true,
-      ...retainedEntries2.length > 0 ? { retainedEntries: retainedEntries2 } : {}
-    };
-  }
-  if (!pending.isDirectory() || pending.isSymbolicLink()) throw new Error(`Invalid workspace hydration transaction: ${transactionPath}`);
-  const manifest = parseHydrationTransactionManifest(transactionPath);
-  if (manifest.version !== 5 || manifest.transactionId !== input.expectedTransactionId) {
-    throw new Error(
-      `Stale hydration recovery transaction identity: expected ${input.expectedTransactionId}, pending ${manifest.transactionId ?? "legacy transaction"}`
-    );
-  }
-  if (hydrationTransactionCommitted(transactionPath))
-    throw new Error(`Hydration transaction ${manifest.transactionId} is committed; ordinary recovery must finish its receipt`);
-  if (!manifest.mounts.some(({ recovery }) => recovery === "guarded"))
-    throw new Error(`Hydration transaction ${manifest.transactionId} has no interrupted guarded mounts`);
-  if (lstatIfExists(archivePath))
-    throw new Error(`Hydration archive already exists while transaction ${manifest.transactionId} is pending`);
-  if (!workspaceHydrationReceiptsEqual(readHydratedWorkspaceReceipt(workspacePath), manifest.receiptBefore)) {
-    throw new Error(`Hydration receipt changed before preservation of transaction ${manifest.transactionId}`);
-  }
-  for (const mount of hydrationEvidenceMounts(manifest)) {
-    assertManagedDirectoryPath({
-      trustedRoot: mount.durabilityRootPath,
-      candidate: mount.sourcePath,
-      label: `Hydration preservation mount ${mount.id}`
-    });
-    const source = lstatIfExists(mount.sourcePath);
-    if (mount.existed && !source) throw new Error(`Hydration preservation mount ${mount.id} is missing: ${mount.sourcePath}`);
-    const snapshotPath = path.join(transactionPath, "mounts", mount.snapshotName);
-    assertManagedDirectoryPath({
-      trustedRoot: transactionPath,
-      candidate: snapshotPath,
-      label: `Hydration preservation snapshot ${mount.id}`
-    });
-    if (!lstatIfExists(snapshotPath)) throw new Error(`Hydration preservation snapshot ${mount.id} is missing`);
-    const basis = manifest.receiptBefore?.mounts.find((entry) => entry.id === mount.id);
-    if (!basis || basis.incarnationKey !== mount.incarnationKey || basis.sourcePath !== mount.sourcePath || basis.durabilityRootPath !== mount.durabilityRootPath || basis.workspaceRelativePath !== mount.workspaceRelativePath) {
-      throw new Error(
-        `Hydration preservation mount ${mount.id} has no matching prior receipt basis; manual salvage is required. The transaction and all snapshots remain at ${transactionPath}`
-      );
-    }
-  }
-  for (const mount of hydrationEvidenceMounts(manifest)) {
-    fsyncHydratedWorkspaceMount({ ...mount, hydrationIncarnationKey: mount.incarnationKey, sourceMode: "all", hydrateDeletionMode: "all" });
-  }
-  const retainedEntries = captureHydrationRetainedEvidence(transactionPath, manifest).map(
-    ({ mountId, sourcePath, archiveRelativePath }) => ({
-      mountId,
-      sourcePath,
-      archivePath: path.join(archivePath, archiveRelativePath)
-    })
-  );
-  fsyncTree(transactionPath);
-  preserveHydrationBases(workspacePath, manifest);
-  repairWorkspaceBasisRefs(workspacePath, manifest.receiptBefore);
-  const markerPath = path.join(transactionPath, "preserved.json");
-  const markerContent = `${JSON.stringify({ version: 1, transactionId: manifest.transactionId })}
-`;
-  const existingMarker = lstatIfExists(markerPath);
-  if (existingMarker) {
-    if (!existingMarker.isFile() || existingMarker.isSymbolicLink() || fs.readFileSync(markerPath, "utf8") !== markerContent) {
-      throw new Error(`Invalid hydration preservation record: ${markerPath}`);
-    }
-  } else {
-    const markerTemporaryPath = path.join(transactionPath, `.preserved.${crypto.randomUUID()}.tmp`);
-    writePrivateFileDurably(markerTemporaryPath, markerContent);
-    fs.renameSync(markerTemporaryPath, markerPath);
-  }
-  fsyncDirectory(transactionPath);
-  if (!lstatIfExists(archivesPath)) {
-    fs.mkdirSync(archivesPath, { mode: 448 });
-    fsyncDirectory(stateDirectory);
-  }
-  fs.renameSync(transactionPath, archivePath);
-  fsyncDirectory(archivesPath);
-  fsyncDirectory(stateDirectory);
-  return {
-    transactionId: manifest.transactionId,
-    archivePath,
-    receiptBefore: manifest.receiptBefore,
-    preservedMountIds: hydrationEvidenceMounts(manifest).map(({ id }) => id).sort(),
-    alreadyPreserved: false,
-    ...retainedEntries.length > 0 ? { retainedEntries } : {}
-  };
-}
-function restoreHydrationTransaction(workspacePath, manifest) {
-  if (manifest.mounts.some(({ recovery }) => recovery === "guarded")) {
-    throw hydrationRecoveryRequiredError(workspacePath, manifest);
-  }
-  const transactionPath = hydrationTransactionPath(workspacePath);
-  const durabilityScopes = /* @__PURE__ */ new Map();
-  for (const mount of manifest.mounts) {
-    assertManagedDirectoryPath({
-      trustedRoot: mount.durabilityRootPath,
-      candidate: mount.sourcePath,
-      label: `Workspace hydration recovery mount ${mount.id}`
-    });
-    if (!mount.existed) {
-      fs.rmSync(mount.sourcePath, { recursive: true, force: true });
-      continue;
-    }
-    const snapshotPath = path.join(transactionPath, "mounts", mount.snapshotName);
-    const snapshotStatus = fs.lstatSync(snapshotPath);
-    if (!snapshotStatus.isDirectory() || snapshotStatus.isSymbolicLink()) {
-      throw new Error(`Workspace hydration snapshot is not a regular directory: ${snapshotPath}`);
-    }
-    if (mount.scope) {
-      const restored = restoreWorkingTreeMirrorScope({ snapshotRoot: snapshotPath, targetRoot: mount.sourcePath, scope: mount.scope });
-      durabilityScopes.set(mount.id, restored.paths);
-      continue;
-    }
-    mirrorWorkingTree({ sourceRoot: snapshotPath, targetRoot: mount.sourcePath, sourceMode: "all", deletionMode: "all" });
-  }
-  fsyncHydratedWorkspaceMounts(
-    manifest.mounts.map((mount) => ({
-      ...mount,
-      hydrationIncarnationKey: mount.incarnationKey,
-      sourceMode: "all",
-      hydrateDeletionMode: "all"
-    })),
-    durabilityScopes
-  );
-}
-function recoverPendingHydrationTransaction(workspacePath) {
-  const stateDirectory = path.dirname(hydrationTransactionPath(workspacePath));
-  const stateStatus = lstatIfExists(stateDirectory);
-  if (!stateStatus) return;
-  if (!stateStatus.isDirectory() || stateStatus.isSymbolicLink()) {
-    throw new Error(`Workspace Git private state is not a regular directory: ${stateDirectory}`);
-  }
-  for (const name of fs.readdirSync(stateDirectory)) {
-    if (!name.startsWith(".workspace-hydration-transaction.") || !name.endsWith(".tmp")) continue;
-    fs.rmSync(path.join(stateDirectory, name), { recursive: true, force: true });
-    fsyncDirectory(stateDirectory);
-  }
-  const transactionPath = hydrationTransactionPath(workspacePath);
-  const transactionStatus = lstatIfExists(transactionPath);
-  if (!transactionStatus) return;
-  if (!transactionStatus.isDirectory() || transactionStatus.isSymbolicLink()) {
-    throw new Error(`Workspace hydration transaction is not a regular directory: ${transactionPath}`);
-  }
-  const manifest = parseHydrationTransactionManifest(transactionPath);
-  if (hydrationTransactionCommitted(transactionPath)) {
-    const receipt2 = readHydratedWorkspaceReceipt(workspacePath);
-    if (manifest.targetReceipt && !workspaceHydrationReceiptsEqual(receipt2, manifest.targetReceipt)) {
-      updateHydratedWorkspaceReceipt(workspacePath, manifest.targetReceipt);
-    }
-    removeHydrationTransaction(workspacePath);
-    return;
-  }
-  const receipt = readHydratedWorkspaceReceipt(workspacePath);
-  if (manifest.version !== 5 && manifest.targetReceipt && !workspaceHydrationReceiptsEqual(manifest.targetReceipt, manifest.receiptBefore) && workspaceHydrationReceiptsEqual(receipt, manifest.targetReceipt)) {
-    removeHydrationTransaction(workspacePath);
-    return;
-  }
-  restoreHydrationTransaction(workspacePath, manifest);
-  removeHydrationTransaction(workspacePath);
-}
-function gitOutputSync(cwd, args, action, input) {
-  const result = Bun.spawnSync(gitCommandArgs(args), {
-    cwd,
-    ...input ? { stdin: input } : {},
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
-  return Buffer.from(result.stdout);
-}
-function workspaceSubtreeChanges(workspacePath, projectedCommit, head, workspaceRelativePath) {
-  const normalized = normalizedWorkspaceMountPath(workspaceRelativePath);
-  const names = [`${projectedCommit}:${normalized}`, `${head}:${normalized}`];
-  const resolved = resolveGitObjectsSync(workspacePath, names);
-  const emptyTree = emptyTreeHash(workspacePath);
-  const subtree = (name) => {
-    const object = resolved.get(name);
-    return object?.type === "tree" ? object.objectId : emptyTree;
-  };
-  const base = subtree(names[0]);
-  const theirs = subtree(names[1]);
-  if (base === theirs) return parseWorkspaceSubtreeChanges(Buffer.alloc(0));
-  return parseWorkspaceSubtreeChanges(
-    gitOutputSync(
-      workspacePath,
-      ["diff-tree", "-r", "-z", "--no-renames", "--raw", base, theirs],
-      "compare projected and hydration subtrees"
-    )
-  );
-}
-function resolveGitObjectsSync(workspacePath, names) {
-  const resolved = /* @__PURE__ */ new Map();
-  const unique = [...new Set(names)];
-  if (unique.length === 0) return resolved;
-  const output = gitOutputSync(
-    workspacePath,
-    ["cat-file", "--batch-check"],
-    "resolve workspace objects",
-    Buffer.from(`${unique.join("\n")}
-`)
-  );
-  const lines = output.toString().split("\n").filter((line) => line.length > 0);
-  if (lines.length !== unique.length) {
-    throw new Error(`Resolve workspace objects: expected ${unique.length} results, received ${lines.length}`);
-  }
-  unique.forEach((name, index) => {
-    const match = /^([0-9a-f]{40,64}) (\S+) \d+$/.exec(lines[index]);
-    resolved.set(name, match ? { objectId: match[1], type: match[2] } : null);
-  });
-  return resolved;
-}
-function storeWorkspaceBlobs(workspacePath, blobs) {
-  for (const [objectId, content] of blobs) {
-    const written = gitOutputSync(workspacePath, ["hash-object", "-w", "-t", "blob", "--no-filters", "--stdin"], "store hydration ledger blob", content).toString().trim();
-    if (written !== objectId) throw new Error(`Hydration ledger blob ${objectId} was stored as ${written}`);
-  }
-}
-function readWorkspaceBlobs(workspacePath, objectIds) {
-  const blobs = /* @__PURE__ */ new Map();
-  const unique = [...new Set(objectIds)];
-  if (unique.length === 0) return blobs;
-  const output = gitOutputSync(
-    workspacePath,
-    ["cat-file", "--batch"],
-    "read projected workspace blobs",
-    Buffer.from(`${unique.join("\n")}
-`)
-  );
-  let offset = 0;
-  while (offset < output.length) {
-    const newline = output.indexOf(10, offset);
-    if (newline < 0) break;
-    const header = output.subarray(offset, newline).toString();
-    offset = newline + 1;
-    const match = /^([0-9a-f]{40,64}) (\S+) (\d+)$/u.exec(header);
-    if (!match) {
-      if (/ missing$/u.test(header)) continue;
-      throw new Error(`Unexpected cat-file record while reading projected blobs: ${header}`);
-    }
-    const size = Number(match[3]);
-    if (match[2] === "blob") blobs.set(match[1], Buffer.from(output.subarray(offset, offset + size)));
-    offset += size + 1;
-  }
-  return blobs;
-}
-function revertReceiptMounts(target, before, mountIds) {
-  if (!target || mountIds.size === 0) return target;
-  const beforeById = new Map(before?.mounts.map((entry) => [entry.id, entry]) ?? []);
-  const mounts = target.mounts.flatMap((entry) => {
-    if (!mountIds.has(entry.id)) return [entry];
-    const previous = beforeById.get(entry.id);
-    return previous ? [previous] : [];
-  }).sort(compareWorkspaceHydrationMountBasis);
-  return { version: 3, mounts };
-}
-function rewriteHydrationTransactionManifest(workspacePath, manifest) {
-  const transactionPath = hydrationTransactionPath(workspacePath);
-  const temporaryPath = path.join(transactionPath, `.manifest.${process.pid}.${crypto.randomUUID()}.tmp`);
-  try {
-    writePrivateFileDurably(temporaryPath, `${JSON.stringify(manifest)}
-`);
-    fs.renameSync(temporaryPath, path.join(transactionPath, "manifest.json"));
-    fsyncDirectory(transactionPath);
-  } catch (error) {
-    fs.rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-}
-function beginHydrationTransaction(workspacePath, mounts, targetReceipt, mergeBases) {
-  recoverPendingHydrationTransaction(workspacePath);
-  const stateDirectory = workspacePrivateStateDirectory(workspacePath);
-  const transactionPath = hydrationTransactionPath(workspacePath);
-  const stagingPath = path.join(stateDirectory, `.workspace-hydration-transaction.${process.pid}.${crypto.randomUUID()}.tmp`);
-  fs.mkdirSync(stagingPath, { mode: 448 });
-  const durabilityScopes = /* @__PURE__ */ new Map();
-  const mergePlans = /* @__PURE__ */ new Map();
-  const skippedMounts = [];
-  try {
-    const snapshotRoot = path.join(stagingPath, "mounts");
-    fs.mkdirSync(snapshotRoot, { mode: 448 });
-    const receiptBefore = readHydratedWorkspaceReceipt(workspacePath);
-    const head = mergeBases && Object.keys(mergeBases).length > 0 ? revParse(workspacePath, "HEAD") : null;
-    const manifestMounts = [];
-    for (const mount of mounts) {
-      const sourcePath = path.resolve(mount.sourcePath);
-      const durabilityRootPath = path.resolve(mount.durabilityRootPath);
-      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(manifestMounts.length);
-      const snapshotPath = path.join(snapshotRoot, snapshotName);
-      let scope;
-      const basis = mergeBases?.[mount.id];
-      if (sourceStatus && mount.hydrateDeletionMode === "git" && basis && head) {
-        const outerPath = workspaceMountOuterPath(workspacePath, mount);
-        assertManagedDirectoryPath({
-          trustedRoot: workspacePath,
-          candidate: outerPath,
-          label: `Workspace mount ${mount.id} outer source`
-        });
-        const prepared = prepareWorkingTreeMirror({
-          sourceRoot: outerPath,
-          targetRoot: sourcePath,
-          sourceMode: "all",
-          deletionMode: "git",
-          sourceGitlinks: outerSubtreeGitlinks(workspacePath, mount)
-        });
-        const decision = decideWorkspaceHydrationMerge({
-          prepared,
-          changes: workspaceSubtreeChanges(workspacePath, basis.projectedCommit, head, mount.workspaceRelativePath),
-          projectedFiles: basis.projectedFiles,
-          ...basis.readAtMs === void 0 ? {} : { readAtMs: basis.readAtMs },
-          readBaseBlobs: (objectIds) => readWorkspaceBlobs(workspacePath, objectIds),
-          readBinaryPaths: (relativePaths) => readHydrationBinaryPaths({ checkoutRoot: prepared.targetRoot, outerRoot: prepared.sourceRoot, relativePaths })
-        });
-        if (decision.kind !== "apply") {
-          skippedMounts.push({
-            mountId: mount.id,
-            reason: decision.kind === "conflict" ? "hydration_merge_conflict" : "hydration_target_changed",
-            paths: decision.paths
-          });
-          continue;
-        }
-        fs.mkdirSync(snapshotPath, { mode: 448 });
-        const plan = planPreparedWorkingTreeMirror(prepared, { selection: decision.selection, overrides: decision.overrides });
-        scope = captureWorkingTreeMirrorPlan({
-          plan,
-          targetRoot: sourcePath,
-          snapshotRoot: snapshotPath,
-          durability: "deferred_private_staging"
-        });
-        durabilityScopes.set(mount.id, [.../* @__PURE__ */ new Set([...plan.desired.keys(), ...decision.selection.remove])]);
-        mergePlans.set(mount.id, { prepared, decision, plan, snapshotPath: path.join(transactionPath, "mounts", snapshotName), basis });
-      } else if (sourceStatus && mount.hydrateDeletionMode === "git") {
-        fs.mkdirSync(snapshotPath, { mode: 448 });
-        const outerPath = workspaceMountOuterPath(workspacePath, mount);
-        assertManagedDirectoryPath({
-          trustedRoot: workspacePath,
-          candidate: outerPath,
-          label: `Workspace mount ${mount.id} outer source`
-        });
-        const plan = planWorkingTreeMirror({
-          sourceRoot: outerPath,
-          targetRoot: sourcePath,
-          sourceMode: "all",
-          deletionMode: "git",
-          sourceGitlinks: outerSubtreeGitlinks(workspacePath, mount)
-        });
-        scope = 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 {
-        fs.mkdirSync(snapshotPath, { mode: 448 });
-        if (sourceStatus) {
-          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"
-          });
-        }
-      }
-      manifestMounts.push({
-        id: mount.id,
-        incarnationKey: mount.hydrationIncarnationKey,
-        sourcePath,
-        durabilityRootPath,
-        workspaceRelativePath: mount.workspaceRelativePath,
-        existed: Boolean(sourceStatus),
-        snapshotName,
-        ...scope ? { scope } : {},
-        recovery: mergePlans.has(mount.id) ? "guarded" : "snapshot"
-      });
-    }
-    const effectiveTargetReceipt = revertReceiptMounts(targetReceipt, receiptBefore, new Set(skippedMounts.map(({ mountId }) => mountId)));
-    const guarded = mergePlans.size > 0;
-    const manifest = {
-      // Older workers reject guarded transactions rather than replaying them
-      // through an unguarded snapshot restore after a downgrade.
-      version: guarded ? 5 : manifestMounts.some((mount) => mount.scope) ? 4 : 3,
-      ...guarded ? { transactionId: crypto.randomUUID() } : {},
-      targetReceipt: effectiveTargetReceipt,
-      receiptBefore,
-      mounts: guarded ? manifestMounts : manifestMounts.map(({ recovery: _recovery, ...mount }) => mount)
-    };
-    writePrivateFileDurably(path.join(stagingPath, "manifest.json"), `${JSON.stringify(manifest)}
-`);
-    fsyncTree(stagingPath);
-    fs.renameSync(stagingPath, transactionPath);
-    fsyncDirectory(stateDirectory);
-    return { manifest, durabilityScopes, mergePlans, skippedMounts, targetReceipt: effectiveTargetReceipt };
-  } catch (error) {
-    fs.rmSync(stagingPath, { recursive: true, force: true });
-    fsyncDirectory(stateDirectory);
-    throw error;
-  }
-}
-function markHydrationTransactionDurable(workspacePath) {
-  const transactionPath = hydrationTransactionPath(workspacePath);
-  const temporaryPath = path.join(transactionPath, `.committed.${crypto.randomUUID()}.tmp`);
-  writePrivateFileDurably(temporaryPath, "committed\n");
-  fs.renameSync(temporaryPath, path.join(transactionPath, "committed"));
-  fsyncDirectory(transactionPath);
-}
-function gitVisibleDurabilityPaths(mount, sourcePath, sourceStatus) {
-  if (mount.hydrateDeletionMode !== "git" || !sourceStatus.isDirectory() || !lstatIfExists(path.join(sourcePath, ".git"))) return null;
-  return [...inspectWorkingTree(sourcePath, "git").keys()];
-}
-function fsyncHydratedWorkspaceMount(mount, scope) {
-  assertManagedDirectoryPath({
-    trustedRoot: mount.durabilityRootPath,
-    candidate: mount.sourcePath,
-    label: `Workspace mount ${mount.id} source`
-  });
-  const syncEntry = (entryPath, root) => {
-    const status = fs.lstatSync(entryPath);
-    if (status.isSymbolicLink()) return;
-    if (status.isDirectory()) {
-      for (const name of fs.readdirSync(entryPath)) {
-        if (root && name === ".git") continue;
-        syncEntry(path.join(entryPath, name), false);
-      }
-      fsyncDirectory(entryPath);
-      return;
-    }
-    if (!status.isFile()) return;
-    const descriptor = fs.openSync(entryPath, fs.constants.O_RDONLY);
-    try {
-      fs.fsyncSync(descriptor);
-    } finally {
-      fs.closeSync(descriptor);
-    }
-  };
-  const sourcePath = path.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}`);
-      fsyncWorkingTreePaths(sourcePath, paths);
-    } else {
-      syncEntry(sourcePath, true);
-    }
-  }
-  const durabilityRoot = path.resolve(mount.durabilityRootPath);
-  let boundaryParent = path.dirname(path.resolve(mount.sourcePath));
-  while (true) {
-    if (fs.existsSync(boundaryParent)) {
-      const boundaryStatus = fs.lstatSync(boundaryParent);
-      if (!boundaryStatus.isDirectory() || boundaryStatus.isSymbolicLink()) {
-        throw new Error(`Workspace mount durability boundary is not a regular directory: ${boundaryParent}`);
-      }
-      fsyncDirectory(boundaryParent);
-    }
-    if (boundaryParent === durabilityRoot) break;
-    const nextParent = path.dirname(boundaryParent);
-    if (nextParent === boundaryParent) {
-      throw new Error(`Workspace mount ${mount.sourcePath} does not descend from durability root ${durabilityRoot}`);
-    }
-    boundaryParent = nextParent;
-  }
-}
-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";
-}
-function workspaceIsClean(workspacePath) {
-  const status = gitResult(workspacePath, ["status", "--porcelain=v1", "-z"]);
-  return status.exitCode === 0 && status.stdout === "";
-}
-function validateMounts(workspacePath, mounts) {
-  const ids = /* @__PURE__ */ new Set();
-  const paths = [];
-  for (const mount of mounts) {
-    if (!mount.id || ids.has(mount.id)) throw new Error(`Workspace mount id must be unique: ${mount.id}`);
-    if (!mount.hydrationIncarnationKey || mount.hydrationIncarnationKey.includes("\0")) {
-      throw new Error(`Workspace mount hydration incarnation is invalid: ${mount.id}`);
-    }
-    ids.add(mount.id);
-    const sourcePath = path.resolve(mount.sourcePath);
-    const durabilityRoot = path.resolve(mount.durabilityRootPath);
-    const durabilityRelative = path.relative(durabilityRoot, sourcePath);
-    const durabilityRootStatus = fs.lstatSync(durabilityRoot);
-    if (!durabilityRootStatus.isDirectory() || durabilityRootStatus.isSymbolicLink() || !durabilityRelative || durabilityRelative === ".." || durabilityRelative.startsWith(`..${path.sep}`) || path.isAbsolute(durabilityRelative)) {
-      throw new Error(`Workspace mount source escapes its durability root: ${mount.sourcePath}`);
-    }
-    assertManagedDirectoryPath({
-      trustedRoot: durabilityRoot,
-      candidate: sourcePath,
-      label: `Workspace mount ${mount.id} source`
-    });
-    const normalized = mount.workspaceRelativePath.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-    if (!normalized || normalized === "." || normalized.split("/").some((segment) => segment === ".." || segment === ".git")) {
-      throw new Error(`Invalid workspace mount path: ${mount.workspaceRelativePath}`);
-    }
-    const targetPath = path.resolve(workspacePath, ...normalized.split("/"));
-    const relative = path.relative(path.resolve(workspacePath), targetPath);
-    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-      throw new Error(`Workspace mount escapes the workspace clone: ${mount.workspaceRelativePath}`);
-    }
-    paths.push(normalized);
-  }
-  paths.sort();
-  for (let index = 0; index < paths.length; index += 1) {
-    const current = paths[index];
-    const overlap = paths.slice(index + 1).find((candidate) => candidate.startsWith(`${current}/`));
-    if (overlap) throw new Error(`Workspace mounts overlap: ${current} and ${overlap}`);
-  }
-}
-async function configureWorkspaceRepository(input) {
-  if (await tryGitAsync(input.workspacePath, ["remote", "get-url", "origin"])) {
-    await gitAsync(input.workspacePath, ["remote", "set-url", "origin", input.remoteUrl], "configure workspace origin");
-  } else {
-    await gitAsync(input.workspacePath, ["remote", "add", "origin", input.remoteUrl], "configure workspace origin");
-  }
-  await tryGitAsync(input.workspacePath, ["config", "--local", "--unset-all", "remote.origin.pushurl"]);
-  await gitAsync(
-    input.workspacePath,
-    ["config", "--local", "--replace-all", "credential.helper", ""],
-    "reset workspace credential helpers"
-  );
-  await gitAsync(
-    input.workspacePath,
-    ["config", "--local", "credential.useHttpPath", "false"],
-    "configure workspace credential path matching"
-  );
-  if (input.credentialUsername) {
-    await gitAsync(
-      input.workspacePath,
-      ["config", "--local", "--replace-all", gitCredentialUsernameConfigKey(input.remoteUrl), input.credentialUsername],
-      "configure workspace credential username"
-    );
-  }
-  if (input.credentialHelper) {
-    await gitAsync(
-      input.workspacePath,
-      ["config", "--local", "--add", "credential.helper", input.credentialHelper],
-      "configure workspace credential helper"
-    );
-  }
-  const name = input.gitIdentity.name.trim();
-  const email = input.gitIdentity.email.trim();
-  if (!name || !email) throw new Error("Workspace Git identity must include name and email");
-  await gitAsync(input.workspacePath, ["config", "--local", "user.name", name], "configure workspace Git user name");
-  await gitAsync(input.workspacePath, ["config", "--local", "user.email", email], "configure workspace Git user email");
-  await gitAsync(
-    input.workspacePath,
-    ["config", "--local", "core.fsync", "committed,reference"],
-    "configure durable workspace commits and references"
-  );
-  await gitAsync(input.workspacePath, ["config", "--local", "core.fsyncMethod", "fsync"], "configure workspace fsync method");
-  const attributesPath = path.join(input.workspacePath, ".git", "info", "attributes");
-  const attributes = [
-    "# r5d workspace clone: checkout bytes are carried verbatim; no conversion or filter may change what projection reads or hydration writes.",
-    "* -text -eol -filter -ident -working-tree-encoding",
-    ""
-  ].join("\n");
-  let currentAttributes = null;
-  try {
-    currentAttributes = await fs.promises.readFile(attributesPath, "utf8");
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-  if (currentAttributes !== attributes) {
-    await fs.promises.mkdir(path.dirname(attributesPath), { recursive: true });
-    await fs.promises.writeFile(attributesPath, attributes, "utf8");
-  }
-}
-async function configureExistingWorkspaceGitForRemediation(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  const workspaceStatus = lstatIfExists(workspacePath);
-  const gitStatus = lstatIfExists(path.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");
-  }
-  await configureWorkspaceRepository({ ...input, workspacePath });
-}
-async function fetchWorkspaceHead(workspacePath, remoteUrl, credentialHelper, credentialUsername) {
-  const result = await gitResultAsync(workspacePath, [
-    ...gitTransportSecurityArgs(remoteUrl, credentialHelper, credentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    "--update-shallow",
-    "origin",
-    `+refs/heads/${WORKSPACE_GIT_BRANCH}:refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`
-  ]);
-  if (result.exitCode !== 0) {
-    const detail = `${result.stderr}
-${result.stdout}`;
-    if (!/(couldn't find remote ref|does not have any commits|remote repository is empty|no such ref)/i.test(detail)) {
-      throw new Error(`Fetch workspace main: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
-    }
-    return null;
-  }
-  return revParse(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`);
-}
-async function resolveWorkspaceRemoteHead(workspacePath, input) {
-  const advertised = input.advertisedRemoteHead;
-  if (advertised && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(advertised)) {
-    const tracked = await revParseAsync(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`);
-    if (tracked === advertised && await tryGitAsync(workspacePath, ["cat-file", "-e", `${tracked}^{commit}`])) {
-      return { head: tracked, fetched: false };
-    }
-  }
-  return {
-    head: await fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername),
-    fetched: true
-  };
-}
-async function ensureWorkspaceGitClone(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  const workspaceParent = path.dirname(workspacePath);
-  const parentStatus = fs.lstatSync(workspaceParent);
-  if (!parentStatus.isDirectory() || parentStatus.isSymbolicLink()) {
-    throw new Error(`Workspace clone parent is not a regular directory: ${workspaceParent}`);
-  }
-  const workspaceStatus = lstatIfExists(workspacePath);
-  if (workspaceStatus) {
-    if (!workspaceStatus.isDirectory() || workspaceStatus.isSymbolicLink()) {
-      throw new Error(`Workspace clone root is not a regular directory: ${workspacePath}`);
-    }
-  }
-  const gitPath = path.join(workspacePath, ".git");
-  const gitStatus = lstatIfExists(gitPath);
-  if (gitStatus) {
-    if (!gitStatus.isDirectory() || gitStatus.isSymbolicLink()) {
-      throw new Error(`Workspace clone Git metadata is not a regular directory: ${gitPath}`);
-    }
-  }
-  if (!fs.existsSync(gitPath)) {
-    fs.rmSync(workspacePath, { recursive: true, force: true });
-    fs.mkdirSync(path.dirname(workspacePath), { recursive: true });
-    const cloneCommand = workspaceCloneCommandArgs(
-      ["clone", "--no-recurse-submodules", "--branch", WORKSPACE_GIT_BRANCH, input.remoteUrl, workspacePath],
-      input.remoteUrl,
-      input.credentialHelper,
-      input.credentialUsername
-    );
-    const clone = Bun.spawn(cloneCommand, {
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "pipe",
-      env: workerGitProcessEnvironment()
-    });
-    const [, , cloneExitCode] = await Promise.all([new Response(clone.stdout).text(), new Response(clone.stderr).text(), clone.exited]);
-    if (cloneExitCode !== 0) {
-      fs.rmSync(workspacePath, { recursive: true, force: true });
-      fs.mkdirSync(workspacePath, { recursive: true });
-      git(workspacePath, ["init", `--initial-branch=${WORKSPACE_GIT_BRANCH}`], "initialize workspace clone");
-    }
-  }
-  await configureWorkspaceRepository({ ...input, workspacePath });
-  await workspaceFilesystemExecutor().run("checkout_durability_recovery", {
-    workspacePath,
-    preserveResolutionInProgress: input.preserveResolutionInProgress === true
-  });
-  const previousRemoteHead = await revParseAsync(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`);
-  const localHeadBeforeFetch = await revParseAsync(workspacePath, "HEAD");
-  if (!await revParseAsync(workspacePath, WORKSPACE_GIT_INTEGRATED_REF) && previousRemoteHead && localHeadBeforeFetch && await tryGitAsync(workspacePath, ["merge-base", "--is-ancestor", previousRemoteHead, localHeadBeforeFetch])) {
-    await updateIntegratedWorkspaceHead(workspacePath, previousRemoteHead);
-  }
-  const resolvedRemoteHead = await resolveWorkspaceRemoteHead(workspacePath, input);
-  const remoteHead = resolvedRemoteHead.head;
-  let localHead = await revParseAsync(workspacePath, "HEAD");
-  if (!localHead && remoteHead) {
-    await runWorkspaceCheckoutTransition(workspacePath, async () => {
-      await gitAsync(
-        workspacePath,
-        ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`],
-        "check out workspace main"
-      );
-    });
-    localHead = remoteHead;
-  }
-  if (localHead && remoteHead && localHead === remoteHead) {
-    await updateIntegratedWorkspaceHead(workspacePath, remoteHead);
-  } else if (localHead && remoteHead && workspaceIsShallow(workspacePath) && !tryGit(workspacePath, ["merge-base", localHead, remoteHead]) && revParse(workspacePath, WORKSPACE_GIT_INTEGRATED_REF) === localHead && workspaceIsClean(workspacePath)) {
-    await runWorkspaceCheckoutTransition(workspacePath, async () => {
-      await gitAsync(workspacePath, ["reset", "--hard", remoteHead], "advance workspace across retained history boundary");
-    });
-    await updateIntegratedWorkspaceHead(workspacePath, remoteHead);
-    localHead = remoteHead;
-  }
-  return { localHead, remoteHead, remoteHeadFetched: resolvedRemoteHead.fetched };
-}
-function activeMounts(mounts) {
-  const active = [];
-  const tombstones = [];
-  const skipped = [];
-  for (const mount of mounts) {
-    if (mountBusy(mount)) skipped.push(mount);
-    else if (fs.existsSync(mount.sourcePath)) active.push(mount);
-    else if (mount.deleteWhenSourceMissing) tombstones.push(mount);
-    else skipped.push(mount);
-  }
-  return { active, tombstones, skipped };
-}
-function mirrorMountsToWorkspace(workspacePath, mounts, projectedFiles) {
-  const projected = [];
-  for (const mount of mounts) {
-    assertManagedDirectoryPath({
-      trustedRoot: mount.durabilityRootPath,
-      candidate: mount.sourcePath,
-      label: `Workspace mount ${mount.id} source`
-    });
-    assertManagedDirectoryPath({
-      trustedRoot: workspacePath,
-      candidate: path.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/")),
-      label: `Workspace mount ${mount.id} outer target`
-    });
-    const mirrored = mirrorWorkingTree({
-      sourceRoot: mount.sourcePath,
-      targetRoot: path.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/")),
-      sourceMode: mount.sourceMode,
-      deletionMode: "all",
-      ...projectedFiles ? { projected: projectedFiles } : {}
-    });
-    projected.push({ mount, gitlinks: mirrored.gitlinks });
-  }
-  return projected;
-}
-async function stageWorkspaceGitlinks(workspacePath, projected) {
-  if (projected.length === 0) return;
-  const mountPaths = projected.map(({ mount }) => normalizedWorkspaceMountPath(mount.workspaceRelativePath));
-  const desired = /* @__PURE__ */ new Map();
-  projected.forEach(({ gitlinks }, index) => {
-    for (const gitlink of gitlinks) desired.set(`${mountPaths[index]}/${gitlink.relativePath}`, gitlink.objectId);
-  });
-  const desiredRoots = new Set(desired.keys());
-  const listed = await gitOutputAsync(
-    workspacePath,
-    ["ls-files", "-z", "--stage", "--", ...mountPaths.map((mountPath) => `:(literal)${mountPath}`)],
-    "inspect staged workspace mount entries"
-  );
-  const feed = [];
-  const current = /* @__PURE__ */ new Map();
-  const drop = (objectId, relativePath) => {
-    feed.push(Buffer.concat([Buffer.from(`0 ${"0".repeat(objectId.length)}	`), Buffer.from(relativePath), Buffer.from([0])]));
-  };
-  for (const record of listed.toString().split("\0")) {
-    const match = /^([0-7]{6}) ([0-9a-f]{40,64}) [0-3]\t(.+)$/su.exec(record);
-    if (!match) continue;
-    const mode = match[1];
-    const objectId = match[2];
-    const relativePath = match[3];
-    if (mode === "160000") {
-      current.set(relativePath, objectId);
-      if (!desired.has(relativePath)) drop(objectId, relativePath);
-      continue;
-    }
-    if (desired.has(relativePath) || hasAncestorIn(relativePath, desiredRoots)) drop(objectId, relativePath);
-  }
-  for (const [relativePath, objectId] of desired) {
-    if (current.get(relativePath) === objectId) continue;
-    feed.push(Buffer.concat([Buffer.from(`160000 ${objectId}	`), Buffer.from(relativePath), Buffer.from([0])]));
-  }
-  if (feed.length === 0) return;
-  await gitOutputAsync(workspacePath, ["update-index", "-z", "--index-info"], "stage workspace gitlinks", Buffer.concat(feed));
-}
-function hasAncestorIn(relativePath, ancestors) {
-  let parent = path.posix.dirname(relativePath);
-  while (parent !== ".") {
-    if (ancestors.has(parent)) return true;
-    parent = path.posix.dirname(parent);
-  }
-  return false;
-}
-function removeWorkspaceMounts(workspacePath, mounts) {
-  for (const mount of mounts) {
-    const targetPath = path.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
-    assertManagedDirectoryPath({
-      trustedRoot: workspacePath,
-      candidate: targetPath,
-      label: `Workspace mount ${mount.id} outer target`
-    });
-    const relative = path.relative(path.resolve(workspacePath), path.resolve(targetPath));
-    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-      throw new Error(`Workspace mount escapes the workspace clone: ${mount.workspaceRelativePath}`);
-    }
-    fs.rmSync(targetPath, { recursive: true, force: true });
-  }
-}
-function restoreDeferredWorkspaceMountsFromHead(workspacePath, mounts) {
-  const head = revParse(workspacePath, "HEAD");
-  for (const mount of mounts) {
-    const normalized = normalizedWorkspaceMountPath(mount.workspaceRelativePath);
-    const targetPath = path.join(workspacePath, ...normalized.split("/"));
-    assertManagedDirectoryPath({
-      trustedRoot: workspacePath,
-      candidate: targetPath,
-      label: `Deferred workspace mount ${mount.id} outer target`
-    });
-    fs.rmSync(targetPath, { recursive: true, force: true });
-    if (head && tryGit(workspacePath, ["cat-file", "-e", `${head}:${normalized}`])) {
-      git(
-        workspacePath,
-        ["checkout", "--no-recurse-submodules", head, "--", `:(literal)${normalized}`],
-        `restore deferred workspace mount ${mount.id} from its integration basis`
-      );
-    }
-  }
-}
-function workspaceMountOuterPath(workspacePath, mount) {
-  return path.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
-}
-function outerSubtreeGitlinks(workspacePath, mount) {
-  const gitlinks = /* @__PURE__ */ new Map();
-  const head = revParse(workspacePath, "HEAD");
-  if (!head) return gitlinks;
-  const subtree = `${head}:${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`;
-  const listed = Bun.spawnSync(gitCommandArgs(["ls-tree", "-r", "-z", subtree]), {
-    cwd: workspacePath,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  if (listed.exitCode !== 0) return gitlinks;
-  for (const record of Buffer.from(listed.stdout).toString().split("\0")) {
-    const match = /^160000 commit ([0-9a-f]{40,64})\t(.+)$/su.exec(record);
-    if (match) gitlinks.set(match[2], match[1]);
-  }
-  return gitlinks;
-}
-function hydrateWorkspaceGitMountsRaw(workspacePath, mounts, options = {}) {
-  const hydratedMountIds = [];
-  const skippedMountIds = [];
-  const mergeSkips = [];
-  const rollbackScopes = /* @__PURE__ */ new Map();
-  const ledgerEntries = {};
-  for (const mount of mounts) {
-    if (!options.ignoreBusy && mountBusy(mount)) {
-      skippedMountIds.push(mount.id);
-      continue;
-    }
-    const mergePlan = options.mergePlans?.get(mount.id);
-    if (mergePlan) {
-      const journal = { entries: [] };
-      const runtimeJournal = { journal, snapshotPath: mergePlan.snapshotPath };
-      options.journals?.set(mount.id, runtimeJournal);
-      try {
-        applyWorkingTreeMirror(mergePlan.prepared, {
-          selection: mergePlan.decision.selection,
-          guards: {
-            expectations: mergePlan.decision.expectations,
-            overrides: mergePlan.decision.overrides,
-            preBlobs: mergePlan.decision.preBlobs,
-            journal
-          }
-        });
-      } catch (error) {
-        if (!(error instanceof WorkingTreeTargetChangedError)) throw error;
-        const rolledBack = rollbackWorkingTreeMirrorJournal({
-          journal,
-          targetRoot: mount.sourcePath,
-          snapshotRoot: mergePlan.snapshotPath
-        });
-        runtimeJournal.rolledBack = rolledBack;
-        const retainedPaths = [
-          ...new Set([...error.retained, ...rolledBack.retained ?? []].map(({ path: retainedPath }) => retainedPath))
-        ].sort();
-        if (retainedPaths.length > 0) {
-          process.stderr.write(
-            `[r5d-worker] hydration preserved displaced writer entries for mount ${mount.id}: ${retainedPaths.join(", ")}
-`
-          );
-        }
-        options.onMergeRollback?.(mount, rolledBack);
-        mergeSkips.push({
-          mountId: mount.id,
-          reason: "hydration_target_changed",
-          paths: [.../* @__PURE__ */ new Set([error.relativePath, ...rolledBack.abandoned])].sort(),
-          ...retainedPaths.length > 0 ? { retainedPaths } : {}
-        });
-        rollbackScopes.set(mount.id, rolledBack.paths);
-        continue;
-      }
-      hydratedMountIds.push(mount.id);
-      storeWorkspaceBlobs(workspacePath, mergePlan.decision.blobsToStore);
-      const left = /* @__PURE__ */ new Map();
-      for (const entry of journal.entries) left.set(entry.relativePath, entry.after);
-      const entries = {};
-      for (const [relativePath, preBlob] of mergePlan.decision.preBlobs) {
-        const postBlob = mergePlan.decision.postBlobs.get(relativePath) ?? null;
-        let after = left.get(relativePath);
-        if (after === void 0) {
-          const current = inspectWorkingTreePath(mount.sourcePath, relativePath);
-          after = current.kind === "entry" ? current.stat : null;
-        }
-        entries[relativePath] = { preBlob, postBlob, stat: after && after.isFile() ? projectedFileEntry(after) : null };
-      }
-      ledgerEntries[mount.id] = entries;
-      continue;
-    }
-    const sourceRoot = workspaceMountOuterPath(workspacePath, mount);
-    assertManagedDirectoryPath({
-      trustedRoot: workspacePath,
-      candidate: sourceRoot,
-      label: `Workspace mount ${mount.id} outer source`
-    });
-    assertManagedDirectoryPath({
-      trustedRoot: mount.durabilityRootPath,
-      candidate: mount.sourcePath,
-      label: `Workspace mount ${mount.id} hydration target`
-    });
-    if (!fs.existsSync(sourceRoot)) {
-      if (mount.hydrateDeletionMode === "all") {
-        fs.rmSync(mount.sourcePath, { recursive: true, force: true });
-      } else if (fs.existsSync(mount.sourcePath)) {
-        const emptyRoot = fs.mkdtempSync(path.join(path.dirname(workspacePath), ".r5d-empty-mount-"));
-        try {
-          mirrorWorkingTree({
-            sourceRoot: emptyRoot,
-            targetRoot: mount.sourcePath,
-            sourceMode: "all",
-            deletionMode: "git"
-          });
-        } finally {
-          fs.rmSync(emptyRoot, { recursive: true, force: true });
-        }
-      }
-      hydratedMountIds.push(mount.id);
-      continue;
-    }
-    const targetExists = fs.existsSync(mount.sourcePath);
-    mirrorWorkingTree({
-      sourceRoot,
-      targetRoot: mount.sourcePath,
-      sourceMode: "all",
-      // The outer worktree shows a submodule as an empty directory; the tree
-      // carries its pointer, which a Git checkout applies to its index (D4).
-      sourceGitlinks: outerSubtreeGitlinks(workspacePath, mount),
-      // A missing checkout has no Git index to define git-only deletions. Its
-      // newly created directory is empty, so all-mode is equivalent and lets
-      // bootstrap hydration preserve the fetched tree before Git initializes.
-      deletionMode: targetExists ? mount.hydrateDeletionMode : "all"
-    });
-    hydratedMountIds.push(mount.id);
-  }
-  return { hydratedMountIds: hydratedMountIds.sort(), skippedMountIds: skippedMountIds.sort(), mergeSkips, rollbackScopes, ledgerEntries };
-}
-async function selectMountsWithUnchangedOuterSubtree(workspacePath, receipt, head, mounts) {
-  const candidates = mounts.flatMap((mount) => {
-    const basisHead = workspaceHydrationReceiptMountBasisHead(receipt, mount);
-    return basisHead && basisHead !== head ? [{ mount, basisHead }] : [];
-  });
-  if (candidates.length === 0) return /* @__PURE__ */ new Set();
-  const objects = await resolveGitObjectsAsync(
-    workspacePath,
-    candidates.flatMap(({ mount, basisHead }) => [
-      workspaceTreeObjectName(basisHead, mount.workspaceRelativePath),
-      workspaceTreeObjectName(head, mount.workspaceRelativePath)
-    ])
-  );
-  const unchanged = /* @__PURE__ */ new Set();
-  for (const { mount, basisHead } of candidates) {
-    const before = objects.get(workspaceTreeObjectName(basisHead, mount.workspaceRelativePath))?.objectId ?? null;
-    const after = objects.get(workspaceTreeObjectName(head, mount.workspaceRelativePath))?.objectId ?? null;
-    if (before === after) unchanged.add(mount.id);
-  }
-  return unchanged;
-}
-async function hydrateWorkspaceGitMountsTransactionally(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  const durabilityMounts = input.durabilityMounts ?? input.mounts;
-  const receiptMounts = input.receiptMounts ?? durabilityMounts;
-  const requiredMounts = input.requiredMounts ?? input.mounts;
-  const carryMounts = input.carryMounts ?? [];
-  if (carryMounts.length > 0 && !input.recordCurrentHead) {
-    throw new Error("Workspace hydration can only carry unchanged mounts while recording the current head");
-  }
-  const candidateMounts = [
-    ...new Map([...input.mounts, ...durabilityMounts, ...requiredMounts, ...carryMounts].map((mount) => [mount.id, mount])).values()
-  ];
-  if (input.recordCurrentHead && !await workspaceCheckoutDurabilityIsCurrentAsync(workspacePath)) {
-    throw new Error("Workspace checkout is not durably materialized at its current HEAD");
-  }
-  const targetHead = input.recordCurrentHead ? await revParseAsync(workspacePath, "HEAD") : null;
-  const receiptBeforeTransaction = targetHead ? await readHydratedWorkspaceReceiptAsync(workspacePath) : null;
-  const computeSelection = () => {
-    const busyMountIds = new Set(input.ignoreBusy ? [] : candidateMounts.filter((mount) => mountBusy(mount)).map(({ id }) => id));
-    const requestedIds = new Set(input.mounts.map(({ id }) => id));
-    const requiredIds = new Set(requiredMounts.map(({ id }) => id));
-    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,
-      advancedDurabilityMounts,
-      skippedMountIds: [.../* @__PURE__ */ new Set([...busyMountIds, ...unavailableRequiredIds])].sort(),
-      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) && await hydratedWorkspaceReceiptFileIsV3(workspacePath) && await workspaceBasisRefsAreCurrentAsync(workspacePath, noopCandidate.targetReceipt)) {
-    return { hydratedMountIds: [], skippedMountIds: noopCandidate.skippedMountIds, mergeSkips: [], hydratedEntryPaths: {} };
-  }
-  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 selection = computeSelection();
-    const { hydrationMounts, advancedDurabilityMounts, targetReceipt } = selection;
-    const heldMountIds = [...new Set([...hydrationMounts, ...advancedDurabilityMounts].map(({ id }) => id))];
-    const releaseHold = hooks?.holdMounts(heldMountIds, `hydration transaction ${context.transactionId}`);
-    try {
-      const mergeBases = {};
-      for (const mount of hydrationMounts) {
-        const basis = input.mergeBases?.get(mount.id);
-        if (basis) mergeBases[mount.id] = basis;
-      }
-      const liveBefore = new Set(hydrationMounts.filter((mount) => mergeBases[mount.id] && mount.processLive?.()).map(({ id }) => id));
-      const hydration = await workspaceFilesystemExecutor().run("hydration_transaction", {
-        workspacePath,
-        hydrationMounts: hydrationMounts.map(workspaceGitMountData),
-        advancedDurabilityMounts: advancedDurabilityMounts.map(workspaceGitMountData),
-        targetReceipt,
-        ...Object.keys(mergeBases).length > 0 ? { mergeBases } : {}
-      });
-      const ledger = hydrationPreBlobLedger(workspacePath);
-      const hydratedEntryPaths = {};
-      for (const mount of hydrationMounts) {
-        if (!hydration.hydratedMountIds.includes(mount.id)) continue;
-        const entries = mergeBases[mount.id] ? hydration.hydratedEntries[mount.id] : void 0;
-        if (!entries) {
-          ledger.clearMount(mount);
-          continue;
-        }
-        const processLiveAcrossHydration = liveBefore.has(mount.id) || mount.processLive?.() === true;
-        hydratedEntryPaths[mount.id] = Object.keys(entries).sort();
-        ledger.record(
-          mount,
-          Object.fromEntries(Object.entries(entries).map(([relativePath, entry]) => [relativePath, { ...entry, processLiveAcrossHydration }])),
-          { replacePreBlobFor: input.ledgerMergedPaths?.get(mount.id) ?? [] }
-        );
-      }
-      return {
-        hydratedMountIds: hydration.hydratedMountIds,
-        skippedMountIds: [.../* @__PURE__ */ new Set([...selection.skippedMountIds, ...hydration.skippedMounts.map(({ mountId }) => mountId)])].sort(),
-        mergeSkips: hydration.skippedMounts,
-        hydratedEntryPaths
-      };
-    } finally {
-      releaseHold?.();
-    }
-  } finally {
-    hooks?.afterTransaction(context);
-  }
-}
-function runHydrationTransactionJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  const { hydrationMounts, advancedDurabilityMounts } = input;
-  const begun = beginHydrationTransaction(workspacePath, hydrationMounts, input.targetReceipt, input.mergeBases);
-  const { durabilityScopes, mergePlans, skippedMounts } = begun;
-  let manifest = begun.manifest;
-  let targetReceipt = begun.targetReceipt;
-  const skippedIds = new Set(skippedMounts.map(({ mountId }) => mountId));
-  const journals = /* @__PURE__ */ new Map();
-  const excludeRolledBackMount = (mount, rollback) => {
-    const settledMount = manifest.mounts.find(({ id }) => id === mount.id);
-    if (!settledMount) return;
-    fsyncHydratedWorkspaceMount(mount, rollback.paths);
-    fsyncHydrationRetainedEvidence(mount);
-    if (rollback.retained?.length) {
-      process.stderr.write(
-        `[r5d-worker] hydration rollback retained writer entries for mount ${mount.id}: ${rollback.retained.map(({ path: retainedPath }) => retainedPath).join(", ")}
-`
-      );
-    }
-    const nextReceipt = revertReceiptMounts(targetReceipt, manifest.receiptBefore, /* @__PURE__ */ new Set([mount.id]));
-    const nextManifest = {
-      ...manifest,
-      targetReceipt: nextReceipt,
-      mounts: manifest.mounts.filter(({ id }) => id !== mount.id),
-      preservedMounts: [...manifest.preservedMounts ?? [], settledMount]
-    };
-    rewriteHydrationTransactionManifest(workspacePath, nextManifest);
-    manifest = nextManifest;
-    targetReceipt = nextReceipt;
-  };
-  try {
-    const activeMounts2 = hydrationMounts.filter(({ id }) => !skippedIds.has(id));
-    const hydration = hydrateWorkspaceGitMountsRaw(workspacePath, activeMounts2, {
-      ignoreBusy: true,
-      mergePlans,
-      journals,
-      onMergeRollback: excludeRolledBackMount
-    });
-    if (hydration.mergeSkips.length > 0) {
-      for (const skip of hydration.mergeSkips) {
-        skippedMounts.push(skip);
-        skippedIds.add(skip.mountId);
-      }
-    }
-    const expectedHydratedIds = activeMounts2.map(({ id }) => id).filter((id) => !skippedIds.has(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.filter(({ id }) => !skippedIds.has(id)),
-      durabilityScopes
-    );
-    markHydrationTransactionDurable(workspacePath);
-    if (targetReceipt) updateHydratedWorkspaceReceipt(workspacePath, targetReceipt);
-    removeHydrationTransaction(workspacePath);
-    return { hydratedMountIds: hydration.hydratedMountIds, skippedMounts, hydratedEntries: hydration.ledgerEntries };
-  } catch (error) {
-    const transactionPath = hydrationTransactionPath(workspacePath);
-    if (lstatIfExists(transactionPath) && hydrationTransactionCommitted(transactionPath)) {
-      throw error;
-    }
-    try {
-      for (const [mountId, mergePlan] of mergePlans) {
-        const mount = hydrationMounts.find(({ id }) => id === mountId);
-        if (!mount || !manifest.mounts.some(({ id }) => id === mountId)) continue;
-        const runtimeJournal = journals.get(mountId);
-        const rolledBack = runtimeJournal ? runtimeJournal.rolledBack ?? rollbackWorkingTreeMirrorJournal({
-          journal: runtimeJournal.journal,
-          targetRoot: mount.sourcePath,
-          snapshotRoot: mergePlan.snapshotPath
-        }) : { paths: [], abandoned: [] };
-        if (runtimeJournal) runtimeJournal.rolledBack = rolledBack;
-        excludeRolledBackMount(mount, rolledBack);
-      }
-      restoreHydrationTransaction(workspacePath, manifest);
-      removeHydrationTransaction(workspacePath);
-    } catch (restoreError) {
-      const pendingManifest = parseHydrationTransactionManifest(transactionPath);
-      if (pendingManifest.mounts.some(({ recovery }) => recovery === "guarded")) {
-        throw hydrationRecoveryRequiredError(
-          workspacePath,
-          pendingManifest,
-          new AggregateError([error, restoreError], "Guarded hydration rollback did not settle")
-        );
-      }
-      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;
-  }
-}
-function runHydrationRawJob(input) {
-  return {
-    hydratedMountIds: hydrateWorkspaceGitMountsRaw(path.resolve(input.workspacePath), input.mounts, { ignoreBusy: true }).hydratedMountIds
-  };
-}
-function runHydrationRecoveryJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  recoverWorkspaceCheckoutDurability(workspacePath, input.preserveResolutionInProgress);
-  recoverPendingHydrationTransaction(workspacePath);
-  repairWorkspaceBasisRefs(workspacePath, readHydratedWorkspaceReceipt(workspacePath));
-  return null;
-}
-async function hydrateWorkspaceGitMounts(workspacePath, mounts, options = {}) {
-  const resolvedWorkspacePath = path.resolve(workspacePath);
-  const gitDirectory = path.join(resolvedWorkspacePath, ".git");
-  if (!fs.existsSync(gitDirectory)) {
-    const skippedMountIds = options.ignoreBusy ? [] : mounts.filter((mount) => mountBusy(mount)).map(({ id }) => id).sort();
-    const skipped = new Set(skippedMountIds);
-    const selected = mounts.filter(({ id }) => !skipped.has(id));
-    const releaseHold = options.hydrationHooks?.holdMounts(
-      selected.map(({ id }) => id),
-      "pre-clone hydration"
-    );
-    try {
-      const hydration = await workspaceFilesystemExecutor().run("hydration_raw", {
-        workspacePath: resolvedWorkspacePath,
-        mounts: selected.map(workspaceGitMountData)
-      });
-      return { hydratedMountIds: hydration.hydratedMountIds, skippedMountIds };
-    } finally {
-      releaseHold?.();
-    }
-  }
-  await workspaceFilesystemExecutor().run("checkout_durability_recovery", {
-    workspacePath: resolvedWorkspacePath,
-    preserveResolutionInProgress: false
-  });
-  return hydrateWorkspaceGitMountsTransactionally({
-    workspacePath,
-    mounts,
-    ignoreBusy: options.ignoreBusy,
-    hydrationHooks: options.hydrationHooks
-  });
-}
-async function recoverWorkspaceGitHydration(workspacePath, mounts, options = {}) {
-  workspacePath = path.resolve(workspacePath);
-  validateMounts(workspacePath, mounts);
-  await workspaceFilesystemExecutor().run("hydration_recovery", {
-    workspacePath,
-    preserveResolutionInProgress: options.preserveResolutionInProgress === true
-  });
-  const currentHead = await revParseAsync(workspacePath, "HEAD");
-  const currentReceipt = await readHydratedWorkspaceReceiptAsync(workspacePath);
-  const preservedBases = await readPreservedHydrationBasesAsync(workspacePath);
-  if (!currentHead) return;
-  const outerHeadContainsMount = (mount) => tryGitAsync(workspacePath, ["cat-file", "-e", `HEAD:${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`]);
-  const configuredBasisMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, mounts, options.deferMountIds);
-  const uncoveredBasisMounts = configuredBasisMounts.filter(
-    (mount) => !workspaceHydrationReceiptCoversMount(currentReceipt, currentHead, mount)
-  );
-  if (workspaceHydrationReceiptMatchesMounts(currentReceipt, currentHead, configuredBasisMounts)) return;
-  const busyMountIds = new Set(options.ignoreBusy ? [] : uncoveredBasisMounts.filter((mount) => mountBusy(mount)).map(({ id }) => id));
-  const recoveryMounts = uncoveredBasisMounts.filter(
-    (mount) => workspaceHydrationReceiptMountBasisHead(currentReceipt, mount) === null || !options.preserveStaleBases && !busyMountIds.has(mount.id) && workspaceHydrationReceiptMountBasisHead(preservedBases, mount) !== workspaceHydrationReceiptMountBasisHead(currentReceipt, mount)
-  );
-  const idleBasislessMounts = recoveryMounts.filter((mount) => !busyMountIds.has(mount.id));
-  const hydrationTargets = [];
-  for (const mount of idleBasislessMounts) {
-    if (mount.deleteWhenSourceMissing) continue;
-    if (mount.preserveLocalOnHydrationBasisChange === true && currentReceipt?.mounts.find(({ id }) => id === mount.id)?.head === currentHead) {
-      continue;
-    }
-    if (await outerHeadContainsMount(mount) || mount.preserveLocalOnInitialOuterAbsence !== true) hydrationTargets.push(mount);
-  }
-  const hydration = await hydrateWorkspaceGitMountsTransactionally({
-    workspacePath,
-    mounts: hydrationTargets,
-    durabilityMounts: idleBasislessMounts,
-    receiptMounts: configuredBasisMounts,
-    requiredMounts: hydrationTargets,
-    ignoreBusy: options.ignoreBusy,
-    recordCurrentHead: true,
-    hydrationHooks: options.hydrationHooks
-  });
-  void hydration;
-}
-async function resetWorkspaceGit(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  validateMounts(workspacePath, input.mounts);
-  const busyResetMountIds = input.mounts.filter((mount) => mountBusy(mount)).map(({ id }) => id);
-  if (busyResetMountIds.length > 0) {
-    throw new Error(`Workspace reset cannot run while mounts are busy: ${busyResetMountIds.sort().join(", ")}`);
-  }
-  hydrationPreBlobLedger(workspacePath).clear();
-  const initial = await ensureWorkspaceGitClone({ ...input, workspacePath });
-  await workspaceFilesystemExecutor().run("hydration_recovery", { workspacePath, preserveResolutionInProgress: false });
-  const status = gitResult(workspacePath, ["status", "--porcelain=v1", "-z"]);
-  const discardedPaths = status.exitCode === 0 ? status.stdout.split("\0").filter(Boolean).map((entry) => entry.slice(3)).sort() : [];
-  const remoteHead = await fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
-  if (remoteHead) {
-    await runWorkspaceCheckoutTransition(workspacePath, async () => {
-      await gitAsync(
-        workspacePath,
-        ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, remoteHead],
-        "reset workspace main"
-      );
-      await gitAsync(workspacePath, ["clean", "-fd", "--", "."], "remove untracked workspace changes");
-    });
-  } else if (revParse(workspacePath, "HEAD")) {
-    await runWorkspaceCheckoutTransition(workspacePath, async () => {
-      await gitAsync(workspacePath, ["rm", "-rf", "--ignore-unmatch", "--", "."], "clear unborn workspace tree");
-      await gitAsync(
-        workspacePath,
-        ["commit", "--allow-empty", "-m", JSON.stringify({ type: "workspace_reset" })],
-        "record empty workspace reset"
-      );
-    });
-  }
-  const selected = activeMounts(input.mounts);
-  const requiredLiveMountsBeforeHydration = input.mounts.filter(({ sourcePath }) => fs.existsSync(sourcePath));
-  const bootstrapMounts = selected.skipped.filter((mount) => {
-    if (mount.deleteWhenSourceMissing || fs.existsSync(mount.sourcePath) || mountBusy(mount)) return false;
-    const outerPath = path.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
-    return fs.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()
-  ];
-  const hydration = await hydrateWorkspaceGitMountsTransactionally({
-    workspacePath,
-    mounts: hydrationMounts,
-    durabilityMounts: [...requiredLiveMounts, ...selected.tombstones, ...durablyAbsentMounts],
-    receiptMounts: input.mounts,
-    requiredMounts: requiredLiveMounts,
-    recordCurrentHead: true,
-    hydrationHooks: input.hydrationHooks
-  });
-  const requiredLiveIds = requiredLiveMounts.map(({ id }) => id).sort();
-  const resetHead = revParse(workspacePath, "HEAD");
-  if (hydration.skippedMountIds.length > 0 || hydration.hydratedMountIds.length !== requiredLiveIds.length || hydration.hydratedMountIds.some((id, index) => id !== requiredLiveIds[index]) || resetHead && !workspaceHydrationReceiptMatchesMounts(readHydratedWorkspaceReceipt(workspacePath), resetHead, input.mounts)) {
-    throw new Error("Workspace reset could not durably hydrate every live mount; remediation remains active");
-  }
-  return {
-    startingHead: initial.localHead,
-    localHead: revParse(workspacePath, "HEAD"),
-    remoteHead,
-    discardedPaths,
-    activeMountIds: hydration.hydratedMountIds,
-    skippedMountIds: [.../* @__PURE__ */ new Set([...uncoveredSkippedMounts.map(({ id }) => id), ...hydration.skippedMountIds])].sort()
-  };
-}
-async function stagedPaths(workspacePath) {
-  return (await gitAsync(workspacePath, ["diff", "--cached", "--name-only", "--no-renames", "-z"], "inspect staged workspace paths")).split("\0").filter(Boolean).sort();
-}
-function emptyTreeHash(workspacePath) {
-  const result = Bun.spawnSync(["git", ...NON_RECURSIVE_GIT_CONFIG, "hash-object", "-t", "tree", "--stdin"], {
-    cwd: workspacePath,
-    stdin: Buffer.alloc(0),
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  if (result.exitCode !== 0)
-    throw new Error(`Create empty workspace tree: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
-  return result.stdout.toString().trim();
-}
-async function changedPaths(workspacePath, baseRevision, headRevision) {
-  const base = baseRevision ?? emptyTreeHash(workspacePath);
-  return (await gitAsync(workspacePath, ["diff", "--name-only", "--no-renames", "-z", base, headRevision], "inspect workspace commit paths")).split("\0").filter(Boolean).sort();
-}
-async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit, pathspecs = []) {
-  const base = baseRevision ?? emptyTreeHash(workspacePath);
-  const subprocess = Bun.spawn(
-    [
-      "git",
-      ...NON_RECURSIVE_GIT_CONFIG,
-      "diff",
-      "--binary",
-      "--no-ext-diff",
-      base,
-      headRevision,
-      ...pathspecs.length > 0 ? ["--", ...pathspecs] : []
-    ],
-    {
-      cwd: workspacePath,
-      stdout: "pipe",
-      stderr: "pipe",
-      env: workerGitProcessEnvironment()
-    }
-  );
-  const stderrPromise = new Response(subprocess.stderr).text();
-  const reader = subprocess.stdout.getReader();
-  let total = 0;
-  while (true) {
-    const chunk = await reader.read();
-    if (chunk.done) break;
-    total += chunk.value.byteLength;
-    if (total > limit) {
-      subprocess.kill();
-      await subprocess.exited;
-      await stderrPromise;
-      return limit + 1;
-    }
-  }
-  const exitCode = await subprocess.exited;
-  const stderr = (await stderrPromise).trim();
-  if (exitCode !== 0) throw new Error(`Measure workspace diff: ${stderr || `git exited ${exitCode}`}`);
-  return total;
-}
-async function resolveGitObjectsAsync(workspacePath, names) {
-  const resolved = /* @__PURE__ */ new Map();
-  const unique = [...new Set(names)];
-  if (unique.length === 0) return resolved;
-  const subprocess = Bun.spawn(gitCommandArgs(["cat-file", "--batch-check"]), {
-    cwd: workspacePath,
-    stdin: Buffer.from(`${unique.join("\n")}
-`),
-    stdout: "pipe",
-    stderr: "pipe",
-    env: workerGitProcessEnvironment()
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(subprocess.stdout).text(),
-    new Response(subprocess.stderr).text(),
-    subprocess.exited
-  ]);
-  if (exitCode !== 0) throw new Error(`Resolve workspace objects: ${stderr.trim() || `git exited ${exitCode}`}`);
-  const lines = stdout.split("\n").filter((line) => line.length > 0);
-  if (lines.length !== unique.length) {
-    throw new Error(`Resolve workspace objects: expected ${unique.length} results, received ${lines.length}`);
-  }
-  unique.forEach((name, index) => {
-    const match = /^([0-9a-f]{40,64}) (\S+) \d+$/.exec(lines[index]);
-    resolved.set(name, match ? { objectId: match[1], type: match[2] } : null);
-  });
-  return resolved;
-}
-function workspaceTreeObjectName(revision, workspaceRelativePath) {
-  return `${revision}:${normalizedWorkspaceMountPath(workspaceRelativePath)}`;
-}
-async function pathsReplacedByGitlinks(workspacePath, baseRevision, headRevision) {
-  const base = baseRevision ?? emptyTreeHash(workspacePath);
-  const raw = await gitOutputAsync(
-    workspacePath,
-    ["diff", "--raw", "--no-renames", "-z", base, headRevision],
-    "inspect workspace gitlink changes"
-  );
-  const records = raw.toString().split("\0");
-  const addedGitlinks = [];
-  for (let index = 0; index + 1 < records.length; index += 2) {
-    if (/^:[0-7]{6} 160000 \S+ \S+ A$/u.test(records[index])) addedGitlinks.push(records[index + 1]);
-  }
-  if (addedGitlinks.length === 0) return [];
-  const objects = await resolveGitObjectsAsync(
-    workspacePath,
-    addedGitlinks.map((relativePath) => `${base}:${relativePath}`)
-  );
-  return addedGitlinks.filter((relativePath) => objects.get(`${base}:${relativePath}`)?.type === "tree").sort();
-}
-function gitlinkMigrationPathspecs(paths) {
-  return paths.map((relativePath) => `:(exclude,literal)${relativePath}`);
-}
-async function measureInitialPublicationDiffSize(input) {
-  const candidates = input.mounts.filter(
-    (mount) => typeof mount.initialPublicationSourceRelativePath === "string"
-  );
-  if (candidates.length === 0) return null;
-  const revisions = [input.localHead, ...input.remoteHead ? [input.remoteHead] : []];
-  const objects = await resolveGitObjectsAsync(
-    input.workspacePath,
-    candidates.flatMap(
-      (mount) => revisions.flatMap((revision) => [
-        workspaceTreeObjectName(revision, mount.workspaceRelativePath),
-        workspaceTreeObjectName(revision, mount.initialPublicationSourceRelativePath)
-      ])
-    )
-  );
-  const lookup = (revision, workspaceRelativePath) => revision ? objects.get(workspaceTreeObjectName(revision, workspaceRelativePath))?.objectId ?? null : null;
-  const initialPublications = candidates.flatMap((mount) => {
-    const published = lookup(input.localHead, mount.workspaceRelativePath);
-    if (!published || lookup(input.remoteHead, mount.workspaceRelativePath)) return [];
-    const source = lookup(input.localHead, mount.initialPublicationSourceRelativePath) ?? lookup(input.remoteHead, mount.initialPublicationSourceRelativePath);
-    return [{ mount, published, source }];
-  });
-  if (initialPublications.length === 0) return null;
-  let size = await input.measure(input.workspacePath, input.remoteHead, input.localHead, input.limit, [
-    ...initialPublications.map(({ mount }) => `:(exclude,literal)${normalizedWorkspaceMountPath(mount.workspaceRelativePath)}`),
-    ...input.excludePathspecs ?? []
-  ]);
-  for (const { published, source } of initialPublications) {
-    if (size > input.limit) break;
-    const migrations = source ? await pathsReplacedByGitlinks(input.workspacePath, source, published) : [];
-    size += await input.measure(input.workspacePath, source, published, input.limit - size, gitlinkMigrationPathspecs(migrations));
-  }
-  return { size, mountIds: initialPublications.map(({ mount }) => mount.id).sort() };
-}
-function conflictPaths(workspacePath) {
-  const result = gitResult(workspacePath, ["diff", "--name-only", "--diff-filter=U", "-z"]);
-  return result.exitCode === 0 ? result.stdout.split("\0").filter(Boolean).sort() : [];
-}
-function snapshotConflict(input) {
-  const suffix = input.attemptId.replace(/[^a-zA-Z0-9._-]/g, "-");
-  const refs = {
-    local: `refs/r5d/workspace-conflicts/${suffix}/local`,
-    remote: `refs/r5d/workspace-conflicts/${suffix}/remote`
-  };
-  git(input.workspacePath, ["update-ref", refs.local, input.localHead], "snapshot local workspace conflict head");
-  git(input.workspacePath, ["update-ref", refs.remote, input.remoteHead], "snapshot remote workspace conflict head");
-  return refs;
-}
-async function rebaseWorkspace(input) {
-  const remoteRevision = `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`;
-  await beginWorkspaceCheckoutTransition(input.workspacePath);
-  const rebase = await gitResultAsync(
-    input.workspacePath,
-    input.truncatedHistoryBase ? ["rebase", "--onto", remoteRevision, input.truncatedHistoryBase] : ["rebase", remoteRevision]
-  );
-  if (rebase.exitCode === 0) {
-    await completeWorkspaceCheckoutTransition(input.workspacePath);
-    return { ok: true };
-  }
-  const conflicts = conflictPaths(input.workspacePath);
-  const refs = snapshotConflict(input);
-  const abort = gitResult(input.workspacePath, ["rebase", "--abort"]);
-  if (abort.exitCode !== 0) {
-    throw new Error(`Abort workspace rebase: ${abort.stderr || abort.stdout || `git exited ${abort.exitCode}`}`);
-  }
-  await completeWorkspaceCheckoutTransition(input.workspacePath);
-  return {
-    ok: false,
-    conflictPaths: conflicts,
-    refs,
-    error: rebase.stderr || rebase.stdout || `Workspace rebase onto ${input.remoteHead} conflicted`
-  };
-}
-async function synchronizeWithFetchedHead(input) {
-  const localHead = await revParseAsync(input.workspacePath, "HEAD");
-  const remoteHead = input.remoteHead;
-  if (!remoteHead) return { kind: "ready", updated: false, rebased: false };
-  if (!localHead) {
-    await runWorkspaceCheckoutTransition(input.workspacePath, async () => {
-      await gitAsync(
-        input.workspacePath,
-        ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`],
-        "check out fetched workspace main"
-      );
-    });
-    return { kind: "ready", updated: true, rebased: false };
-  }
-  if (localHead === remoteHead) {
-    await updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
-    return { kind: "ready", updated: false, rebased: false };
-  }
-  if (await tryGitAsync(input.workspacePath, ["merge-base", "--is-ancestor", localHead, remoteHead])) {
-    await runWorkspaceCheckoutTransition(input.workspacePath, async () => {
-      await gitAsync(input.workspacePath, ["reset", "--hard", remoteHead], "fast-forward workspace main");
-    });
-    await updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
-    return { kind: "ready", updated: true, rebased: false };
-  }
-  if (await tryGitAsync(input.workspacePath, ["merge-base", "--is-ancestor", remoteHead, localHead])) {
-    await updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
-    return { kind: "ready", updated: false, rebased: false };
-  }
-  const integratedHead = await revParseAsync(input.workspacePath, WORKSPACE_GIT_INTEGRATED_REF);
-  const truncatedHistoryBase = workspaceIsShallow(input.workspacePath) && integratedHead && tryGit(input.workspacePath, ["merge-base", "--is-ancestor", integratedHead, localHead]) ? integratedHead : void 0;
-  if (workspaceIsShallow(input.workspacePath) && !truncatedHistoryBase) {
-    throw new Error(
-      "Workspace history was truncated before this clone's integrated base could be identified; reset the workspace clone before retrying"
-    );
-  }
-  const rebased = await rebaseWorkspace({
-    workspacePath: input.workspacePath,
-    localHead,
-    remoteHead,
-    attemptId: input.attemptId,
-    truncatedHistoryBase
-  });
-  if (rebased.ok) await updateIntegratedWorkspaceHead(input.workspacePath, remoteHead);
-  return rebased.ok ? { kind: "ready", updated: false, rebased: true } : { kind: "conflict", conflictPaths: rebased.conflictPaths, refs: rebased.refs, error: rebased.error };
-}
-async function synchronizeWorkspaceGit(input) {
-  const remoteHeadFetches = { count: 0 };
-  const result = await runWorkspaceGitSynchronization(input, remoteHeadFetches);
-  return { ...result, remoteHeadFetches: remoteHeadFetches.count };
-}
-async function runWorkspaceGitSynchronization(input, remoteHeadFetches) {
-  const workspacePath = path.resolve(input.workspacePath);
-  const attemptId = input.attemptId ?? crypto.randomUUID();
-  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 = await ensureWorkspaceGitClone({ ...input, workspacePath, preserveResolutionInProgress });
-  if (initial.remoteHeadFetched) remoteHeadFetches.count += 1;
-  assertWorkspaceRemediationAncestry({
-    workspacePath,
-    currentHead: initial.localHead,
-    remoteHead: initial.remoteHead,
-    requiredAncestorHeads
-  });
-  const verifiedAncestorHeads = requiredAncestorHeads.length > 0 ? requiredAncestorHeads : void 0;
-  const startingHead = initial.localHead;
-  const receiptBeforeInitialHydration = await readHydratedWorkspaceReceiptAsync(workspacePath);
-  const deferredMountIds = /* @__PURE__ */ new Set();
-  if (initial.localHead && initial.remoteHead && initial.remoteHead !== initial.localHead) {
-    for (const mount of input.mounts) {
-      if (!mount.deleteWhenSourceMissing && mount.preserveLocalOnInitialOuterAbsence !== true && mount.preserveLocalOnHydrationBasisChange !== true && workspaceHydrationReceiptMountBasisHead(receiptBeforeInitialHydration, mount) === null) {
-        deferredMountIds.add(mount.id);
-      }
-    }
-  }
-  await recoverWorkspaceGitHydration(workspacePath, input.mounts, {
-    ...deferredMountIds.size > 0 ? { deferMountIds: deferredMountIds } : {},
-    preserveResolutionInProgress,
-    preserveStaleBases: true,
-    hydrationHooks: input.hydrationHooks
-  });
-  const selected = activeMounts(input.mounts);
-  const projectionMutationTokens = new Map(
-    input.mounts.flatMap((mount) => mount.mutationToken ? [[mount.id, mount.mutationToken()]] : [])
-  );
-  const cycleSkippedMountIds = new Set(selected.skipped.map(({ id }) => id));
-  const receiptRequiredLiveMounts = selected.active;
-  const projectionBasisHead = await revParseAsync(workspacePath, "HEAD");
-  const projectionBasisReceipt = await readHydratedWorkspaceReceiptAsync(workspacePath);
-  const allProjectionReceiptMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, input.mounts);
-  const fastProjectionMounts = [];
-  const mergedProjectionTrees = /* @__PURE__ */ new Map();
-  const mergedProjectionMounts = [];
-  const projectionSkippedIds = /* @__PURE__ */ new Set();
-  let projectionWarning;
-  const projectedMountFiles = /* @__PURE__ */ new Map();
-  const mergedProjectionBases = /* @__PURE__ */ new Map();
-  const projectedMountBases = /* @__PURE__ */ new Map();
-  const mountSkipReasons = {};
-  const staleRewriteLedger = hydrationPreBlobLedger(workspacePath);
-  const hydrationLedgerFor = (mount) => {
-    const entries = staleRewriteLedger.entries(mount);
-    return entries.size > 0 ? Object.fromEntries(entries) : void 0;
-  };
-  const forceHydrationMountIds = /* @__PURE__ */ new Set();
-  const ledgerMergedPathsByMount = /* @__PURE__ */ new Map();
-  const recordStaleRewrite = (mount, paths) => {
-    projectionSkippedIds.add(mount.id);
-    mountSkipReasons[mount.id] = { reason: "stale_rewrite_detected", paths: [...paths] };
-    const holders = mount.describeHolders?.();
-    process.stderr.write(
-      `[r5d-worker] stale rewrite detected in mount ${mount.id}: ${describeHydrationSkipPaths(mount.sourcePath, paths)} hold exactly the bytes the last hydration replaced; the mount stays pinned at its recorded basis until they change${holders ? `; holders: ${holders}` : ""}
-`
-    );
-  };
-  const refreshCycleSkippedMounts = (mounts = input.mounts) => {
-    for (const mount of mounts) {
-      const projectionToken = projectionMutationTokens.get(mount.id);
-      if (projectionToken !== void 0 && mount.mutationToken?.() !== projectionToken) cycleSkippedMountIds.add(mount.id);
-      if (mountBusy(mount)) cycleSkippedMountIds.add(mount.id);
-    }
-  };
-  const classifyMounts = (activeCandidates, additionalSkippedIds = []) => {
-    refreshCycleSkippedMounts();
-    const skippedIds = /* @__PURE__ */ new Set([...cycleSkippedMountIds, ...projectionSkippedIds, ...additionalSkippedIds]);
-    const activeMountIds = [...new Set(activeCandidates.filter(({ id }) => !skippedIds.has(id)).map(({ id }) => id))].sort();
-    return {
-      activeMountIds,
-      skippedMountIds: [...skippedIds].sort(),
-      // An active mount's token is unchanged since capture (a moved token
-      // lands it in cycleSkippedMountIds above), so this is the token its
-      // projected bytes belong to.
-      projectedMutationTokens: Object.fromEntries(
-        activeMountIds.flatMap((id) => {
-          const token = projectionMutationTokens.get(id);
-          return token === void 0 ? [] : [[id, token]];
-        })
-      ),
-      ...Object.keys(mountSkipReasons).length > 0 ? { mountSkipReasons: { ...mountSkipReasons } } : {}
-    };
-  };
-  const mountProjectionIsCurrent = (mount) => mount.lastProjectedMutationToken !== void 0 && !mount.deleteWhenSourceMissing && mount.preserveLocalOnHydrationBasisChange !== true && projectionBasisHead !== null && workspaceHydrationReceiptMountBasisHead(projectionBasisReceipt, mount) === projectionBasisHead && projectionMutationTokens.get(mount.id) === mount.lastProjectedMutationToken && mount.mutationToken?.() === mount.lastProjectedMutationToken;
-  const mergeProjectMount = async (mount, basisHead, currentHead) => {
-    const releaseMergeHold = input.hydrationHooks?.holdMounts([mount.id], `merge projection of mount ${mount.id}`);
-    let merged;
-    try {
-      const hydrationLedger = hydrationLedgerFor(mount);
-      merged = await workspaceFilesystemExecutor().run("projection_merge", {
-        workspacePath,
-        mount: {
-          id: mount.id,
-          sourcePath: mount.sourcePath,
-          workspaceRelativePath: normalizedWorkspaceMountPath(mount.workspaceRelativePath),
-          sourceMode: mount.sourceMode
-        },
-        basisHead,
-        currentHead,
-        attemptId,
-        ...hydrationLedger ? { hydrationLedger } : {}
-      });
-    } finally {
-      releaseMergeHold?.();
-    }
-    if (merged.staleRewriteCleared.length > 0) staleRewriteLedger.forget(mount, merged.staleRewriteCleared);
-    if (merged.kind === "stale_rewrite") {
-      recordStaleRewrite(mount, merged.paths);
-      return { kind: "skipped" };
-    }
-    if (merged.kind === "conflict" && mount.processLive?.()) {
-      projectionSkippedIds.add(mount.id);
-      mountSkipReasons[mount.id] = { reason: "projection_conflict_deferred", paths: merged.conflictPaths };
-      const holders = mount.describeHolders?.();
-      process.stderr.write(
-        `[r5d-worker] projection of mount ${mount.id} conflicts with the workspace head at ${merged.conflictPaths.join(", ")}; deferred while a process runs in the checkout${holders ? ` (${holders})` : ""}, reported once the mount is idle
-`
-      );
-      return { kind: "skipped" };
-    }
-    mergedProjectionBases.set(mount.id, {
-      projectedCommit: merged.oursCommit,
-      projectedFiles: merged.projectedFiles,
-      readAtMs: merged.readAtMs
-    });
-    if (merged.kind === "conflict") {
-      const refs = snapshotConflict({ workspacePath, attemptId, localHead: merged.oursCommit, remoteHead: currentHead });
-      return {
-        kind: "conflict",
-        result: {
-          outcome: "conflict_blocked",
-          startingHead,
-          localHead: merged.oursCommit,
-          remoteHead: initial.remoteHead,
-          publishedHead: initial.remoteHead,
-          rebaseCount: 0,
-          diffSizeBytes: 0,
-          affectedPaths: merged.conflictPaths,
-          activeMountIds: [],
-          skippedMountIds: input.mounts.map(({ id }) => id).sort(),
-          conflictPaths: merged.conflictPaths,
-          conflictSnapshotRefs: refs,
-          conflictKind: "projection_merge",
-          ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
-          error: merged.error
-        }
-      };
-    }
-    mergedProjectionTrees.set(mount.id, merged.resultTree);
-    mergedProjectionMounts.push(mount);
-    if (merged.ledgerMergedPaths.length > 0) {
-      forceHydrationMountIds.add(mount.id);
-      ledgerMergedPathsByMount.set(mount.id, merged.ledgerMergedPaths);
-    }
-    return { kind: "projected" };
-  };
-  if (!input.skipMountMirror) {
-    const mergeProjectionEnabled = process.env.R5D_WORKSPACE_MERGE_PROJECTION !== "0";
-    const mergeSupport = mergeProjectionEnabled ? workspaceMergeProjectionSupport() : { supported: false, error: "Workspace merge projection is disabled by R5D_WORKSPACE_MERGE_PROJECTION=0" };
-    const activeProjectionIds = new Set(selected.active.map(({ id }) => id));
-    for (const mount of [...selected.active, ...selected.tombstones]) {
-      if (deferredMountIds.has(mount.id)) continue;
-      const basisHead = workspaceHydrationReceiptMountBasisHead(projectionBasisReceipt, mount);
-      if (projectionBasisHead === null) {
-        fastProjectionMounts.push(mount);
-        continue;
-      }
-      if (basisHead === projectionBasisHead) {
-        const hydrationLedger = activeProjectionIds.has(mount.id) ? hydrationLedgerFor(mount) : void 0;
-        if (!hydrationLedger || !Object.values(hydrationLedger).some(({ processLiveAcrossHydration }) => processLiveAcrossHydration) || !mergeSupport.supported) {
-          fastProjectionMounts.push(mount);
-          continue;
-        }
-        if (cycleSkippedMountIds.has(mount.id) || mountBusy(mount)) {
-          cycleSkippedMountIds.add(mount.id);
-          continue;
-        }
-        const releaseCheckHold = input.hydrationHooks?.holdMounts([mount.id], `hydration ledger check of mount ${mount.id}`);
-        let checked;
-        try {
-          checked = await workspaceFilesystemExecutor().run("projection_mirror", {
-            workspacePath,
-            mount: workspaceGitMountData(mount),
-            hydrationLedger,
-            checkOnly: true
-          });
-        } finally {
-          releaseCheckHold?.();
-        }
-        if (checked.staleRewriteCleared.length > 0) staleRewriteLedger.forget(mount, checked.staleRewriteCleared);
-        if (checked.staleRewritePaths.length > 0) {
-          recordStaleRewrite(mount, checked.staleRewritePaths);
-          continue;
-        }
-        if (checked.ledgerMergePaths.length === 0) {
-          fastProjectionMounts.push(mount);
-          continue;
-        }
-        if (cycleSkippedMountIds.has(mount.id) || mountBusy(mount)) {
-          cycleSkippedMountIds.add(mount.id);
-          continue;
-        }
-        const outcome2 = await mergeProjectMount(mount, projectionBasisHead, projectionBasisHead);
-        if (outcome2.kind === "conflict") return outcome2.result;
-        continue;
-      }
-      if (basisHead === null) {
-        deferredMountIds.add(mount.id);
-        continue;
-      }
-      if (!mergeSupport.supported) {
-        projectionSkippedIds.add(mount.id);
-        projectionWarning = mergeSupport.error ?? "Git 2.40 or newer is required for stale workspace mount projection";
-        continue;
-      }
-      if (cycleSkippedMountIds.has(mount.id) || mountBusy(mount)) {
-        cycleSkippedMountIds.add(mount.id);
-        continue;
-      }
-      const outcome = await mergeProjectMount(mount, basisHead, projectionBasisHead);
-      if (outcome.kind === "conflict") return outcome.result;
-    }
-  }
-  if (projectionWarning) process.stderr.write(`[r5d-worker] ${projectionWarning}
-`);
-  const completedMountSelection = async (requireCurrentHeadReceipt = false) => {
-    const currentHeadBeforeHydration = await revParseAsync(workspacePath, "HEAD");
-    const completionReceiptMounts = configuredWorkspaceHydrationBasisMounts(workspacePath, input.mounts);
-    const currentReceiptBeforeHydration = await readHydratedWorkspaceReceiptAsync(workspacePath);
-    refreshCycleSkippedMounts(completionReceiptMounts);
-    const mountIsAlreadyCovered = (mount) => !forceHydrationMountIds.has(mount.id) && Boolean(
-      currentHeadBeforeHydration && workspaceHydrationReceiptCoversMount(currentReceiptBeforeHydration, currentHeadBeforeHydration, mount)
-    );
-    if (currentHeadBeforeHydration && completionReceiptMounts.every((mount) => cycleSkippedMountIds.has(mount.id) || mountIsAlreadyCovered(mount))) {
-      return classifyMounts([...selected.active, ...selected.tombstones]);
-    }
-    const uncoveredCompletionMounts = selected.active.filter(
-      (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
-    );
-    const uncoveredRequiredLiveMounts = receiptRequiredLiveMounts.filter(
-      (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
-    );
-    const uncoveredCompletionBasisMounts = completionReceiptMounts.filter(
-      (mount) => !cycleSkippedMountIds.has(mount.id) && !projectionSkippedIds.has(mount.id) && !mountIsAlreadyCovered(mount)
-    );
-    const unchangedMountIds = currentHeadBeforeHydration ? await selectMountsWithUnchangedOuterSubtree(
-      workspacePath,
-      currentReceiptBeforeHydration,
-      currentHeadBeforeHydration,
-      uncoveredCompletionMounts
-    ) : /* @__PURE__ */ new Set();
-    for (const id of forceHydrationMountIds) unchangedMountIds.delete(id);
-    const hydrationMounts = uncoveredCompletionMounts.filter(({ id }) => !unchangedMountIds.has(id));
-    const mergeBases = /* @__PURE__ */ new Map();
-    if (workspaceMergeHydrationEnabled()) {
-      for (const mount of hydrationMounts) {
-        const basis = projectedMountBases.get(mount.id);
-        if (basis) mergeBases.set(mount.id, basis);
-      }
-    }
-    const hydration = await hydrateWorkspaceGitMountsTransactionally({
-      workspacePath,
-      mounts: hydrationMounts,
-      durabilityMounts: uncoveredCompletionBasisMounts.filter(({ id }) => !unchangedMountIds.has(id)),
-      carryMounts: uncoveredCompletionMounts.filter(({ id }) => unchangedMountIds.has(id)),
-      receiptMounts: completionReceiptMounts,
-      requiredMounts: uncoveredRequiredLiveMounts.filter(({ id }) => !unchangedMountIds.has(id)),
-      recordCurrentHead: true,
-      hydrationHooks: input.hydrationHooks,
-      ...mergeBases.size > 0 ? { mergeBases } : {},
-      ...ledgerMergedPathsByMount.size > 0 ? { ledgerMergedPaths: ledgerMergedPathsByMount } : {}
-    });
-    for (const id of hydration.skippedMountIds) cycleSkippedMountIds.add(id);
-    for (const mount of hydrationMounts) {
-      const mergedPaths = ledgerMergedPathsByMount.get(mount.id);
-      if (!mergedPaths || !hydration.hydratedMountIds.includes(mount.id)) continue;
-      const written = new Set(hydration.hydratedEntryPaths[mount.id] ?? []);
-      const settled = mergedPaths.filter((relativePath) => !written.has(relativePath));
-      if (settled.length > 0) staleRewriteLedger.forget(mount, settled);
-      ledgerMergedPathsByMount.delete(mount.id);
-      forceHydrationMountIds.delete(mount.id);
-    }
-    if (currentHeadBeforeHydration) {
-      for (const id of hydration.hydratedMountIds) {
-        if (mergeBases.has(id)) projectedMountBases.set(id, { projectedCommit: currentHeadBeforeHydration, projectedFiles: null });
-      }
-    }
-    for (const skip of hydration.mergeSkips) {
-      const mount = hydrationMounts.find(({ id }) => id === skip.mountId);
-      const basis = mount ? workspaceHydrationReceiptMountBasisHead(currentReceiptBeforeHydration, mount) : null;
-      mountSkipReasons[skip.mountId] = {
-        reason: skip.reason,
-        paths: skip.paths,
-        ...skip.retainedPaths?.length ? { retainedPaths: skip.retainedPaths } : {}
-      };
-      process.stderr.write(
-        `[r5d-worker] merge hydration pinned mount ${skip.mountId} at ${basis ?? "its recorded basis"} (${skip.reason}): ${skip.reason === "hydration_merge_conflict" ? "writes that landed after the projection read conflict with the inbound change at" : "the checkout changed while it was being hydrated at"} ${describeHydrationSkipPaths(mount?.sourcePath ?? skip.mountId, skip.paths)}; the next projection merges it from that basis${skip.retainedPaths?.length ? `; displaced writer entries preserved at ${skip.retainedPaths.join(", ")}` : ""}
-`
-      );
-    }
-    refreshCycleSkippedMounts(completionReceiptMounts);
-    if (requireCurrentHeadReceipt) {
-      const currentHead = await revParseAsync(workspacePath, "HEAD");
-      const receipt = await readHydratedWorkspaceReceiptAsync(workspacePath);
-      const transactionSkippedMountIds = new Set(hydration.skippedMountIds);
-      const idleMounts = completionReceiptMounts.filter(
-        (mount) => !cycleSkippedMountIds.has(mount.id) && !transactionSkippedMountIds.has(mount.id) && !mountBusy(mount) && !projectionSkippedIds.has(mount.id)
-      );
-      if (currentHead && !idleMounts.every((mount) => workspaceHydrationReceiptCoversMount(receipt, currentHead, mount))) {
-        throw new Error(`Workspace inbound integration ${currentHead} could not be fully hydrated before publication continued`);
-      }
-    }
-    return classifyMounts([...selected.active, ...selected.tombstones], hydration.skippedMountIds);
-  };
-  let newlyStagedPaths = [];
-  const projectedGitlinks = [];
-  const stageAndCommitWorkspace = async () => {
-    if (workspaceResolutionInProgress(workspacePath) || await workspaceHasUnmergedEntries(workspacePath)) {
-      throw new Error("Outer workspace clone has an unfinished merge/rebase; finish or abort it before synchronizing");
-    }
-    await stageWorkspaceGitlinks(workspacePath, projectedGitlinks);
-    await gitAsync(workspacePath, ["add", "-A", "--", "."], "stage workspace working trees");
-    newlyStagedPaths = await stagedPaths(workspacePath);
-    if (newlyStagedPaths.length > 0) {
-      if (workspaceResolutionInProgress(workspacePath) || await workspaceHasUnmergedEntries(workspacePath)) {
-        throw new Error("Outer workspace clone has an unfinished merge/rebase; finish or abort it before synchronizing");
-      }
-      await gitAsync(
-        workspacePath,
-        [
-          "commit",
-          "-m",
-          JSON.stringify({ type: "workspace_sync", worker: input.workerLabel, attemptId, detail: input.commitDetail ?? null })
-        ],
-        "commit workspace working trees"
-      );
-    }
-  };
-  const projectedFastMounts = [];
-  const currentProjectionMounts = [];
-  const selectedActiveIdSet = new Set(selected.active.map(({ id }) => id));
-  if (!input.skipMountMirror) {
-    await beginWorkspaceCheckoutTransition(workspacePath);
-    try {
-      const selectedActiveIds = selectedActiveIdSet;
-      const fastActiveMounts = fastProjectionMounts.filter(({ id }) => selectedActiveIds.has(id));
-      const fastTombstones = fastProjectionMounts.filter(({ id }) => !selectedActiveIds.has(id));
-      for (const mount of fastActiveMounts) {
-        if (cycleSkippedMountIds.has(mount.id) || mountBusy(mount)) {
-          cycleSkippedMountIds.add(mount.id);
-          continue;
-        }
-        if (mountProjectionIsCurrent(mount)) {
-          currentProjectionMounts.push(mount);
-          continue;
-        }
-        const releaseMirrorHold = input.hydrationHooks?.holdMounts([mount.id], `projection of mount ${mount.id}`);
-        let staleRewritePaths;
-        let ledgerMergePaths;
-        try {
-          const hydrationLedger = hydrationLedgerFor(mount);
-          const mirrored = await workspaceFilesystemExecutor().run("projection_mirror", {
-            workspacePath,
-            mount: workspaceGitMountData(mount),
-            ...hydrationLedger ? { hydrationLedger } : {}
-          });
-          staleRewritePaths = mirrored.staleRewritePaths;
-          ledgerMergePaths = mirrored.ledgerMergePaths;
-          if (mirrored.staleRewriteCleared.length > 0) staleRewriteLedger.forget(mount, mirrored.staleRewriteCleared);
-          if (staleRewritePaths.length === 0 && ledgerMergePaths.length === 0) {
-            projectedGitlinks.push({ mount, gitlinks: mirrored.gitlinks });
-            projectedMountFiles.set(mount.id, { files: mirrored.projectedFiles, readAtMs: mirrored.readAtMs });
-          }
-        } finally {
-          releaseMirrorHold?.();
-        }
-        if (ledgerMergePaths.length > 0) {
-          projectionSkippedIds.add(mount.id);
-          mountSkipReasons[mount.id] = { reason: "hydration_target_changed", paths: ledgerMergePaths };
-          process.stderr.write(
-            `[r5d-worker] projection of mount ${mount.id} skipped: a running process rewrote ${describeHydrationSkipPaths(mount.sourcePath, ledgerMergePaths)} while the cycle prepared the mirror; the next cycle merges it
-`
-          );
-          continue;
-        }
-        if (staleRewritePaths.length > 0) {
-          recordStaleRewrite(mount, staleRewritePaths);
-          continue;
-        }
-        projectedFastMounts.push(mount);
-      }
-      await workspaceFilesystemExecutor().run("projection_outer_apply", {
-        workspacePath,
-        removeMounts: fastTombstones.map(workspaceGitMountData),
-        materialize: mergedProjectionMounts.map((mount) => ({
-          workspaceRelativePath: normalizedWorkspaceMountPath(mount.workspaceRelativePath),
-          resultTree: mergedProjectionTrees.get(mount.id)
-        })),
-        restoreFromHead: input.mounts.filter(
-          (mount) => deferredMountIds.has(mount.id) || mount.preserveLocalOnHydrationBasisChange === true && cycleSkippedMountIds.has(mount.id)
-        ).map(workspaceGitMountData)
-      });
-      projectedFastMounts.push(...fastTombstones);
-      await stageAndCommitWorkspace();
-      await workspaceFilesystemExecutor().run("outer_checkout_fsync", { workspacePath });
-    } catch (error) {
-      await throwAfterWorkspaceCheckoutRecovery(workspacePath, error);
-    }
-  } else {
-    await stageAndCommitWorkspace();
-    if (newlyStagedPaths.length > 0) await completeWorkspaceCheckoutTransition(workspacePath);
-  }
-  if (!input.skipMountMirror) {
-    const projectedHead = await revParseAsync(workspacePath, "HEAD");
-    if (!projectedHead) throw new Error("Workspace projection did not retain a local HEAD");
-    for (const mount of projectedFastMounts) {
-      if (!selectedActiveIdSet.has(mount.id)) continue;
-      const read = projectedMountFiles.get(mount.id);
-      projectedMountBases.set(mount.id, {
-        projectedCommit: projectedHead,
-        projectedFiles: read?.files ?? null,
-        ...read ? { readAtMs: read.readAtMs } : {}
-      });
-    }
-    for (const mount of currentProjectionMounts)
-      projectedMountBases.set(mount.id, { projectedCommit: projectedHead, projectedFiles: null });
-    for (const [mountId, basis] of mergedProjectionBases) projectedMountBases.set(mountId, basis);
-    const targetProjectionReceipt = receiptWithMountsAtHead(
-      projectionBasisReceipt,
-      projectedHead,
-      [...projectedFastMounts, ...currentProjectionMounts],
-      allProjectionReceiptMounts
-    );
-    const currentProjectionReceipt = await readHydratedWorkspaceReceiptAsync(workspacePath);
-    if (!workspaceHydrationReceiptsEqual(currentProjectionReceipt, targetProjectionReceipt) || !await hydratedWorkspaceReceiptFileIsV3(workspacePath) || !await workspaceBasisRefsAreCurrentAsync(workspacePath, targetProjectionReceipt)) {
-      await workspaceFilesystemExecutor().run("projection_receipt", {
-        workspacePath,
-        fsyncMounts: projectedFastMounts.map(workspaceGitMountData),
-        receipt: targetProjectionReceipt
-      });
-    }
-    await completeWorkspaceCheckoutTransition(workspacePath);
-  }
-  const prePublishRemoteHead = await resolveWorkspaceRemoteHead(workspacePath, input);
-  if (prePublishRemoteHead.fetched) remoteHeadFetches.count += 1;
-  let remoteHead = prePublishRemoteHead.head;
-  let rebaseCount = 0;
-  let updated = false;
-  for (let pushAttempt = 0; pushAttempt < maxPushAttempts; pushAttempt += 1) {
-    assertWorkspaceRemediationAncestry({
-      workspacePath,
-      currentHead: await revParseAsync(workspacePath, "HEAD"),
-      remoteHead,
-      requiredAncestorHeads
-    });
-    const reconciled = await synchronizeWithFetchedHead({ workspacePath, remoteHead, attemptId });
-    if (reconciled.kind === "conflict") {
-      const localHead2 = await revParseAsync(workspacePath, "HEAD");
-      const classifiedMounts = classifyMounts([...fastProjectionMounts, ...mergedProjectionMounts], deferredMountIds);
-      return {
-        outcome: "conflict_blocked",
-        startingHead,
-        localHead: localHead2,
-        remoteHead,
-        publishedHead: remoteHead,
-        rebaseCount: rebaseCount + 1,
-        diffSizeBytes: 0,
-        affectedPaths: [.../* @__PURE__ */ new Set([...newlyStagedPaths, ...reconciled.conflictPaths])].sort(),
-        ...classifiedMounts,
-        conflictPaths: reconciled.conflictPaths,
-        conflictSnapshotRefs: reconciled.refs,
-        conflictKind: "integration_rebase",
-        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
-        error: reconciled.error
-      };
-    }
-    updated ||= reconciled.updated;
-    if (reconciled.rebased) rebaseCount += 1;
-    if (reconciled.updated || reconciled.rebased) await completedMountSelection(true);
-    const localHead = await revParseAsync(workspacePath, "HEAD");
-    if (!localHead) {
-      const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones], deferredMountIds);
-      return {
-        outcome: "no_change",
-        startingHead,
-        localHead: null,
-        remoteHead,
-        publishedHead: remoteHead,
-        rebaseCount,
-        diffSizeBytes: 0,
-        affectedPaths: [],
-        ...classifiedMounts,
-        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
-        ...projectionWarning ? { error: projectionWarning } : {}
-      };
-    }
-    const paths = await changedPaths(workspacePath, remoteHead, localHead);
-    const measureDiffSize = input.measureDiffSize ?? diffSizeBytes;
-    const gitlinkMigrations = paths.length > 0 ? await pathsReplacedByGitlinks(workspacePath, remoteHead, localHead) : [];
-    const gitlinkMigrationExcludes = gitlinkMigrationPathspecs(gitlinkMigrations);
-    let size = paths.length > 0 ? await measureDiffSize(workspacePath, remoteHead, localHead, maxDiffBytes, gitlinkMigrationExcludes) : 0;
-    input.assertStillAdmitted?.();
-    let initialPublicationMountIds;
-    if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
-      const initialPublication = await measureInitialPublicationDiffSize({
-        workspacePath,
-        remoteHead,
-        localHead,
-        mounts: input.mounts,
-        limit: maxDiffBytes,
-        measure: measureDiffSize,
-        excludePathspecs: gitlinkMigrationExcludes
-      });
-      input.assertStillAdmitted?.();
-      if (initialPublication && initialPublication.size <= maxDiffBytes) {
-        size = initialPublication.size;
-        initialPublicationMountIds = initialPublication.mountIds;
-      }
-    }
-    let gitlinkMigrationConfirmed = false;
-    if (gitlinkMigrations.length > 0 && size <= maxDiffBytes && !input.allowLargeDiff) {
-      gitlinkMigrationConfirmed = await measureDiffSize(workspacePath, remoteHead, localHead, maxDiffBytes) > maxDiffBytes;
-      input.assertStillAdmitted?.();
-    }
-    if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
-      const classifiedMounts = classifyMounts([...selected.active, ...selected.tombstones]);
-      return {
-        outcome: "large_diff_blocked",
-        startingHead,
-        localHead,
-        remoteHead,
-        publishedHead: remoteHead,
-        rebaseCount,
-        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 = await completedMountSelection(Boolean(input.skipMountMirror));
-      await input.afterWorkspacePublished?.({
-        publishedHead: localHead,
-        activeMountIds: completedMounts.activeMountIds
-      });
-      input.assertStillAdmitted?.();
-      return {
-        outcome: updated ? "updated" : "no_change",
-        startingHead,
-        localHead,
-        remoteHead,
-        publishedHead: localHead,
-        rebaseCount,
-        diffSizeBytes: size,
-        affectedPaths: paths,
-        ...completedMounts,
-        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
-        ...projectionWarning ? { error: projectionWarning } : {}
-      };
-    }
-    assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
-    const pushArgs = [
-      ...gitTransportSecurityArgs(input.remoteUrl, input.credentialHelper, input.credentialUsername),
-      "push",
-      "--no-recurse-submodules"
-    ];
-    if (input.allowLargeDiff || initialPublicationMountIds || gitlinkMigrationConfirmed) {
-      pushArgs.push(`--push-option=${WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION}`);
-    }
-    pushArgs.push("origin", `HEAD:refs/heads/${WORKSPACE_GIT_BRANCH}`);
-    const push = await gitResultAsync(workspacePath, pushArgs);
-    if (push.exitCode === 0) {
-      assertWorkspaceRemediationAncestry({ workspacePath, currentHead: localHead, remoteHead, requiredAncestorHeads });
-      await updateIntegratedWorkspaceHead(workspacePath, localHead);
-      const completedMounts = await completedMountSelection(Boolean(input.skipMountMirror));
-      await input.afterWorkspacePublished?.({
-        publishedHead: localHead,
-        activeMountIds: completedMounts.activeMountIds
-      });
-      input.assertStillAdmitted?.();
-      return {
-        outcome: "pushed",
-        startingHead,
-        localHead,
-        remoteHead,
-        publishedHead: localHead,
-        rebaseCount,
-        diffSizeBytes: size,
-        affectedPaths: paths,
-        ...completedMounts,
-        ...initialPublicationMountIds ? { initialPublicationMountIds } : {},
-        ...verifiedAncestorHeads ? { verifiedAncestorHeads } : {},
-        ...projectionWarning ? { error: projectionWarning } : {}
-      };
-    }
-    if (!/(non-fast-forward|fetch first|rejected|failed to push some refs)/i.test(`${push.stderr}
-${push.stdout}`)) {
-      throw new Error(`Push workspace main: ${push.stderr || push.stdout || `git exited ${push.exitCode}`}`);
-    }
-    remoteHead = await fetchWorkspaceHead(workspacePath, input.remoteUrl, input.credentialHelper, input.credentialUsername);
-    remoteHeadFetches.count += 1;
-  }
-  throw new Error(`Workspace push did not converge after ${maxPushAttempts} attempts`);
-}
-function inspectHydrationLedger(workspacePath, mount, hydrationLedger) {
-  const outerRoot = workspaceMountOuterPath(workspacePath, mount);
-  const stale = [];
-  const merge = [];
-  const cleared = [];
-  for (const [relativePath, entry] of Object.entries(hydrationLedger)) {
-    const algorithm = gitObjectHashAlgorithmFor(entry.preBlob);
-    if (!algorithm) continue;
-    const source = inspectWorkingTreePath(mount.sourcePath, relativePath);
-    if (source.kind !== "entry" || !source.stat.isFile()) {
-      if (entry.postBlob !== null) cleared.push(relativePath);
-      continue;
-    }
-    if (entry.stat && projectedFileEntryMatches(entry.stat, source.stat)) continue;
-    const content = fs.readFileSync(source.absolutePath);
-    const hash = gitBlobHash(content, algorithm);
-    if (hash === entry.postBlob) continue;
-    const outer = inspectWorkingTreePath(outerRoot, relativePath);
-    const outerEqual = outer.kind === "entry" && outer.stat.isFile() && fs.readFileSync(outer.absolutePath).equals(content);
-    if (outerEqual) {
-      cleared.push(relativePath);
-      continue;
-    }
-    if (entry.processLiveAcrossHydration) {
-      merge.push(relativePath);
-      continue;
-    }
-    if (hash !== entry.preBlob) {
-      cleared.push(relativePath);
-      continue;
-    }
-    stale.push(relativePath);
-  }
-  return { stale: stale.sort(), merge: merge.sort(), cleared: cleared.sort() };
-}
-function runProjectionMirrorJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  let staleRewriteCleared = [];
-  if (input.hydrationLedger) {
-    const inspected = inspectHydrationLedger(workspacePath, input.mount, input.hydrationLedger);
-    staleRewriteCleared = inspected.cleared;
-    if (inspected.stale.length > 0 || inspected.merge.length > 0 || input.checkOnly) {
-      return {
-        gitlinks: [],
-        projectedFiles: {},
-        readAtMs: Date.now(),
-        staleRewritePaths: inspected.stale,
-        ledgerMergePaths: inspected.merge,
-        staleRewriteCleared
-      };
-    }
-  } else if (input.checkOnly) {
-    return { gitlinks: [], projectedFiles: {}, readAtMs: Date.now(), staleRewritePaths: [], ledgerMergePaths: [], staleRewriteCleared };
-  }
-  const projectedFiles = /* @__PURE__ */ new Map();
-  const projected = mirrorMountsToWorkspace(workspacePath, [input.mount], projectedFiles);
-  return {
-    gitlinks: projected[0]?.gitlinks ?? [],
-    projectedFiles: Object.fromEntries(projectedFiles),
-    readAtMs: Date.now(),
-    staleRewritePaths: [],
-    ledgerMergePaths: [],
-    staleRewriteCleared
-  };
-}
-function runProjectionOuterApplyJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  removeWorkspaceMounts(workspacePath, input.removeMounts);
-  for (const { workspaceRelativePath, resultTree } of input.materialize) {
-    materializeWorkspaceProjectionTree({ workspacePath, workspaceRelativePath, resultTree });
-  }
-  restoreDeferredWorkspaceMountsFromHead(workspacePath, input.restoreFromHead);
-  return null;
-}
-function runProjectionReceiptJob(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  for (const mount of input.fsyncMounts) fsyncHydratedWorkspaceMount(mount);
-  updateHydratedWorkspaceReceipt(workspacePath, input.receipt);
-  return null;
-}
-const workspaceGitSyncTestHarness = {
-  beginHydrationTransaction,
-  commandArgs: gitCommandArgs,
-  workspaceCloneCommandArgs,
-  configureWorkspaceRepository,
-  mirrorMountsToWorkspace,
-  hydrateMountsFromWorkspace: hydrateWorkspaceGitMounts,
-  hydrationPreBlobLedger,
-  resetHydrationPreBlobLedgers() {
-    hydrationPreBlobLedgers.clear();
-  }
-};
-export {
-  MAX_WORKSPACE_GIT_DIFF_BYTES,
-  WORKSPACE_GIT_BRANCH,
-  WORKSPACE_GIT_CHECKOUT_DURABILITY,
-  WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION,
-  WORKSPACE_GIT_HYDRATED_RECEIPT,
-  WORKSPACE_GIT_HYDRATION_RECOVERIES,
-  WORKSPACE_GIT_HYDRATION_TRANSACTION,
-  WORKSPACE_MERGE_HYDRATION_SWITCH,
-  WORKSPACE_PROCESS_BUSY_FENCE_SWITCH,
-  WorkspaceHydrationRecoveryRequiredError,
-  WorkspaceRemediationAncestryError,
-  configureExistingWorkspaceGitForRemediation,
-  ensureWorkspaceGitClone,
-  hydrateWorkspaceGitMounts,
-  recoverWorkspaceGitHydration,
-  resetWorkspaceGit,
-  runCheckoutDurabilityRecoveryJob,
-  runCheckoutTransitionBeginJob,
-  runCheckoutTransitionCompleteJob,
-  runHydrationPreserveInterruptedJob,
-  runHydrationRawJob,
-  runHydrationRecoveryInspectJob,
-  runHydrationRecoveryJob,
-  runHydrationTransactionJob,
-  runOuterCheckoutFsyncJob,
-  runProjectionMirrorJob,
-  runProjectionOuterApplyJob,
-  runProjectionReceiptJob,
-  synchronizeWorkspaceGit,
-  workspaceGitHydrationIsCurrent,
-  workspaceGitHydrationIsRecoverable,
-  workspaceGitMountData,
-  workspaceGitMountsForRemediation,
-  workspaceGitSyncTestHarness
-};