@ricsam/r5d-worker 0.0.137 → 0.0.138

package/dist/cjs/workspace-hydration-ledger.cjs

@@ -1,83 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var workspace_hydration_ledger_exports = {};
-__export(workspace_hydration_ledger_exports, {
-  WorkspaceHydrationLedger: () => WorkspaceHydrationLedger,
-  WorkspaceHydrationPreBlobLedger: () => WorkspaceHydrationPreBlobLedger
-});
-module.exports = __toCommonJS(workspace_hydration_ledger_exports);
-class WorkspaceHydrationLedger {
-  mounts = /* @__PURE__ */ new Map();
-  static key(mount) {
-    return `${mount.hydrationIncarnationKey}\0${mount.id}`;
-  }
-  /** Entries by mount-relative path for the mount, or an empty map. */
-  entries(mount) {
-    return this.mounts.get(WorkspaceHydrationLedger.key(mount)) ?? /* @__PURE__ */ new Map();
-  }
-  /** Blob ids by mount-relative path for the mount (the §3.3 detector's input), or an empty map. */
-  preBlobs(mount) {
-    return new Map([...this.entries(mount)].map(([relativePath, entry]) => [relativePath, entry.preBlob]));
-  }
-  /**
-   * Record what a merge hydration replaced; earlier entries for other paths
-   * are kept. A path that already carries a live entry keeps its `preBlob`
-   * while the new hydration also ran across a live process: the process's
-   * read predates both hydrations, so what it read is still the first blob.
-   */
-  record(mount, entries, options = {}) {
-    const incoming = entries instanceof Map ? [...entries] : Object.entries(entries);
-    if (incoming.length === 0) return;
-    const replace = new Set(options.replacePreBlobFor ?? []);
-    const key = WorkspaceHydrationLedger.key(mount);
-    const current = this.mounts.get(key) ?? /* @__PURE__ */ new Map();
-    for (const [relativePath, entry] of incoming) {
-      const previous = current.get(relativePath);
-      const preBlob = previous && previous.processLiveAcrossHydration && entry.processLiveAcrossHydration && !replace.has(relativePath) ? previous.preBlob : entry.preBlob;
-      current.set(relativePath, { ...entry, preBlob });
-    }
-    this.mounts.set(key, current);
-  }
-  /** Forget the mount: its checkout was rewritten by something this ledger did not observe. */
-  clearMount(mount) {
-    this.mounts.delete(WorkspaceHydrationLedger.key(mount));
-  }
-  /** Forget paths whose checkout content moved on from the hydrated bytes: a later return to the old bytes is a deliberate edit. */
-  forget(mount, paths) {
-    const key = WorkspaceHydrationLedger.key(mount);
-    const current = this.mounts.get(key);
-    if (!current) return;
-    for (const relativePath of paths) current.delete(relativePath);
-    if (current.size === 0) this.mounts.delete(key);
-  }
-  clear() {
-    this.mounts.clear();
-  }
-  get size() {
-    let total = 0;
-    for (const entries of this.mounts.values()) total += entries.size;
-    return total;
-  }
-}
-const WorkspaceHydrationPreBlobLedger = WorkspaceHydrationLedger;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WorkspaceHydrationLedger,
-  WorkspaceHydrationPreBlobLedger
-});

package/dist/cjs/workspace-hydration-merge.cjs

