@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/mjs/working-tree-mirror.mjs

@@ -1,1817 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createHash, randomUUID } from "node:crypto";
-import { workerGitProcessEnvironment } from "./git-process-environment.mjs";
-import { AtomicRenameError, atomicRenamePrimitivesFor, isAtomicRenameUnsupported } from "./atomic-rename.mjs";
-function projectedFileEntry(stat) {
-  return { kind: "file", size: stat.size, mode: stat.mode, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, ino: stat.ino };
-}
-function projectedFileEntryMatches(entry, stat) {
-  return stat.isFile() && stat.ino === entry.ino && stat.size === entry.size && stat.mode === entry.mode && stat.mtimeMs === entry.mtimeMs && stat.ctimeMs === entry.ctimeMs;
-}
-function workingTreeStatsMatch(left, right) {
-  return left.isFile() === right.isFile() && left.isDirectory() === right.isDirectory() && left.isSymbolicLink() === right.isSymbolicLink() && left.ino === right.ino && left.dev === right.dev && left.size === right.size && left.mode === right.mode && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
-}
-function sameWorkingTreeInode(left, right) {
-  return left.ino === right.ino && left.dev === right.dev;
-}
-function displacedEntryMatches(expected, displaced) {
-  return sameWorkingTreeInode(expected, displaced) && displaced.mode === expected.mode && displaced.size === expected.size && displaced.mtimeMs === expected.mtimeMs;
-}
-class WorkingTreeTargetChangedError extends Error {
-  constructor(relativePath, options = {}) {
-    const retained = options.retained ?? [];
-    super(
-      `Working-tree target changed while it was being hydrated: ${relativePath}` + (options.detail ? ` (${options.detail})` : "") + (retained.length > 0 ? `; displaced entries retained at ${retained.map(({ path: retainedPath }) => retainedPath).join(", ")}` : "")
-    );
-    this.relativePath = relativePath;
-    this.name = "WorkingTreeTargetChangedError";
-    this.retained = retained;
-  }
-  relativePath;
-  retained;
-}
-let raceHook = null;
-function setWorkingTreeMirrorRaceHook(hook) {
-  raceHook = hook;
-}
-function raceWindow(phase, relativePath, targetPath) {
-  if (raceHook) raceHook({ phase, relativePath, targetPath });
-}
-const HFS_IGNORED_CODE_POINTS = /[\u200c-\u200f\u202a-\u202e\u206a-\u206f\ufeff]/gu;
-const MIRROR_TEMPORARY_FILE_PREFIX = ".r5d-working-tree-mirror-";
-const OBJECT_ID_PATTERN = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u;
-const GITLINK_STALE_HEADS_FILE = "gitlink-heads.json";
-const NON_RECURSIVE_GIT_CONFIG = [
-  "-c",
-  "submodule.recurse=false",
-  "-c",
-  "fetch.recurseSubmodules=false",
-  "-c",
-  "push.recurseSubmodules=false"
-];
-function isPortableGitMetadataSegment(segment) {
-  const hfsFolded = segment.replace(HFS_IGNORED_CODE_POINTS, "").toLowerCase();
-  if (hfsFolded === ".git") return true;
-  const ntfsFolded = segment.toLowerCase();
-  return /^(?:\.git|git~1)[ .]*(?::|$)/u.test(ntfsFolded);
-}
-function isGitMetadataPath(relativePath) {
-  return relativePath.split(/[\\/]/u).some(isPortableGitMetadataSegment);
-}
-function assertWorkingTreeHasNoPortableGitMetadataAliases(root) {
-  root = path.resolve(root);
-  const rootStatus = fs.lstatSync(root);
-  if (!rootStatus.isDirectory() || rootStatus.isSymbolicLink()) {
-    throw new Error(`Working-tree root is not a regular directory: ${root}`);
-  }
-  const inspectDirectory = (directoryPath, relativeDirectory) => {
-    for (const name of fs.readdirSync(directoryPath).sort()) {
-      const relativePath = relativeDirectory ? path.posix.join(relativeDirectory, name) : name;
-      if (name === ".git") continue;
-      if (isGitMetadataPath(relativePath)) {
-        throw new Error(`Working tree contains a portable Git metadata alias that cannot be moved safely: ${relativePath}`);
-      }
-      const entryPath = path.join(directoryPath, name);
-      const status = fs.lstatSync(entryPath);
-      if (status.isDirectory() && !status.isSymbolicLink()) inspectDirectory(entryPath, relativePath);
-    }
-  };
-  inspectDirectory(root, "");
-}
-function normalizeRelativePath(value) {
-  const normalized = value.split(path.sep).join(path.posix.sep).replace(/^\.\/+/, "").replace(/^\/+|\/+$/g, "");
-  if (!normalized || normalized === "." || normalized.split("/").includes("..") || isGitMetadataPath(normalized)) return null;
-  return normalized;
-}
-function assertInside(root, candidate) {
-  const relative = path.relative(path.resolve(root), path.resolve(candidate));
-  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-    throw new Error(`Working-tree path escapes its root: ${candidate}`);
-  }
-}
-function inspectRelativePathWithoutFollowingAncestors(root, relativePath) {
-  const normalized = normalizeRelativePath(relativePath);
-  if (!normalized) return { kind: "blocked", blockingPath: relativePath };
-  let current = path.resolve(root);
-  const segments = normalized.split("/");
-  for (let index = 0; index < segments.length; index += 1) {
-    current = path.join(current, segments[index]);
-    assertInside(root, current);
-    let stat;
-    try {
-      stat = fs.lstatSync(current);
-    } catch (error) {
-      if (error.code === "ENOENT") return { kind: "missing" };
-      throw error;
-    }
-    if (index < segments.length - 1 && (!stat.isDirectory() || stat.isSymbolicLink())) {
-      return { kind: "blocked", blockingPath: current };
-    }
-    if (index === segments.length - 1) return { kind: "entry", absolutePath: current, stat };
-  }
-  return { kind: "missing" };
-}
-function inspectWorkingTreePath(root, relativePath) {
-  return inspectRelativePathWithoutFollowingAncestors(path.resolve(root), relativePath);
-}
-function inspectDirectoryRoot(root, options) {
-  let stat;
-  try {
-    stat = fs.lstatSync(root);
-  } catch (error) {
-    if (options.allowMissing && error.code === "ENOENT") return false;
-    throw error;
-  }
-  if (!stat.isDirectory() || stat.isSymbolicLink()) {
-    throw new Error(`${options.label} is not a regular directory: ${root}`);
-  }
-  return true;
-}
-function lstatIfExists(targetPath) {
-  try {
-    return fs.lstatSync(targetPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-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 gitOutput(cwd, args, action, options = {}) {
-  const result = Bun.spawnSync(["git", ...NON_RECURSIVE_GIT_CONFIG, ...args], {
-    cwd,
-    ...options.stdin ? { stdin: options.stdin } : {},
-    stdout: "pipe",
-    stderr: "pipe",
-    env: options.environment ?? workerGitProcessEnvironment()
-  });
-  if (result.exitCode !== 0) {
-    throw new Error(`${action}: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
-  }
-  return Buffer.from(result.stdout);
-}
-function listGitCheckout(root) {
-  const output = gitOutput(
-    root,
-    ["ls-files", "-z", "-t", "--stage", "--cached", "--others", "--exclude-standard", "--", "."],
-    "Inspect Git working tree"
-  );
-  const roots = /* @__PURE__ */ new Map();
-  const indexRecords = [];
-  for (const record of nulRecords(output)) {
-    const text = record.toString();
-    const other = /^\? (.*)$/su.exec(text);
-    if (other) {
-      const normalized2 = normalizeRelativePath(other[1]);
-      if (normalized2 && !roots.has(normalized2)) roots.set(normalized2, other[1].endsWith("/"));
-      continue;
-    }
-    const staged = /^[A-Z] ([0-7]{6}) ([0-9a-f]{40,64}) ([0-3])\t(.*)$/su.exec(text);
-    if (!staged) continue;
-    const normalized = normalizeRelativePath(staged[4]);
-    if (!normalized) continue;
-    indexRecords.push({ mode: staged[1], objectId: staged[2], stage: Number(staged[3]), relativePath: normalized });
-    if (!roots.has(normalized)) roots.set(normalized, false);
-  }
-  return {
-    roots: [...roots].map(([relativePath, nestedRepository]) => ({ relativePath, nestedRepository })).sort((left, right) => left.relativePath < right.relativePath ? -1 : left.relativePath > right.relativePath ? 1 : 0),
-    indexRecords
-  };
-}
-function populatedCheckoutHead(root, absolutePath) {
-  if (!lstatIfExists(path.join(absolutePath, ".git"))) return null;
-  const result = Bun.spawnSync(["git", ...NON_RECURSIVE_GIT_CONFIG, "rev-parse", "--verify", "HEAD^{commit}"], {
-    cwd: absolutePath,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...workerGitProcessEnvironment(), GIT_CEILING_DIRECTORIES: root }
-  });
-  if (result.exitCode !== 0) return null;
-  const head = result.stdout.toString().trim();
-  return OBJECT_ID_PATTERN.test(head) ? head : null;
-}
-function checkoutGitDirectory(root) {
-  const dotGit = path.join(root, ".git");
-  const status = lstatIfExists(dotGit);
-  if (!status) return null;
-  if (status.isDirectory()) return dotGit;
-  if (!status.isFile()) return null;
-  const match = /^gitdir:[ \t]*(.+?)\s*$/u.exec(fs.readFileSync(dotGit, "utf8").split(/\r?\n/u)[0] ?? "");
-  return match ? path.resolve(root, match[1]) : null;
-}
-function gitlinkStaleHeadsPath(root) {
-  const gitDirectory = checkoutGitDirectory(root);
-  return gitDirectory ? path.join(gitDirectory, "r5d", GITLINK_STALE_HEADS_FILE) : null;
-}
-function readGitlinkStaleHeads(root) {
-  const heads = /* @__PURE__ */ new Map();
-  const markerPath = gitlinkStaleHeadsPath(root);
-  if (!markerPath || !lstatIfExists(markerPath)?.isFile()) return heads;
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(markerPath, "utf8"));
-  } catch {
-    return heads;
-  }
-  if (!parsed || typeof parsed !== "object" || parsed.version !== 1) return heads;
-  const recorded = parsed.heads;
-  if (!recorded || typeof recorded !== "object") return heads;
-  for (const [relativePath, objectId] of Object.entries(recorded)) {
-    const normalized = normalizeRelativePath(relativePath);
-    if (normalized && typeof objectId === "string" && OBJECT_ID_PATTERN.test(objectId)) heads.set(normalized, objectId);
-  }
-  return heads;
-}
-function writeGitlinkStaleHeads(root, heads) {
-  const markerPath = gitlinkStaleHeadsPath(root);
-  if (!markerPath) return;
-  const directory = path.dirname(markerPath);
-  if (heads.size === 0) {
-    if (!lstatIfExists(markerPath)) return;
-    fs.rmSync(markerPath, { force: true });
-    fsyncPath(directory, fs.constants.O_RDONLY);
-    return;
-  }
-  const directoryStatus = lstatIfExists(directory);
-  if (!directoryStatus) fs.mkdirSync(directory, { mode: 448 });
-  else if (!directoryStatus.isDirectory() || directoryStatus.isSymbolicLink()) {
-    throw new Error(`Checkout private state is not a regular directory: ${directory}`);
-  }
-  const temporaryPath = path.join(directory, `.${GITLINK_STALE_HEADS_FILE}.${randomUUID()}.tmp`);
-  const descriptor = fs.openSync(temporaryPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
-  try {
-    fs.writeFileSync(descriptor, `${JSON.stringify({ version: 1, heads: Object.fromEntries([...heads].sort()) })}
-`);
-    fs.fsyncSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-  fs.renameSync(temporaryPath, markerPath);
-  fsyncPath(directory, fs.constants.O_RDONLY);
-}
-function addEntry(entries, root, relativePath, recurseDirectories, gitlinks, stats) {
-  const normalized = normalizeRelativePath(relativePath);
-  if (!normalized || entries.has(normalized)) return;
-  const gitlink = gitlinks?.get(normalized);
-  if (gitlink !== void 0) {
-    entries.set(normalized, { kind: "gitlink", objectId: gitlink });
-    return;
-  }
-  const inspected = inspectRelativePathWithoutFollowingAncestors(root, normalized);
-  if (inspected.kind !== "entry") return;
-  const { absolutePath, stat } = inspected;
-  if (stat.isSymbolicLink()) {
-    for (const existing of [...entries.keys()]) {
-      if (existing.startsWith(`${normalized}/`)) {
-        entries.delete(existing);
-        stats?.delete(existing);
-      }
-    }
-    entries.set(normalized, { kind: "symlink", mode: stat.mode, target: fs.readlinkSync(absolutePath) });
-    stats?.set(normalized, stat);
-    return;
-  }
-  if (stat.isFile()) {
-    entries.set(normalized, { kind: "file", mode: stat.mode, size: stat.size });
-    stats?.set(normalized, stat);
-    return;
-  }
-  if (!stat.isDirectory()) return;
-  entries.set(normalized, { kind: "directory", mode: stat.mode });
-  stats?.set(normalized, stat);
-  if (!recurseDirectories) return;
-  for (const child of fs.readdirSync(absolutePath).sort()) {
-    addEntry(entries, root, path.posix.join(normalized, child), true, gitlinks, stats);
-  }
-}
-function addParentDirectories(entries, root, stats) {
-  for (const relativePath of [...entries.keys()]) {
-    let parent = path.posix.dirname(relativePath);
-    while (parent !== ".") {
-      if (!entries.has(parent)) {
-        const inspected = inspectRelativePathWithoutFollowingAncestors(root, parent);
-        if (inspected.kind !== "entry" || !inspected.stat.isDirectory() || inspected.stat.isSymbolicLink()) {
-          throw new Error(`Working-tree entry has an unsafe parent directory: ${parent}`);
-        }
-        entries.set(parent, { kind: "directory", mode: inspected.stat.mode });
-        stats?.set(parent, inspected.stat);
-      }
-      parent = path.posix.dirname(parent);
-    }
-  }
-}
-function inspectGitWorkingTree(root, stats) {
-  const entries = /* @__PURE__ */ new Map();
-  const listing = listGitCheckout(root);
-  const indexGitlinks = /* @__PURE__ */ new Map();
-  for (const record of listing.indexRecords) {
-    if (record.mode === "160000" && !indexGitlinks.has(record.relativePath)) indexGitlinks.set(record.relativePath, record.objectId);
-  }
-  const submodules = /* @__PURE__ */ new Map();
-  let staleHeads = null;
-  for (const { relativePath, nestedRepository } of listing.roots) {
-    if (entries.has(relativePath)) continue;
-    const indexObjectId = indexGitlinks.get(relativePath);
-    if (indexObjectId === void 0 && !nestedRepository) {
-      addEntry(entries, root, relativePath, true, void 0, stats);
-      continue;
-    }
-    const inspected = inspectRelativePathWithoutFollowingAncestors(root, relativePath);
-    if (inspected.kind !== "entry") continue;
-    if (!inspected.stat.isDirectory() || inspected.stat.isSymbolicLink()) {
-      addEntry(entries, root, relativePath, true, void 0, stats);
-      continue;
-    }
-    const head = populatedCheckoutHead(root, inspected.absolutePath);
-    submodules.set(relativePath, head);
-    let objectId = indexObjectId ?? head;
-    if (head && indexObjectId !== void 0 && head !== indexObjectId) {
-      staleHeads ??= readGitlinkStaleHeads(root);
-      objectId = staleHeads.get(relativePath) === head ? indexObjectId : head;
-    }
-    if (objectId) {
-      entries.set(relativePath, { kind: "gitlink", objectId });
-      stats?.set(relativePath, inspected.stat);
-    }
-  }
-  addParentDirectories(entries, root, stats);
-  return { entries, indexRecords: listing.indexRecords, submodules };
-}
-function normalizedGitlinks(gitlinks) {
-  const normalized = /* @__PURE__ */ new Map();
-  for (const [relativePath, objectId] of gitlinks ?? []) {
-    const relative = normalizeRelativePath(relativePath);
-    if (!relative) throw new Error(`Invalid working-tree gitlink path: ${relativePath}`);
-    if (!OBJECT_ID_PATTERN.test(objectId)) throw new Error(`Invalid working-tree gitlink object id for ${relativePath}: ${objectId}`);
-    normalized.set(relative, objectId);
-  }
-  return normalized;
-}
-function inspectWorkingTree(root, mode, options = {}) {
-  const entries = /* @__PURE__ */ new Map();
-  root = path.resolve(root);
-  if (!inspectDirectoryRoot(root, { allowMissing: true, label: "Working-tree root" })) return entries;
-  if (mode === "git") return inspectGitWorkingTree(root, options.stats).entries;
-  const gitlinks = normalizedGitlinks(options.gitlinks);
-  for (const child of fs.readdirSync(root).sort()) addEntry(entries, root, child, true, gitlinks, options.stats);
-  for (const [relativePath, objectId] of gitlinks) {
-    if (entries.get(relativePath)?.kind !== "gitlink") {
-      entries.set(relativePath, { kind: "gitlink", objectId });
-      options.stats?.delete(relativePath);
-    }
-  }
-  addParentDirectories(entries, root, options.stats);
-  return entries;
-}
-function removeEntry(targetRoot, relativePath) {
-  const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (inspected.kind === "missing") return;
-  if (inspected.kind === "blocked") {
-    throw new Error(`Refusing to remove a working-tree path through a symlink or non-directory: ${inspected.blockingPath}`);
-  }
-  fs.rmSync(inspected.absolutePath, { recursive: true, force: true });
-}
-function assertTargetExpectation(targetRoot, relativePath, guards) {
-  if (!guards?.expectations?.has(relativePath)) return;
-  const expected = guards.expectations.get(relativePath) ?? null;
-  const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (expected === null) {
-    if (inspected.kind === "missing") return;
-    throw new WorkingTreeTargetChangedError(relativePath);
-  }
-  if (expected.isDirectory() && !expected.isSymbolicLink()) {
-    if (inspected.kind === "entry" && inspected.stat.isDirectory() && !inspected.stat.isSymbolicLink()) return;
-    throw new WorkingTreeTargetChangedError(relativePath);
-  }
-  if (inspected.kind !== "entry" || !workingTreeStatsMatch(expected, inspected.stat)) throw new WorkingTreeTargetChangedError(relativePath);
-}
-const DISPLACED_RETENTION_DIRECTORY = "hydration-displaced";
-const RETAINED_NAME_MAX_ENCODED_LENGTH = 150;
-const YIELD_ATTEMPTS = 4;
-const passStates = /* @__PURE__ */ new WeakMap();
-function newPassState(targetRoot) {
-  const retention = retentionDirectoryFor(targetRoot);
-  const primitives = atomicRenamePrimitivesFor(retention ?? targetRoot);
-  return { targetRoot, retention, primitives, exchangeUnavailable: primitives.support.exchange === "unavailable" };
-}
-function workingTreeAtomicRenameSupport(targetRoot) {
-  return newPassState(path.resolve(targetRoot)).primitives.support;
-}
-function guardedPassState(guards, targetRoot) {
-  let state = passStates.get(guards);
-  if (!state) {
-    state = newPassState(targetRoot);
-    passStates.set(guards, state);
-  }
-  return state;
-}
-function workingTreeDisplacedRetentionDirectory(targetRoot) {
-  const gitDirectory = checkoutGitDirectory(path.resolve(targetRoot));
-  return gitDirectory ? path.join(gitDirectory, "r5d", DISPLACED_RETENTION_DIRECTORY) : null;
-}
-function retentionDirectoryFor(targetRoot) {
-  const directory = workingTreeDisplacedRetentionDirectory(targetRoot);
-  if (!directory) return null;
-  try {
-    fs.mkdirSync(directory, { recursive: true, mode: 448 });
-    const status = fs.lstatSync(directory);
-    if (!status.isDirectory() || status.isSymbolicLink()) return null;
-    if (status.dev !== fs.lstatSync(targetRoot).dev) return null;
-    return directory;
-  } catch {
-    return null;
-  }
-}
-function encodeRetainedName(relativePath) {
-  let encoded = "";
-  for (const byte of Buffer.from(relativePath, "utf8")) {
-    const isPlain = byte >= 48 && byte <= 57 || byte >= 65 && byte <= 90 || byte >= 97 && byte <= 122 || byte === 45 || byte === 46 || byte === 95;
-    encoded += isPlain ? String.fromCharCode(byte) : `%${byte.toString(16).padStart(2, "0")}`;
-  }
-  return encoded.length > RETAINED_NAME_MAX_ENCODED_LENGTH ? encoded.slice(0, RETAINED_NAME_MAX_ENCODED_LENGTH) : encoded;
-}
-function stagingPathFor(state, targetPath, relativePath) {
-  if (state.retention) return path.join(state.retention, `${randomUUID()}.${encodeRetainedName(relativePath)}`);
-  return path.join(path.dirname(targetPath), `${MIRROR_TEMPORARY_FILE_PREFIX}${randomUUID()}.tmp`);
-}
-function switchExpectation(targetRoot, relativePath, guards) {
-  if (guards.expectations?.has(relativePath)) return guards.expectations.get(relativePath) ?? null;
-  const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (inspected.kind === "blocked") throw new Error(`Refusing to copy through a symlink or non-directory: ${inspected.blockingPath}`);
-  return inspected.kind === "entry" ? inspected.stat : null;
-}
-function settledAfter(targetPath, stagedStat, stagedContent) {
-  const current = lstatIfExists(targetPath);
-  return current && displacedEntryMatches(stagedStat, current) && entryContent(targetPath, current) === stagedContent ? current : stagedStat;
-}
-function entryContent(filePath, expected, expectedBlob) {
-  try {
-    if (expected.isSymbolicLink()) {
-      const before = fs.lstatSync(filePath);
-      if (!workingTreeStatsMatch(expected, before)) return null;
-      const bytes = Buffer.from(fs.readlinkSync(filePath));
-      if (!workingTreeStatsMatch(before, fs.lstatSync(filePath))) return null;
-      const digest = createHash("sha256").update(`blob ${bytes.length}\0`).update(bytes).digest("hex");
-      if (expectedBlob && (expectedBlob.length === 64 ? digest : createHash("sha1").update(`blob ${bytes.length}\0`).update(bytes).digest("hex")) !== expectedBlob)
-        return null;
-      return digest;
-    }
-    if (!expected.isFile()) return null;
-    const descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-    try {
-      const before = fs.fstatSync(descriptor);
-      if (!workingTreeStatsMatch(expected, before)) return null;
-      const hash = createHash("sha256").update(`blob ${before.size}\0`);
-      const knownHash = expectedBlob && expectedBlob.length !== 64 ? createHash("sha1").update(`blob ${before.size}\0`) : null;
-      const buffer = Buffer.allocUnsafe(64 * 1024);
-      for (let offset = 0; offset < before.size; ) {
-        const count = fs.readSync(descriptor, buffer, 0, Math.min(buffer.length, before.size - offset), offset);
-        if (count <= 0) return null;
-        const bytes = buffer.subarray(0, count);
-        hash.update(bytes);
-        knownHash?.update(bytes);
-        offset += count;
-      }
-      if (!workingTreeStatsMatch(before, fs.fstatSync(descriptor)) || !workingTreeStatsMatch(before, fs.lstatSync(filePath))) return null;
-      const digest = hash.digest("hex");
-      if (expectedBlob && (knownHash ? knownHash.digest("hex") : digest) !== expectedBlob) return null;
-      return digest;
-    } finally {
-      fs.closeSync(descriptor);
-    }
-  } catch (error) {
-    if (isPathStateCode(error.code) || error.code === "ELOOP") return null;
-    throw error;
-  }
-}
-function fsyncRetainedEntry(retainedPath) {
-  const status = fs.lstatSync(retainedPath);
-  if (status.isDirectory() && !status.isSymbolicLink()) {
-    for (const child of fs.readdirSync(retainedPath)) fsyncRetainedEntry(path.join(retainedPath, child));
-    fsyncPath(retainedPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-  } else if (status.isFile()) {
-    fsyncPath(retainedPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-  }
-  fsyncPath(path.dirname(retainedPath), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-}
-function retainForeign(journal, relativePath, retainedPath, reason) {
-  fsyncRetainedEntry(retainedPath);
-  const retained = { relativePath, path: retainedPath, reason };
-  if (journal) (journal.retained ??= []).push(retained);
-  return retained;
-}
-function isPathStateCode(code) {
-  return code === "EEXIST" || code === "ENOENT" || code === "ENOTDIR" || code === "ENOTEMPTY" || code === "EISDIR";
-}
-function publishNoReplace(state, stagedPath, stagedStat, relativePath, targetPath) {
-  if (stagedStat.isSymbolicLink() && state.primitives.support.noReplace === "link") {
-    throw new WorkingTreeTargetChangedError(relativePath, { detail: "filesystem cannot publish a symlink with provable ownership" });
-  }
-  try {
-    state.primitives.renameNoReplace(stagedPath, targetPath);
-  } catch (error) {
-    if (error instanceof AtomicRenameError && isPathStateCode(error.code)) throw new WorkingTreeTargetChangedError(relativePath);
-    throw error;
-  }
-  return null;
-}
-function restoreDisplacedNoReplace(state, displacedPath, displaced, targetPath) {
-  try {
-    if (displaced.isSymbolicLink() && state.primitives.support.noReplace === "link") {
-      return false;
-    }
-    state.primitives.renameNoReplace(displacedPath, targetPath);
-    return true;
-  } catch (error) {
-    const code = error instanceof AtomicRenameError ? error.code : error.code;
-    if (isPathStateCode(code) || code === "ENOTSUP") return false;
-    throw error;
-  }
-}
-function discardStaged(input, reason) {
-  const current = lstatIfExists(input.stagedPath);
-  if (!current) return null;
-  if (input.onFailure === "unlink" && input.stagedContent && displacedEntryMatches(input.stagedStat, current) && entryContent(input.stagedPath, current) === input.stagedContent) {
-    fs.rmSync(input.stagedPath, { force: true });
-    return null;
-  }
-  return retainForeign(input.journal, input.relativePath, input.stagedPath, reason);
-}
-function discardStagedAndThrow(input, error) {
-  const retained = discardStaged(input, "unrestorable");
-  if (retained && error instanceof WorkingTreeTargetChangedError) {
-    throw new WorkingTreeTargetChangedError(input.relativePath, { detail: error.message, retained: [...error.retained, retained] });
-  }
-  throw error;
-}
-function switchStagedEntry(input) {
-  const { state, targetRoot, relativePath, targetPath, stagedPath, stagedStat, expected } = input;
-  const stagedContent = input.stagedContent ?? entryContent(stagedPath, stagedStat);
-  if (!stagedContent) {
-    const retained = retainForeign(input.journal, relativePath, stagedPath, "unrestorable");
-    throw new WorkingTreeTargetChangedError(relativePath, { retained: [retained] });
-  }
-  input.stagedContent = stagedContent;
-  if (stagedStat.isSymbolicLink() && state.primitives.support.noReplace === "link") {
-    discardStagedAndThrow(
-      input,
-      new WorkingTreeTargetChangedError(relativePath, { detail: "filesystem cannot publish a symlink with provable ownership" })
-    );
-  }
-  const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (inspected.kind === "blocked") {
-    discardStagedAndThrow(input, new Error(`Refusing to copy through a symlink or non-directory: ${inspected.blockingPath}`));
-  }
-  if (expected === null) {
-    if (inspected.kind !== "missing") {
-      discardStagedAndThrow(input, new WorkingTreeTargetChangedError(relativePath));
-    }
-    raceWindow(input.phase, relativePath, targetPath);
-    let created;
-    try {
-      created = publishNoReplace(state, stagedPath, stagedStat, relativePath, targetPath);
-    } catch (error) {
-      discardStagedAndThrow(input, error);
-    }
-    raceWindow("after_switch", relativePath, targetPath);
-    return { after: created ?? settledAfter(targetPath, stagedStat, stagedContent), afterContent: stagedContent, displaced: null };
-  }
-  if (inspected.kind !== "entry" || !workingTreeStatsMatch(expected, inspected.stat)) {
-    discardStagedAndThrow(input, new WorkingTreeTargetChangedError(relativePath));
-  }
-  const expectedContent = entryContent(targetPath, expected, input.expectedBlob);
-  if (!expectedContent || input.expectedContent && input.expectedContent !== expectedContent) {
-    discardStagedAndThrow(input, new WorkingTreeTargetChangedError(relativePath));
-  }
-  input.expectedContent = expectedContent;
-  raceWindow(input.phase, relativePath, targetPath);
-  if (!state.exchangeUnavailable) {
-    try {
-      state.primitives.exchange(stagedPath, targetPath);
-    } catch (error) {
-      if (isAtomicRenameUnsupported(error)) {
-        state.exchangeUnavailable = true;
-        return switchWithoutExchange(input);
-      }
-      if (error instanceof AtomicRenameError && isPathStateCode(error.code)) {
-        discardStagedAndThrow(input, new WorkingTreeTargetChangedError(relativePath, { detail: `${error.code} at the switch` }));
-      }
-      discardStagedAndThrow(input, error);
-    }
-    raceWindow("after_switch", relativePath, targetPath);
-    const displaced = fs.lstatSync(stagedPath);
-    if (displacedEntryMatches(expected, displaced) && entryContent(stagedPath, displaced) === expectedContent) {
-      return {
-        after: settledAfter(targetPath, stagedStat, stagedContent),
-        afterContent: stagedContent,
-        displaced: { path: stagedPath, stat: displaced, content: expectedContent }
-      };
-    }
-    return yieldDisplacedEntry(input, displaced);
-  }
-  return switchWithoutExchange(input);
-}
-function yieldDisplacedEntry(input, displaced) {
-  const { state, relativePath, targetPath, stagedPath, stagedStat } = input;
-  raceWindow("before_yield", relativePath, targetPath);
-  let installedBefore = stagedStat;
-  let toInstall = displaced;
-  for (let attempt = 0; attempt < YIELD_ATTEMPTS; attempt += 1) {
-    try {
-      state.primitives.exchange(stagedPath, targetPath);
-    } catch (error) {
-      if (!(error instanceof AtomicRenameError && isPathStateCode(error.code))) throw error;
-      if (restoreDisplacedNoReplace(state, stagedPath, toInstall, targetPath)) {
-        throw new WorkingTreeTargetChangedError(relativePath, { detail: "another writer replaced the entry; its bytes were kept" });
-      }
-      const retained2 = retainForeign(input.journal, relativePath, stagedPath, "later_writer");
-      throw new WorkingTreeTargetChangedError(relativePath, { retained: [retained2] });
-    }
-    const returned = fs.lstatSync(stagedPath);
-    if (sameWorkingTreeInode(returned, installedBefore)) {
-      if (sameWorkingTreeInode(returned, stagedStat)) {
-        discardStagedAndThrow(
-          input,
-          new WorkingTreeTargetChangedError(relativePath, { detail: "another writer replaced the entry; its bytes were kept" })
-        );
-      }
-      const retained2 = retainForeign(input.journal, relativePath, stagedPath, "later_writer");
-      throw new WorkingTreeTargetChangedError(relativePath, { retained: [retained2] });
-    }
-    installedBefore = toInstall;
-    toInstall = returned;
-  }
-  const retained = retainForeign(input.journal, relativePath, stagedPath, "unrestorable");
-  throw new WorkingTreeTargetChangedError(relativePath, { detail: "the path kept changing while the pass yielded", retained: [retained] });
-}
-function switchWithoutExchange(input) {
-  const { state, relativePath, targetPath, stagedPath, stagedStat, expected } = input;
-  const park = stagingPathFor(state, targetPath, relativePath);
-  try {
-    fs.renameSync(targetPath, park);
-  } catch (error) {
-    if (isPathStateCode(error.code))
-      discardStagedAndThrow(input, new WorkingTreeTargetChangedError(relativePath, { detail: "removed before the switch" }));
-    discardStagedAndThrow(input, error);
-  }
-  raceWindow("after_switch", relativePath, targetPath);
-  const displaced = fs.lstatSync(park);
-  if (displacedEntryMatches(expected, displaced) && entryContent(park, displaced) === input.expectedContent) {
-    let created;
-    try {
-      created = publishNoReplace(state, stagedPath, stagedStat, relativePath, targetPath);
-    } catch (error) {
-      if (error instanceof WorkingTreeTargetChangedError) {
-        const retained2 = retainForeign(input.journal, relativePath, park, "reappeared");
-        discardStagedAndThrow(
-          input,
-          new WorkingTreeTargetChangedError(relativePath, {
-            detail: "an entry was created while the path was being replaced",
-            retained: [retained2]
-          })
-        );
-      }
-      if (!restoreDisplacedNoReplace(state, park, displaced, targetPath)) retainForeign(input.journal, relativePath, park, "unrestorable");
-      discardStagedAndThrow(input, error);
-    }
-    return {
-      after: created ?? settledAfter(targetPath, stagedStat, input.stagedContent),
-      afterContent: input.stagedContent,
-      displaced: { path: park, stat: displaced, content: input.expectedContent }
-    };
-  }
-  raceWindow("before_yield", relativePath, targetPath);
-  const stagedRetained = discardStaged(input, "unrestorable");
-  if (restoreDisplacedNoReplace(state, park, displaced, targetPath)) {
-    throw new WorkingTreeTargetChangedError(relativePath, {
-      detail: "another writer replaced the entry; its bytes were kept",
-      retained: stagedRetained ? [stagedRetained] : []
-    });
-  }
-  const retained = retainForeign(input.journal, relativePath, park, "later_writer");
-  throw new WorkingTreeTargetChangedError(relativePath, { retained: [...stagedRetained ? [stagedRetained] : [], retained] });
-}
-function removeSwitchedEntry(input) {
-  const { state, targetRoot, relativePath, targetPath, expected } = input;
-  const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (inspected.kind === "blocked") {
-    throw new Error(`Refusing to remove a working-tree path through a symlink or non-directory: ${inspected.blockingPath}`);
-  }
-  if (inspected.kind !== "entry" || !workingTreeStatsMatch(expected, inspected.stat)) throw new WorkingTreeTargetChangedError(relativePath);
-  const content = entryContent(targetPath, expected, input.expectedBlob);
-  if (!content || input.expectedContent && content !== input.expectedContent) throw new WorkingTreeTargetChangedError(relativePath);
-  raceWindow(input.phase, relativePath, targetPath);
-  const park = stagingPathFor(state, targetPath, relativePath);
-  try {
-    fs.renameSync(targetPath, park);
-  } catch (error) {
-    if (isPathStateCode(error.code))
-      throw new WorkingTreeTargetChangedError(relativePath, { detail: "removed before the switch" });
-    throw error;
-  }
-  raceWindow("after_remove", relativePath, targetPath);
-  const displaced = fs.lstatSync(park);
-  if (displacedEntryMatches(expected, displaced) && entryContent(park, displaced) === content)
-    return { path: park, stat: displaced, content };
-  raceWindow("before_yield", relativePath, targetPath);
-  if (restoreDisplacedNoReplace(state, park, displaced, targetPath)) {
-    throw new WorkingTreeTargetChangedError(relativePath, { detail: "another writer replaced the entry; its bytes were kept" });
-  }
-  const retained = retainForeign(input.journal, relativePath, park, "later_writer");
-  throw new WorkingTreeTargetChangedError(relativePath, { retained: [retained] });
-}
-function removeEntryGuarded(targetRoot, relativePath, replaced, guards) {
-  if (!guards) {
-    removeEntry(targetRoot, relativePath);
-    return;
-  }
-  const state = guardedPassState(guards, targetRoot);
-  const expected = switchExpectation(targetRoot, relativePath, guards);
-  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
-  assertInside(targetRoot, targetPath);
-  const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (inspected.kind === "blocked") {
-    throw new Error(`Refusing to remove a working-tree path through a symlink or non-directory: ${inspected.blockingPath}`);
-  }
-  if (expected === null) {
-    if (inspected.kind !== "missing") throw new WorkingTreeTargetChangedError(relativePath);
-    return;
-  }
-  if (expected.isDirectory() && !expected.isSymbolicLink()) {
-    if (inspected.kind === "entry") {
-      if (!inspected.stat.isDirectory() || inspected.stat.isSymbolicLink()) throw new WorkingTreeTargetChangedError(relativePath);
-      raceWindow("before_remove", relativePath, targetPath);
-      try {
-        fs.rmdirSync(inspected.absolutePath);
-      } catch (error) {
-        const code = error.code;
-        if (code === "ENOTEMPTY" || code === "EEXIST" || code === "ENOTDIR") throw new WorkingTreeTargetChangedError(relativePath);
-        if (code !== "ENOENT") throw error;
-      }
-    }
-    if (guards.expectations?.has(relativePath)) guards.expectations.set(relativePath, null);
-    if (replaced) guards.journal?.entries.push({ relativePath, replaced, after: null });
-    return;
-  }
-  const displaced = removeSwitchedEntry({
-    state,
-    targetRoot,
-    relativePath,
-    targetPath,
-    expected,
-    expectedBlob: guards.preBlobs?.get(relativePath),
-    journal: guards.journal,
-    phase: "before_remove"
-  });
-  if (guards.expectations?.has(relativePath)) guards.expectations.set(relativePath, null);
-  const recorded = replaced ?? treeEntryFromStat(displaced.stat, displaced.path);
-  if (guards.journal && recorded) guards.journal.entries.push({ relativePath, replaced: recorded, after: null, displaced });
-  else releaseRetainedEntry(void 0, relativePath, displaced);
-}
-function ensureDirectoryGuarded(targetRoot, relativePath, guards) {
-  if (!guards) {
-    ensureDirectory(targetRoot, relativePath, 493);
-    return;
-  }
-  const normalized = normalizeRelativePath(relativePath);
-  if (!normalized) throw new Error(`Invalid working-tree directory path: ${relativePath}`);
-  let current = path.resolve(targetRoot);
-  let relative = "";
-  for (const segment of normalized.split("/")) {
-    current = path.join(current, segment);
-    relative = relative ? `${relative}/${segment}` : segment;
-    assertInside(targetRoot, current);
-    const stat = lstatIfExists(current);
-    if (stat && (!stat.isDirectory() || stat.isSymbolicLink())) throw new WorkingTreeTargetChangedError(relative);
-    if (stat) continue;
-    try {
-      fs.mkdirSync(current, { mode: 493 });
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      const now = lstatIfExists(current);
-      if (!now || !now.isDirectory() || now.isSymbolicLink()) throw new WorkingTreeTargetChangedError(relative);
-    }
-  }
-}
-function replaceWithSymlink(targetRoot, relativePath, target) {
-  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
-  assertInside(targetRoot, targetPath);
-  const temporaryPath = path.join(path.dirname(targetPath), `${MIRROR_TEMPORARY_FILE_PREFIX}${randomUUID()}.tmp`);
-  fs.symlinkSync(target, temporaryPath);
-  try {
-    const current = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-    if (current.kind === "blocked") throw new Error(`Refusing to copy through a symlink or non-directory: ${current.blockingPath}`);
-    if (current.kind === "entry" && current.stat.isDirectory() && !current.stat.isSymbolicLink()) removeEntry(targetRoot, relativePath);
-    fs.renameSync(temporaryPath, targetPath);
-  } catch (error) {
-    fs.rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-}
-function ensureDirectory(targetRoot, relativePath, mode) {
-  const normalized = normalizeRelativePath(relativePath);
-  if (!normalized) throw new Error(`Invalid working-tree directory path: ${relativePath}`);
-  let current = path.resolve(targetRoot);
-  const segments = normalized.split("/");
-  for (let index = 0; index < segments.length; index += 1) {
-    current = path.join(current, segments[index]);
-    assertInside(targetRoot, current);
-    let stat = null;
-    try {
-      stat = fs.lstatSync(current);
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-    if (stat && (!stat.isDirectory() || stat.isSymbolicLink())) {
-      fs.rmSync(current, { recursive: true, force: true });
-      stat = null;
-    }
-    if (!stat) fs.mkdirSync(current, { mode: index === segments.length - 1 ? mode & 511 : 493 });
-  }
-}
-function filesEqual(leftPath, rightPath, entry) {
-  let rightStat;
-  try {
-    rightStat = fs.lstatSync(rightPath);
-  } catch {
-    return false;
-  }
-  if (!rightStat.isFile() || rightStat.size !== entry.size || (rightStat.mode & 511) !== (entry.mode & 511)) return false;
-  let left;
-  let right;
-  try {
-    left = fs.openSync(leftPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-    right = fs.openSync(rightPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-  } catch {
-    if (left !== void 0) fs.closeSync(left);
-    if (right !== void 0) fs.closeSync(right);
-    return false;
-  }
-  const leftBuffer = Buffer.allocUnsafe(64 * 1024);
-  const rightBuffer = Buffer.allocUnsafe(64 * 1024);
-  try {
-    let offset = 0;
-    while (offset < entry.size) {
-      const length = Math.min(leftBuffer.length, entry.size - offset);
-      const leftRead = fs.readSync(left, leftBuffer, 0, length, offset);
-      const rightRead = fs.readSync(right, rightBuffer, 0, length, offset);
-      if (leftRead <= 0 || rightRead <= 0) return false;
-      if (leftRead !== rightRead || !leftBuffer.subarray(0, leftRead).equals(rightBuffer.subarray(0, rightRead))) return false;
-      offset += leftRead;
-    }
-    return true;
-  } finally {
-    fs.closeSync(left);
-    fs.closeSync(right);
-  }
-}
-function stageRegularFile(sourcePath, stagedPath, entry, durability) {
-  const source = fs.openSync(sourcePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-  let target;
-  try {
-    const sourceStat = fs.fstatSync(source);
-    if (!sourceStat.isFile() || sourceStat.size !== entry.size || (sourceStat.mode & 511) !== (entry.mode & 511)) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    target = fs.openSync(
-      stagedPath,
-      fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW,
-      entry.mode & 511
-    );
-    const buffer = Buffer.allocUnsafe(64 * 1024);
-    let offset = 0;
-    while (offset < sourceStat.size) {
-      const bytesRead = fs.readSync(source, buffer, 0, Math.min(buffer.length, sourceStat.size - offset), offset);
-      if (bytesRead <= 0) throw new Error(`Working-tree source ended while it was being mirrored: ${sourcePath}`);
-      let written = 0;
-      while (written < bytesRead) {
-        written += fs.writeSync(target, buffer, written, bytesRead - written, offset + written);
-      }
-      offset += bytesRead;
-    }
-    fs.fchmodSync(target, entry.mode & 511);
-    if (durability === "per_entry") fs.fsyncSync(target);
-    const finalSourceStat = fs.fstatSync(source);
-    if (!finalSourceStat.isFile() || finalSourceStat.size !== sourceStat.size || (finalSourceStat.mode & 511) !== (sourceStat.mode & 511) || finalSourceStat.mtimeMs !== sourceStat.mtimeMs || finalSourceStat.ctimeMs !== sourceStat.ctimeMs) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    const stagedStat = fs.fstatSync(target);
-    fs.closeSync(target);
-    target = void 0;
-    return { sourceStat: finalSourceStat, stagedStat };
-  } catch (error) {
-    if (target !== void 0) {
-      fs.closeSync(target);
-      target = void 0;
-    }
-    fs.rmSync(stagedPath, { force: true });
-    throw error;
-  } finally {
-    if (target !== void 0) fs.closeSync(target);
-    fs.closeSync(source);
-  }
-}
-function writeStagedContent(stagedPath, override, durability) {
-  const target = fs.openSync(
-    stagedPath,
-    fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW,
-    override.mode & 511
-  );
-  try {
-    let written = 0;
-    while (written < override.content.length) {
-      written += fs.writeSync(target, override.content, written, override.content.length - written, written);
-    }
-    fs.fchmodSync(target, override.mode & 511);
-    if (durability === "per_entry") fs.fsyncSync(target);
-    return fs.fstatSync(target);
-  } catch (error) {
-    fs.rmSync(stagedPath, { force: true });
-    throw error;
-  } finally {
-    fs.closeSync(target);
-  }
-}
-function copyRegularFile(sourcePath, targetPath, entry, durability) {
-  const temporaryPath = path.join(path.dirname(targetPath), `${MIRROR_TEMPORARY_FILE_PREFIX}${randomUUID()}.tmp`);
-  const { sourceStat } = stageRegularFile(sourcePath, temporaryPath, entry, durability);
-  try {
-    fs.renameSync(temporaryPath, targetPath);
-  } catch (error) {
-    fs.rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-  if (durability === "per_entry") fsyncPath(path.dirname(targetPath), fs.constants.O_RDONLY);
-  return sourceStat;
-}
-function copyEntry(sourceRoot, targetRoot, relativePath, entry, durability) {
-  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
-  assertInside(targetRoot, targetPath);
-  const parent = path.posix.dirname(relativePath);
-  if (parent !== ".") ensureDirectory(targetRoot, parent, 493);
-  const source = inspectRelativePathWithoutFollowingAncestors(sourceRoot, relativePath);
-  if (source.kind !== "entry") {
-    throw new Error(`Working-tree source became unsafe while it was being mirrored: ${relativePath}`);
-  }
-  const sourcePath = source.absolutePath;
-  if (entry.kind === "directory") {
-    if (!source.stat.isDirectory() || source.stat.isSymbolicLink()) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    ensureDirectory(targetRoot, relativePath, entry.mode);
-    return null;
-  }
-  if (entry.kind === "symlink") {
-    if (!source.stat.isSymbolicLink() || fs.readlinkSync(sourcePath) !== entry.target) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    let unchanged = false;
-    try {
-      unchanged = fs.lstatSync(targetPath).isSymbolicLink() && fs.readlinkSync(targetPath) === entry.target;
-    } catch {
-      unchanged = false;
-    }
-    if (!unchanged) replaceWithSymlink(targetRoot, relativePath, entry.target);
-    return { kind: "symlink", target: entry.target };
-  }
-  if (entry.kind === "gitlink") {
-    throw new Error(`Working-tree gitlink cannot be copied as content: ${relativePath}`);
-  }
-  if (!source.stat.isFile() || source.stat.isSymbolicLink() || source.stat.size !== entry.size) {
-    throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-  }
-  if (filesEqual(sourcePath, targetPath, entry)) {
-    const settled = fs.lstatSync(sourcePath);
-    if (!settled.isFile() || settled.ino !== source.stat.ino || settled.size !== source.stat.size || settled.mode !== source.stat.mode) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    if (settled.mtimeMs !== source.stat.mtimeMs || settled.ctimeMs !== source.stat.ctimeMs) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    return projectedFileEntry(settled);
-  }
-  const target = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (target.kind === "blocked") {
-    throw new Error(`Refusing to copy through a symlink or non-directory: ${target.blockingPath}`);
-  }
-  if (target.kind === "entry" && !target.stat.isFile()) removeEntry(targetRoot, relativePath);
-  return projectedFileEntry(copyRegularFile(sourcePath, targetPath, entry, durability));
-}
-function copyEntryGuarded(sourceRoot, targetRoot, relativePath, entry, durability, guards) {
-  const state = guardedPassState(guards, targetRoot);
-  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
-  assertInside(targetRoot, targetPath);
-  const parent = path.posix.dirname(relativePath);
-  if (parent !== ".") ensureDirectoryGuarded(targetRoot, parent, guards);
-  const override = guards.overrides?.get(relativePath);
-  if (override && entry.kind !== "file") throw new Error(`Working-tree override must replace a regular file: ${relativePath}`);
-  let sourcePath = null;
-  let sourceStat = null;
-  if (!override) {
-    const source = inspectRelativePathWithoutFollowingAncestors(sourceRoot, relativePath);
-    if (source.kind !== "entry") throw new Error(`Working-tree source became unsafe while it was being mirrored: ${relativePath}`);
-    sourcePath = source.absolutePath;
-    sourceStat = source.stat;
-  }
-  if (entry.kind === "directory") {
-    if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    const target2 = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-    if (target2.kind === "blocked") throw new Error(`Refusing to copy through a symlink or non-directory: ${target2.blockingPath}`);
-    if (target2.kind === "entry" && target2.stat.isDirectory() && !target2.stat.isSymbolicLink()) return null;
-    if (target2.kind === "entry") {
-      if (guards.expectations && !guards.expectations.has(relativePath)) throw new WorkingTreeTargetChangedError(relativePath);
-      removeEntryGuarded(targetRoot, relativePath, treeEntryFromStat(target2.stat, target2.absolutePath), guards);
-    } else assertTargetExpectation(targetRoot, relativePath, guards);
-    createDirectoryGuarded(targetRoot, relativePath, entry.mode, guards);
-    return null;
-  }
-  if (entry.kind === "gitlink") {
-    throw new Error(`Working-tree gitlink cannot be copied as content: ${relativePath}`);
-  }
-  const target = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (target.kind === "blocked") throw new Error(`Refusing to copy through a symlink or non-directory: ${target.blockingPath}`);
-  if (entry.kind === "symlink") {
-    if (!sourceStat.isSymbolicLink() || fs.readlinkSync(sourcePath) !== entry.target) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    if (target.kind === "entry" && target.stat.isSymbolicLink() && fs.readlinkSync(target.absolutePath) === entry.target) {
-      return { kind: "symlink", target: entry.target };
-    }
-  } else if (!override) {
-    if (!sourceStat.isFile() || sourceStat.isSymbolicLink() || sourceStat.size !== entry.size) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-    }
-    if (filesEqual(sourcePath, targetPath, entry)) {
-      const settled = fs.lstatSync(sourcePath);
-      if (!settled.isFile() || settled.ino !== sourceStat.ino || settled.size !== sourceStat.size || settled.mode !== sourceStat.mode) {
-        throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-      }
-      if (settled.mtimeMs !== sourceStat.mtimeMs || settled.ctimeMs !== sourceStat.ctimeMs) {
-        throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
-      }
-      return projectedFileEntry(settled);
-    }
-  }
-  let replaced = target.kind === "entry" ? treeEntryFromStat(target.stat, target.absolutePath) : null;
-  let expected = switchExpectation(targetRoot, relativePath, guards);
-  if (target.kind === "entry" && target.stat.isDirectory() && !target.stat.isSymbolicLink()) {
-    removeEntryGuarded(targetRoot, relativePath, replaced, guards);
-    replaced = null;
-    expected = null;
-  }
-  const stagedPath = stagingPathFor(state, targetPath, relativePath);
-  let stagedStat;
-  let projected = null;
-  if (entry.kind === "symlink") {
-    fs.symlinkSync(entry.target, stagedPath);
-    stagedStat = fs.lstatSync(stagedPath);
-    projected = { kind: "symlink", target: entry.target };
-  } else if (override) {
-    stagedStat = writeStagedContent(stagedPath, override, durability);
-  } else {
-    const staged = stageRegularFile(sourcePath, stagedPath, entry, durability);
-    stagedStat = staged.stagedStat;
-    projected = projectedFileEntry(staged.sourceStat);
-  }
-  const outcome = switchStagedEntry({
-    state,
-    targetRoot,
-    relativePath,
-    targetPath,
-    stagedPath,
-    stagedStat,
-    expected,
-    expectedBlob: guards.preBlobs?.get(relativePath),
-    journal: guards.journal,
-    phase: "before_switch",
-    onFailure: "unlink"
-  });
-  if (durability === "per_entry") fsyncPath(path.dirname(targetPath), fs.constants.O_RDONLY);
-  if (guards.journal)
-    guards.journal.entries.push({
-      relativePath,
-      replaced,
-      after: outcome.after,
-      afterContent: outcome.afterContent,
-      ...outcome.displaced ? { displaced: outcome.displaced } : {}
-    });
-  else if (outcome.displaced) releaseRetainedEntry(void 0, relativePath, outcome.displaced);
-  if (guards.expectations?.has(relativePath)) guards.expectations.set(relativePath, outcome.after);
-  return projected;
-}
-function createDirectoryGuarded(targetRoot, relativePath, mode, guards) {
-  if (!guards) {
-    ensureDirectory(targetRoot, relativePath, mode);
-    return;
-  }
-  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
-  assertInside(targetRoot, targetPath);
-  try {
-    fs.mkdirSync(targetPath, { mode: mode & 511 });
-  } catch (error) {
-    if (isPathStateCode(error.code)) throw new WorkingTreeTargetChangedError(relativePath);
-    throw error;
-  }
-  if (!guards.journal) return;
-  const created = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-  if (created.kind !== "entry" || !created.stat.isDirectory() || created.stat.isSymbolicLink()) {
-    throw new WorkingTreeTargetChangedError(relativePath);
-  }
-  guards.journal.entries.push({ relativePath, replaced: null, after: created.stat });
-}
-function retainedEntryIntact(retained, current) {
-  return retained.content !== void 0 && sameWorkingTreeInode(retained.stat, current) && current.mode === retained.stat.mode && current.size === retained.stat.size && current.mtimeMs === retained.stat.mtimeMs && current.ctimeMs === retained.stat.ctimeMs && entryContent(retained.path, current) === retained.content;
-}
-function settleRetainedEntries(journal, targetRoot) {
-  raceWindow("before_settle", "", targetRoot);
-  for (const entry of journal.entries) {
-    if (!entry.displaced) continue;
-    const current = lstatIfExists(entry.displaced.path);
-    if (!current || !retainedEntryIntact(entry.displaced, current)) {
-      throw new WorkingTreeTargetChangedError(entry.relativePath, {
-        detail: "written through a descriptor opened before hydration replaced the path"
-      });
-    }
-  }
-  releaseRetainedEntries(journal);
-}
-function releaseRetainedEntries(journal) {
-  for (const entry of journal.entries) {
-    if (!entry.displaced) continue;
-    releaseRetainedEntry(journal, entry.relativePath, entry.displaced);
-    delete entry.displaced;
-  }
-}
-function releaseRetainedEntry(journal, relativePath, displaced) {
-  const current = lstatIfExists(displaced.path);
-  if (!current) return;
-  if (!retainedEntryIntact(displaced, current)) {
-    const retained = retainForeign(journal, relativePath, displaced.path, "unrestorable");
-    if (!journal) throw new WorkingTreeTargetChangedError(relativePath, { retained: [retained] });
-    return;
-  }
-  fs.rmSync(displaced.path, { force: true });
-}
-function inspectMirrorTarget(targetRoot, deletionMode, stats) {
-  if (deletionMode !== "git") return { existing: inspectWorkingTree(targetRoot, "all", { stats }), git: null };
-  const inspection = inspectGitWorkingTree(targetRoot, stats);
-  const occupied = /* @__PURE__ */ new Set();
-  for (const relativePath of inspection.submodules.keys()) {
-    const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-    if (inspected.kind === "entry" && inspected.stat.isDirectory() && fs.readdirSync(inspected.absolutePath).length > 0) {
-      occupied.add(relativePath);
-    }
-  }
-  return { existing: inspection.entries, git: { indexRecords: inspection.indexRecords, submodules: inspection.submodules, occupied } };
-}
-function shieldedDesiredPaths(desired, git) {
-  const shielded = /* @__PURE__ */ new Set();
-  if (git.submodules.size === 0) return shielded;
-  const roots = new Set(git.submodules.keys());
-  for (const [relativePath, entry] of desired) {
-    if (hasAncestorIn(relativePath, roots)) {
-      shielded.add(relativePath);
-      continue;
-    }
-    if (!roots.has(relativePath) || entry.kind === "gitlink") continue;
-    if (entry.kind === "directory" || git.occupied.has(relativePath)) shielded.add(relativePath);
-  }
-  return shielded;
-}
-function directoryShieldsSubmodule(relativePath, entry, git) {
-  if (!git || entry.kind !== "directory") return false;
-  const prefix = `${relativePath}/`;
-  for (const root of git.submodules.keys()) if (root.startsWith(prefix)) return true;
-  return false;
-}
-function planIndexChanges(desired, shielded, git) {
-  const removed = [];
-  const written = [];
-  const desiredGitlinks = /* @__PURE__ */ new Map();
-  for (const [relativePath, entry] of desired) {
-    if (entry.kind === "gitlink" && !shielded.has(relativePath)) desiredGitlinks.set(relativePath, entry.objectId);
-  }
-  const desiredGitlinkRoots = new Set(desiredGitlinks.keys());
-  const currentGitlinks = /* @__PURE__ */ new Map();
-  for (const record of git.indexRecords) {
-    const desiredObjectId = desiredGitlinks.get(record.relativePath);
-    if (record.mode === "160000") {
-      if (record.stage === 0) currentGitlinks.set(record.relativePath, record.objectId);
-      if (desiredObjectId !== void 0) {
-        if (desiredObjectId !== record.objectId) removed.push(record);
-        continue;
-      }
-      const desiredEntry = desired.get(record.relativePath);
-      if (desiredEntry?.kind !== "directory" && desiredEntry?.kind !== "gitlink" && !git.occupied.has(record.relativePath)) {
-        removed.push(record);
-      }
-      continue;
-    }
-    if (desiredObjectId !== void 0 || hasAncestorIn(record.relativePath, desiredGitlinkRoots)) removed.push(record);
-  }
-  for (const [relativePath, objectId] of desiredGitlinks) {
-    if (currentGitlinks.get(relativePath) !== objectId) written.push({ relativePath, objectId });
-  }
-  return { removed, written };
-}
-function indexInfoRecord(record) {
-  const stage = record.stage === 0 ? "" : ` ${record.stage}`;
-  return Buffer.concat([Buffer.from(`${record.mode} ${record.objectId}${stage}	`), Buffer.from(record.relativePath), Buffer.from([0])]);
-}
-function updateIndex(targetRoot, changes) {
-  if (changes.drop.length === 0 && changes.put.length === 0) return;
-  const feed = Buffer.concat([
-    ...changes.drop.map(
-      ({ relativePath, objectId }) => indexInfoRecord({ mode: "0", objectId: "0".repeat(objectId.length), stage: 0, relativePath })
-    ),
-    ...changes.put.map(indexInfoRecord)
-  ]);
-  gitOutput(
-    targetRoot,
-    ["-c", "core.fsync=index", "-c", "core.fsyncMethod=fsync", "update-index", "-z", "--index-info"],
-    "Update Git working-tree index",
-    { stdin: feed }
-  );
-  const gitDirectory = checkoutGitDirectory(targetRoot);
-  if (!gitDirectory) return;
-  const indexPath = path.join(gitDirectory, "index");
-  if (lstatIfExists(indexPath)?.isFile()) fsyncPath(indexPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-  fsyncPath(gitDirectory, fs.constants.O_RDONLY);
-}
-function recordGitlinkStaleHeads(targetRoot, desired, shielded, git) {
-  const heads = readGitlinkStaleHeads(targetRoot);
-  let changed = false;
-  for (const [relativePath, head] of git.submodules) {
-    const entry = desired.get(relativePath);
-    const next = entry?.kind === "gitlink" && !shielded.has(relativePath) && head && head !== entry.objectId ? head : null;
-    if ((heads.get(relativePath) ?? null) === next) continue;
-    if (next) heads.set(relativePath, next);
-    else heads.delete(relativePath);
-    changed = true;
-  }
-  for (const relativePath of [...heads.keys()]) {
-    if (git.submodules.has(relativePath)) continue;
-    heads.delete(relativePath);
-    changed = true;
-  }
-  if (changed) writeGitlinkStaleHeads(targetRoot, heads);
-}
-function prepareWorkingTreeMirror(input) {
-  const sourceRoot = path.resolve(input.sourceRoot);
-  const targetRoot = path.resolve(input.targetRoot);
-  if (!inspectDirectoryRoot(targetRoot, { allowMissing: true, label: "Working-tree target root" })) {
-    fs.mkdirSync(targetRoot, { recursive: true });
-  }
-  inspectDirectoryRoot(targetRoot, { allowMissing: false, label: "Working-tree target root" });
-  const desired = inspectWorkingTree(sourceRoot, input.sourceMode, { gitlinks: input.sourceGitlinks });
-  const existingStats = /* @__PURE__ */ new Map();
-  const target = inspectMirrorTarget(targetRoot, input.deletionMode, existingStats);
-  const shielded = target.git ? shieldedDesiredPaths(desired, target.git) : /* @__PURE__ */ new Set();
-  return {
-    sourceRoot,
-    targetRoot,
-    deletionMode: input.deletionMode,
-    desired,
-    existing: target.existing,
-    existingStats,
-    git: target.git,
-    shielded
-  };
-}
-function applyWorkingTreeMirror(prepared, options = {}) {
-  const { sourceRoot, targetRoot, desired, existing, shielded } = prepared;
-  const durability = options.durability ?? "per_entry";
-  const guards = options.guards;
-  const selection = options.selection;
-  const target = { existing, git: prepared.git };
-  const indexDesired = selection?.desiredForIndex ?? desired;
-  const index = target.git ? planIndexChanges(indexDesired, shielded, target.git) : null;
-  const neededDirectories = /* @__PURE__ */ new Set();
-  if (selection) {
-    for (const relativePath of selection.write) {
-      let parent = path.posix.dirname(relativePath);
-      while (parent !== ".") {
-        neededDirectories.add(parent);
-        parent = path.posix.dirname(parent);
-      }
-    }
-  }
-  for (const relativePath of [...existing.keys()].sort(deepestFirst)) {
-    if (selection ? !selection.remove.has(relativePath) : desired.has(relativePath)) continue;
-    const entry = existing.get(relativePath);
-    if (entry.kind === "gitlink" || directoryShieldsSubmodule(relativePath, entry, target.git)) continue;
-    if (selection && entry.kind === "directory") {
-      const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-      if (inspected.kind !== "entry" || !inspected.stat.isDirectory() || inspected.stat.isSymbolicLink()) continue;
-      try {
-        fs.rmdirSync(inspected.absolutePath);
-      } catch (error) {
-        const code = error.code;
-        if (code === "ENOTEMPTY" || code === "EEXIST" || code === "ENOENT") continue;
-        throw error;
-      }
-      if (guards?.expectations?.has(relativePath)) guards.expectations.set(relativePath, null);
-      guards?.journal?.entries.push({ relativePath, replaced: entry, after: null });
-      continue;
-    }
-    removeEntryGuarded(targetRoot, relativePath, entry, guards);
-  }
-  const gitlinks = [];
-  for (const [relativePath, entry] of [...desired.entries()].sort(([left], [right]) => shallowestFirst(left, right))) {
-    if (shielded.has(relativePath)) continue;
-    if (selection && entry.kind === "directory" && !neededDirectories.has(relativePath)) continue;
-    if (selection && entry.kind !== "directory" && !selection.write.has(relativePath)) continue;
-    if (entry.kind === "gitlink") {
-      if (guards) {
-        const parent = path.posix.dirname(relativePath);
-        if (parent !== ".") ensureDirectoryGuarded(targetRoot, parent, guards);
-        const current = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-        if (current.kind === "blocked") throw new Error(`Refusing to copy through a symlink or non-directory: ${current.blockingPath}`);
-        if (current.kind === "entry" && (!current.stat.isDirectory() || current.stat.isSymbolicLink())) {
-          if (guards.expectations && !guards.expectations.has(relativePath)) throw new WorkingTreeTargetChangedError(relativePath);
-          removeEntryGuarded(targetRoot, relativePath, treeEntryFromStat(current.stat, current.absolutePath), guards);
-          createDirectoryGuarded(targetRoot, relativePath, 493, guards);
-        } else if (current.kind !== "entry") {
-          assertTargetExpectation(targetRoot, relativePath, guards);
-          createDirectoryGuarded(targetRoot, relativePath, 493, guards);
-        }
-      } else {
-        ensureDirectory(targetRoot, relativePath, 493);
-      }
-      gitlinks.push({ relativePath, objectId: entry.objectId });
-      options.projected?.set(relativePath, { kind: "gitlink", objectId: entry.objectId });
-      continue;
-    }
-    const projected = guards ? copyEntryGuarded(sourceRoot, targetRoot, relativePath, entry, durability, guards) : copyEntry(sourceRoot, targetRoot, relativePath, entry, durability);
-    if (projected && options.projected) options.projected.set(relativePath, projected);
-  }
-  if (guards?.journal) settleRetainedEntries(guards.journal, targetRoot);
-  if (index && target.git) {
-    updateIndex(targetRoot, { drop: index.removed, put: index.written.map((gitlink) => ({ mode: "160000", stage: 0, ...gitlink })) });
-    if (guards?.journal && (index.removed.length > 0 || index.written.length > 0)) guards.journal.indexApplied = index;
-    recordGitlinkStaleHeads(targetRoot, indexDesired, shielded, target.git);
-  }
-  return {
-    paths: [...desired.keys()].filter((relativePath) => !shielded.has(relativePath) && desired.get(relativePath)?.kind !== "directory").sort(),
-    gitlinks
-  };
-}
-function mirrorWorkingTree(input) {
-  return applyWorkingTreeMirror(prepareWorkingTreeMirror(input), { durability: input.durability, projected: input.projected });
-}
-function normalizeWorkingTreeRelativePath(value) {
-  return normalizeRelativePath(value);
-}
-const MIRROR_TEMPORARY_FILE_PATTERN = /^\.r5d-working-tree-mirror-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp$/u;
-function relativeDepth(relativePath) {
-  return relativePath.split("/").length;
-}
-function shallowestFirst(left, right) {
-  return relativeDepth(left) - relativeDepth(right) || left.localeCompare(right);
-}
-function deepestFirst(left, right) {
-  return relativeDepth(right) - relativeDepth(left) || left.localeCompare(right);
-}
-function hasAncestorIn(relativePath, ancestors) {
-  let parent = path.posix.dirname(relativePath);
-  while (parent !== ".") {
-    if (ancestors.has(parent)) return true;
-    parent = path.posix.dirname(parent);
-  }
-  return false;
-}
-function treeEntryFromStat(stat, absolutePath) {
-  if (stat.isSymbolicLink()) return { kind: "symlink", mode: stat.mode, target: fs.readlinkSync(absolutePath) };
-  if (stat.isFile()) return { kind: "file", mode: stat.mode, size: stat.size };
-  if (stat.isDirectory()) return { kind: "directory", mode: stat.mode };
-  return null;
-}
-function fsyncPath(targetPath, flags) {
-  const descriptor = fs.openSync(targetPath, flags);
-  try {
-    fs.fsyncSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function planWorkingTreeMirror(input) {
-  return planPreparedWorkingTreeMirror(prepareWorkingTreeMirror(input));
-}
-function planPreparedWorkingTreeMirror(prepared, options = {}) {
-  const { sourceRoot, targetRoot, existing, shielded } = prepared;
-  const inspectedDesired = prepared.desired;
-  const selection = options.selection;
-  const target = { existing, git: prepared.git };
-  const desired = new Map(
-    [...inspectedDesired].filter(
-      ([relativePath, entry]) => !shielded.has(relativePath) && (!selection || entry.kind === "directory" || selection.write.has(relativePath))
-    )
-  );
-  const replaced = /* @__PURE__ */ new Map();
-  const absent = [];
-  for (const [relativePath, entry] of existing) {
-    if (selection ? !selection.remove.has(relativePath) : inspectedDesired.has(relativePath)) continue;
-    if (entry.kind === "gitlink") continue;
-    if (directoryShieldsSubmodule(relativePath, entry, target.git)) continue;
-    replaced.set(relativePath, entry);
-  }
-  for (const [relativePath, entry] of desired) {
-    const targetEntry = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-    if (targetEntry.kind !== "entry") {
-      absent.push(relativePath);
-      continue;
-    }
-    const { absolutePath, stat } = targetEntry;
-    if (options.overrides?.has(relativePath)) {
-    } else if (entry.kind === "directory" || entry.kind === "gitlink") {
-      if (stat.isDirectory()) continue;
-    } else if (entry.kind === "symlink") {
-      if (stat.isSymbolicLink() && fs.readlinkSync(absolutePath) === entry.target) continue;
-    } else if (stat.isFile() && filesEqual(path.join(sourceRoot, ...relativePath.split("/")), absolutePath, entry)) {
-      continue;
-    }
-    const current = treeEntryFromStat(stat, absolutePath);
-    if (current) replaced.set(relativePath, current);
-    else absent.push(relativePath);
-  }
-  const replacedDirectories = new Set(
-    [...replaced].filter(([, entry]) => entry.kind === "directory").map(([relativePath]) => relativePath)
-  );
-  for (const relativePath of [...replaced.keys()]) {
-    if (hasAncestorIn(relativePath, replacedDirectories)) replaced.delete(relativePath);
-  }
-  return {
-    desired,
-    replaced,
-    absent: absent.filter((relativePath) => !hasAncestorIn(relativePath, replacedDirectories)).sort(shallowestFirst),
-    index: target.git ? planIndexChanges(selection?.desiredForIndex ?? inspectedDesired, shielded, target.git) : { removed: [], written: [] }
-  };
-}
-function rollbackWorkingTreeMirrorJournal(input) {
-  const targetRoot = path.resolve(input.targetRoot);
-  const snapshotRoot = path.resolve(input.snapshotRoot);
-  const { journal } = input;
-  const state = newPassState(targetRoot);
-  const touched = /* @__PURE__ */ new Set();
-  const abandoned = [];
-  const restoredTrees = /* @__PURE__ */ new Set();
-  const targetPathOf = (relativePath) => {
-    const targetPath = path.join(targetRoot, ...relativePath.split("/"));
-    assertInside(targetRoot, targetPath);
-    return targetPath;
-  };
-  const stageFromSnapshot = (relativePath, replaced) => {
-    const captured = inspectRelativePathWithoutFollowingAncestors(snapshotRoot, relativePath);
-    if (captured.kind !== "entry") throw new Error(`Working-tree snapshot does not hold the replaced entry: ${relativePath}`);
-    const stagedPath = stagingPathFor(state, targetPathOf(relativePath), relativePath);
-    if (replaced.kind === "symlink") {
-      if (!captured.stat.isSymbolicLink()) throw new Error(`Working-tree snapshot does not hold the replaced entry: ${relativePath}`);
-      fs.symlinkSync(fs.readlinkSync(captured.absolutePath), stagedPath);
-      return { path: stagedPath, stat: fs.lstatSync(stagedPath) };
-    }
-    if (!captured.stat.isFile()) throw new Error(`Working-tree snapshot does not hold the replaced entry: ${relativePath}`);
-    return { path: stagedPath, stat: stageRegularFile(captured.absolutePath, stagedPath, replaced, "per_entry").stagedStat };
-  };
-  const restoreReplaced = (entry, expected) => {
-    const replaced = entry.replaced;
-    const { relativePath } = entry;
-    if (replaced.kind === "gitlink") return true;
-    if (replaced.kind === "directory") return restoreCapturedDirectory(relativePath, replaced);
-    let staged;
-    let onFailure = "unlink";
-    if (entry.displaced && lstatIfExists(entry.displaced.path)) {
-      const current = fs.lstatSync(entry.displaced.path);
-      if (!sameWorkingTreeInode(current, entry.displaced.stat))
-        throw new Error(`Retained working-tree entry was replaced: ${entry.displaced.path}`);
-      if (!retainedEntryIntact(entry.displaced, current)) onFailure = "retain";
-      staged = { path: entry.displaced.path, stat: current };
-    } else {
-      staged = stageFromSnapshot(relativePath, replaced);
-    }
-    try {
-      const outcome = switchStagedEntry({
-        state,
-        targetRoot,
-        relativePath,
-        targetPath: targetPathOf(relativePath),
-        stagedPath: staged.path,
-        stagedStat: staged.stat,
-        expected,
-        expectedContent: expected === null ? void 0 : entry.afterContent,
-        journal,
-        phase: "before_rollback_switch",
-        onFailure
-      });
-      if (outcome.displaced) releaseRetainedEntry(journal, relativePath, outcome.displaced);
-      delete entry.displaced;
-      return true;
-    } catch (error) {
-      if (!(error instanceof WorkingTreeTargetChangedError)) throw error;
-      if (onFailure === "retain") delete entry.displaced;
-      else if (entry.displaced && !lstatIfExists(entry.displaced.path)) delete entry.displaced;
-      return false;
-    }
-  };
-  const restoreCapturedDirectory = (relativePath, replaced) => {
-    const captured = inspectRelativePathWithoutFollowingAncestors(snapshotRoot, relativePath);
-    if (captured.kind !== "entry" || !captured.stat.isDirectory()) {
-      throw new Error(`Working-tree snapshot does not hold the captured directory: ${relativePath}`);
-    }
-    try {
-      fs.mkdirSync(targetPathOf(relativePath), { mode: replaced.mode & 511 });
-    } catch (error) {
-      if (isPathStateCode(error.code)) return false;
-      throw error;
-    }
-    let complete = true;
-    const children = inspectWorkingTree(captured.absolutePath, "all");
-    for (const [childRelative, child] of [...children.entries()].sort(([left], [right]) => shallowestFirst(left, right))) {
-      const childPath = path.posix.join(relativePath, childRelative);
-      if (child.kind === "gitlink") continue;
-      if (child.kind === "directory") {
-        try {
-          fs.mkdirSync(targetPathOf(childPath), { mode: child.mode & 511 });
-        } catch (error) {
-          if (!isPathStateCode(error.code)) throw error;
-          const now = inspectRelativePathWithoutFollowingAncestors(targetRoot, childPath);
-          if (now.kind !== "entry" || !now.stat.isDirectory() || now.stat.isSymbolicLink()) {
-            abandoned.push(childPath);
-            complete = false;
-          }
-        }
-        continue;
-      }
-      const staged = stageFromSnapshot(childPath, child);
-      try {
-        switchStagedEntry({
-          state,
-          targetRoot,
-          relativePath: childPath,
-          targetPath: targetPathOf(childPath),
-          stagedPath: staged.path,
-          stagedStat: staged.stat,
-          expected: null,
-          journal,
-          phase: "before_rollback_switch",
-          onFailure: "unlink"
-        });
-      } catch (error) {
-        if (!(error instanceof WorkingTreeTargetChangedError)) throw error;
-        abandoned.push(childPath);
-        complete = false;
-      }
-    }
-    restoredTrees.add(relativePath);
-    return complete;
-  };
-  for (const entry of [...journal.entries].reverse()) {
-    const { relativePath } = entry;
-    if (hasAncestorIn(relativePath, restoredTrees)) {
-      touched.add(relativePath);
-      continue;
-    }
-    const current = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-    if (current.kind === "blocked") {
-      abandoned.push(relativePath);
-      continue;
-    }
-    if (entry.after === null) {
-      if (current.kind !== "missing") {
-        abandoned.push(relativePath);
-        continue;
-      }
-      if (entry.replaced && !restoreReplaced(entry, null)) {
-        abandoned.push(relativePath);
-        continue;
-      }
-      touched.add(relativePath);
-      continue;
-    }
-    if (current.kind !== "entry" || !workingTreeStatsMatch(entry.after, current.stat) || entry.afterContent !== void 0 && entryContent(current.absolutePath, current.stat) !== entry.afterContent) {
-      if (!(current.kind === "entry" && entry.after.isDirectory() && current.stat.isDirectory())) {
-        abandoned.push(relativePath);
-        continue;
-      }
-    }
-    if (current.stat.isDirectory() && !current.stat.isSymbolicLink()) {
-      try {
-        fs.rmdirSync(current.absolutePath);
-      } catch (error) {
-        const code = error.code;
-        if (code === "ENOTEMPTY" || code === "EEXIST" || code === "ENOTDIR") {
-          abandoned.push(relativePath);
-          continue;
-        }
-        if (code !== "ENOENT") throw error;
-      }
-      if (entry.replaced && !restoreReplaced(entry, null)) {
-        abandoned.push(relativePath);
-        continue;
-      }
-      touched.add(relativePath);
-      continue;
-    }
-    if (entry.replaced) {
-      if (!restoreReplaced(entry, entry.after)) {
-        abandoned.push(relativePath);
-        continue;
-      }
-      touched.add(relativePath);
-      continue;
-    }
-    try {
-      const displaced = removeSwitchedEntry({
-        state,
-        targetRoot,
-        relativePath,
-        targetPath: targetPathOf(relativePath),
-        expected: entry.after,
-        expectedContent: entry.afterContent,
-        journal,
-        phase: "before_rollback_remove"
-      });
-      releaseRetainedEntry(journal, relativePath, displaced);
-    } catch (error) {
-      if (!(error instanceof WorkingTreeTargetChangedError)) throw error;
-      abandoned.push(relativePath);
-      continue;
-    }
-    touched.add(relativePath);
-  }
-  releaseRetainedEntries(journal);
-  if (journal.indexApplied) {
-    updateIndex(targetRoot, { drop: journal.indexApplied.written, put: journal.indexApplied.removed });
-  }
-  return {
-    paths: [...touched].sort(shallowestFirst),
-    abandoned: [...new Set(abandoned)].sort(shallowestFirst),
-    ...journal.retained && journal.retained.length > 0 ? { retained: [...journal.retained] } : {}
-  };
-}
-function captureWorkingTreeMirrorPlan(input) {
-  const targetRoot = path.resolve(input.targetRoot);
-  const snapshotRoot = path.resolve(input.snapshotRoot);
-  const durability = input.durability ?? "per_entry";
-  inspectDirectoryRoot(targetRoot, { allowMissing: false, label: "Working-tree target root" });
-  if (!inspectDirectoryRoot(snapshotRoot, { allowMissing: true, label: "Working-tree snapshot root" })) {
-    fs.mkdirSync(snapshotRoot, { recursive: true });
-  }
-  const trees = [];
-  for (const [relativePath, entry] of [...input.plan.replaced.entries()].sort(([left], [right]) => shallowestFirst(left, right))) {
-    if (entry.kind === "gitlink") continue;
-    if (entry.kind !== "directory") {
-      copyEntry(targetRoot, snapshotRoot, relativePath, entry, durability);
-      continue;
-    }
-    const source = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-    if (source.kind !== "entry" || !source.stat.isDirectory()) {
-      throw new Error(`Working-tree source changed while it was being mirrored: ${path.join(targetRoot, ...relativePath.split("/"))}`);
-    }
-    ensureDirectory(snapshotRoot, relativePath, entry.mode);
-    mirrorWorkingTree({
-      sourceRoot: source.absolutePath,
-      targetRoot: path.join(snapshotRoot, ...relativePath.split("/")),
-      sourceMode: "all",
-      deletionMode: "all",
-      durability
-    });
-    trees.push(relativePath);
-  }
-  const { index } = input.plan;
-  return {
-    absent: [...input.plan.absent].sort(shallowestFirst),
-    trees: trees.sort(shallowestFirst),
-    ...index.removed.length > 0 || index.written.length > 0 ? { index } : {}
-  };
-}
-function restoreWorkingTreeMirrorScope(input) {
-  const snapshotRoot = path.resolve(input.snapshotRoot);
-  const targetRoot = path.resolve(input.targetRoot);
-  inspectDirectoryRoot(snapshotRoot, { allowMissing: false, label: "Working-tree snapshot root" });
-  if (!inspectDirectoryRoot(targetRoot, { allowMissing: true, label: "Working-tree target root" })) {
-    fs.mkdirSync(targetRoot, { recursive: true });
-  }
-  const normalize = (relativePath) => {
-    const normalized = normalizeRelativePath(relativePath);
-    if (!normalized) throw new Error(`Invalid working-tree scope path: ${relativePath}`);
-    return normalized;
-  };
-  const absent = input.scope.absent.map(normalize);
-  const trees = new Set(input.scope.trees.map(normalize));
-  const captured = inspectWorkingTree(snapshotRoot, "all");
-  for (const tree of trees) {
-    if (captured.get(tree)?.kind !== "directory") {
-      throw new Error(`Working-tree snapshot does not hold the captured directory: ${tree}`);
-    }
-  }
-  const touched = /* @__PURE__ */ new Set();
-  for (const relativePath of [...absent].sort(deepestFirst)) {
-    const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-    if (inspected.kind === "entry" && inspected.stat.isDirectory() && lstatIfExists(path.join(inspected.absolutePath, ".git"))) continue;
-    if (inspected.kind === "entry") fs.rmSync(inspected.absolutePath, { recursive: true, force: true });
-    touched.add(relativePath);
-  }
-  const writtenDirectories = /* @__PURE__ */ new Set();
-  for (const relativePath of absent) writtenDirectories.add(path.posix.dirname(relativePath));
-  for (const [relativePath, entry] of captured) {
-    if (entry.kind !== "directory" && !hasAncestorIn(relativePath, trees)) writtenDirectories.add(path.posix.dirname(relativePath));
-  }
-  for (const directory of writtenDirectories) {
-    let absoluteDirectory = targetRoot;
-    if (directory !== ".") {
-      const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, directory);
-      if (inspected.kind !== "entry" || !inspected.stat.isDirectory()) continue;
-      absoluteDirectory = inspected.absolutePath;
-    }
-    for (const name of fs.readdirSync(absoluteDirectory)) {
-      if (!MIRROR_TEMPORARY_FILE_PATTERN.test(name)) continue;
-      const temporaryPath = path.join(absoluteDirectory, name);
-      const temporaryStatus = fs.lstatSync(temporaryPath);
-      if (!temporaryStatus.isFile() && !temporaryStatus.isSymbolicLink()) continue;
-      fs.rmSync(temporaryPath, { force: true });
-      touched.add(directory === "." ? name : path.posix.join(directory, name));
-    }
-  }
-  for (const [relativePath, entry] of [...captured.entries()].sort(([left], [right]) => shallowestFirst(left, right))) {
-    touched.add(relativePath);
-    if (hasAncestorIn(relativePath, trees)) continue;
-    if (!trees.has(relativePath)) {
-      copyEntry(snapshotRoot, targetRoot, relativePath, entry, "per_entry");
-      continue;
-    }
-    const current = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
-    if (current.kind === "blocked") {
-      throw new Error(`Refusing to restore a working-tree directory through a symlink or non-directory: ${current.blockingPath}`);
-    }
-    if (current.kind === "entry" && !current.stat.isDirectory()) {
-      fs.rmSync(current.absolutePath, { recursive: true, force: true });
-    }
-    ensureDirectory(targetRoot, relativePath, entry.kind === "directory" ? entry.mode : 493);
-    mirrorWorkingTree({
-      sourceRoot: path.join(snapshotRoot, ...relativePath.split("/")),
-      targetRoot: path.join(targetRoot, ...relativePath.split("/")),
-      sourceMode: "all",
-      deletionMode: "all"
-    });
-  }
-  if (input.scope.index) updateIndex(targetRoot, { drop: input.scope.index.written, put: input.scope.index.removed });
-  return { paths: [...touched].sort(shallowestFirst) };
-}
-function fsyncWorkingTreePaths(root, relativePaths) {
-  root = path.resolve(root);
-  inspectDirectoryRoot(root, { allowMissing: false, label: "Working-tree root" });
-  const directories = /* @__PURE__ */ new Set(["."]);
-  for (const relativePath of relativePaths) {
-    const normalized = normalizeRelativePath(relativePath);
-    if (!normalized) throw new Error(`Invalid working-tree path: ${relativePath}`);
-    directories.add(path.posix.dirname(normalized));
-    const inspected = inspectRelativePathWithoutFollowingAncestors(root, normalized);
-    if (inspected.kind !== "entry") continue;
-    if (inspected.stat.isDirectory()) directories.add(normalized);
-    else if (inspected.stat.isFile()) fsyncPath(inspected.absolutePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
-  }
-  for (const directory of directories) {
-    if (directory === ".") {
-      fsyncPath(root, fs.constants.O_RDONLY);
-      continue;
-    }
-    const inspected = inspectRelativePathWithoutFollowingAncestors(root, directory);
-    if (inspected.kind === "entry" && inspected.stat.isDirectory()) fsyncPath(inspected.absolutePath, fs.constants.O_RDONLY);
-  }
-}
-export {
-  WorkingTreeTargetChangedError,
-  applyWorkingTreeMirror,
-  assertWorkingTreeHasNoPortableGitMetadataAliases,
-  captureWorkingTreeMirrorPlan,
-  displacedEntryMatches,
-  fsyncWorkingTreePaths,
-  inspectWorkingTree,
-  inspectWorkingTreePath,
-  mirrorWorkingTree,
-  normalizeWorkingTreeRelativePath,
-  planPreparedWorkingTreeMirror,
-  planWorkingTreeMirror,
-  prepareWorkingTreeMirror,
-  projectedFileEntry,
-  projectedFileEntryMatches,
-  restoreWorkingTreeMirrorScope,
-  rollbackWorkingTreeMirrorJournal,
-  sameWorkingTreeInode,
-  setWorkingTreeMirrorRaceHook,
-  workingTreeAtomicRenameSupport,
-  workingTreeDisplacedRetentionDirectory,
-  workingTreeStatsMatch
-};