@ricsam/r5d-worker 0.0.132 → 0.0.134

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

@@ -178,7 +178,7 @@ function hashRegularFile(workspacePath, sourcePath, entry) {
     if (pathStatus.dev !== after.dev || pathStatus.ino !== after.ino || !pathStatus.isFile() || pathStatus.isSymbolicLink()) {
       throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
     }
-    return objectId;
+    return { objectId, projected: (0, import_working_tree_mirror.projectedFileEntry)(after) };
   } finally {
     import_node_fs.default.closeSync(descriptor);
   }
@@ -211,6 +211,8 @@ function synthesizeMountTree(input) {
   const entries = (0, import_working_tree_mirror.inspectWorkingTree)(sourceRoot, input.sourceMode);
   const indexPath = temporaryIndexPath(input.workspacePath);
   const environment = temporaryIndexEnvironment(indexPath);
+  const projectedFiles = {};
+  const blobs = /* @__PURE__ */ new Map();
   try {
     git(input.workspacePath, ["read-tree", "--empty"], "initialize workspace projection index", { environment });
     const records = [];
@@ -218,10 +220,20 @@ function synthesizeMountTree(input) {
       if (entry.kind === "directory") continue;
       if (entry.kind === "gitlink") {
         records.push(indexInfoRecord("160000", entry.objectId, relativePath));
+        projectedFiles[relativePath] = { kind: "gitlink", objectId: entry.objectId };
         continue;
       }
       const sourcePath = sourceEntryPath(sourceRoot, relativePath);
-      const objectId = entry.kind === "file" ? hashRegularFile(input.workspacePath, sourcePath, entry) : hashSymlink(input.workspacePath, sourcePath, entry);
+      let objectId;
+      if (entry.kind === "file") {
+        const hashed = hashRegularFile(input.workspacePath, sourcePath, entry);
+        objectId = hashed.objectId;
+        projectedFiles[relativePath] = hashed.projected;
+      } else {
+        objectId = hashSymlink(input.workspacePath, sourcePath, entry);
+        projectedFiles[relativePath] = { kind: "symlink", target: entry.target };
+      }
+      blobs.set(relativePath, objectId);
       records.push(indexInfoRecord(indexMode(entry), objectId, relativePath));
     }
     if (records.length > 0) {
@@ -230,14 +242,54 @@ function synthesizeMountTree(input) {
         stdin: Buffer.concat(records)
       });
     }
-    return requireObjectId(
+    const tree = requireObjectId(
       gitText(input.workspacePath, ["write-tree"], "write workspace projection mount tree", { environment }),
       "Workspace projection mount tree"
     );
+    return { tree, projectedFiles, blobs };
   } finally {
     removeTemporaryIndex(indexPath);
   }
 }
