@ricsam/r5d-worker 0.0.137 → 0.0.139

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

@@ -1,594 +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 ledgerStatMatches(recorded, projected) {
-  return recorded !== null && projected?.kind === "file" && projected.ino === recorded.ino && projected.size === recorded.size && projected.mode === recorded.mode && projected.mtimeMs === recorded.mtimeMs && projected.ctimeMs === recorded.ctimeMs;
-}
-function classifyHydrationLedger(input) {
-  const entries = Object.entries(input.hydrationLedger ?? {});
-  if (entries.length === 0) return { stale: [], merge: [], 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 merge = [];
-  const cleared = [];
-  for (const [relativePath, entry] of entries) {
-    const synthesized = input.blobs.get(relativePath);
-    if (synthesized === void 0) {
-      if (entry.postBlob === null) continue;
-      cleared.push(relativePath);
-      continue;
-    }
-    if (ledgerStatMatches(entry.stat, input.projectedFiles[relativePath]) || synthesized === entry.postBlob) continue;
-    if (!changed.has(relativePath)) {
-      cleared.push(relativePath);
-      continue;
-    }
-    if (entry.processLiveAcrossHydration) {
-      merge.push({ relativePath, preBlob: entry.preBlob, postBlob: entry.postBlob });
-      continue;
-    }
-    if (synthesized === entry.preBlob) {
-      stale.push(relativePath);
-      continue;
-    }
-    cleared.push(relativePath);
-  }
-  if (merge.length > 0) {
-    const ids = [...new Set(merge.flatMap(({ preBlob, postBlob }) => postBlob ? [preBlob, postBlob] : [preBlob]))];
-    const checked = gitText(input.workspacePath, ["cat-file", "--batch-check"], "verify hydration ledger blobs", {
-      stdin: Buffer.from(`${ids.join("\n")}
-`)
-    });
-    const missing = new Set(
-      checked.split("\n").filter((line) => / missing$/u.test(line)).map((line) => line.split(" ")[0])
-    );
-    if (missing.size > 0) {
-      for (let index = merge.length - 1; index >= 0; index -= 1) {
-        const { relativePath, preBlob, postBlob } = merge[index];
-        if (missing.has(preBlob) || postBlob !== null && missing.has(postBlob)) {
-          merge.splice(index, 1);
-          cleared.push(relativePath);
-        }
-      }
-    }
-  }
-  return { stale: stale.sort(), merge: merge.sort((left, right) => left.relativePath.localeCompare(right.relativePath)), cleared: cleared.sort() };
-}
-function hydrationLedgerMergeBase(input) {
-  if (input.merges.length === 0) return input.basisHead;
-  return commitWithLedgerPaths({
-    workspacePath: input.workspacePath,
-    workspaceRelativePath: input.workspaceRelativePath,
-    parent: input.basisHead,
-    paths: input.merges.map(({ relativePath, preBlob }) => ({ relativePath, blob: preBlob })),
-    message: JSON.stringify({
-      type: "workspace_hydration_ledger_basis",
-      mountId: input.mountId,
-      attemptId: input.attemptId,
-      paths: input.merges.map(({ relativePath }) => relativePath)
-    }),
-    action: "hydration ledger merge base"
-  });
-}
-function hydrationLedgerTheirs(input) {
-  const paths = input.merges.flatMap(({ relativePath, postBlob }) => postBlob ? [{ relativePath, blob: postBlob }] : []);
-  if (paths.length === 0) return input.currentHead;
-  return commitWithLedgerPaths({
-    workspacePath: input.workspacePath,
-    workspaceRelativePath: input.workspaceRelativePath,
-    parent: input.currentHead,
-    paths,
-    message: JSON.stringify({
-      type: "workspace_hydration_ledger_theirs",
-      mountId: input.mountId,
-      attemptId: input.attemptId,
-      paths: paths.map(({ relativePath }) => relativePath)
-    }),
-    action: "hydration ledger theirs"
-  });
-}
-function commitWithLedgerPaths(input) {
-  const indexPath = temporaryIndexPath(input.workspacePath);
-  const environment = temporaryIndexEnvironment(indexPath);
-  try {
-    git(input.workspacePath, ["read-tree", input.parent], `read workspace tree for the ${input.action}`, { environment });
-    const paths = input.paths.map(({ relativePath }) => `${input.workspaceRelativePath}/${relativePath}`);
-    const listed = git(
-      input.workspacePath,
-      ["ls-files", "-z", "--stage", "--", ...paths.map((entry) => `:(literal)${entry}`)],
-      `inspect modes for the ${input.action}`,
-      { environment }
-    );
-    const modes = /* @__PURE__ */ new Map();
-    for (const record of nulRecords(listed)) {
-      const match = /^([0-7]{6}) [0-9a-f]{40,64} [0-3]\t(.+)$/su.exec(record.toString());
-      if (match) modes.set(match[2], match[1]);
-    }
-    const records = input.paths.map(
-      ({ relativePath, blob }, index) => indexInfoRecord(modes.get(paths[index]) ?? "100644", requireObjectId(blob, `hydration ledger blob for ${relativePath}`), paths[index])
-    );
-    git(input.workspacePath, ["update-index", "-z", "--index-info"], `rewrite paths for the ${input.action}`, {
-      environment,
-      stdin: Buffer.concat(records)
-    });
-    const tree = requireObjectId(gitText(input.workspacePath, ["write-tree"], `write the ${input.action}`, { environment }), `${input.action} tree`);
-    return requireObjectId(
-      gitText(input.workspacePath, ["commit-tree", tree, "-p", input.parent, "-m", input.message], `commit the ${input.action}`),
-      `${input.action} commit`
-    );
-  } finally {
-    removeTemporaryIndex(indexPath);
-  }
-}
-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
-      });
-    }
-    if (input.mountTree !== null) {
-      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 mountSubtreeObjectId(workspacePath, revision, workspaceRelativePath, label) {
-  const spec = `${revision}:${workspaceRelativePath}`;
-  if (gitResult(workspacePath, ["cat-file", "-e", spec]).exitCode !== 0) return null;
-  const type = gitText(workspacePath, ["cat-file", "-t", spec], `inspect ${label}`);
-  if (type !== "tree") throw new Error(`${label} is not a directory at ${workspaceRelativePath}`);
-  return requireObjectId(gitText(workspacePath, ["rev-parse", spec], `resolve ${label}`), label);
-}
-function synthesizeOursCommit(input) {
-  const synthesized = synthesizeMountTree({
-    workspacePath: input.workspacePath,
-    sourcePath: input.mount.sourcePath,
-    sourceMode: input.mount.sourceMode
-  });
-  const classified = classifyHydrationLedger({
-    workspacePath: input.workspacePath,
-    workspaceRelativePath: input.workspaceRelativePath,
-    basisHead: input.basisHead,
-    mountTree: synthesized.tree,
-    blobs: synthesized.blobs,
-    projectedFiles: synthesized.projectedFiles,
-    hydrationLedger: input.hydrationLedger
-  });
-  if (classified.stale.length > 0) return { staleRewritePaths: classified.stale, staleRewriteCleared: classified.cleared };
-  const mergeBase = hydrationLedgerMergeBase({
-    workspacePath: input.workspacePath,
-    workspaceRelativePath: input.workspaceRelativePath,
-    basisHead: input.basisHead,
-    merges: classified.merge,
-    mountId: input.mount.id,
-    attemptId: input.attemptId
-  });
-  const rootTree = graftMountTree({
-    workspacePath: input.workspacePath,
-    workspaceRelativePath: input.workspaceRelativePath,
-    basisHead: mergeBase,
-    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", mergeBase, "-m", message],
-      `commit synthesized workspace projection for mount ${input.mount.id}`
-    ),
-    `Synthesized workspace projection commit for mount ${input.mount.id}`
-  );
-  return {
-    oursCommit,
-    mergeBase,
-    projectedFiles: synthesized.projectedFiles,
-    staleRewriteCleared: classified.cleared,
-    ledgerMerges: classified.merge
-  };
-}
-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.hydrationLedger ? { hydrationLedger: input.hydrationLedger } : {}
-  });
-  if ("staleRewritePaths" in synthesized) {
-    return { kind: "stale_rewrite", paths: synthesized.staleRewritePaths, staleRewriteCleared: synthesized.staleRewriteCleared };
-  }
-  const { oursCommit, mergeBase, projectedFiles, staleRewriteCleared, ledgerMerges } = synthesized;
-  const ledgerMergedPaths = ledgerMerges.map(({ relativePath }) => relativePath);
-  const theirsHead = hydrationLedgerTheirs({
-    workspacePath,
-    workspaceRelativePath,
-    currentHead,
-    merges: ledgerMerges,
-    mountId: input.mount.id,
-    attemptId: input.attemptId
-  });
-  const readAtMs = Date.now();
-  const inboundMountTree = mountSubtreeObjectId(
-    workspacePath,
-    theirsHead,
-    workspaceRelativePath,
-    `current workspace head subtree for mount ${input.mount.id}`
-  );
-  const inboundCommit = requireObjectId(
-    gitText(
-      workspacePath,
-      [
-        "commit-tree",
-        graftMountTree({ workspacePath, workspaceRelativePath, basisHead: mergeBase, mountTree: inboundMountTree }),
-        "-p",
-        mergeBase,
-        "-m",
-        JSON.stringify({ type: "workspace_projection_inbound", mountId: input.mount.id, attemptId: input.attemptId })
-      ],
-      `commit inbound workspace projection for mount ${input.mount.id}`
-    ),
-    `Inbound workspace projection commit for mount ${input.mount.id}`
-  );
-  const merged = gitResult(workspacePath, [
-    "merge-tree",
-    "--write-tree",
-    `--merge-base=${mergeBase}`,
-    "--name-only",
-    "-z",
-    "--no-messages",
-    oursCommit,
-    inboundCommit
-  ]);
-  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 mergedTree = records.shift()?.toString() ?? "";
-  requireObjectId(mergedTree, `Merged workspace projection tree for mount ${input.mount.id}`);
-  if (merged.exitCode === 0) {
-    const resultTree = graftMountTree({
-      workspacePath,
-      workspaceRelativePath,
-      basisHead: currentHead,
-      mountTree: mountSubtreeObjectId(workspacePath, mergedTree, workspaceRelativePath, `merged subtree for mount ${input.mount.id}`)
-    });
-    return { kind: "clean", resultTree, oursCommit, projectedFiles, readAtMs, staleRewriteCleared, ledgerMergedPaths };
-  }
-  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,
-    ledgerMergedPaths
-  };
-}
-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
-};