@ricsam/r5d-worker 0.0.74 → 0.0.76

package/dist/cjs/project-worktrees.cjs

@@ -0,0 +1,559 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_worktrees_exports = {};
+__export(project_worktrees_exports, {
+  PROJECT_WORKTREE_SNAPSHOT_PREFIX: () => PROJECT_WORKTREE_SNAPSHOT_PREFIX,
+  cleanupStaleProjectWorktreeSnapshots: () => cleanupStaleProjectWorktreeSnapshots,
+  createLinkedProjectBranch: () => createLinkedProjectBranch,
+  deleteLinkedProjectBranch: () => deleteLinkedProjectBranch,
+  deleteProjectMirrorBranch: () => deleteProjectMirrorBranch,
+  ensureProjectWorktrees: () => ensureProjectWorktrees,
+  fastForwardProjectHeadsFromMirror: () => fastForwardProjectHeadsFromMirror,
+  hasLinkedProjectWorktreeLayout: () => hasLinkedProjectWorktreeLayout,
+  projectWorktreeConfigurationFingerprint: () => projectWorktreeConfigurationFingerprint,
+  projectWorktreeOperationInProgress: () => projectWorktreeOperationInProgress,
+  projectWorktreesTestHarness: () => projectWorktreesTestHarness,
+  pushProjectMirrorHeads: () => pushProjectMirrorHeads,
+  removeProjectWorktrees: () => removeProjectWorktrees
+});
+module.exports = __toCommonJS(project_worktrees_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_managed_paths = require("./managed-paths.cjs");
+var import_working_tree_mirror = require("./working-tree-mirror.cjs");
+const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
+const PROJECT_WORKTREE_SNAPSHOT_NAME = new RegExp(
+  `^${PROJECT_WORKTREE_SNAPSHOT_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([1-9]\\d*)-([A-Za-z0-9]{6})$`
+);
+function projectWorktreeConfigurationFingerprint(input) {
+  return (0, import_node_crypto.createHash)("sha256").update(
+    JSON.stringify({
+      checkoutPathSegments: input.checkoutPathSegments,
+      projectPath: input.projectPath,
+      repoHttpUrl: input.repoHttpUrl,
+      repoAuthHeader: input.repoAuthHeader,
+      defaultBranch: input.defaultBranch,
+      branches: [...input.branches].sort((left, right) => left.branchName.localeCompare(right.branchName)).map(({ branchName, sourceBranchName, baseCommitHash }) => ({
+        branchName,
+        sourceBranchName: sourceBranchName ?? null,
+        baseCommitHash
+      })),
+      gitIdentity: input.gitIdentity
+    })
+  ).digest("hex");
+}
+const NON_RECURSIVE_GIT_CONFIG = [
+  "-c",
+  "submodule.recurse=false",
+  "-c",
+  "fetch.recurseSubmodules=false",
+  "-c",
+  "push.recurseSubmodules=false"
+];
+function normalizedHttpOrigin(value) {
+  try {
+    const url = new URL(value);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return value.replace(/\/+$/, "");
+  }
+}
+function authArgs(auth) {
+  if (!auth) return [];
+  const key = `http.${normalizedHttpOrigin(auth.extraHeaderUrl)}/.extraHeader`;
+  return ["-c", "http.extraHeader=", "-c", `${key}=`, "-c", `${key}=${auth.header}`];
+}
+function gitResult(cwd, args, auth) {
+  const result = Bun.spawnSync(["git", ...NON_RECURSIVE_GIT_CONFIG, ...authArgs(auth), ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString().trim(),
+    stderr: result.stderr.toString().trim()
+  };
+}
+function git(cwd, args, action, auth) {
+  const result = gitResult(cwd, args, auth);
+  if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
+  return result.stdout;
+}
+function tryGit(cwd, args, auth) {
+  return gitResult(cwd, args, auth).exitCode === 0;
+}
+function branchPath(projectRoot, branchName) {
+  (0, import_managed_paths.validateManagedBranchName)(branchName);
+  const result = import_node_path.default.join(projectRoot, ...branchName.split("/"));
+  const relative = import_node_path.default.relative(import_node_path.default.resolve(projectRoot), import_node_path.default.resolve(result));
+  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+    throw new Error(`Branch path escapes its project root: ${branchName}`);
+  }
+  return result;
+}
+function assertNonOverlappingBranches(branches) {
+  const names = branches.map(({ branchName }) => branchName).sort();
+  if (new Set(names).size !== names.length) throw new Error("Project worktree branch names must be unique");
+  for (let index = 0; index < names.length; index += 1) {
+    const name = names[index];
+    (0, import_managed_paths.validateManagedBranchName)(name);
+    const baseCommitHash = branches.find(({ branchName }) => branchName === name)?.baseCommitHash;
+    if (!baseCommitHash || !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(baseCommitHash)) {
+      throw new Error(`Invalid base commit hash for project branch ${name}`);
+    }
+    const overlapping = names.slice(index + 1).find((candidate) => candidate.startsWith(`${name}/`));
+    if (overlapping) throw new Error(`Branch folders overlap: ${name} and ${overlapping}`);
+  }
+}
+function gitDirectoryKind(checkoutPath) {
+  const gitPath = import_node_path.default.join(checkoutPath, ".git");
+  try {
+    const stat = import_node_fs.default.lstatSync(gitPath);
+    if (stat.isDirectory()) return "directory";
+    if (stat.isFile()) return "file";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function commonGitDirectory(checkoutPath) {
+  const result = gitResult(checkoutPath, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  return result.exitCode === 0 ? import_node_path.default.resolve(result.stdout) : null;
+}
+function hasLinkedProjectWorktreeLayout(input) {
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  if (gitDirectoryKind(primaryPath) !== "directory") return false;
+  const primaryCommonDir = commonGitDirectory(primaryPath);
+  if (!primaryCommonDir) return false;
+  return input.branches.every(({ branchName }) => {
+    const checkoutPath = branchPath(input.projectRoot, branchName);
+    if (branchName === input.primaryBranchName) return commonGitDirectory(checkoutPath) === primaryCommonDir;
+    return gitDirectoryKind(checkoutPath) === "file" && commonGitDirectory(checkoutPath) === primaryCommonDir;
+  });
+}
+function hasCompatibleLinkedProjectWorktreeLayout(input) {
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  if (gitDirectoryKind(primaryPath) !== "directory") return false;
+  const primaryCommonDir = commonGitDirectory(primaryPath);
+  if (!primaryCommonDir) return false;
+  return input.branches.every(({ branchName }) => {
+    if (branchName === input.primaryBranchName) return true;
+    const checkoutPath = branchPath(input.projectRoot, branchName);
+    const kind = gitDirectoryKind(checkoutPath);
+    return kind === null || kind === "file" && commonGitDirectory(checkoutPath) === primaryCommonDir;
+  });
+}
+function createProjectWorktreeSnapshotRoot() {
+  return import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), `${PROJECT_WORKTREE_SNAPSHOT_PREFIX}${process.pid}-`));
+}
+function snapshotBranchTrees(projectRoot, branches) {
+  const root = createProjectWorktreeSnapshotRoot();
+  const paths = /* @__PURE__ */ new Map();
+  try {
+    for (const { branchName } of branches) {
+      const checkoutPath = branchPath(projectRoot, branchName);
+      if (!import_node_fs.default.existsSync(checkoutPath)) continue;
+      const snapshotPath = import_node_path.default.join(root, ...branchName.split("/"));
+      (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: checkoutPath, targetRoot: snapshotPath, sourceMode: "all", deletionMode: "all" });
+      paths.set(branchName, snapshotPath);
+    }
+    return { root, paths };
+  } catch (error) {
+    import_node_fs.default.rmSync(root, { recursive: true, force: true });
+    throw error;
+  }
+}
+function isProcessAlive(processId) {
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function cleanupStaleProjectWorktreeSnapshots(input = {}) {
+  const temporaryRoot = import_node_path.default.resolve(input.temporaryRoot ?? import_node_os.default.tmpdir());
+  const processAlive = input.processAlive ?? isProcessAlive;
+  const removed = [];
+  const failed = [];
+  let entries;
+  try {
+    entries = import_node_fs.default.readdirSync(temporaryRoot, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return { removed, failed };
+    return { removed, failed: [{ path: temporaryRoot, error: error instanceof Error ? error.message : String(error) }] };
+  }
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    const match = PROJECT_WORKTREE_SNAPSHOT_NAME.exec(entry.name);
+    if (!match) continue;
+    const ownerProcessId = Number(match[1]);
+    if (!Number.isSafeInteger(ownerProcessId) || processAlive(ownerProcessId)) continue;
+    const candidate = import_node_path.default.join(temporaryRoot, entry.name);
+    try {
+      const stat = import_node_fs.default.lstatSync(candidate);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) continue;
+      import_node_fs.default.rmSync(candidate, { recursive: true, force: true });
+      removed.push(candidate);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      failed.push({ path: candidate, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { removed, failed };
+}
+function configureRepository(input) {
+  if (tryGit(input.primaryPath, ["remote", "get-url", "origin"])) {
+    git(input.primaryPath, ["remote", "set-url", "origin", input.originUrl], "configure project origin");
+  } else {
+    git(input.primaryPath, ["remote", "add", "origin", input.originUrl], "configure project origin");
+  }
+  git(input.primaryPath, ["config", "--local", "--replace-all", "credential.helper", ""], "reset project credential helpers");
+  if (input.credentialHelper) {
+    git(
+      input.primaryPath,
+      ["config", "--local", "--add", "credential.helper", input.credentialHelper],
+      "configure project credential helper"
+    );
+  }
+  if (input.gitIdentity) {
+    const name = input.gitIdentity.name.trim();
+    const email = input.gitIdentity.email.trim();
+    if (!name || !email) throw new Error("Git identity must include name and email");
+    git(input.primaryPath, ["config", "--local", "user.name", name], "configure project Git user name");
+    git(input.primaryPath, ["config", "--local", "user.email", email], "configure project Git user email");
+  }
+}
+function fetchProjectHeads(input) {
+  const originFetch = gitResult(
+    input.primaryPath,
+    ["fetch", "--no-recurse-submodules", "--prune", "origin", "+refs/heads/*:refs/remotes/origin/*"],
+    input.originAuth
+  );
+  if (originFetch.exitCode !== 0) {
+    throw new Error(`Fetch project origin: ${originFetch.stderr || originFetch.stdout || `git exited ${originFetch.exitCode}`}`);
+  }
+  const mirrorFetch = gitResult(
+    input.primaryPath,
+    ["fetch", "--no-recurse-submodules", "--prune", input.mirrorUrl, "+refs/heads/*:refs/r5d/mirror/*"],
+    input.mirrorAuth
+  );
+  if (mirrorFetch.exitCode !== 0 && !/(couldn't find remote ref|does not have any commits|remote repository is empty|no such ref)/i.test(
+    `${mirrorFetch.stderr}
+${mirrorFetch.stdout}`
+  )) {
+    throw new Error(`Fetch project head mirror: ${mirrorFetch.stderr || mirrorFetch.stdout || `git exited ${mirrorFetch.exitCode}`}`);
+  }
+}
+function ensureCommitAvailable(input) {
+  if (tryGit(input.primaryPath, ["cat-file", "-e", `${input.commitHash}^{commit}`])) return;
+  for (const [url, auth] of [
+    [input.mirrorUrl, input.mirrorAuth],
+    [input.originUrl, input.originAuth]
+  ]) {
+    if (tryGit(input.primaryPath, ["fetch", "--no-recurse-submodules", "--no-tags", url, input.commitHash], auth)) return;
+  }
+  throw new Error(`Project base commit ${input.commitHash} is unavailable from origin and the canonical mirror`);
+}
+function seedForBranch(input) {
+  const mirrorRef = `refs/r5d/mirror/${input.branch.branchName}`;
+  const mirrorHead = tryGit(input.primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? git(input.primaryPath, ["rev-parse", mirrorRef], "resolve project mirror head") : null;
+  const seed = mirrorHead ?? input.branch.baseCommitHash;
+  ensureCommitAvailable({ ...input, commitHash: seed });
+  return { seed, mirrorHead };
+}
+function preserveHead(checkoutPath) {
+  if (!tryGit(checkoutPath, ["rev-parse", "--verify", "HEAD"])) return;
+  const head = git(checkoutPath, ["rev-parse", "HEAD"], "read pre-reconciliation project head");
+  git(checkoutPath, ["update-ref", `refs/r5d/pre-connect/${head}`, head], "preserve pre-reconciliation project head");
+}
+function initializeLinkedLayout(input) {
+  for (const { branchName } of [...input.branches].sort((left, right) => right.branchName.length - left.branchName.length)) {
+    import_node_fs.default.rmSync(branchPath(input.projectRoot, branchName), { recursive: true, force: true });
+  }
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(primaryPath), { recursive: true });
+  git(void 0, ["init", `--initial-branch=${input.primaryBranchName}`, primaryPath], "initialize primary project clone");
+  configureRepository({ ...input, primaryPath });
+  fetchProjectHeads({ ...input, primaryPath });
+  const seeds = /* @__PURE__ */ new Map();
+  const mirrorHeads = /* @__PURE__ */ new Map();
+  for (const branch of input.branches) {
+    const resolved = seedForBranch({ ...input, primaryPath, branch });
+    seeds.set(branch.branchName, resolved.seed);
+    mirrorHeads.set(branch.branchName, resolved.mirrorHead);
+  }
+  git(
+    primaryPath,
+    ["checkout", "--no-recurse-submodules", "-B", input.primaryBranchName, seeds.get(input.primaryBranchName)],
+    "anchor primary project worktree"
+  );
+  for (const branch of input.branches) {
+    if (branch.branchName === input.primaryBranchName) continue;
+    git(primaryPath, ["branch", "-f", branch.branchName, seeds.get(branch.branchName)], `anchor project branch ${branch.branchName}`);
+    const checkoutPath = branchPath(input.projectRoot, branch.branchName);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(checkoutPath), { recursive: true });
+    git(primaryPath, ["worktree", "add", "--force", checkoutPath, branch.branchName], `create linked worktree ${branch.branchName}`);
+  }
+  return mirrorHeads;
+}
+function reconcileLinkedLayout(input) {
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  configureRepository({ ...input, primaryPath });
+  tryGit(primaryPath, ["worktree", "prune"]);
+  fetchProjectHeads({ ...input, primaryPath });
+  const mirrorHeads = /* @__PURE__ */ new Map();
+  for (const branch of input.branches) {
+    const checkoutPath = branchPath(input.projectRoot, branch.branchName);
+    const resolved = seedForBranch({ ...input, primaryPath, branch });
+    mirrorHeads.set(branch.branchName, resolved.mirrorHead);
+    if (branch.branchName === input.primaryBranchName || commonGitDirectory(checkoutPath) === commonGitDirectory(primaryPath)) {
+      preserveHead(checkoutPath);
+      git(checkoutPath, ["reset", "--hard", resolved.seed], `anchor linked worktree ${branch.branchName}`);
+      continue;
+    }
+    import_node_fs.default.rmSync(checkoutPath, { recursive: true, force: true });
+    git(primaryPath, ["branch", "-f", branch.branchName, resolved.seed], `anchor project branch ${branch.branchName}`);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(checkoutPath), { recursive: true });
+    git(primaryPath, ["worktree", "add", "--force", checkoutPath, branch.branchName], `create linked worktree ${branch.branchName}`);
+  }
+  return mirrorHeads;
+}
+function aheadBehind(checkoutPath, branchName) {
+  const originRef = `refs/remotes/origin/${branchName}`;
+  if (!tryGit(checkoutPath, ["show-ref", "--verify", "--quiet", originRef])) return { ahead: null, behind: null };
+  const output = git(checkoutPath, ["rev-list", "--left-right", "--count", `${originRef}...HEAD`], "measure project origin divergence");
+  const [behind, ahead] = output.split(/\s+/).map(Number);
+  return Number.isFinite(ahead) && Number.isFinite(behind) ? { ahead, behind } : { ahead: null, behind: null };
+}
+function ensureProjectWorktrees(input) {
+  const projectRoot = import_node_path.default.resolve(input.projectRoot);
+  assertNonOverlappingBranches(input.branches);
+  if (!input.branches.some(({ branchName }) => branchName === input.primaryBranchName)) {
+    throw new Error(`Primary project branch ${input.primaryBranchName} is missing from the workspace configuration`);
+  }
+  const snapshot = snapshotBranchTrees(projectRoot, input.branches);
+  try {
+    import_node_fs.default.mkdirSync(projectRoot, { recursive: true });
+    const linked = hasCompatibleLinkedProjectWorktreeLayout({
+      projectRoot,
+      primaryBranchName: input.primaryBranchName,
+      branches: input.branches
+    });
+    const mirrorHeads = linked ? reconcileLinkedLayout({ ...input, projectRoot }) : initializeLinkedLayout({ ...input, projectRoot });
+    for (const branch of input.branches) {
+      const snapshotPath = snapshot.paths.get(branch.branchName);
+      if (!snapshotPath) continue;
+      (0, import_working_tree_mirror.mirrorWorkingTree)({
+        sourceRoot: snapshotPath,
+        targetRoot: branchPath(projectRoot, branch.branchName),
+        sourceMode: "all",
+        deletionMode: "git"
+      });
+    }
+    return input.branches.map((branch) => {
+      const checkoutPath = branchPath(projectRoot, branch.branchName);
+      const divergence = aheadBehind(checkoutPath, branch.branchName);
+      return {
+        branchName: branch.branchName,
+        branchPath: checkoutPath,
+        head: git(checkoutPath, ["rev-parse", "HEAD"], `resolve project head ${branch.branchName}`),
+        mirrorHead: mirrorHeads.get(branch.branchName) ?? null,
+        ...divergence
+      };
+    }).sort((left, right) => left.branchName.localeCompare(right.branchName));
+  } finally {
+    import_node_fs.default.rmSync(snapshot.root, { recursive: true, force: true });
+  }
+}
+function projectWorktreeOperationInProgress(checkoutPath) {
+  const gitPaths = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "rebase-merge", "rebase-apply", "sequencer"];
+  return gitPaths.some((gitPath) => {
+    const result = gitResult(checkoutPath, ["rev-parse", "--git-path", gitPath]);
+    if (result.exitCode !== 0) return false;
+    const resolved = import_node_path.default.isAbsolute(result.stdout) ? result.stdout : import_node_path.default.resolve(checkoutPath, result.stdout);
+    return import_node_fs.default.existsSync(resolved);
+  });
+}
+function createLinkedProjectBranch(input) {
+  (0, import_managed_paths.validateManagedBranchName)(input.sourceBranchName);
+  (0, import_managed_paths.validateManagedBranchName)(input.branchName);
+  if (input.sourceBranchName === input.branchName) throw new Error("Source and target branch names must differ");
+  const sourcePath = branchPath(input.projectRoot, input.sourceBranchName);
+  const targetPath = branchPath(input.projectRoot, input.branchName);
+  if (!commonGitDirectory(sourcePath)) throw new Error(`Source worktree ${input.sourceBranchName} is unavailable`);
+  if (projectWorktreeOperationInProgress(sourcePath)) {
+    throw new Error(`Source worktree ${input.sourceBranchName} has an in-progress Git operation`);
+  }
+  if (import_node_fs.default.existsSync(targetPath) || tryGit(sourcePath, ["show-ref", "--verify", "--quiet", `refs/heads/${input.branchName}`])) {
+    throw new Error(`Project branch ${input.branchName} already exists`);
+  }
+  const registeredWorktrees = git(sourcePath, ["worktree", "list", "--porcelain"], "inspect linked project worktrees").split(/\r?\n/).flatMap((line) => line.startsWith("worktree ") ? [import_node_path.default.resolve(line.slice("worktree ".length))] : []);
+  const overlappingWorktree = registeredWorktrees.find((worktreePath) => {
+    const targetRelative = import_node_path.default.relative(worktreePath, targetPath);
+    const worktreeRelative = import_node_path.default.relative(targetPath, worktreePath);
+    return targetRelative === "" || targetRelative !== ".." && !targetRelative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(targetRelative) || worktreeRelative !== ".." && !worktreeRelative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(worktreeRelative);
+  });
+  if (overlappingWorktree) throw new Error(`Project branch folder overlaps linked worktree ${overlappingWorktree}`);
+  const sourceHead = git(sourcePath, ["rev-parse", "HEAD"], "resolve source branch head");
+  const snapshotRoot = createProjectWorktreeSnapshotRoot();
+  try {
+    (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: sourcePath, targetRoot: snapshotRoot, sourceMode: "git", deletionMode: "all" });
+    git(sourcePath, ["branch", input.branchName, sourceHead], `create project branch ${input.branchName}`);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(targetPath), { recursive: true });
+    try {
+      git(sourcePath, ["worktree", "add", "--force", targetPath, input.branchName], `create linked worktree ${input.branchName}`);
+      (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: snapshotRoot, targetRoot: targetPath, sourceMode: "all", deletionMode: "git" });
+    } catch (error) {
+      import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
+      tryGit(sourcePath, ["worktree", "prune"]);
+      tryGit(sourcePath, ["branch", "-D", input.branchName]);
+      throw error;
+    }
+    return { branchPath: targetPath, baseCommitHash: sourceHead };
+  } finally {
+    import_node_fs.default.rmSync(snapshotRoot, { recursive: true, force: true });
+  }
+}
+function deleteLinkedProjectBranch(input) {
+  (0, import_managed_paths.validateManagedBranchName)(input.primaryBranchName);
+  (0, import_managed_paths.validateManagedBranchName)(input.branchName);
+  if (input.branchName === input.primaryBranchName) throw new Error(`Cannot delete the primary project branch ${input.primaryBranchName}`);
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  const checkoutPath = branchPath(input.projectRoot, input.branchName);
+  const primaryCommonDir = commonGitDirectory(primaryPath);
+  if (!primaryCommonDir) throw new Error("Primary project checkout is unavailable");
+  if (import_node_fs.default.existsSync(checkoutPath)) {
+    const checkoutCommonDir = commonGitDirectory(checkoutPath);
+    if (checkoutCommonDir !== primaryCommonDir) {
+      throw new Error(`Project branch path ${input.branchName} is not a linked worktree of the configured project`);
+    }
+    if (projectWorktreeOperationInProgress(checkoutPath)) {
+      throw new Error(`Project branch ${input.branchName} has an in-progress Git operation`);
+    }
+    git(primaryPath, ["worktree", "remove", "--force", checkoutPath], `remove linked worktree ${input.branchName}`);
+  } else {
+    tryGit(primaryPath, ["worktree", "prune"]);
+  }
+  const branchRef = `refs/heads/${input.branchName}`;
+  if (tryGit(primaryPath, ["show-ref", "--verify", "--quiet", branchRef])) {
+    git(primaryPath, ["branch", "-D", input.branchName], `delete project branch ${input.branchName}`);
+  }
+  return { branchName: input.branchName };
+}
+function removeProjectWorktrees(input) {
+  const projectRoot = import_node_path.default.resolve(input.projectRoot);
+  if (input.branchNames.length === 0) throw new Error("Cannot remove a project with no configured branches");
+  for (const branchName of input.branchNames) {
+    (0, import_managed_paths.validateManagedBranchName)(branchName);
+    const checkoutPath = branchPath(projectRoot, branchName);
+    if (import_node_fs.default.existsSync(checkoutPath) && projectWorktreeOperationInProgress(checkoutPath)) {
+      throw new Error(`Project branch ${branchName} has an in-progress Git operation`);
+    }
+  }
+  import_node_fs.default.rmSync(projectRoot, { recursive: true, force: true });
+}
+function deleteProjectMirrorBranch(input) {
+  (0, import_managed_paths.validateManagedBranchName)(input.branchName);
+  const deleted = gitResult(
+    input.gitDirectory,
+    ["push", "--no-recurse-submodules", input.mirrorUrl, `:refs/heads/${input.branchName}`],
+    input.mirrorAuth
+  );
+  if (deleted.exitCode !== 0 && !/(remote ref does not exist|unable to delete|no such ref)/i.test(`${deleted.stderr}
+${deleted.stdout}`)) {
+    throw new Error(
+      `Delete hidden project mirror for ${input.branchName}: ${deleted.stderr || deleted.stdout || `git exited ${deleted.exitCode}`}`
+    );
+  }
+}
+function pushProjectMirrorHeads(input) {
+  const results = [];
+  for (const branchName of [...input.branchNames].sort()) {
+    if (input.onlyBranches && !input.onlyBranches.has(branchName)) continue;
+    const checkoutPath = branchPath(input.projectRoot, branchName);
+    const head = git(checkoutPath, ["rev-parse", "HEAD"], `resolve mirror head for ${branchName}`);
+    if (projectWorktreeOperationInProgress(checkoutPath)) {
+      results.push({ branchName, head, pushed: false, reason: "git_operation_in_progress" });
+      continue;
+    }
+    git(
+      checkoutPath,
+      ["push", "--no-recurse-submodules", input.mirrorUrl, `+HEAD:refs/heads/${branchName}`],
+      `push hidden project mirror for ${branchName}`,
+      input.mirrorAuth
+    );
+    results.push({ branchName, head, pushed: true });
+  }
+  return results;
+}
+function fastForwardProjectHeadsFromMirror(input) {
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  const fetch = gitResult(
+    primaryPath,
+    ["fetch", "--no-recurse-submodules", "--prune", input.mirrorUrl, "+refs/heads/*:refs/r5d/mirror/*"],
+    input.mirrorAuth
+  );
+  if (fetch.exitCode !== 0)
+    throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
+  return [...input.branchNames].sort().map((branchName) => {
+    const checkoutPath = branchPath(input.projectRoot, branchName);
+    const previousHead = git(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
+    const mirrorRef = `refs/r5d/mirror/${branchName}`;
+    const mirrorHead = tryGit(primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? git(primaryPath, ["rev-parse", mirrorRef], `resolve refreshed mirror head ${branchName}`) : null;
+    if (!mirrorHead || mirrorHead === previousHead || projectWorktreeOperationInProgress(checkoutPath) || !tryGit(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead])) {
+      return { branchName, previousHead, mirrorHead, fastForwarded: false };
+    }
+    git(checkoutPath, ["update-ref", `refs/heads/${branchName}`, mirrorHead, previousHead], `fast-forward project branch ${branchName}`);
+    git(checkoutPath, ["reset", "--mixed", mirrorHead], `refresh project index ${branchName}`);
+    return { branchName, previousHead, mirrorHead, fastForwarded: true };
+  });
+}
+const projectWorktreesTestHarness = {
+  commandArgs: (args, auth) => ["git", ...NON_RECURSIVE_GIT_CONFIG, ...authArgs(auth), ...args]
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROJECT_WORKTREE_SNAPSHOT_PREFIX,
+  cleanupStaleProjectWorktreeSnapshots,
+  createLinkedProjectBranch,
+  deleteLinkedProjectBranch,
+  deleteProjectMirrorBranch,
+  ensureProjectWorktrees,
+  fastForwardProjectHeadsFromMirror,
+  hasLinkedProjectWorktreeLayout,
+  projectWorktreeConfigurationFingerprint,
+  projectWorktreeOperationInProgress,
+  projectWorktreesTestHarness,
+  pushProjectMirrorHeads,
+  removeProjectWorktrees
+});