@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/mjs/workspace-merge-projection.mjs

@@ -1,433 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { workerGitProcessEnvironment } from "./git-process-environment.mjs";
-import {
-  inspectWorkingTree,
-  projectedFileEntry
-} from "./working-tree-mirror.mjs";
-import { assertManagedDirectoryPath } from "./workspace-mount-boundary.mjs";
-const MINIMUM_MERGE_TREE_GIT_VERSION = { major: 2, minor: 40 };
-const NON_RECURSIVE_GIT_CONFIG = [
-  "-c",
-  "submodule.recurse=false",
-  "-c",
-  "fetch.recurseSubmodules=false",
-  "-c",
-  "push.recurseSubmodules=false"
-];
-let cachedWorkspaceMergeProjectionSupport = null;
-function gitCommandArgs(args) {
-  return ["git", ...NON_RECURSIVE_GIT_CONFIG, ...args];
-}
-function gitResult(cwd, args, options = {}) {
-  const result = Bun.spawnSync(gitCommandArgs(args), {
-    cwd,
-    ...options.stdin !== void 0 ? { stdin: options.stdin } : {},
-    stdout: "pipe",
-    stderr: "pipe",
-    env: options.environment ?? workerGitProcessEnvironment()
-  });
-  return { exitCode: result.exitCode, stdout: Buffer.from(result.stdout), stderr: Buffer.from(result.stderr) };
-}
-function git(cwd, args, action, options = {}) {
-  const result = gitResult(cwd, args, options);
-  if (result.exitCode !== 0) {
-    const detail = result.stderr.toString().trim() || result.stdout.toString().trim() || `git exited ${result.exitCode}`;
-    throw new Error(`${action}: ${detail}`);
-  }
-  return result.stdout;
-}
-function gitText(cwd, args, action, options = {}) {
-  return git(cwd, args, action, options).toString().trim();
-}
-function gitVersionIsSupported(version) {
-  const match = /(?:^|\s)(\d+)\.(\d+)(?:\.\d+)?(?:\s|$)/u.exec(version);
-  if (!match) return false;
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  return major > MINIMUM_MERGE_TREE_GIT_VERSION.major || major === MINIMUM_MERGE_TREE_GIT_VERSION.major && minor >= MINIMUM_MERGE_TREE_GIT_VERSION.minor;
-}
-function workspaceMergeProjectionSupport() {
-  if (cachedWorkspaceMergeProjectionSupport) return cachedWorkspaceMergeProjectionSupport;
-  if (process.env.R5D_WORKSPACE_MERGE_PROJECTION === "0") {
-    cachedWorkspaceMergeProjectionSupport = {
-      supported: false,
-      error: "Workspace merge projection is disabled by R5D_WORKSPACE_MERGE_PROJECTION=0; stale mounts will remain pinned until it is enabled"
-    };
-    return cachedWorkspaceMergeProjectionSupport;
-  }
-  const version = gitResult(void 0, ["--version"]);
-  const versionText = version.stdout.toString().trim();
-  if (version.exitCode !== 0 || !gitVersionIsSupported(versionText)) {
-    const observed = versionText || version.stderr.toString().trim() || `git exited ${version.exitCode}`;
-    cachedWorkspaceMergeProjectionSupport = {
-      supported: false,
-      error: `Workspace merge projection requires Git 2.40 or newer (found ${observed}); upgrade Git before synchronizing stale mounts`
-    };
-    return cachedWorkspaceMergeProjectionSupport;
-  }
-  cachedWorkspaceMergeProjectionSupport = { supported: true };
-  return cachedWorkspaceMergeProjectionSupport;
-}
-function normalizeWorkspaceRelativePath(value) {
-  const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
-  if (!normalized || normalized === "." || normalized.includes("\0") || normalized.split("/").some((segment) => segment === ".." || segment === ".git")) {
-    throw new Error(`Invalid workspace merge-projection path: ${value}`);
-  }
-  return normalized;
-}
-function requireObjectId(value, label) {
-  if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(value)) throw new Error(`${label} is not a Git object id: ${value}`);
-  return value;
-}
-function requireCommit(workspacePath, revision, label) {
-  const head = gitText(workspacePath, ["rev-parse", "--verify", `${revision}^{commit}`], `resolve ${label}`);
-  return requireObjectId(head, label);
-}
-function workspacePrivateStateDirectory(workspacePath) {
-  const gitDirectory = path.join(workspacePath, ".git");
-  const gitStatus = fs.lstatSync(gitDirectory);
-  if (!gitStatus.isDirectory() || gitStatus.isSymbolicLink()) {
-    throw new Error(`Workspace Git directory is not a regular directory: ${gitDirectory}`);
-  }
-  const stateDirectory = path.join(gitDirectory, "r5d");
-  let stateStatus = null;
-  try {
-    stateStatus = fs.lstatSync(stateDirectory);
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-  if (!stateStatus) fs.mkdirSync(stateDirectory, { mode: 448 });
-  else if (!stateStatus.isDirectory() || stateStatus.isSymbolicLink()) {
-    throw new Error(`Workspace Git private state is not a regular directory: ${stateDirectory}`);
-  }
-  return stateDirectory;
-}
-function temporaryIndexPath(workspacePath) {
-  return path.join(workspacePrivateStateDirectory(workspacePath), `tmp-index-${crypto.randomUUID()}`);
-}
-function temporaryIndexEnvironment(indexPath) {
-  return { ...workerGitProcessEnvironment(), GIT_INDEX_FILE: indexPath };
-}
-function removeTemporaryIndex(indexPath) {
-  fs.rmSync(indexPath, { force: true });
-  fs.rmSync(`${indexPath}.lock`, { force: true });
-}
-function sourceEntryPath(sourceRoot, relativePath) {
-  const candidate = path.resolve(sourceRoot, ...relativePath.split("/"));
-  const relative = path.relative(sourceRoot, candidate);
-  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-    throw new Error(`Workspace merge-projection source escapes its root: ${relativePath}`);
-  }
-  return candidate;
-}
-function assertSameOpenFile(before, after, sourcePath) {
-  if (!after.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mode !== after.mode || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
-    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
-  }
-}
-function hashRegularFile(workspacePath, sourcePath, entry) {
-  const descriptor = fs.openSync(sourcePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-  try {
-    const before = fs.fstatSync(descriptor);
-    if (!before.isFile() || before.size !== entry.size || (before.mode & 511) !== (entry.mode & 511)) {
-      throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
-    }
-    const objectId = requireObjectId(
-      gitText(workspacePath, ["hash-object", "-w", "--stdin"], `hash workspace projection file ${sourcePath}`, {
-        stdin: descriptor
-      }),
-      `Workspace projection blob for ${sourcePath}`
-    );
-    const after = fs.fstatSync(descriptor);
-    assertSameOpenFile(before, after, sourcePath);
-    const pathStatus = fs.lstatSync(sourcePath);
-    if (pathStatus.dev !== after.dev || pathStatus.ino !== after.ino || !pathStatus.isFile() || pathStatus.isSymbolicLink()) {
-      throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
-    }
-    return { objectId, projected: projectedFileEntry(after) };
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function hashSymlink(workspacePath, sourcePath, entry) {
-  const status = fs.lstatSync(sourcePath);
-  if (!status.isSymbolicLink() || fs.readlinkSync(sourcePath) !== entry.target) {
-    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
-  }
-  const objectId = requireObjectId(
-    gitText(workspacePath, ["hash-object", "-w", "--stdin"], `hash workspace projection symlink ${sourcePath}`, {
-      stdin: Buffer.from(entry.target)
-    }),
-    `Workspace projection symlink blob for ${sourcePath}`
-  );
-  if (!fs.lstatSync(sourcePath).isSymbolicLink() || fs.readlinkSync(sourcePath) !== entry.target) {
-    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
-  }
-  return objectId;
-}
-function indexMode(entry) {
-  if (entry.kind === "symlink") return "120000";
-  return (entry.mode & 73) !== 0 ? "100755" : "100644";
-}
-function indexInfoRecord(mode, objectId, relativePath) {
-  return Buffer.concat([Buffer.from(`${mode} ${objectId}	`), Buffer.from(relativePath), Buffer.from([0])]);
-}
-function synthesizeMountTree(input) {
-  const sourceRoot = path.resolve(input.sourcePath);
-  const entries = inspectWorkingTree(sourceRoot, input.sourceMode);
-  const indexPath = temporaryIndexPath(input.workspacePath);
-  const environment = temporaryIndexEnvironment(indexPath);
-  const projectedFiles = {};
-  const blobs = /* @__PURE__ */ new Map();
-  try {
-    git(input.workspacePath, ["read-tree", "--empty"], "initialize workspace projection index", { environment });
-    const records = [];
-    for (const [relativePath, entry] of [...entries.entries()].sort(([left], [right]) => left.localeCompare(right))) {
-      if (entry.kind === "directory") continue;
-      if (entry.kind === "gitlink") {
-        records.push(indexInfoRecord("160000", entry.objectId, relativePath));
-        projectedFiles[relativePath] = { kind: "gitlink", objectId: entry.objectId };
-        continue;
-      }
-      const sourcePath = sourceEntryPath(sourceRoot, relativePath);
-      let objectId;
-      if (entry.kind === "file") {
-        const hashed = hashRegularFile(input.workspacePath, sourcePath, entry);
-        objectId = hashed.objectId;
-        projectedFiles[relativePath] = hashed.projected;
-      } else {
-        objectId = hashSymlink(input.workspacePath, sourcePath, entry);
-        projectedFiles[relativePath] = { kind: "symlink", target: entry.target };
-      }
-      blobs.set(relativePath, objectId);
-      records.push(indexInfoRecord(indexMode(entry), objectId, relativePath));
-    }
-    if (records.length > 0) {
-      git(input.workspacePath, ["update-index", "-z", "--index-info"], "populate workspace projection index", {
-        environment,
-        stdin: Buffer.concat(records)
-      });
-    }
-    const tree = requireObjectId(
-      gitText(input.workspacePath, ["write-tree"], "write workspace projection mount tree", { environment }),
-      "Workspace projection mount tree"
-    );
-    return { tree, projectedFiles, blobs };
-  } finally {
-    removeTemporaryIndex(indexPath);
-  }
-}
-function staleRewritePaths(input) {
-  const entries = Object.entries(input.staleRewriteBlobs ?? {});
-  if (entries.length === 0) return { stale: [], cleared: [] };
-  const probed = gitText(input.workspacePath, ["cat-file", "--batch-check"], "resolve workspace projection basis subtree", {
-    stdin: Buffer.from(`${input.basisHead}:${input.workspaceRelativePath}
-`)
-  });
-  const basisSubtree = /^([0-9a-f]{40,64}) tree \d+$/u.exec(probed);
-  if (!basisSubtree && !/ missing$/u.test(probed))
-    throw new Error(`Resolve workspace projection basis subtree: unexpected answer ${probed}`);
-  const changed = /* @__PURE__ */ new Set();
-  if (!basisSubtree) {
-    for (const relativePath of input.blobs.keys()) changed.add(relativePath);
-  } else {
-    const listing = git(
-      input.workspacePath,
-      ["diff-tree", "-r", "-z", "--no-renames", "--raw", basisSubtree[1], input.mountTree],
-      "compare workspace projection with its basis"
-    );
-    const records = nulRecords(listing);
-    for (let index = 0; index + 1 < records.length; index += 2) changed.add(records[index + 1].toString());
-  }
-  const stale = [];
-  const cleared = [];
-  for (const [relativePath, blob] of entries) {
-    const synthesized = input.blobs.get(relativePath);
-    if (synthesized === void 0) {
-      cleared.push(relativePath);
-      continue;
-    }
-    if (synthesized === blob) {
-      if (changed.has(relativePath)) stale.push(relativePath);
-      else cleared.push(relativePath);
-      continue;
-    }
-    if (changed.has(relativePath)) cleared.push(relativePath);
-  }
-  return { stale: stale.sort(), cleared: cleared.sort() };
-}
-function nulRecords(content) {
-  const records = [];
-  let start = 0;
-  for (let index = 0; index < content.length; index += 1) {
-    if (content[index] !== 0) continue;
-    if (index > start) records.push(content.subarray(start, index));
-    start = index + 1;
-  }
-  if (start < content.length) records.push(content.subarray(start));
-  return records;
-}
-function indexedSubtreePaths(content, workspaceRelativePath) {
-  const prefix = Buffer.from(workspaceRelativePath);
-  const descendantPrefix = Buffer.from(`${workspaceRelativePath}/`);
-  const records = nulRecords(content).filter(
-    (record) => record.equals(prefix) || record.length > descendantPrefix.length && record.subarray(0, descendantPrefix.length).equals(descendantPrefix)
-  );
-  return records.length > 0 ? Buffer.concat(records.flatMap((record) => [record, Buffer.from([0])])) : Buffer.alloc(0);
-}
-function graftMountTree(input) {
-  const indexPath = temporaryIndexPath(input.workspacePath);
-  const environment = temporaryIndexEnvironment(indexPath);
-  try {
-    git(input.workspacePath, ["read-tree", input.basisHead], "read workspace projection basis", { environment });
-    const indexedPaths = git(input.workspacePath, ["ls-files", "-z"], "enumerate workspace projection basis", { environment });
-    const removedPaths = indexedSubtreePaths(indexedPaths, input.workspaceRelativePath);
-    if (removedPaths.length > 0) {
-      git(input.workspacePath, ["update-index", "--force-remove", "-z", "--stdin"], "remove prior workspace projection subtree", {
-        environment,
-        stdin: removedPaths
-      });
-    }
-    git(
-      input.workspacePath,
-      ["read-tree", "-i", `--prefix=${input.workspaceRelativePath}/`, input.mountTree],
-      "graft workspace projection mount tree",
-      { environment }
-    );
-    return requireObjectId(
-      gitText(input.workspacePath, ["write-tree"], "write grafted workspace projection tree", { environment }),
-      "Grafted workspace projection tree"
-    );
-  } finally {
-    removeTemporaryIndex(indexPath);
-  }
-}
-function synthesizeOursCommit(input) {
-  const synthesized = synthesizeMountTree({
-    workspacePath: input.workspacePath,
-    sourcePath: input.mount.sourcePath,
-    sourceMode: input.mount.sourceMode
-  });
-  const detected = staleRewritePaths({
-    workspacePath: input.workspacePath,
-    workspaceRelativePath: input.workspaceRelativePath,
-    basisHead: input.basisHead,
-    mountTree: synthesized.tree,
-    blobs: synthesized.blobs,
-    staleRewriteBlobs: input.staleRewriteBlobs
-  });
-  if (detected.stale.length > 0) return { staleRewritePaths: detected.stale, staleRewriteCleared: detected.cleared };
-  const rootTree = graftMountTree({
-    workspacePath: input.workspacePath,
-    workspaceRelativePath: input.workspaceRelativePath,
-    basisHead: input.basisHead,
-    mountTree: synthesized.tree
-  });
-  const message = JSON.stringify({
-    type: "workspace_projection_basis",
-    mountId: input.mount.id,
-    attemptId: input.attemptId
-  });
-  const oursCommit = requireObjectId(
-    gitText(
-      input.workspacePath,
-      ["commit-tree", rootTree, "-p", input.basisHead, "-m", message],
-      `commit synthesized workspace projection for mount ${input.mount.id}`
-    ),
-    `Synthesized workspace projection commit for mount ${input.mount.id}`
-  );
-  return { oursCommit, projectedFiles: synthesized.projectedFiles, staleRewriteCleared: detected.cleared };
-}
-function mergeWorkspaceProjectionMount(input) {
-  const support = workspaceMergeProjectionSupport();
-  if (!support.supported) throw new Error(support.error);
-  const workspacePath = path.resolve(input.workspacePath);
-  const workspaceRelativePath = normalizeWorkspaceRelativePath(input.mount.workspaceRelativePath);
-  const basisHead = requireCommit(workspacePath, input.basisHead, `workspace projection basis for mount ${input.mount.id}`);
-  const currentHead = requireCommit(workspacePath, input.currentHead, "current workspace projection head");
-  const synthesized = synthesizeOursCommit({
-    workspacePath,
-    mount: input.mount,
-    workspaceRelativePath,
-    basisHead,
-    attemptId: input.attemptId,
-    ...input.staleRewriteBlobs ? { staleRewriteBlobs: input.staleRewriteBlobs } : {}
-  });
-  if ("staleRewritePaths" in synthesized) {
-    return { kind: "stale_rewrite", paths: synthesized.staleRewritePaths, staleRewriteCleared: synthesized.staleRewriteCleared };
-  }
-  const { oursCommit, projectedFiles, staleRewriteCleared } = synthesized;
-  const readAtMs = Date.now();
-  const merged = gitResult(workspacePath, [
-    "merge-tree",
-    "--write-tree",
-    `--merge-base=${basisHead}`,
-    "--name-only",
-    "-z",
-    "--no-messages",
-    oursCommit,
-    currentHead
-  ]);
-  if (merged.exitCode !== 0 && merged.exitCode !== 1) {
-    const detail = merged.stderr.toString().trim() || merged.stdout.toString().trim() || `git exited ${merged.exitCode}`;
-    throw new Error(`Merge workspace projection for mount ${input.mount.id}: ${detail}`);
-  }
-  const records = nulRecords(merged.stdout);
-  const resultTree = records.shift()?.toString() ?? "";
-  requireObjectId(resultTree, `Merged workspace projection tree for mount ${input.mount.id}`);
-  if (merged.exitCode === 0) return { kind: "clean", resultTree, oursCommit, projectedFiles, readAtMs, staleRewriteCleared };
-  const conflictPaths = records.map((record) => record.toString()).sort();
-  return {
-    kind: "conflict",
-    oursCommit,
-    conflictPaths,
-    error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`,
-    projectedFiles,
-    readAtMs,
-    staleRewriteCleared
-  };
-}
-function materializeWorkspaceProjectionTree(input) {
-  const workspacePath = path.resolve(input.workspacePath);
-  const workspaceRelativePath = normalizeWorkspaceRelativePath(input.workspaceRelativePath);
-  const resultTree = requireObjectId(input.resultTree, "Workspace projection result tree");
-  const targetPath = path.join(workspacePath, ...workspaceRelativePath.split("/"));
-  assertManagedDirectoryPath({
-    trustedRoot: workspacePath,
-    candidate: targetPath,
-    label: "Workspace merge-projection target"
-  });
-  git(workspacePath, ["cat-file", "-e", `${resultTree}^{tree}`], "resolve workspace merge-projection result tree");
-  const subtree = gitResult(workspacePath, ["cat-file", "-e", `${resultTree}:${workspaceRelativePath}`]);
-  if (subtree.exitCode !== 0) {
-    fs.rmSync(targetPath, { recursive: true, force: true });
-    return;
-  }
-  const subtreeType = gitText(
-    workspacePath,
-    ["cat-file", "-t", `${resultTree}:${workspaceRelativePath}`],
-    "inspect workspace merge-projection result subtree"
-  );
-  if (subtreeType !== "tree") {
-    throw new Error(`Workspace merge-projection result is not a directory at ${workspaceRelativePath}`);
-  }
-  fs.rmSync(targetPath, { recursive: true, force: true });
-  git(
-    workspacePath,
-    ["checkout", "--no-recurse-submodules", resultTree, "--", `:(literal)${workspaceRelativePath}`],
-    "materialize merged workspace projection subtree"
-  );
-}
-const workspaceMergeProjectionTestHarness = {
-  gitVersionIsSupported,
-  resetSupportProbe() {
-    cachedWorkspaceMergeProjectionSupport = null;
-  }
-};
-export {
-  materializeWorkspaceProjectionTree,
-  mergeWorkspaceProjectionMount,
-  workspaceMergeProjectionSupport,
-  workspaceMergeProjectionTestHarness
-};

package/dist/mjs/workspace-mount-boundary.mjs

@@ -1,37 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-function containedRelative(root, candidate) {
-  const relative = path.relative(root, candidate);
-  if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-    throw new Error(`Managed directory path escapes its trusted root: ${candidate}`);
-  }
-  return relative;
-}
-function assertManagedDirectoryPath(input) {
-  const trustedRoot = path.resolve(input.trustedRoot);
-  const candidate = path.resolve(input.candidate);
-  const relative = containedRelative(trustedRoot, candidate);
-  const rootStatus = fs.lstatSync(trustedRoot);
-  if (!rootStatus.isDirectory() || rootStatus.isSymbolicLink()) {
-    throw new Error(`${input.label} trusted root is not a regular directory: ${trustedRoot}`);
-  }
-  const realRoot = fs.realpathSync(trustedRoot);
-  let current = trustedRoot;
-  for (const segment of relative.split(path.sep)) {
-    current = path.join(current, segment);
-    let status;
-    try {
-      status = fs.lstatSync(current);
-    } catch (error) {
-      if (error.code === "ENOENT") return;
-      throw error;
-    }
-    if (!status.isDirectory() || status.isSymbolicLink()) {
-      throw new Error(`${input.label} contains a symlink or non-directory component: ${current}`);
-    }
-    containedRelative(realRoot, fs.realpathSync(current));
-  }
-}
-export {
-  assertManagedDirectoryPath
-};

package/dist/mjs/workspace-mount-hold-fence.mjs

@@ -1,95 +0,0 @@
-class WorkspaceMountHoldAbortedError extends Error {
-  constructor(reason) {
-    super(reason);
-    this.name = "WorkspaceMountHoldAbortedError";
-  }
-}
-class WorkspaceMountHoldFence {
-  holds = /* @__PURE__ */ new Map();
-  waiters = /* @__PURE__ */ new Set();
-  now;
-  constructor(options = {}) {
-    this.now = options.now ?? (() => Date.now());
-  }
-  /** Take one hold on every listed mount; the returned release is idempotent. */
-  hold(mountIds, description) {
-    const ids = [...new Set(mountIds)];
-    for (const id of ids) {
-      const existing = this.holds.get(id);
-      if (existing) {
-        existing.count += 1;
-        continue;
-      }
-      this.holds.set(id, { count: 1, description, sinceMs: this.now() });
-    }
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      for (const id of ids) {
-        const existing = this.holds.get(id);
-        if (!existing) continue;
-        existing.count -= 1;
-        if (existing.count === 0) this.holds.delete(id);
-      }
-      this.wake();
-    };
-  }
-  isHeld(mountIds) {
-    return mountIds.some((id) => this.holds.has(id));
-  }
-  /** Human-readable holder of the first held mount among `mountIds`, for diagnostics. */
-  describeHold(mountIds) {
-    for (const id of mountIds) {
-      const hold = this.holds.get(id);
-      if (hold) return `${hold.description} (held for ${Math.round((this.now() - hold.sinceMs) / 1e3)}s)`;
-    }
-    return null;
-  }
-  /** Every held mount id, sorted, for status reporting. */
-  heldMountIds() {
-    return [...this.holds.keys()].sort();
-  }
-  /**
-   * Resolves in the same turn as the release that leaves none of `mountIds`
-   * held, so the caller can re-check and reserve without an interleaving
-   * hold. Resolves immediately when nothing is held. Rejects with
-   * WorkspaceMountHoldAbortedError when `signal` aborts first.
-   */
-  waitForRelease(mountIds, options = {}) {
-    if (options.signal?.aborted) {
-      return Promise.reject(new WorkspaceMountHoldAbortedError(abortReason(options.signal)));
-    }
-    if (!this.isHeld(mountIds)) return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const waiter = { mountIds, resolve, reject, signal: options.signal };
-      if (options.signal) {
-        const signal = options.signal;
-        waiter.onAbort = () => {
-          this.waiters.delete(waiter);
-          reject(new WorkspaceMountHoldAbortedError(abortReason(signal)));
-        };
-        signal.addEventListener("abort", waiter.onAbort, { once: true });
-      }
-      this.waiters.add(waiter);
-    });
-  }
-  wake() {
-    for (const waiter of [...this.waiters]) {
-      if (this.isHeld(waiter.mountIds)) continue;
-      this.waiters.delete(waiter);
-      if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
-      waiter.resolve();
-    }
-  }
-}
-function abortReason(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error) return reason.message;
-  if (typeof reason === "string" && reason) return reason;
-  return "Workspace mount reservation was aborted";
-}
-export {
-  WorkspaceMountHoldAbortedError,
-  WorkspaceMountHoldFence
-};

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

@@ -1,103 +0,0 @@
-class WorkspaceMutationGate {
-  activeMutations = 0;
-  syncActive = false;
-  waiters = [];
-  acquireMutation() {
-    return new Promise((resolve) => {
-      this.waiters.push({ kind: "mutation", resolve });
-      this.drain();
-    });
-  }
-  async runMutation(operation) {
-    const release = await this.acquireMutation();
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  async runSync(operation) {
-    const release = await new Promise((resolve) => {
-      this.waiters.push({ kind: "sync", resolve });
-      this.drain();
-    });
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  /** A worktree create/delete lease; see the branch lane in the class comment. */
-  acquireBranchMutation() {
-    return new Promise((resolve) => {
-      this.waiters.push({ kind: "branch", resolve });
-      this.drain();
-    });
-  }
-  async runBranchMutation(operation) {
-    const release = await this.acquireBranchMutation();
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  /**
-   * Operations a branch mutation requested now would wait for: the running
-   * sync, if any, plus branch mutations queued behind it. Zero means it runs
-   * at once. Ordinary waiters are not counted because the branch lane admits
-   * ahead of them.
-   */
-  branchMutationQueuePosition() {
-    if (!this.syncActive) return 0;
-    return 1 + this.waiters.filter((waiter) => waiter.kind === "branch").length;
-  }
-  drain() {
-    if (this.syncActive || this.waiters.length === 0) return;
-    for (let index = 0; index < this.waiters.length; ) {
-      const waiter = this.waiters[index];
-      if (waiter?.kind !== "branch") {
-        index += 1;
-        continue;
-      }
-      this.waiters.splice(index, 1);
-      this.activeMutations += 1;
-      waiter.resolve(this.releaseMutation());
-    }
-    const first = this.waiters[0];
-    if (first?.kind === "sync") {
-      if (this.activeMutations > 0) return;
-      this.waiters.shift();
-      this.syncActive = true;
-      first.resolve(this.releaseSync());
-      return;
-    }
-    while (this.waiters[0]?.kind === "mutation") {
-      const waiter = this.waiters.shift();
-      if (!waiter || waiter.kind !== "mutation") break;
-      this.activeMutations += 1;
-      waiter.resolve(this.releaseMutation());
-    }
-  }
-  releaseMutation() {
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      this.activeMutations -= 1;
-      this.drain();
-    };
-  }
-  releaseSync() {
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      this.syncActive = false;
-      this.drain();
-    };
-  }
-}
-export {
-  WorkspaceMutationGate
-};