@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/mjs/project-workspace-state.mjs

@@ -1,937 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import {
-  managedBranchPath,
-  managedProjectRoot,
-  validateCheckoutPathSegments,
-  validateManagedBranchName
-} from "./managed-paths.mjs";
-const PROJECT_WORKSPACE_STATE_FILE = "project-workspace-state.json";
-const PROJECT_WORKSPACE_STATE_VERSION = 1;
-const PROJECT_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const GIT_OBJECT_ID_PATTERN = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
-class ProjectWorkspacePendingBranchPathChangeError extends Error {
-  projectId;
-  branchName;
-  currentCheckoutPathSegments;
-  incomingCheckoutPathSegments;
-  constructor(input) {
-    super(`Cannot move project ${input.projectId} while creator-local branch ${input.branchName} is pending publication`);
-    this.name = "ProjectWorkspacePendingBranchPathChangeError";
-    this.projectId = input.projectId;
-    this.branchName = input.branchName;
-    this.currentCheckoutPathSegments = [...input.currentCheckoutPathSegments];
-    this.incomingCheckoutPathSegments = [...input.incomingCheckoutPathSegments];
-  }
-}
-class ProjectWorkspaceCheckoutPathCollisionError extends Error {
-  projectId;
-  occupyingProjectId;
-  checkoutPathSegments;
-  constructor(input) {
-    super(
-      `Cannot assign checkout path ${input.checkoutPathSegments.join("/")} to project ${input.projectId} while project ${input.occupyingProjectId} still owns a durable checkout or deletion tombstone there`
-    );
-    this.name = "ProjectWorkspaceCheckoutPathCollisionError";
-    this.projectId = input.projectId;
-    this.occupyingProjectId = input.occupyingProjectId;
-    this.checkoutPathSegments = [...input.checkoutPathSegments];
-  }
-}
-const EMPTY_STATE = {
-  version: PROJECT_WORKSPACE_STATE_VERSION,
-  desiredProjects: [],
-  locallyPendingCreatedBranches: [],
-  enabledRepositoryTransitions: [],
-  tombstones: []
-};
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validateProjectId(projectId) {
-  if (typeof projectId !== "string" || projectId !== "local" && projectId !== "local-code" && !PROJECT_ID_PATTERN.test(projectId)) {
-    throw new Error(`Invalid project workspace state project id: ${String(projectId)}`);
-  }
-  return projectId;
-}
-function comparePathSegments(left, right) {
-  return left[0].localeCompare(right[0]) || left[1].localeCompare(right[1]);
-}
-function samePathSegments(left, right) {
-  return left[0] === right[0] && left[1] === right[1];
-}
-function pathsOverlap(left, right) {
-  const relative = path.relative(path.resolve(left), path.resolve(right));
-  const reverse = path.relative(path.resolve(right), path.resolve(left));
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative) || reverse !== ".." && !reverse.startsWith(`..${path.sep}`) && !path.isAbsolute(reverse);
-}
-function normalizeBranchNames(branches, label) {
-  const branchNames = branches.map(({ branchName }) => {
-    validateManagedBranchName(branchName);
-    return branchName;
-  });
-  if (new Set(branchNames).size !== branchNames.length) throw new Error(`${label} contains duplicate branches`);
-  const sorted = [...branchNames].sort();
-  for (const [index, branchName] of sorted.entries()) {
-    const overlapping = sorted.slice(index + 1).find((candidate) => candidate.startsWith(`${branchName}/`));
-    if (overlapping) throw new Error(`${label} contains overlapping branch paths ${branchName} and ${overlapping}`);
-  }
-  return sorted;
-}
-function normalizeDesiredProjects(projects) {
-  const normalized = projects.map((project) => {
-    const projectId = validateProjectId(project.projectId);
-    const checkoutPathSegments = validateCheckoutPathSegments(project.checkoutPathSegments);
-    validateManagedBranchName(project.defaultBranch);
-    const branchNames = normalizeBranchNames(project.branches, `Project ${projectId}`);
-    return {
-      projectId,
-      checkoutPathSegments,
-      defaultBranch: project.defaultBranch,
-      branches: branchNames.map((branchName) => ({ branchName }))
-    };
-  });
-  if (new Set(normalized.map(({ projectId }) => projectId)).size !== normalized.length) {
-    throw new Error("Project workspace state contains duplicate project ids");
-  }
-  const checkoutPaths = /* @__PURE__ */ new Map();
-  for (const project of normalized) {
-    const checkoutPath = project.checkoutPathSegments.join("/");
-    const existing = checkoutPaths.get(checkoutPath);
-    if (existing) throw new Error(`Projects ${existing} and ${project.projectId} share managed checkout path ${checkoutPath}`);
-    checkoutPaths.set(checkoutPath, project.projectId);
-  }
-  return normalized.sort(
-    (left, right) => left.projectId.localeCompare(right.projectId) || comparePathSegments(left.checkoutPathSegments, right.checkoutPathSegments)
-  );
-}
-function normalizePendingCreatedBranches(value) {
-  if (!Array.isArray(value)) throw new Error("Invalid durable locally pending project branches");
-  const pending = value.map((entry) => {
-    if (!isRecord(entry) || typeof entry.branchName !== "string") {
-      throw new Error("Invalid durable locally pending project branch");
-    }
-    const projectId = validateProjectId(entry.projectId);
-    validateManagedBranchName(entry.branchName);
-    if (entry.branchId !== void 0 && (typeof entry.branchId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(entry.branchId))) {
-      throw new Error("Invalid durable locally pending project branch id");
-    }
-    return { ...entry.branchId ? { branchId: entry.branchId } : {}, projectId, branchName: entry.branchName };
-  });
-  const keys = pending.map(({ projectId, branchName }) => `${projectId}\0${branchName}`);
-  if (new Set(keys).size !== keys.length) throw new Error("Duplicate durable locally pending project branch");
-  return pending.sort((left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName));
-}
-function normalizePreserveOnlyBranches(value) {
-  const normalized = normalizePendingCreatedBranches(value);
-  if (normalized.some(({ branchId }) => !branchId)) throw new Error("Preserve-only branch is missing its durable branch id");
-  return normalized;
-}
-function normalizeEnabledRepositoryTransitions(value) {
-  if (value === void 0) return [];
-  if (!Array.isArray(value)) throw new Error("Invalid durable enabled repository transitions");
-  const transitions = value.map((entry) => {
-    if (!isRecord(entry)) throw new Error("Invalid durable enabled repository transition");
-    const projectId = validateProjectId(entry.projectId);
-    if (entry.transitionId !== null && (typeof entry.transitionId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(entry.transitionId))) {
-      throw new Error("Invalid durable enabled repository transition id");
-    }
-    return { projectId, transitionId: entry.transitionId };
-  });
-  if (new Set(transitions.map(({ projectId }) => projectId)).size !== transitions.length) {
-    throw new Error("Duplicate durable enabled repository transition project");
-  }
-  return transitions.sort((left, right) => left.projectId.localeCompare(right.projectId));
-}
-function tombstoneBranchNames(tombstone) {
-  return tombstone.kind === "branch" ? [tombstone.branchName] : tombstone.branchNames;
-}
-function deletionId(input) {
-  const digest = createHash("sha256").update(
-    JSON.stringify([input.kind, input.projectId, input.checkoutPathSegments[0], input.checkoutPathSegments[1], input.branchName ?? null])
-  ).digest("hex");
-  return `${input.kind}:${digest}`;
-}
-function normalizeDeletedMirrorRefs(value, branchNames, label) {
-  if (!Array.isArray(value) || value.some((branchName) => typeof branchName !== "string")) {
-    throw new Error(`${label} has invalid deleted mirror refs`);
-  }
-  const normalized = [...new Set(value)].sort();
-  if (normalized.some((branchName) => !branchNames.includes(branchName))) {
-    throw new Error(`${label} records a mirror ref outside its branch set`);
-  }
-  return normalized;
-}
-function normalizeTreePublishedHead(value, label) {
-  if (value === null) return null;
-  if (typeof value !== "string" || !GIT_OBJECT_ID_PATTERN.test(value)) {
-    throw new Error(`${label} has an invalid published workspace head`);
-  }
-  return value;
-}
-function normalizeTombstone(value) {
-  if (!isRecord(value)) throw new Error("Invalid project workspace deletion tombstone");
-  const projectId = validateProjectId(value.projectId);
-  const checkoutPathSegments = validateCheckoutPathSegments(value.checkoutPathSegments);
-  if (value.kind === "branch") {
-    if (typeof value.branchName !== "string") throw new Error("Invalid project workspace branch deletion tombstone");
-    validateManagedBranchName(value.branchName);
-    const expectedId2 = deletionId({ kind: "branch", projectId, checkoutPathSegments, branchName: value.branchName });
-    if (value.id !== expectedId2) throw new Error("Project workspace branch deletion tombstone id does not match its target");
-    return {
-      id: expectedId2,
-      kind: "branch",
-      projectId,
-      checkoutPathSegments,
-      branchName: value.branchName,
-      treePublishedHead: normalizeTreePublishedHead(value.treePublishedHead, `Deletion ${expectedId2}`),
-      mirrorRefsDeleted: normalizeDeletedMirrorRefs(value.mirrorRefsDeleted, [value.branchName], `Deletion ${expectedId2}`)
-    };
-  }
-  if (value.kind !== "project" || !Array.isArray(value.branchNames)) {
-    throw new Error("Invalid project workspace project deletion tombstone");
-  }
-  const branchNames = normalizeBranchNames(
-    value.branchNames.map((branchName) => ({ branchName: String(branchName) })),
-    `Deletion ${String(value.id)}`
-  );
-  const expectedId = deletionId({ kind: "project", projectId, checkoutPathSegments });
-  if (value.id !== expectedId) throw new Error("Project workspace project deletion tombstone id does not match its target");
-  return {
-    id: expectedId,
-    kind: "project",
-    projectId,
-    checkoutPathSegments,
-    branchNames,
-    treePublishedHead: normalizeTreePublishedHead(value.treePublishedHead, `Deletion ${expectedId}`),
-    mirrorRefsDeleted: normalizeDeletedMirrorRefs(value.mirrorRefsDeleted, branchNames, `Deletion ${expectedId}`)
-  };
-}
-function normalizeState(value) {
-  if (!isRecord(value) || value.version !== PROJECT_WORKSPACE_STATE_VERSION) {
-    throw new Error("Unsupported or invalid project workspace state file");
-  }
-  if (!Array.isArray(value.desiredProjects) || !Array.isArray(value.locallyPendingCreatedBranches) || !Array.isArray(value.tombstones)) {
-    throw new Error("Invalid project workspace state file");
-  }
-  const desiredProjects = normalizeDesiredProjects(value.desiredProjects);
-  const locallyPendingCreatedBranches = normalizePendingCreatedBranches(value.locallyPendingCreatedBranches);
-  const enabledRepositoryTransitions = normalizeEnabledRepositoryTransitions(value.enabledRepositoryTransitions);
-  const desiredById = new Map(desiredProjects.map((project) => [project.projectId, project]));
-  for (const pending of locallyPendingCreatedBranches) {
-    const project = desiredById.get(pending.projectId);
-    if (!project || !project.branches.some(({ branchName }) => branchName === pending.branchName)) {
-      throw new Error(`Durable pending branch ${pending.projectId}/${pending.branchName} is missing from desired project state`);
-    }
-  }
-  const tombstones = value.tombstones.map(normalizeTombstone);
-  if (new Set(tombstones.map(({ id }) => id)).size !== tombstones.length) {
-    throw new Error("Project workspace state contains duplicate deletion tombstones");
-  }
-  return {
-    version: PROJECT_WORKSPACE_STATE_VERSION,
-    desiredProjects,
-    locallyPendingCreatedBranches,
-    enabledRepositoryTransitions,
-    tombstones: tombstones.sort((left, right) => left.id.localeCompare(right.id))
-  };
-}
-function cloneDesiredProjects(projects) {
-  return projects.map((project) => ({
-    ...project,
-    checkoutPathSegments: [...project.checkoutPathSegments],
-    branches: project.branches.map((branch) => ({ ...branch }))
-  }));
-}
-function cloneTombstones(tombstones) {
-  return tombstones.map((tombstone) => ({
-    ...tombstone,
-    checkoutPathSegments: [...tombstone.checkoutPathSegments],
-    mirrorRefsDeleted: [...tombstone.mirrorRefsDeleted],
-    ...tombstone.kind === "project" ? { branchNames: [...tombstone.branchNames] } : {}
-  }));
-}
-function readState(statePath) {
-  try {
-    return normalizeState(JSON.parse(fs.readFileSync(statePath, "utf8")));
-  } catch (error) {
-    if (error.code === "ENOENT") return normalizeState(EMPTY_STATE);
-    throw new Error(
-      `Could not read durable project workspace state at ${statePath}: ${error instanceof Error ? error.message : String(error)}`,
-      { cause: error }
-    );
-  }
-}
-function fsyncDirectory(directory) {
-  let descriptor;
-  try {
-    descriptor = fs.openSync(directory, "r");
-    fs.fsyncSync(descriptor);
-  } finally {
-    if (descriptor !== void 0) fs.closeSync(descriptor);
-  }
-}
-function lstatIfExists(targetPath) {
-  try {
-    return fs.lstatSync(targetPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-async function fsyncDirectoryAsync(directory) {
-  const handle = await fs.promises.open(directory, "r");
-  try {
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-}
-async function lstatIfExistsAsync(targetPath) {
-  try {
-    return await fs.promises.lstat(targetPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-async function ensureDurableStateRoot(stateRoot) {
-  const resolvedStateRoot = path.resolve(stateRoot);
-  let existingAncestor = resolvedStateRoot;
-  while (!await lstatIfExistsAsync(existingAncestor)) {
-    const parent = path.dirname(existingAncestor);
-    if (parent === existingAncestor) throw new Error(`Project workspace state has no existing ancestor: ${resolvedStateRoot}`);
-    existingAncestor = parent;
-  }
-  const ancestorStat = await lstatIfExistsAsync(existingAncestor);
-  if (!ancestorStat || ancestorStat.isSymbolicLink() || !ancestorStat.isDirectory()) {
-    throw new Error(`Project workspace state must descend from a real directory: ${resolvedStateRoot}`);
-  }
-  await fs.promises.mkdir(resolvedStateRoot, { recursive: true, mode: 448 });
-  let current = resolvedStateRoot;
-  while (true) {
-    const stat = await lstatIfExistsAsync(current);
-    if (!stat || stat.isSymbolicLink() || !stat.isDirectory()) {
-      throw new Error(`Project workspace state path must be a real directory: ${current}`);
-    }
-    await fsyncDirectoryAsync(current);
-    if (current === existingAncestor) break;
-    current = path.dirname(current);
-  }
-}
-async function writeStateAtomically(stateRoot, statePath, state, afterStateRootFsync) {
-  await ensureDurableStateRoot(stateRoot);
-  afterStateRootFsync?.();
-  const temporaryPath = path.join(stateRoot, `.${PROJECT_WORKSPACE_STATE_FILE}.${process.pid}.${randomUUID()}.tmp`);
-  let handle;
-  try {
-    handle = await fs.promises.open(temporaryPath, "wx", 384);
-    await handle.writeFile(`${JSON.stringify(normalizeState(state), null, 2)}
-`, "utf8");
-    await handle.sync();
-    await handle.close();
-    handle = void 0;
-    await fs.promises.rename(temporaryPath, statePath);
-    await fsyncDirectoryAsync(stateRoot);
-  } finally {
-    if (handle !== void 0) await handle.close();
-    await fs.promises.rm(temporaryPath, { force: true });
-  }
-}
-function createBranchTombstone(project, branchName) {
-  return {
-    id: deletionId({ kind: "branch", projectId: project.projectId, checkoutPathSegments: project.checkoutPathSegments, branchName }),
-    kind: "branch",
-    projectId: project.projectId,
-    checkoutPathSegments: [...project.checkoutPathSegments],
-    branchName,
-    treePublishedHead: null,
-    mirrorRefsDeleted: []
-  };
-}
-function createProjectTombstone(project) {
-  return {
-    id: deletionId({ kind: "project", projectId: project.projectId, checkoutPathSegments: project.checkoutPathSegments }),
-    kind: "project",
-    projectId: project.projectId,
-    checkoutPathSegments: [...project.checkoutPathSegments],
-    branchNames: project.branches.map(({ branchName }) => branchName).sort(),
-    treePublishedHead: null,
-    mirrorRefsDeleted: []
-  };
-}
-function addBranchTombstone(tombstones, project, branchName) {
-  const projectTombstone = tombstones.find(
-    (tombstone) => tombstone.kind === "project" && tombstone.projectId === project.projectId && samePathSegments(tombstone.checkoutPathSegments, project.checkoutPathSegments)
-  );
-  if (projectTombstone) {
-    if (!projectTombstone.branchNames.includes(branchName)) {
-      projectTombstone.branchNames.push(branchName);
-      projectTombstone.branchNames.sort();
-      projectTombstone.treePublishedHead = null;
-    }
-    return;
-  }
-  const created = createBranchTombstone(project, branchName);
-  if (!tombstones.some(({ id }) => id === created.id)) tombstones.push(created);
-}
-function addProjectTombstone(tombstones, project) {
-  const created = createProjectTombstone(project);
-  const existing = tombstones.find(({ id }) => id === created.id);
-  if (existing) return;
-  const supersededBranches = tombstones.filter(
-    (tombstone) => tombstone.kind === "branch" && tombstone.projectId === project.projectId && samePathSegments(tombstone.checkoutPathSegments, project.checkoutPathSegments)
-  );
-  const alreadyDeleted = new Set(supersededBranches.flatMap(({ mirrorRefsDeleted }) => mirrorRefsDeleted));
-  created.mirrorRefsDeleted = created.branchNames.filter((branchName) => alreadyDeleted.has(branchName));
-  tombstones.splice(
-    0,
-    tombstones.length,
-    ...tombstones.filter((tombstone) => !supersededBranches.some(({ id }) => id === tombstone.id)),
-    created
-  );
-}
-function applyPendingCreatedBranches(desiredProjects, pendingCreatedBranches) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const pending of pendingCreatedBranches) {
-    const projectId = validateProjectId(pending.projectId);
-    validateManagedBranchName(pending.branchName);
-    const key = `${projectId}\0${pending.branchName}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    const project = desiredProjects.find((candidate) => candidate.projectId === projectId);
-    if (!project) throw new Error(`Pending local branch ${projectId}/${pending.branchName} has no desired project`);
-    if (!project.branches.some(({ branchName }) => branchName === pending.branchName)) {
-      project.branches.push({ branchName: pending.branchName });
-      project.branches = normalizeBranchNames(project.branches, `Project ${projectId}`).map((branchName) => ({ branchName }));
-    }
-  }
-}
-function pendingCreatedBranchKey(input) {
-  return `${input.projectId}\0${input.branchName}`;
-}
-function pruneAuthoritativelyDesiredBranchDeletions(pendingDeletions, desiredProjects) {
-  const desiredKeys = new Set(
-    desiredProjects.flatMap(
-      (project) => project.branches.map(({ branchName }) => pendingCreatedBranchKey({ projectId: project.projectId, branchName }))
-    )
-  );
-  for (const [key, deletion] of pendingDeletions) {
-    if (key === pendingCreatedBranchKey(deletion) && desiredKeys.has(key)) pendingDeletions.delete(key);
-  }
-}
-function desiredProjectHasBranch(desiredProjects, pending) {
-  return Boolean(
-    desiredProjects.find(({ projectId }) => projectId === pending.projectId)?.branches.some(({ branchName }) => branchName === pending.branchName)
-  );
-}
-function mergePendingCreatedBranches(...groups) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const pending of groups.flat()) {
-    const normalized = normalizePendingCreatedBranches([pending])[0];
-    const key = pendingCreatedBranchKey(normalized);
-    const existing = byKey.get(key);
-    if (existing?.branchId && normalized.branchId && existing.branchId !== normalized.branchId) {
-      throw new Error(`Pending local branch ${normalized.projectId}/${normalized.branchName} changed durable branch id`);
-    }
-    byKey.set(key, normalized.branchId ? normalized : existing ?? normalized);
-  }
-  return [...byKey.values()].sort(
-    (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
-  );
-}
-function primaryBranch(project) {
-  if (project.branches.some(({ branchName }) => branchName === "main")) return "main";
-  if (project.branches.some(({ branchName }) => branchName === project.defaultBranch)) return project.defaultBranch;
-  return project.branches[0]?.branchName ?? null;
-}
-function branchIsCurrentlyDesired(desiredProjects, projectId, branchName) {
-  return Boolean(
-    desiredProjects.find((project) => project.projectId === projectId)?.branches.some((branch) => branch.branchName === branchName)
-  );
-}
-function tombstoneTargetIsCurrentlyDesired(desiredProjects, tombstone) {
-  const project = desiredProjects.find(
-    (candidate) => candidate.projectId === tombstone.projectId && samePathSegments(candidate.checkoutPathSegments, tombstone.checkoutPathSegments)
-  );
-  if (!project) return false;
-  return tombstone.kind === "project" || project.branches.some(({ branchName }) => branchName === tombstone.branchName);
-}
-function tombstoneManagedPath(projectsRoot, tombstone) {
-  return tombstone.kind === "branch" ? managedBranchPath(projectsRoot, tombstone.checkoutPathSegments, tombstone.branchName) : managedProjectRoot(projectsRoot, tombstone.checkoutPathSegments);
-}
-function effectiveDesiredProjects(projectsRoot, desiredProjects, tombstones) {
-  const blockedPaths = tombstones.map((tombstone) => tombstoneManagedPath(projectsRoot, tombstone));
-  return desiredProjects.flatMap((project) => {
-    const projectRoot = managedProjectRoot(projectsRoot, project.checkoutPathSegments);
-    if (blockedPaths.some((blockedPath) => blockedPath === projectRoot)) return [];
-    return [
-      {
-        ...project,
-        checkoutPathSegments: [...project.checkoutPathSegments],
-        branches: project.branches.filter(({ branchName }) => {
-          const branchPath = managedBranchPath(projectsRoot, project.checkoutPathSegments, branchName);
-          return !blockedPaths.some((blockedPath) => pathsOverlap(blockedPath, branchPath));
-        })
-      }
-    ];
-  });
-}
-function stateView(projectsRoot, state) {
-  const effectiveProjects = effectiveDesiredProjects(projectsRoot, state.desiredProjects, state.tombstones);
-  const effectiveByPath = new Map(effectiveProjects.map((project) => [project.checkoutPathSegments.join("/"), project]));
-  const pendingTreeDeletions = state.tombstones.flatMap((tombstone) => {
-    if (tombstone.treePublishedHead) return [];
-    if (tombstone.kind === "project") {
-      return [
-        {
-          tombstoneId: tombstone.id,
-          kind: "project",
-          projectId: tombstone.projectId,
-          checkoutPathSegments: [...tombstone.checkoutPathSegments],
-          branchNames: [...tombstone.branchNames],
-          managedPath: managedProjectRoot(projectsRoot, tombstone.checkoutPathSegments),
-          projectDeleted: !state.desiredProjects.some(({ projectId }) => projectId === tombstone.projectId)
-        }
-      ];
-    }
-    return [
-      {
-        tombstoneId: tombstone.id,
-        kind: "branch",
-        projectId: tombstone.projectId,
-        checkoutPathSegments: [...tombstone.checkoutPathSegments],
-        branchName: tombstone.branchName,
-        managedPath: managedBranchPath(projectsRoot, tombstone.checkoutPathSegments, tombstone.branchName),
-        primaryBranchName: primaryBranch(
-          effectiveByPath.get(tombstone.checkoutPathSegments.join("/")) ?? {
-            projectId: tombstone.projectId,
-            checkoutPathSegments: tombstone.checkoutPathSegments,
-            defaultBranch: "main",
-            branches: []
-          }
-        )
-      }
-    ];
-  });
-  const pendingMirrorRefDeletions = state.tombstones.flatMap((tombstone) => {
-    if (!tombstone.treePublishedHead || tombstone.kind === "project" || branchIsCurrentlyDesired(state.desiredProjects, tombstone.projectId, tombstone.branchName)) {
-      return [];
-    }
-    return tombstoneBranchNames(tombstone).filter((branchName) => !tombstone.mirrorRefsDeleted.includes(branchName)).map((branchName) => ({
-      tombstoneId: tombstone.id,
-      projectId: tombstone.projectId,
-      branchName,
-      checkoutPathSegments: [...tombstone.checkoutPathSegments],
-      managedPath: managedBranchPath(projectsRoot, tombstone.checkoutPathSegments, branchName),
-      primaryBranchName: primaryBranch(
-        effectiveByPath.get(tombstone.checkoutPathSegments.join("/")) ?? {
-          projectId: tombstone.projectId,
-          checkoutPathSegments: tombstone.checkoutPathSegments,
-          defaultBranch: "main",
-          branches: []
-        }
-      ),
-      treePublishedHead: tombstone.treePublishedHead
-    }));
-  });
-  return {
-    desiredProjects: cloneDesiredProjects(state.desiredProjects),
-    effectiveDesiredProjects: effectiveProjects,
-    locallyPendingCreatedBranches: state.locallyPendingCreatedBranches.map((pending) => ({ ...pending })),
-    enabledRepositoryTransitions: state.enabledRepositoryTransitions.map((transition) => ({ ...transition })),
-    tombstones: cloneTombstones(state.tombstones),
-    pendingTreeDeletions,
-    pendingMirrorRefDeletions
-  };
-}
-function isRealDirectory(candidate) {
-  try {
-    return fs.lstatSync(candidate).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function directoryEntries(directory) {
-  if (!isRealDirectory(directory)) return null;
-  try {
-    return fs.readdirSync(directory, { withFileTypes: true });
-  } catch {
-    return null;
-  }
-}
-function canonicalEncodedBranchName(entryName) {
-  try {
-    const branchName = decodeURIComponent(entryName);
-    validateManagedBranchName(branchName);
-    return encodeURIComponent(branchName) === entryName ? branchName : null;
-  } catch {
-    return null;
-  }
-}
-function validOuterProjectId(entryName) {
-  try {
-    return validateProjectId(entryName);
-  } catch {
-    return null;
-  }
-}
-function discoveredOuterProject(projects, projectId) {
-  const existing = projects.get(projectId);
-  if (existing) return existing;
-  const created = {
-    projectId,
-    projectTreePath: null,
-    projectTreeRootIsWhollyManaged: false,
-    planTreePath: null,
-    planTreeRootIsWhollyManaged: false,
-    branches: /* @__PURE__ */ new Map()
-  };
-  projects.set(projectId, created);
-  return created;
-}
-function discoveredOuterBranch(project, branchName) {
-  const existing = project.branches.get(branchName);
-  if (existing) return existing;
-  const created = { branchName, projectTreePath: null, planTreePath: null };
-  project.branches.set(branchName, created);
-  return created;
-}
-function discoverStaleOuterProjectWorkspaceEntries(input) {
-  const workspaceShadowRoot = path.resolve(input.workspaceShadowRoot);
-  const desiredProjects = normalizeDesiredProjects(input.desiredProjects);
-  applyPendingCreatedBranches(desiredProjects, input.locallyPendingCreatedBranches ?? []);
-  const desiredProjectIds = new Set(desiredProjects.map(({ projectId }) => projectId));
-  const desiredBranchKeys = new Set(
-    desiredProjects.flatMap((project) => project.branches.map(({ branchName }) => `${project.projectId}\0${branchName}`))
-  );
-  const discovered = /* @__PURE__ */ new Map();
-  const projectsContainer = path.join(workspaceShadowRoot, "projects");
-  for (const projectEntry of directoryEntries(projectsContainer) ?? []) {
-    const projectId = validOuterProjectId(projectEntry.name);
-    const projectTreePath = path.join(projectsContainer, projectEntry.name);
-    if (!projectId || !projectEntry.isDirectory() || !isRealDirectory(projectTreePath)) continue;
-    const project = discoveredOuterProject(discovered, projectId);
-    project.projectTreePath = projectTreePath;
-    const projectEntries = directoryEntries(projectTreePath);
-    const branchesPath = path.join(projectTreePath, "branches");
-    const branchEntries = directoryEntries(branchesPath);
-    project.projectTreeRootIsWhollyManaged = Boolean(
-      projectEntries && projectEntries.every((entry) => entry.name === "branches" && entry.isDirectory()) && branchEntries
-    );
-    if (!branchEntries) continue;
-    for (const branchEntry of branchEntries) {
-      const branchName = canonicalEncodedBranchName(branchEntry.name);
-      const branchTreePath = path.join(branchesPath, branchEntry.name);
-      if (!branchName || !branchEntry.isDirectory() || !isRealDirectory(branchTreePath)) {
-        project.projectTreeRootIsWhollyManaged = false;
-        continue;
-      }
-      discoveredOuterBranch(project, branchName).projectTreePath = branchTreePath;
-    }
-  }
-  const plansContainer = path.join(workspaceShadowRoot, "plans");
-  for (const projectEntry of directoryEntries(plansContainer) ?? []) {
-    const projectId = validOuterProjectId(projectEntry.name);
-    const planTreePath = path.join(plansContainer, projectEntry.name);
-    if (!projectId || !projectEntry.isDirectory() || !isRealDirectory(planTreePath)) continue;
-    const project = discoveredOuterProject(discovered, projectId);
-    project.planTreePath = planTreePath;
-    const planEntries = directoryEntries(planTreePath);
-    project.planTreeRootIsWhollyManaged = Boolean(planEntries);
-    if (!planEntries) continue;
-    const desiredBranchNames = desiredProjects.find((desiredProject) => desiredProject.projectId === projectId)?.branches.map(({ branchName }) => branchName) ?? [];
-    for (const planEntry of planEntries) {
-      const branchPlanPath = path.join(planTreePath, planEntry.name);
-      const containsDesiredLegacyNestedPlan = desiredBranchNames.some((desiredBranchName) => {
-        const segments = desiredBranchName.split("/");
-        return segments.length > 1 && segments[0] === planEntry.name && isRealDirectory(path.join(planTreePath, ...segments));
-      });
-      if (containsDesiredLegacyNestedPlan) continue;
-      const branchName = canonicalEncodedBranchName(planEntry.name);
-      if (!branchName || !planEntry.isDirectory() || !isRealDirectory(branchPlanPath)) {
-        project.planTreeRootIsWhollyManaged = false;
-        continue;
-      }
-      discoveredOuterBranch(project, branchName).planTreePath = branchPlanPath;
-    }
-  }
-  const stale = [];
-  for (const project of [...discovered.values()].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
-    const branches = [...project.branches.values()].sort((left, right) => left.branchName.localeCompare(right.branchName));
-    if (!desiredProjectIds.has(project.projectId)) {
-      const projectTreePath = project.projectTreeRootIsWhollyManaged ? project.projectTreePath : null;
-      const planTreePath = project.planTreeRootIsWhollyManaged ? project.planTreePath : null;
-      const individuallySafeBranches = branches.map((branch) => ({
-        branchName: branch.branchName,
-        projectTreePath: projectTreePath ? null : branch.projectTreePath,
-        planTreePath: planTreePath ? null : branch.planTreePath
-      }));
-      if (projectTreePath || planTreePath || individuallySafeBranches.some((branch) => branch.projectTreePath || branch.planTreePath)) {
-        stale.push({
-          kind: "project",
-          projectId: project.projectId,
-          projectTreePath,
-          planTreePath,
-          branches: individuallySafeBranches
-        });
-      }
-      continue;
-    }
-    for (const branch of branches) {
-      if (desiredBranchKeys.has(`${project.projectId}\0${branch.branchName}`)) continue;
-      stale.push({
-        kind: "branch",
-        projectId: project.projectId,
-        branchName: branch.branchName,
-        projectTreePath: branch.projectTreePath,
-        planTreePath: branch.planTreePath
-      });
-    }
-  }
-  return stale;
-}
-class ProjectWorkspaceStateStore {
-  stateRoot;
-  projectsRoot;
-  statePath;
-  constructor(input) {
-    this.stateRoot = path.resolve(input.stateRoot);
-    this.projectsRoot = path.resolve(input.projectsRoot);
-    this.statePath = path.join(this.stateRoot, PROJECT_WORKSPACE_STATE_FILE);
-  }
-  read() {
-    return stateView(this.projectsRoot, readState(this.statePath));
-  }
-  discoverStaleOuterEntries(workspaceShadowRoot) {
-    const state = readState(this.statePath);
-    return discoverStaleOuterProjectWorkspaceEntries({
-      workspaceShadowRoot,
-      desiredProjects: state.desiredProjects,
-      locallyPendingCreatedBranches: state.locallyPendingCreatedBranches
-    });
-  }
-  async reconcile(input) {
-    const previous = readState(this.statePath);
-    const authoritativeDesiredProjects = normalizeDesiredProjects(input.desiredProjects);
-    for (const project of authoritativeDesiredProjects) {
-      const occupyingProjectId = previous.desiredProjects.find(
-        (candidate) => candidate.projectId !== project.projectId && samePathSegments(candidate.checkoutPathSegments, project.checkoutPathSegments)
-      )?.projectId ?? previous.tombstones.find(
-        (candidate) => candidate.projectId !== project.projectId && samePathSegments(candidate.checkoutPathSegments, project.checkoutPathSegments)
-      )?.projectId;
-      if (occupyingProjectId) {
-        throw new ProjectWorkspaceCheckoutPathCollisionError({
-          projectId: project.projectId,
-          occupyingProjectId,
-          checkoutPathSegments: project.checkoutPathSegments
-        });
-      }
-    }
-    const authoritativeProjectIds = new Set(authoritativeDesiredProjects.map(({ projectId }) => projectId));
-    const preserveOnlyBranches = normalizePreserveOnlyBranches(input.preserveOnlyBranches ?? []);
-    for (const preserved of preserveOnlyBranches) {
-      const project = authoritativeDesiredProjects.find(({ projectId }) => projectId === preserved.projectId);
-      if (!project) {
-        throw new Error(`Preserve-only branch ${preserved.projectId}/${preserved.branchName} has no desired project`);
-      }
-      if (project.branches.some(({ branchName }) => branchName === preserved.branchName)) {
-        throw new Error(`Preserve-only branch ${preserved.projectId}/${preserved.branchName} is already active`);
-      }
-    }
-    const locallyPendingCreatedBranches = mergePendingCreatedBranches(
-      previous.locallyPendingCreatedBranches,
-      input.locallyPendingCreatedBranches ?? []
-    ).filter(
-      (pending) => authoritativeProjectIds.has(pending.projectId) && !desiredProjectHasBranch(authoritativeDesiredProjects, pending)
-    );
-    for (const pending of locallyPendingCreatedBranches) {
-      const currentProject = previous.desiredProjects.find(({ projectId }) => projectId === pending.projectId);
-      const incomingProject = authoritativeDesiredProjects.find(({ projectId }) => projectId === pending.projectId);
-      if (currentProject && incomingProject && !samePathSegments(currentProject.checkoutPathSegments, incomingProject.checkoutPathSegments)) {
-        throw new ProjectWorkspacePendingBranchPathChangeError({
-          projectId: pending.projectId,
-          branchName: pending.branchName,
-          currentCheckoutPathSegments: currentProject.checkoutPathSegments,
-          incomingCheckoutPathSegments: incomingProject.checkoutPathSegments
-        });
-      }
-    }
-    const desiredProjects = cloneDesiredProjects(authoritativeDesiredProjects);
-    applyPendingCreatedBranches(desiredProjects, preserveOnlyBranches);
-    applyPendingCreatedBranches(desiredProjects, locallyPendingCreatedBranches);
-    const desiredById = new Map(desiredProjects.map((project) => [project.projectId, project]));
-    const tombstones = cloneTombstones(previous.tombstones);
-    for (const previousProject of previous.desiredProjects) {
-      const desiredProject = desiredById.get(previousProject.projectId);
-      if (!desiredProject || !samePathSegments(previousProject.checkoutPathSegments, desiredProject.checkoutPathSegments)) {
-        addProjectTombstone(tombstones, previousProject);
-        continue;
-      }
-      const desiredBranchNames = new Set(desiredProject.branches.map(({ branchName }) => branchName));
-      for (const { branchName } of previousProject.branches) {
-        if (!desiredBranchNames.has(branchName)) addBranchTombstone(tombstones, previousProject, branchName);
-      }
-    }
-    tombstones.splice(
-      0,
-      tombstones.length,
-      ...tombstones.filter(
-        (tombstone) => !tombstoneTargetIsCurrentlyDesired(desiredProjects, tombstone) && (!tombstone.treePublishedHead || tombstone.kind === "branch" && !branchIsCurrentlyDesired(desiredProjects, tombstone.projectId, tombstone.branchName))
-      )
-    );
-    const nextState = normalizeState({
-      version: PROJECT_WORKSPACE_STATE_VERSION,
-      desiredProjects,
-      locallyPendingCreatedBranches,
-      enabledRepositoryTransitions: previous.enabledRepositoryTransitions.filter(({ projectId }) => authoritativeProjectIds.has(projectId)),
-      tombstones
-    });
-    await writeStateAtomically(this.stateRoot, this.statePath, nextState);
-    return stateView(this.projectsRoot, nextState);
-  }
-  /** Record a successful enabled reseed without letting disabled config consume it. */
-  async recordEnabledRepositoryTransition(input) {
-    const [transition] = normalizeEnabledRepositoryTransitions([input]);
-    const state = readState(this.statePath);
-    if (!state.desiredProjects.some(({ projectId }) => projectId === transition.projectId)) {
-      throw new Error(`Cannot record an enabled repository transition for missing project ${transition.projectId}`);
-    }
-    state.enabledRepositoryTransitions = state.enabledRepositoryTransitions.filter(({ projectId }) => projectId !== transition.projectId);
-    state.enabledRepositoryTransitions.push(transition);
-    state.enabledRepositoryTransitions.sort((left, right) => left.projectId.localeCompare(right.projectId));
-    await writeStateAtomically(this.stateRoot, this.statePath, state);
-    return stateView(this.projectsRoot, state);
-  }
-  /** Persist the create intent before invoking Git so a crash cannot orphan an untracked worktree. */
-  async recordPendingCreatedBranch(input) {
-    const [pending] = normalizePendingCreatedBranches([input]);
-    const state = readState(this.statePath);
-    const existingPending = state.locallyPendingCreatedBranches.find(
-      (candidate) => pendingCreatedBranchKey(candidate) === pendingCreatedBranchKey(pending)
-    );
-    if (existingPending) {
-      if (existingPending.branchId !== pending.branchId) {
-        throw new Error(`Pending project branch ${pending.branchName} belongs to another durable branch incarnation`);
-      }
-      return stateView(this.projectsRoot, state);
-    }
-    const project = state.desiredProjects.find(({ projectId }) => projectId === pending.projectId);
-    if (!project) throw new Error(`Cannot record pending branch ${pending.projectId}/${pending.branchName} without a desired project`);
-    if (project.branches.some(({ branchName }) => branchName === pending.branchName)) {
-      throw new Error(`Cannot record pending branch ${pending.projectId}/${pending.branchName}: branch is already desired`);
-    }
-    project.branches.push({ branchName: pending.branchName });
-    project.branches = normalizeBranchNames(project.branches, `Project ${project.projectId}`).map((branchName) => ({ branchName }));
-    state.locallyPendingCreatedBranches.push(pending);
-    state.locallyPendingCreatedBranches.sort(
-      (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
-    );
-    await writeStateAtomically(this.stateRoot, this.statePath, state);
-    return stateView(this.projectsRoot, state);
-  }
-  /** Roll back an intent only when Git failed before creating its branch. */
-  async rollbackPendingCreatedBranch(input) {
-    const [pending] = normalizePendingCreatedBranches([input]);
-    const state = readState(this.statePath);
-    const key = pendingCreatedBranchKey(pending);
-    const existing = state.locallyPendingCreatedBranches.find((candidate) => pendingCreatedBranchKey(candidate) === key);
-    if (!existing || pending.branchId && existing.branchId !== pending.branchId) {
-      return stateView(this.projectsRoot, state);
-    }
-    state.locallyPendingCreatedBranches = state.locallyPendingCreatedBranches.filter(
-      (candidate) => pendingCreatedBranchKey(candidate) !== key
-    );
-    const project = state.desiredProjects.find(({ projectId }) => projectId === pending.projectId);
-    if (project) project.branches = project.branches.filter(({ branchName }) => branchName !== pending.branchName);
-    await writeStateAtomically(this.stateRoot, this.statePath, state);
-    return stateView(this.projectsRoot, state);
-  }
-  /** Clear a create intent after an authoritative desired config contains it. */
-  async clearPendingCreatedBranch(input) {
-    const [pending] = normalizePendingCreatedBranches([input]);
-    const state = readState(this.statePath);
-    const key = pendingCreatedBranchKey(pending);
-    if (!state.locallyPendingCreatedBranches.some((candidate) => pendingCreatedBranchKey(candidate) === key)) {
-      return stateView(this.projectsRoot, state);
-    }
-    state.locallyPendingCreatedBranches = state.locallyPendingCreatedBranches.filter(
-      (candidate) => pendingCreatedBranchKey(candidate) !== key
-    );
-    await writeStateAtomically(this.stateRoot, this.statePath, state);
-    return stateView(this.projectsRoot, state);
-  }
-  /** Persist a branch tombstone before mutating its linked worktree or local ref. */
-  async beginBranchDeletion(input) {
-    const [target] = normalizePendingCreatedBranches([input]);
-    const state = readState(this.statePath);
-    const project = state.desiredProjects.find(({ projectId }) => projectId === target.projectId);
-    if (!project)
-      throw new Error(`Cannot begin branch deletion for ${target.projectId}/${target.branchName}: desired project is missing`);
-    const existingTombstone = state.tombstones.find(
-      (tombstone) => tombstone.kind === "branch" && tombstone.projectId === target.projectId && samePathSegments(tombstone.checkoutPathSegments, project.checkoutPathSegments) && tombstone.branchName === target.branchName
-    );
-    if (existingTombstone) return stateView(this.projectsRoot, state);
-    addBranchTombstone(state.tombstones, project, target.branchName);
-    project.branches = project.branches.filter(({ branchName }) => branchName !== target.branchName);
-    const key = pendingCreatedBranchKey(target);
-    state.locallyPendingCreatedBranches = state.locallyPendingCreatedBranches.filter(
-      (candidate) => pendingCreatedBranchKey(candidate) !== key
-    );
-    await writeStateAtomically(this.stateRoot, this.statePath, state);
-    return stateView(this.projectsRoot, state);
-  }
-  async recordTreePublication(input) {
-    if (!GIT_OBJECT_ID_PATTERN.test(input.publishedHead)) throw new Error("Invalid published workspace head");
-    const state = readState(this.statePath);
-    const ids = new Set(input.tombstoneIds);
-    let changed = false;
-    for (const tombstone of state.tombstones) {
-      if (!ids.has(tombstone.id) || tombstone.treePublishedHead) continue;
-      tombstone.treePublishedHead = input.publishedHead;
-      changed = true;
-    }
-    state.tombstones = state.tombstones.filter(
-      (tombstone) => !tombstone.treePublishedHead || tombstone.kind === "branch" && !branchIsCurrentlyDesired(state.desiredProjects, tombstone.projectId, tombstone.branchName)
-    );
-    if (changed) await writeStateAtomically(this.stateRoot, this.statePath, state);
-    return stateView(this.projectsRoot, state);
-  }
-  async recordMirrorRefDeletion(input) {
-    validateManagedBranchName(input.branchName);
-    const state = readState(this.statePath);
-    const tombstone = state.tombstones.find(({ id }) => id === input.tombstoneId);
-    if (!tombstone) return stateView(this.projectsRoot, state);
-    const branchNames = tombstoneBranchNames(tombstone);
-    if (!branchNames.includes(input.branchName)) {
-      throw new Error(`Branch ${input.branchName} does not belong to deletion ${input.tombstoneId}`);
-    }
-    if (!tombstone.treePublishedHead) {
-      throw new Error(`Cannot record mirror deletion before workspace tree publication for ${input.tombstoneId}`);
-    }
-    if (!tombstone.mirrorRefsDeleted.includes(input.branchName)) {
-      tombstone.mirrorRefsDeleted.push(input.branchName);
-      tombstone.mirrorRefsDeleted.sort();
-    }
-    if (branchNames.every((branchName) => tombstone.mirrorRefsDeleted.includes(branchName))) {
-      state.tombstones = state.tombstones.filter(({ id }) => id !== tombstone.id);
-    }
-    await writeStateAtomically(this.stateRoot, this.statePath, state);
-    return stateView(this.projectsRoot, state);
-  }
-}
-const projectWorkspaceStateTestHarness = {
-  writeEmptyStateAtDurableRootBoundary(stateRoot, afterStateRootFsync) {
-    return writeStateAtomically(stateRoot, path.join(stateRoot, PROJECT_WORKSPACE_STATE_FILE), EMPTY_STATE, afterStateRootFsync);
-  }
-};
-export {
-  PROJECT_WORKSPACE_STATE_FILE,
-  ProjectWorkspaceCheckoutPathCollisionError,
-  ProjectWorkspacePendingBranchPathChangeError,
-  ProjectWorkspaceStateStore,
-  discoverStaleOuterProjectWorkspaceEntries,
-  projectWorkspaceStateTestHarness,
-  pruneAuthoritativelyDesiredBranchDeletions
-};