@ricsam/r5d-worker 0.0.74 → 0.0.76

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

@@ -0,0 +1,777 @@
+"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_workspace_state_exports = {};
+__export(project_workspace_state_exports, {
+  PROJECT_WORKSPACE_STATE_FILE: () => PROJECT_WORKSPACE_STATE_FILE,
+  ProjectWorkspaceStateStore: () => ProjectWorkspaceStateStore,
+  discoverStaleOuterProjectWorkspaceEntries: () => discoverStaleOuterProjectWorkspaceEntries,
+  pruneAuthoritativelyDesiredBranchDeletions: () => pruneAuthoritativelyDesiredBranchDeletions
+});
+module.exports = __toCommonJS(project_workspace_state_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_managed_paths = require("./managed-paths.cjs");
+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})$/;
+const EMPTY_STATE = {
+  version: PROJECT_WORKSPACE_STATE_VERSION,
+  desiredProjects: [],
+  locallyPendingCreatedBranches: [],
+  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 = import_node_path.default.relative(import_node_path.default.resolve(left), import_node_path.default.resolve(right));
+  const reverse = import_node_path.default.relative(import_node_path.default.resolve(right), import_node_path.default.resolve(left));
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(relative) || reverse !== ".." && !reverse.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(reverse);
+}
+function normalizeBranchNames(branches, label) {
+  const branchNames = branches.map(({ branchName }) => {
+    (0, import_managed_paths.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 = (0, import_managed_paths.validateCheckoutPathSegments)(project.checkoutPathSegments);
+    (0, import_managed_paths.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);
+    (0, import_managed_paths.validateManagedBranchName)(entry.branchName);
+    return { 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 tombstoneBranchNames(tombstone) {
+  return tombstone.kind === "branch" ? [tombstone.branchName] : tombstone.branchNames;
+}
+function deletionId(input) {
+  const digest = (0, import_node_crypto.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 = (0, import_managed_paths.validateCheckoutPathSegments)(value.checkoutPathSegments);
+  if (value.kind === "branch") {
+    if (typeof value.branchName !== "string") throw new Error("Invalid project workspace branch deletion tombstone");
+    (0, import_managed_paths.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 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,
+    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(import_node_fs.default.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 = import_node_fs.default.openSync(directory, "r");
+    import_node_fs.default.fsyncSync(descriptor);
+  } finally {
+    if (descriptor !== void 0) import_node_fs.default.closeSync(descriptor);
+  }
+}
+function writeStateAtomically(stateRoot, statePath, state) {
+  import_node_fs.default.mkdirSync(stateRoot, { recursive: true, mode: 448 });
+  const temporaryPath = import_node_path.default.join(stateRoot, `.${PROJECT_WORKSPACE_STATE_FILE}.${process.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`);
+  let descriptor;
+  try {
+    descriptor = import_node_fs.default.openSync(temporaryPath, "wx", 384);
+    import_node_fs.default.writeFileSync(descriptor, `${JSON.stringify(normalizeState(state), null, 2)}
+`, "utf8");
+    import_node_fs.default.fsyncSync(descriptor);
+    import_node_fs.default.closeSync(descriptor);
+    descriptor = void 0;
+    import_node_fs.default.renameSync(temporaryPath, statePath);
+    fsyncDirectory(stateRoot);
+  } finally {
+    if (descriptor !== void 0) import_node_fs.default.closeSync(descriptor);
+    import_node_fs.default.rmSync(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);
+    (0, import_managed_paths.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];
+    byKey.set(pendingCreatedBranchKey(normalized), 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" ? (0, import_managed_paths.managedBranchPath)(projectsRoot, tombstone.checkoutPathSegments, tombstone.branchName) : (0, import_managed_paths.managedProjectRoot)(projectsRoot, tombstone.checkoutPathSegments);
+}
+function effectiveDesiredProjects(projectsRoot, desiredProjects, tombstones) {
+  const blockedPaths = tombstones.map((tombstone) => tombstoneManagedPath(projectsRoot, tombstone));
+  return desiredProjects.flatMap((project) => {
+    const projectRoot = (0, import_managed_paths.managedProjectRoot)(projectsRoot, project.checkoutPathSegments);
+    if (blockedPaths.some((blockedPath) => blockedPath === projectRoot)) return [];
+    return [
+      {
+        ...project,
+        checkoutPathSegments: [...project.checkoutPathSegments],
+        branches: project.branches.filter(({ branchName }) => {
+          const branchPath = (0, import_managed_paths.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: (0, import_managed_paths.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: (0, import_managed_paths.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: (0, import_managed_paths.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 })),
+    tombstones: cloneTombstones(state.tombstones),
+    pendingTreeDeletions,
+    pendingMirrorRefDeletions
+  };
+}
+function isRealDirectory(candidate) {
+  try {
+    return import_node_fs.default.lstatSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function directoryEntries(directory) {
+  if (!isRealDirectory(directory)) return null;
+  try {
+    return import_node_fs.default.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+function canonicalEncodedBranchName(entryName) {
+  try {
+    const branchName = decodeURIComponent(entryName);
+    (0, import_managed_paths.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 = import_node_path.default.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 = import_node_path.default.join(workspaceShadowRoot, "projects");
+  for (const projectEntry of directoryEntries(projectsContainer) ?? []) {
+    const projectId = validOuterProjectId(projectEntry.name);
+    const projectTreePath = import_node_path.default.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 = import_node_path.default.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 = import_node_path.default.join(branchesPath, branchEntry.name);
+      if (!branchName || !branchEntry.isDirectory() || !isRealDirectory(branchTreePath)) {
+        project.projectTreeRootIsWhollyManaged = false;
+        continue;
+      }
+      discoveredOuterBranch(project, branchName).projectTreePath = branchTreePath;
+    }
+  }
+  const plansContainer = import_node_path.default.join(workspaceShadowRoot, "plans");
+  for (const projectEntry of directoryEntries(plansContainer) ?? []) {
+    const projectId = validOuterProjectId(projectEntry.name);
+    const planTreePath = import_node_path.default.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 = import_node_path.default.join(planTreePath, planEntry.name);
+      const containsDesiredLegacyNestedPlan = desiredBranchNames.some((desiredBranchName) => {
+        const segments = desiredBranchName.split("/");
+        return segments.length > 1 && segments[0] === planEntry.name && isRealDirectory(import_node_path.default.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 = import_node_path.default.resolve(input.stateRoot);
+    this.projectsRoot = import_node_path.default.resolve(input.projectsRoot);
+    this.statePath = import_node_path.default.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
+    });
+  }
+  reconcile(input) {
+    const previous = readState(this.statePath);
+    const authoritativeDesiredProjects = normalizeDesiredProjects(input.desiredProjects);
+    const authoritativeProjectIds = new Set(authoritativeDesiredProjects.map(({ projectId }) => projectId));
+    const locallyPendingCreatedBranches = mergePendingCreatedBranches(
+      previous.locallyPendingCreatedBranches,
+      input.locallyPendingCreatedBranches ?? []
+    ).filter(
+      (pending) => authoritativeProjectIds.has(pending.projectId) && !desiredProjectHasBranch(authoritativeDesiredProjects, pending)
+    );
+    const desiredProjects = cloneDesiredProjects(authoritativeDesiredProjects);
+    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,
+      tombstones
+    });
+    writeStateAtomically(this.stateRoot, this.statePath, nextState);
+    return stateView(this.projectsRoot, nextState);
+  }
+  /** Persist the create intent before invoking Git so a crash cannot orphan an untracked worktree. */
+  recordPendingCreatedBranch(input) {
+    const [pending] = normalizePendingCreatedBranches([input]);
+    const state = readState(this.statePath);
+    if (state.locallyPendingCreatedBranches.some((candidate) => pendingCreatedBranchKey(candidate) === pendingCreatedBranchKey(pending))) {
+      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)
+    );
+    writeStateAtomically(this.stateRoot, this.statePath, state);
+    return stateView(this.projectsRoot, state);
+  }
+  /** Clear a create intent after an authoritative desired config contains it. */
+  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
+    );
+    writeStateAtomically(this.stateRoot, this.statePath, state);
+    return stateView(this.projectsRoot, state);
+  }
+  /** Persist a branch tombstone before mutating its linked worktree or local ref. */
+  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
+    );
+    writeStateAtomically(this.stateRoot, this.statePath, state);
+    return stateView(this.projectsRoot, state);
+  }
+  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) writeStateAtomically(this.stateRoot, this.statePath, state);
+    return stateView(this.projectsRoot, state);
+  }
+  recordMirrorRefDeletion(input) {
+    (0, import_managed_paths.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);
+    }
+    writeStateAtomically(this.stateRoot, this.statePath, state);
+    return stateView(this.projectsRoot, state);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROJECT_WORKSPACE_STATE_FILE,
+  ProjectWorkspaceStateStore,
+  discoverStaleOuterProjectWorkspaceEntries,
+  pruneAuthoritativelyDesiredBranchDeletions
+});