+function staleRewritePaths(input) {
+  const entries = Object.entries(input.staleRewriteBlobs ?? {});
+  if (entries.length === 0) return { stale: [], cleared: [] };
+  const probed = gitText(input.workspacePath, ["cat-file", "--batch-check"], "resolve workspace projection basis subtree", {
+    stdin: Buffer.from(`${input.basisHead}:${input.workspaceRelativePath}
+`)
+  });
+  const basisSubtree = /^([0-9a-f]{40,64}) tree \d+$/u.exec(probed);
+  if (!basisSubtree && !/ missing$/u.test(probed))
+    throw new Error(`Resolve workspace projection basis subtree: unexpected answer ${probed}`);
+  const changed = /* @__PURE__ */ new Set();
+  if (!basisSubtree) {
+    for (const relativePath of input.blobs.keys()) changed.add(relativePath);
+  } else {
+    const listing = git(
+      input.workspacePath,
+      ["diff-tree", "-r", "-z", "--no-renames", "--raw", basisSubtree[1], input.mountTree],
+      "compare workspace projection with its basis"
+    );
+    const records = nulRecords(listing);
+    for (let index = 0; index + 1 < records.length; index += 2) changed.add(records[index + 1].toString());
+  }
+  const stale = [];
+  const cleared = [];
+  for (const [relativePath, blob] of entries) {
+    const synthesized = input.blobs.get(relativePath);
+    if (synthesized === void 0) {
+      cleared.push(relativePath);
+      continue;
+    }
+    if (synthesized === blob) {
+      if (changed.has(relativePath)) stale.push(relativePath);
+      else cleared.push(relativePath);
+      continue;
+    }
+    if (changed.has(relativePath)) cleared.push(relativePath);
+  }
+  return { stale: stale.sort(), cleared: cleared.sort() };
+}
 function nulRecords(content) {
   const records = [];
   let start = 0;
@@ -285,23 +337,32 @@ function graftMountTree(input) {
   }
 }
 function synthesizeOursCommit(input) {
-  const mountTree = synthesizeMountTree({
+  const synthesized = synthesizeMountTree({
     workspacePath: input.workspacePath,
     sourcePath: input.mount.sourcePath,
     sourceMode: input.mount.sourceMode
   });
+  const detected = staleRewritePaths({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    basisHead: input.basisHead,
+    mountTree: synthesized.tree,
+    blobs: synthesized.blobs,
+    staleRewriteBlobs: input.staleRewriteBlobs
+  });
+  if (detected.stale.length > 0) return { staleRewritePaths: detected.stale, staleRewriteCleared: detected.cleared };
   const rootTree = graftMountTree({
     workspacePath: input.workspacePath,
     workspaceRelativePath: input.workspaceRelativePath,
     basisHead: input.basisHead,
-    mountTree
+    mountTree: synthesized.tree
   });
   const message = JSON.stringify({
     type: "workspace_projection_basis",
     mountId: input.mount.id,
     attemptId: input.attemptId
   });
-  return requireObjectId(
+  const oursCommit = requireObjectId(
     gitText(
       input.workspacePath,
       ["commit-tree", rootTree, "-p", input.basisHead, "-m", message],
@@ -309,6 +370,7 @@ function synthesizeOursCommit(input) {
     ),
     `Synthesized workspace projection commit for mount ${input.mount.id}`
   );
+  return { oursCommit, projectedFiles: synthesized.projectedFiles, staleRewriteCleared: detected.cleared };
 }
 function mergeWorkspaceProjectionMount(input) {
   const support = workspaceMergeProjectionSupport();
@@ -317,13 +379,19 @@ function mergeWorkspaceProjectionMount(input) {
   const workspaceRelativePath = normalizeWorkspaceRelativePath(input.mount.workspaceRelativePath);
   const basisHead = requireCommit(workspacePath, input.basisHead, `workspace projection basis for mount ${input.mount.id}`);
   const currentHead = requireCommit(workspacePath, input.currentHead, "current workspace projection head");
-  const oursCommit = synthesizeOursCommit({
+  const synthesized = synthesizeOursCommit({
     workspacePath,
     mount: input.mount,
     workspaceRelativePath,
     basisHead,
-    attemptId: input.attemptId
+    attemptId: input.attemptId,
+    ...input.staleRewriteBlobs ? { staleRewriteBlobs: input.staleRewriteBlobs } : {}
   });
+  if ("staleRewritePaths" in synthesized) {
+    return { kind: "stale_rewrite", paths: synthesized.staleRewritePaths, staleRewriteCleared: synthesized.staleRewriteCleared };
+  }
+  const { oursCommit, projectedFiles, staleRewriteCleared } = synthesized;
+  const readAtMs = Date.now();
   const merged = gitResult(workspacePath, [
     "merge-tree",
     "--write-tree",
@@ -341,13 +409,16 @@ function mergeWorkspaceProjectionMount(input) {
   const records = nulRecords(merged.stdout);
   const resultTree = records.shift()?.toString() ?? "";
   requireObjectId(resultTree, `Merged workspace projection tree for mount ${input.mount.id}`);
-  if (merged.exitCode === 0) return { kind: "clean", resultTree, oursCommit };
+  if (merged.exitCode === 0) return { kind: "clean", resultTree, oursCommit, projectedFiles, readAtMs, staleRewriteCleared };
   const conflictPaths = records.map((record) => record.toString()).sort();
   return {
     kind: "conflict",
     oursCommit,
     conflictPaths,
-    error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`
+    error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`,
+    projectedFiles,
+    readAtMs,
+    staleRewriteCleared
   };
 }
 function materializeWorkspaceProjectionTree(input) {

package/dist/cjs/workspace-project-config-policy.cjs

@@ -18,29 +18,36 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var workspace_project_config_policy_exports = {};
 __export(workspace_project_config_policy_exports, {
-  busyProjectConfigurationChangeIds: () => busyProjectConfigurationChangeIds,
-  deferredProjectConfigurationPendingBranches: () => deferredProjectConfigurationPendingBranches
+  busyProjectConfigurationChanges: () => busyProjectConfigurationChanges,
+  deferredProjectConfigurationPendingBranches: () => deferredProjectConfigurationPendingBranches,
+  describeBusyProjectConfigurationChanges: () => describeBusyProjectConfigurationChanges
 });
 module.exports = __toCommonJS(workspace_project_config_policy_exports);
 function deferredProjectConfigurationPendingBranches(projects) {
-  return projects.flatMap((project) => project.branches.map(({ branchName }) => ({ projectId: project.projectId, branchName }))).sort((left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName));
+  return projects.filter((project) => !project.executionDisabled).flatMap((project) => project.branches.map(({ branchName }) => ({ projectId: project.projectId, branchName }))).sort((left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName));
 }
-function busyProjectConfigurationChangeIds(input) {
+function busyProjectConfigurationChanges(input) {
   const currentById = new Map(input.currentProjects.map((project) => [project.projectId, project]));
   const incomingById = new Map(input.incomingProjects.map((project) => [project.projectId, project]));
   const targets = [...input.activeTargets];
   const busyProjectIds = targets.some((target) => target.type === "workspace" && target.rootProfile === "visible_projects") ? /* @__PURE__ */ new Set([...currentById.keys(), ...incomingById.keys()]) : new Set(targets.flatMap((target) => target.type === "project" ? [target.projectId] : []));
-  return [...busyProjectIds].filter((projectId) => {
+  return [...busyProjectIds].flatMap((projectId) => {
     const current = currentById.get(projectId);
     const incoming = incomingById.get(projectId);
-    if (!current && !incoming) return false;
-    if (!current || !incoming) return true;
-    if (!input.currentProjectReady(current)) return true;
-    return input.currentFingerprint(current) !== input.incomingFingerprint(incoming);
-  }).sort();
+    if (!current && !incoming) return [];
+    if (!current) return [{ projectId, reason: "added" }];
+    if (!incoming) return [{ projectId, reason: "removed" }];
+    if (!input.currentProjectReady(current)) return [{ projectId, reason: "initializing" }];
+    if (input.currentFingerprint(current) !== input.incomingFingerprint(incoming)) return [{ projectId, reason: "changed" }];
+    return [];
+  }).sort((left, right) => left.projectId.localeCompare(right.projectId));
+}
+function describeBusyProjectConfigurationChanges(changes) {
+  return changes.map(({ projectId, reason }) => `${projectId} (${reason})`).join(", ");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  busyProjectConfigurationChangeIds,
-  deferredProjectConfigurationPendingBranches
+  busyProjectConfigurationChanges,
+  deferredProjectConfigurationPendingBranches,
+  describeBusyProjectConfigurationChanges
 });

package/dist/mjs/atomic-rename.mjs

@@ -0,0 +1,261 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+class AtomicRenameError extends Error {
+  constructor(syscall, code, errno, path2, dest) {
+    super(`${code}: ${syscall} failed, ${path2} -> ${dest}`);
+    this.syscall = syscall;
+    this.code = code;
+    this.errno = errno;
+    this.path = path2;
+    this.dest = dest;
+    this.name = "AtomicRenameError";
+  }
+  syscall;
+  code;
+  errno;
+  path;
+  dest;
+}
+const UNSUPPORTED_CODES = /* @__PURE__ */ new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM"]);
+function isAtomicRenameUnsupported(error) {
+  return error instanceof AtomicRenameError && UNSUPPORTED_CODES.has(error.code);
+}
+const LINUX_AT_FDCWD = -100;
+const LINUX_RENAME_NOREPLACE = 1;
+const LINUX_RENAME_EXCHANGE = 2;
+const DARWIN_RENAME_SWAP = 2;
+const DARWIN_RENAME_EXCL = 4;
+const LINUX_SYS_RENAMEAT2 = { x64: 316, arm64: 276 };
+const PROBE_PREFIX = ".r5d-atomic-rename-probe-";
+let loaded = null;
+let override = null;
+const errnoNames = /* @__PURE__ */ new Map();
+for (const [name, value] of Object.entries(os.constants.errno)) errnoNames.set(value, name);
+function errnoCode(errno) {
+  return errnoNames.get(errno) ?? `E${errno}`;
+}
+function cString(value) {
+  return Buffer.from(`${value}\0`, "utf8");
+}
+function loadNative() {
+  if (loaded) return loaded;
+  loaded = { calls: null, detail: "not attempted" };
+  try {
+    const ffi = require("bun:ffi");
+    const { dlopen, FFIType, ptr, read } = ffi;
+    if (process.platform === "darwin") {
+      const lib = dlopen("libSystem.B.dylib", {
+        renamex_np: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+        __error: { args: [], returns: FFIType.ptr }
+      });
+      loaded = {
+        calls: {
+          rename2: (from, to, flags) => {
+            const fromBuffer = cString(from);
+            const toBuffer = cString(to);
+            return lib.symbols.renamex_np(ptr(fromBuffer), ptr(toBuffer), flags);
+          },
+          errno: () => read.i32(lib.symbols.__error(), 0),
+          exchangeFlag: DARWIN_RENAME_SWAP,
+          noReplaceFlag: DARWIN_RENAME_EXCL,
+          backend: "renamex_np"
+        }
+      };
+      return loaded;
+    }
+    if (process.platform === "linux") {
+      const errnoLib = dlopen("libc.so.6", { __errno_location: { args: [], returns: FFIType.ptr } });
+      const errno = () => read.i32(errnoLib.symbols.__errno_location(), 0);
+      try {
+        const lib = dlopen("libc.so.6", {
+          renameat2: { args: [FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 }
+        });
+        loaded = {
+          calls: {
+            rename2: (from, to, flags) => {
+              const fromBuffer = cString(from);
+              const toBuffer = cString(to);
+              return lib.symbols.renameat2(LINUX_AT_FDCWD, ptr(fromBuffer), LINUX_AT_FDCWD, ptr(toBuffer), flags);
+            },
+            errno,
+            exchangeFlag: LINUX_RENAME_EXCHANGE,
+            noReplaceFlag: LINUX_RENAME_NOREPLACE,
+            backend: "renameat2"
+          }
+        };
+        return loaded;
+      } catch (error) {
+        const number = LINUX_SYS_RENAMEAT2[process.arch];
+        if (number === void 0) {
+          loaded = { calls: null, detail: `renameat2 symbol unavailable and no syscall number for ${process.arch}: ${String(error)}` };
+          return loaded;
+        }
+        const lib = dlopen("libc.so.6", {
+          syscall: {
+            args: [FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64],
+            returns: FFIType.i64
+          }
+        });
+        loaded = {
+          calls: {
+            rename2: (from, to, flags) => {
+              const fromBuffer = cString(from);
+              const toBuffer = cString(to);
+              return Number(
+                lib.symbols.syscall(number, LINUX_AT_FDCWD, Number(ptr(fromBuffer)), LINUX_AT_FDCWD, Number(ptr(toBuffer)), flags)
+              );
+            },
+            errno,
+            exchangeFlag: LINUX_RENAME_EXCHANGE,
+            noReplaceFlag: LINUX_RENAME_NOREPLACE,
+            backend: "syscall"
+          }
+        };
+        return loaded;
+      }
+    }
+    loaded = { calls: null, detail: `no atomic exchange primitive on ${process.platform}` };
+  } catch (error) {
+    loaded = { calls: null, detail: `bun:ffi unavailable: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  return loaded;
+}
+function applyOverride(support) {
+  if (override?.exchange !== void 0) support.exchange = override.exchange;
+  if (override?.noReplace !== void 0) support.noReplace = override.noReplace;
+  return support;
+}
+function atomicRenameSupport() {
+  const native = loadNative();
+  return applyOverride(
+    native.calls ? { platform: process.platform, exchange: native.calls.backend, noReplace: native.calls.backend } : { platform: process.platform, exchange: "unavailable", noReplace: "link", detail: native.detail }
+  );
+}
+function overrideAtomicRenameSupportForTests(value) {
+  override = value;
+}
+function resetAtomicRenameProbesForTests() {
+  probes.clear();
+}
+function call(native, syscall, from, to, flags) {
+  if (native.rename2(from, to, flags) === 0) return;
+  const errno = native.errno();
+  throw new AtomicRenameError(syscall, errnoCode(errno), errno, from, to);
+}
+function exchangeWith(support, a, b) {
+  const native = loadNative().calls;
+  if (support.exchange === "unavailable" || !native) {
+    throw new AtomicRenameError("exchange", "ENOSYS", os.constants.errno.ENOSYS, a, b);
+  }
+  call(native, support.exchange, a, b, native.exchangeFlag);
+}
+function renameNoReplaceWith(support, from, to) {
+  const native = loadNative().calls;
+  if (support.noReplace !== "link" && native) {
+    call(native, support.noReplace, from, to, native.noReplaceFlag);
+    return;
+  }
+  const source = fs.lstatSync(from);
+  if (!source.isFile()) throw new AtomicRenameError("link", "ENOTSUP", os.constants.errno.ENOTSUP, from, to);
+  try {
+    fs.linkSync(from, to);
+  } catch (error) {
+    const code = error.code ?? "EIO";
+    throw new AtomicRenameError("link", code, error.errno ?? 0, from, to);
+  }
+  fs.unlinkSync(from);
+}
+function exchangePaths(a, b) {
+  exchangeWith(atomicRenameSupport(), a, b);
+}
+function renameNoReplace(from, to) {
+  renameNoReplaceWith(atomicRenameSupport(), from, to);
+}
+const probes = /* @__PURE__ */ new Map();
+function withoutTemporaries(directory, run) {
+  const token = randomUUID();
+  const a = path.join(directory, `${PROBE_PREFIX}${token}-a`);
+  const b = path.join(directory, `${PROBE_PREFIX}${token}-b`);
+  try {
+    run(a, b);
+  } finally {
+    fs.rmSync(a, { force: true });
+    fs.rmSync(b, { force: true });
+  }
+}
+function createProbeFile(filePath, content) {
+  const descriptor = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
+  try {
+    fs.writeSync(descriptor, content);
+    return fs.fstatSync(descriptor);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+function probeAtomicRenameSupport(directory) {
+  const native = atomicRenameSupport();
+  const dev = fs.lstatSync(directory).dev;
+  const cached = probes.get(dev);
+  if (cached) return applyOverride({ ...cached });
+  const probed = { ...native };
+  if (native.exchange !== "unavailable") {
+    withoutTemporaries(directory, (a, b) => {
+      const statA = createProbeFile(a, "a");
+      const statB = createProbeFile(b, "b");
+      let swapped = false;
+      let detail;
+      try {
+        exchangeWith(native, a, b);
+        const afterA = fs.lstatSync(a);
+        const afterB = fs.lstatSync(b);
+        swapped = afterA.ino === statB.ino && afterB.ino === statA.ino;
+        if (!swapped) detail = `exchange flag ignored by the filesystem holding ${directory}`;
+      } catch (error) {
+        detail = `exchange rejected by the filesystem holding ${directory}: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      if (!swapped) {
+        probed.exchange = "unavailable";
+        probed.detail = detail;
+      }
+    });
+  }
+  if (native.noReplace !== "link") {
+    withoutTemporaries(directory, (a, b) => {
+      createProbeFile(a, "a");
+      createProbeFile(b, "b");
+      let refused = false;
+      try {
+        renameNoReplaceWith(native, a, b);
+      } catch (error) {
+        refused = error instanceof AtomicRenameError && error.code === "EEXIST";
+      }
+      if (!refused) {
+        probed.noReplace = "link";
+        probed.detail = `${probed.detail ? `${probed.detail}; ` : ""}no-replace flag ignored by the filesystem holding ${directory}`;
+      }
+    });
+  }
+  probes.set(dev, probed);
+  return applyOverride({ ...probed });
+}
+function atomicRenamePrimitivesFor(directory) {
+  const support = probeAtomicRenameSupport(directory);
+  return {
+    support,
+    exchange: (a, b) => exchangeWith(support, a, b),
+    renameNoReplace: (from, to) => renameNoReplaceWith(support, from, to)
+  };
+}
+export {
+  AtomicRenameError,
+  atomicRenamePrimitivesFor,
+  atomicRenameSupport,
+  exchangePaths,
+  isAtomicRenameUnsupported,
+  overrideAtomicRenameSupportForTests,
+  probeAtomicRenameSupport,
+  renameNoReplace,
+  resetAtomicRenameProbesForTests
+};

package/dist/mjs/git-blob-hash.mjs

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+function gitObjectHashAlgorithmFor(objectId) {
+  if (/^[0-9a-f]{40}$/u.test(objectId)) return "sha1";
+  if (/^[0-9a-f]{64}$/u.test(objectId)) return "sha256";
+  return null;
+}
+function gitBlobHash(content, algorithm) {
+  const hash = createHash(algorithm);
+  hash.update(`blob ${content.length}\0`);
+  hash.update(content);
+  return hash.digest("hex");
+}
+export {
+  gitBlobHash,
+  gitObjectHashAlgorithmFor
+};