@@ -1,448 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var workspace_hydration_merge_exports = {};
-__export(workspace_hydration_merge_exports, {
-  RACY_PROJECTION_WINDOW_MS: () => RACY_PROJECTION_WINDOW_MS,
-  decideWorkspaceHydrationMerge: () => decideWorkspaceHydrationMerge,
-  describeHydrationSkipPaths: () => describeHydrationSkipPaths,
-  parseWorkspaceSubtreeChanges: () => parseWorkspaceSubtreeChanges,
-  readHydrationBinaryPaths: () => readHydrationBinaryPaths
-});
-module.exports = __toCommonJS(workspace_hydration_merge_exports);
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_git_process_environment = require("./git-process-environment.cjs");
-var import_git_blob_hash = require("./git-blob-hash.cjs");
-var import_three_way_merge = require("./three-way-merge.cjs");
-var import_working_tree_mirror = require("./working-tree-mirror.cjs");
-const RACY_PROJECTION_WINDOW_MS = 2e3;
-class TargetChanged extends Error {
-  constructor(relativePath) {
-    super(`Working-tree target changed while merge hydration inspected it: ${relativePath}`);
-    this.relativePath = relativePath;
-  }
-  relativePath;
-}
-function isBlobMode(mode) {
-  return mode === "100644" || mode === "100755";
-}
-function executableBit(mode) {
-  return (mode & 73) !== 0;
-}
-function resolveExecutable(base, ours, theirs) {
-  if (ours === base) return theirs;
-  if (theirs === base) return ours;
-  return ours === theirs ? ours : null;
-}
-function withExecutable(mode, executable) {
-  const bits = mode & 511;
-  return executable ? bits | 73 : bits & ~73;
-}
-function readOwnedFile(root, relativePath, expected) {
-  const inspected = (0, import_working_tree_mirror.inspectWorkingTreePath)(root, relativePath);
-  if (inspected.kind !== "entry" || !(0, import_working_tree_mirror.workingTreeStatsMatch)(expected, inspected.stat)) throw new TargetChanged(relativePath);
-  const descriptor = import_node_fs.default.openSync(inspected.absolutePath, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
-  try {
-    const before = import_node_fs.default.fstatSync(descriptor);
-    if (!(0, import_working_tree_mirror.workingTreeStatsMatch)(expected, before)) throw new TargetChanged(relativePath);
-    const content = Buffer.allocUnsafe(before.size);
-    let offset = 0;
-    while (offset < before.size) {
-      const bytesRead = import_node_fs.default.readSync(descriptor, content, offset, before.size - offset, offset);
-      if (bytesRead <= 0) throw new TargetChanged(relativePath);
-      offset += bytesRead;
-    }
-    if (!(0, import_working_tree_mirror.workingTreeStatsMatch)(expected, import_node_fs.default.fstatSync(descriptor))) throw new TargetChanged(relativePath);
-    return content;
-  } finally {
-    import_node_fs.default.closeSync(descriptor);
-  }
-}
-function readOuterFile(root, relativePath) {
-  const inspected = (0, import_working_tree_mirror.inspectWorkingTreePath)(root, relativePath);
-  if (inspected.kind !== "entry" || !inspected.stat.isFile())
-    throw new Error(`Outer worktree does not hold a regular file at ${relativePath}`);
-  return import_node_fs.default.readFileSync(inspected.absolutePath);
-}
-function currentTargetStat(root, relativePath) {
-  const inspected = (0, import_working_tree_mirror.inspectWorkingTreePath)(root, relativePath);
-  return inspected.kind === "entry" ? inspected.stat : null;
-}
-function directoryHoldsOnlyVisibleEntries(root, relativePath, existing) {
-  const inspected = (0, import_working_tree_mirror.inspectWorkingTreePath)(root, relativePath);
-  if (inspected.kind !== "entry" || !inspected.stat.isDirectory()) return true;
-  const pending = [{ absolutePath: inspected.absolutePath, relativePath }];
-  while (pending.length > 0) {
-    const directory = pending.pop();
-    for (const name of import_node_fs.default.readdirSync(directory.absolutePath)) {
-      const childRelative = `${directory.relativePath}/${name}`;
-      if (!existing.has(childRelative)) return false;
-      const child = import_node_fs.default.lstatSync(import_node_path.default.join(directory.absolutePath, name));
-      if (child.isDirectory() && !child.isSymbolicLink())
-        pending.push({ absolutePath: import_node_path.default.join(directory.absolutePath, name), relativePath: childRelative });
-    }
-  }
-  return true;
-}
-function decideWorkspaceHydrationMerge(input) {
-  const { prepared, changes, projectedFiles } = input;
-  const trustedProjection = (projected, stat) => (0, import_working_tree_mirror.projectedFileEntryMatches)(projected, stat) && (input.readAtMs === void 0 || projected.mtimeMs < input.readAtMs - RACY_PROJECTION_WINDOW_MS && projected.ctimeMs < input.readAtMs - RACY_PROJECTION_WINDOW_MS);
-  const { desired, existing, existingStats, shielded, sourceRoot, targetRoot } = prepared;
-  const conflicts = /* @__PURE__ */ new Set();
-  const write = /* @__PURE__ */ new Set();
-  const remove = /* @__PURE__ */ new Set();
-  const overrides = /* @__PURE__ */ new Map();
-  const expectations = /* @__PURE__ */ new Map();
-  const preBlobs = /* @__PURE__ */ new Map();
-  const postBlobs = /* @__PURE__ */ new Map();
-  const blobsToStore = /* @__PURE__ */ new Map();
-  const mergedPaths = [];
-  const keptPaths = /* @__PURE__ */ new Set();
-  const desiredForIndex = new Map(desired);
-  let algorithm = "sha1";
-  for (const change of changes.values()) {
-    const detected = (0, import_git_blob_hash.gitObjectHashAlgorithmFor)(change.base?.objectId ?? change.theirs?.objectId ?? "");
-    if (detected) {
-      algorithm = detected;
-      break;
-    }
-  }
-  const hashOf = (content) => (0, import_git_blob_hash.gitBlobHash)(content, algorithm);
-  const mergeCandidates = [];
-  const directoryReplacements = [];
-  const oursState = (relativePath, change) => {
-    const ours = existing.get(relativePath);
-    const oursStat = existingStats.get(relativePath);
-    if (!ours || !oursStat) return change.base ? "deleted" : "absent";
-    if (!change.base) return "added";
-    const base = change.base;
-    if (ours.kind === "file" && isBlobMode(base.mode)) {
-      if (executableBit(ours.mode) !== (base.mode === "100755")) return "changed";
-      const projected = projectedFiles?.[relativePath];
-      if (projected?.kind === "file" && trustedProjection(projected, oursStat)) return "base";
-      if (projectedFiles !== null && projected === void 0) return "changed";
-      return hashOf(readOwnedFile(targetRoot, relativePath, oursStat)) === base.objectId ? "base" : "changed";
-    }
-    if (ours.kind === "symlink" && base.mode === "120000") return hashOf(Buffer.from(ours.target)) === base.objectId ? "base" : "changed";
-    if (ours.kind === "gitlink" && base.mode === "160000") return ours.objectId === base.objectId ? "base" : "changed";
-    return "changed";
-  };
-  try {
-    for (const [relativePath, change] of [...changes].sort(([left], [right]) => left.localeCompare(right))) {
-      if (shielded.has(relativePath)) continue;
-      const ours = existing.get(relativePath);
-      const oursStat = existingStats.get(relativePath);
-      const theirsEntry = desired.get(relativePath);
-      if (change.theirs && (!theirsEntry || theirsEntry.kind === "directory")) {
-        conflicts.add(relativePath);
-        continue;
-      }
-      if (ours?.kind === "directory" && !change.base && change.theirs) {
-        directoryReplacements.push(relativePath);
-        continue;
-      }
-      const state = oursState(relativePath, change);
-      if (state === "base" || state === "absent") {
-        if (!change.theirs) {
-          if (ours && oursStat) {
-            remove.add(relativePath);
-            expectations.set(relativePath, oursStat);
-          }
-          if (change.base && isBlobMode(change.base.mode)) {
-            preBlobs.set(relativePath, change.base.objectId);
-            postBlobs.set(relativePath, null);
-          }
-          continue;
-        }
-        write.add(relativePath);
-        expectations.set(relativePath, oursStat ?? currentTargetStat(targetRoot, relativePath));
-        if (change.base && isBlobMode(change.base.mode) && change.base.objectId !== change.theirs.objectId) {
-          preBlobs.set(relativePath, change.base.objectId);
-          postBlobs.set(relativePath, isBlobMode(change.theirs.mode) ? change.theirs.objectId : null);
-        }
-        continue;
-      }
-      if (state === "deleted") {
-        if (change.theirs) conflicts.add(relativePath);
-        continue;
-      }
-      if (!change.theirs) {
-        conflicts.add(relativePath);
-        continue;
-      }
-      const theirs = change.theirs;
-      if (ours.kind === "file" && isBlobMode(theirs.mode)) {
-        const oursBytes = readOwnedFile(targetRoot, relativePath, oursStat);
-        const theirsBytes = readOuterFile(sourceRoot, relativePath);
-        const oursExecutable = executableBit(ours.mode);
-        const theirsExecutable = theirs.mode === "100755";
-        if (oursBytes.equals(theirsBytes)) {
-          if (oursExecutable === theirsExecutable) {
-            keptPaths.add(relativePath);
-            continue;
-          }
-          const baseExecutable = change.base ? change.base.mode === "100755" : null;
-          const resolved = baseExecutable === null ? null : resolveExecutable(baseExecutable, oursExecutable, theirsExecutable);
-          if (resolved === null) {
-            conflicts.add(relativePath);
-            continue;
-          }
-          overrides.set(relativePath, { content: theirsBytes, mode: withExecutable(oursStat.mode, resolved) });
-          write.add(relativePath);
-          expectations.set(relativePath, oursStat);
-          mergedPaths.push(relativePath);
-          continue;
-        }
-        if (!change.base || !isBlobMode(change.base.mode)) {
-          conflicts.add(relativePath);
-          continue;
-        }
-        mergeCandidates.push({
-          relativePath,
-          ours,
-          oursStat,
-          base: change.base.objectId,
-          baseExecutable: change.base.mode === "100755",
-          theirs
-        });
-        continue;
-      }
-      if (ours.kind === "symlink" && theirs.mode === "120000" && theirsEntry?.kind === "symlink") {
-        if (ours.target === theirsEntry.target) keptPaths.add(relativePath);
-        else conflicts.add(relativePath);
-        continue;
-      }
-      if (ours.kind === "gitlink" && theirs.mode === "160000") {
-        if (ours.objectId === theirs.objectId) keptPaths.add(relativePath);
-        else conflicts.add(relativePath);
-        continue;
-      }
-      conflicts.add(relativePath);
-    }
-    for (const relativePath of directoryReplacements) {
-      const prefix = `${relativePath}/`;
-      let container = true;
-      for (const candidate of existing.keys()) {
-        if (candidate.startsWith(prefix) && !remove.has(candidate)) {
-          container = false;
-          break;
-        }
-      }
-      if (container && !directoryHoldsOnlyVisibleEntries(targetRoot, relativePath, existing)) container = false;
-      if (!container) {
-        conflicts.add(relativePath);
-        continue;
-      }
-      write.add(relativePath);
-      expectations.set(relativePath, existingStats.get(relativePath) ?? null);
-    }
-    if (mergeCandidates.length > 0) {
-      const binaryPaths = input.readBinaryPaths?.(mergeCandidates.map(({ relativePath }) => relativePath));
-      const baseBlobs = input.readBaseBlobs([...new Set(mergeCandidates.map(({ base }) => base))]);
-      for (const candidate of mergeCandidates) {
-        const { relativePath } = candidate;
-        const baseBytes = baseBlobs.get(candidate.base);
-        if (!baseBytes) throw new Error(`Projected blob ${candidate.base} for ${relativePath} is missing from the workspace clone`);
-        const oursBytes = readOwnedFile(targetRoot, relativePath, candidate.oursStat);
-        const theirsBytes = readOuterFile(sourceRoot, relativePath);
-        if (binaryPaths?.has(relativePath) || (0, import_three_way_merge.isBinaryContent)(baseBytes) || (0, import_three_way_merge.isBinaryContent)(oursBytes) || (0, import_three_way_merge.isBinaryContent)(theirsBytes)) {
-          conflicts.add(relativePath);
-          continue;
-        }
-        const merged = (0, import_three_way_merge.mergeThreeWay)(baseBytes, oursBytes, theirsBytes);
-        if (merged.kind === "conflict") {
-          conflicts.add(relativePath);
-          continue;
-        }
-        const resolved = resolveExecutable(
-          candidate.baseExecutable,
-          executableBit(candidate.ours.mode),
-          candidate.theirs.mode === "100755"
-        );
-        if (resolved === null) {
-          conflicts.add(relativePath);
-          continue;
-        }
-        const mode = withExecutable(candidate.oursStat.mode, resolved);
-        const contentUnchanged = merged.content.equals(oursBytes);
-        if (contentUnchanged && mode === (candidate.oursStat.mode & 511)) {
-          keptPaths.add(relativePath);
-          continue;
-        }
-        overrides.set(relativePath, { content: merged.content, mode });
-        write.add(relativePath);
-        expectations.set(relativePath, candidate.oursStat);
-        if (!contentUnchanged) {
-          const preBlob = hashOf(oursBytes);
-          const postBlob = hashOf(merged.content);
-          preBlobs.set(relativePath, preBlob);
-          postBlobs.set(relativePath, postBlob);
-          blobsToStore.set(preBlob, oursBytes);
-          blobsToStore.set(postBlob, merged.content);
-        }
-        mergedPaths.push(relativePath);
-      }
-    }
-    const neededDirectories = /* @__PURE__ */ new Set();
-    for (const relativePath of write) {
-      let parent = import_node_path.default.posix.dirname(relativePath);
-      while (parent !== ".") {
-        neededDirectories.add(parent);
-        parent = import_node_path.default.posix.dirname(parent);
-      }
-    }
-    for (const [relativePath, entry] of desired) {
-      if (shielded.has(relativePath) || changes.has(relativePath)) continue;
-      const current = existing.get(relativePath);
-      if (entry.kind === "directory") {
-        if (!neededDirectories.has(relativePath)) continue;
-        if (current && current.kind !== "directory") {
-          if (!remove.has(relativePath)) conflicts.add(relativePath);
-          continue;
-        }
-        expectations.set(relativePath, currentTargetStat(targetRoot, relativePath));
-        continue;
-      }
-      if (entry.kind === "gitlink") {
-        if (current?.kind === "gitlink") desiredForIndex.set(relativePath, current);
-        else {
-          const record = prepared.git?.indexRecords.find((candidate) => candidate.relativePath === relativePath && candidate.stage === 0);
-          if (record?.mode === "160000") desiredForIndex.set(relativePath, { kind: "gitlink", objectId: record.objectId });
-          else desiredForIndex.delete(relativePath);
-        }
-      }
-      if (!current || current.kind !== entry.kind) {
-        keptPaths.add(relativePath);
-        continue;
-      }
-      if (current.kind === "file") {
-        const stat = existingStats.get(relativePath);
-        const projected = projectedFiles?.[relativePath];
-        const unchanged = projected?.kind === "file" && stat ? trustedProjection(projected, stat) : projectedFiles === null || projected !== void 0;
-        if (!unchanged) keptPaths.add(relativePath);
-      }
-    }
-    for (const [relativePath, entry] of existing) {
-      if (desired.has(relativePath) || changes.has(relativePath) || entry.kind === "directory" || shielded.has(relativePath)) continue;
-      keptPaths.add(relativePath);
-    }
-    const blockedDirectories = /* @__PURE__ */ new Set();
-    for (const [relativePath, entry] of existing) {
-      if (entry.kind === "directory" || remove.has(relativePath)) continue;
-      let parent = import_node_path.default.posix.dirname(relativePath);
-      while (parent !== ".") {
-        blockedDirectories.add(parent);
-        parent = import_node_path.default.posix.dirname(parent);
-      }
-    }
-    for (const [relativePath, entry] of existing) {
-      if (entry.kind !== "directory" || desired.has(relativePath) || blockedDirectories.has(relativePath)) continue;
-      remove.add(relativePath);
-    }
-  } catch (error) {
-    if (error instanceof TargetChanged) return { kind: "target_changed", paths: [error.relativePath] };
-    throw error;
-  }
-  if (conflicts.size > 0) return { kind: "conflict", paths: [...conflicts].sort() };
-  for (const relativePath of [...write, ...overrides.keys()]) {
-    if (!expectations.has(relativePath)) expectations.set(relativePath, currentTargetStat(targetRoot, relativePath));
-  }
-  return {
-    kind: "apply",
-    selection: { write, remove, desiredForIndex },
-    overrides,
-    expectations,
-    preBlobs,
-    postBlobs,
-    blobsToStore,
-    mergedPaths: mergedPaths.sort(),
-    keptPaths: [...keptPaths].sort()
-  };
-}
-function readHydrationBinaryPaths(input) {
-  const binary = /* @__PURE__ */ new Set();
-  if (!input.relativePaths.length) return binary;
-  const requested = new Set(input.relativePaths);
-  for (const cwd of [input.checkoutRoot, input.outerRoot]) {
-    const result = Bun.spawnSync(["git", "check-attr", "-z", "--stdin", "diff"], {
-      cwd,
-      env: (0, import_git_process_environment.workerGitProcessEnvironment)(),
-      stdin: Buffer.from(`${input.relativePaths.join("\0")}\0`),
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    if (result.exitCode !== 0) throw new Error(`Cannot inspect hydration binary attributes: ${result.stderr.toString().trim()}`);
-    const records = result.stdout.toString().split("\0");
-    if (records.pop() !== "" || records.length !== requested.size * 3) throw new Error("Invalid hydration attribute response");
-    const seen = /* @__PURE__ */ new Set();
-    for (let index = 0; index < records.length; index += 3) {
-      const relativePath = records[index];
-      if (!requested.has(relativePath) || seen.has(relativePath) || records[index + 1] !== "diff")
-        throw new Error("Invalid hydration attribute path");
-      seen.add(relativePath);
-      if (records[index + 2] === "unset") binary.add(relativePath);
-    }
-  }
-  return binary;
-}
-function parseWorkspaceSubtreeChanges(raw) {
-  const changes = /* @__PURE__ */ new Map();
-  const records = [];
-  let start = 0;
-  for (let index = 0; index < raw.length; index += 1) {
-    if (raw[index] !== 0) continue;
-    if (index > start) records.push(raw.subarray(start, index));
-    start = index + 1;
-  }
-  if (start < raw.length) records.push(raw.subarray(start));
-  for (let index = 0; index + 1 < records.length; index += 2) {
-    const match = /^:([0-7]{6}) ([0-7]{6}) ([0-9a-f]{40,64}) ([0-9a-f]{40,64}) ([A-Z])/u.exec(records[index].toString());
-    if (!match) throw new Error(`Unexpected diff-tree record: ${records[index].toString()}`);
-    const relativePath = records[index + 1].toString();
-    if (relativePath.split("/").some((segment) => segment === ".." || segment === "" || segment === ".git")) {
-      throw new Error(`Unsafe path in workspace subtree diff: ${relativePath}`);
-    }
-    const base = match[1] === "000000" ? null : { mode: match[1], objectId: match[3] };
-    const theirs = match[2] === "000000" ? null : { mode: match[2], objectId: match[4] };
-    changes.set(relativePath, { base, theirs });
-  }
-  return changes;
-}
-function describeHydrationSkipPaths(mountSourcePath, paths) {
-  const shown = paths.slice(0, 5).map((relativePath) => import_node_path.default.join(mountSourcePath, ...relativePath.split("/")));
-  return paths.length > 5 ? `${shown.join(", ")} and ${paths.length - 5} more` : shown.join(", ");
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RACY_PROJECTION_WINDOW_MS,
-  decideWorkspaceHydrationMerge,
-  describeHydrationSkipPaths,
-  parseWorkspaceSubtreeChanges,
-  readHydrationBinaryPaths
-});

package/dist/cjs/workspace-hydration-recovery-state.cjs

@@ -1,53 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var workspace_hydration_recovery_state_exports = {};
-__export(workspace_hydration_recovery_state_exports, {
-  findHydrationRecovery: () => findHydrationRecovery
-});
-module.exports = __toCommonJS(workspace_hydration_recovery_state_exports);
-function findHydrationRecovery(error) {
-  const pending = [error];
-  const seen = /* @__PURE__ */ new Set();
-  while (pending.length) {
-    const candidate = pending.pop();
-    if (!candidate || typeof candidate !== "object" || seen.has(candidate)) continue;
-    seen.add(candidate);
-    const record = candidate;
-    if (record.code === "hydration_recovery_required" && record.hydrationRecovery && typeof record.hydrationRecovery === "object") {
-      const evidence = record.hydrationRecovery;
-      if (typeof evidence.transactionId === "string" && typeof evidence.transactionPath === "string" && Array.isArray(evidence.mounts)) {
-        const retainedPaths = [...new Set(evidence.mounts.flatMap((mount) => mount.retainedPaths ?? []))];
-        return {
-          transactionId: evidence.transactionId,
-          transactionPath: evidence.transactionPath,
-          mountIds: evidence.mounts.map(({ id }) => id),
-          previousHeads: Object.fromEntries((evidence.receiptBefore?.mounts ?? []).map(({ id, head }) => [id, head])),
-          ...retainedPaths.length > 0 ? { retainedPaths } : {}
-        };
-      }
-    }
-    pending.push(record.cause);
-    if (Array.isArray(record.errors)) pending.push(...record.errors);
-  }
-  return void 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  findHydrationRecovery
-});

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

@@ -1,37 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var workspace_incident_state_exports = {};
-__export(workspace_incident_state_exports, {
-  applyWorkspaceIncidentUpdate: () => applyWorkspaceIncidentUpdate,
-  workspaceConfigurationRefreshesDeferredConfiguration: () => workspaceConfigurationRefreshesDeferredConfiguration
-});
-module.exports = __toCommonJS(workspace_incident_state_exports);
-function applyWorkspaceIncidentUpdate(currentIncidentId, update) {
-  if (update.status === "remediating" || update.status === "waiting_for_worker") return update.incidentId;
-  if (currentIncidentId && update.incidentId && update.incidentId !== currentIncidentId) return currentIncidentId;
-  return null;
-}
-function workspaceConfigurationRefreshesDeferredConfiguration(input) {
-  return input.deferredIncidentId !== null && input.activeIncidentId === null && input.requestedDeferredIncidentId === void 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  applyWorkspaceIncidentUpdate,
-  workspaceConfigurationRefreshesDeferredConfiguration
-});