@ricsam/r5d-worker 0.0.78 → 0.0.79

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

@@ -0,0 +1,71 @@
+"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_mount_boundary_exports = {};
+__export(workspace_mount_boundary_exports, {
+  assertManagedDirectoryPath: () => assertManagedDirectoryPath
+});
+module.exports = __toCommonJS(workspace_mount_boundary_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+function containedRelative(root, candidate) {
+  const relative = import_node_path.default.relative(root, candidate);
+  if (!relative || relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+    throw new Error(`Managed directory path escapes its trusted root: ${candidate}`);
+  }
+  return relative;
+}
+function assertManagedDirectoryPath(input) {
+  const trustedRoot = import_node_path.default.resolve(input.trustedRoot);
+  const candidate = import_node_path.default.resolve(input.candidate);
+  const relative = containedRelative(trustedRoot, candidate);
+  const rootStatus = import_node_fs.default.lstatSync(trustedRoot);
+  if (!rootStatus.isDirectory() || rootStatus.isSymbolicLink()) {
+    throw new Error(`${input.label} trusted root is not a regular directory: ${trustedRoot}`);
+  }
+  const realRoot = import_node_fs.default.realpathSync(trustedRoot);
+  let current = trustedRoot;
+  for (const segment of relative.split(import_node_path.default.sep)) {
+    current = import_node_path.default.join(current, segment);
+    let status;
+    try {
+      status = import_node_fs.default.lstatSync(current);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    if (!status.isDirectory() || status.isSymbolicLink()) {
+      throw new Error(`${input.label} contains a symlink or non-directory component: ${current}`);
+    }
+    containedRelative(realRoot, import_node_fs.default.realpathSync(current));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertManagedDirectoryPath
+});

package/dist/cjs/workspace-path-move.cjs

@@ -0,0 +1,195 @@
+"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_path_move_exports = {};
+__export(workspace_path_move_exports, {
+  checkoutPathMovePublicationComplete: () => checkoutPathMovePublicationComplete,
+  preserveProjectCheckoutPathMove: () => preserveProjectCheckoutPathMove
+});
+module.exports = __toCommonJS(workspace_path_move_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_crypto = require("node:crypto");
+var import_project_worktrees = require("./project-worktrees.cjs");
+var import_managed_paths = require("./managed-paths.cjs");
+var import_working_tree_mirror = require("./working-tree-mirror.cjs");
+var import_workspace_mount_boundary = require("./workspace-mount-boundary.cjs");
+function checkoutPathMovePublicationComplete(requiredMountIds, activeMountIds) {
+  return requiredMountIds.length > 0 && requiredMountIds.every((mountId) => activeMountIds.has(mountId));
+}
+function pathIsInside(root, candidate) {
+  const relative = import_node_path.default.relative(import_node_path.default.resolve(root), import_node_path.default.resolve(candidate));
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(relative);
+}
+function fsyncTree(targetPath) {
+  const stat = import_node_fs.default.lstatSync(targetPath);
+  if (stat.isSymbolicLink()) return;
+  if (stat.isDirectory()) {
+    for (const entry of import_node_fs.default.readdirSync(targetPath).sort()) fsyncTree(import_node_path.default.join(targetPath, entry));
+  }
+  if (!stat.isDirectory() && !stat.isFile()) return;
+  const descriptor = import_node_fs.default.openSync(targetPath, "r");
+  try {
+    import_node_fs.default.fsyncSync(descriptor);
+  } finally {
+    import_node_fs.default.closeSync(descriptor);
+  }
+}
+function fsyncDirectory(directoryPath) {
+  const descriptor = import_node_fs.default.openSync(directoryPath, "r");
+  try {
+    import_node_fs.default.fsyncSync(descriptor);
+  } finally {
+    import_node_fs.default.closeSync(descriptor);
+  }
+}
+function fsyncAncestorsToRoot(targetPath, durabilityRoot) {
+  const root = import_node_path.default.resolve(durabilityRoot);
+  let current = import_node_path.default.dirname(import_node_path.default.resolve(targetPath));
+  while (true) {
+    if (import_node_fs.default.existsSync(current)) {
+      const status = import_node_fs.default.lstatSync(current);
+      if (!status.isDirectory() || status.isSymbolicLink()) {
+        throw new Error(`Project checkout path move durability boundary is not a regular directory: ${current}`);
+      }
+      fsyncDirectory(current);
+    }
+    if (current === root) return;
+    const parent = import_node_path.default.dirname(current);
+    if (parent === current) throw new Error(`Project checkout path move escapes durability root ${root}`);
+    current = parent;
+  }
+}
+function stableTree(targetPath, durabilityRoot) {
+  fsyncTree(targetPath);
+  fsyncAncestorsToRoot(targetPath, durabilityRoot);
+}
+function directoryEntryExists(targetPath) {
+  try {
+    import_node_fs.default.lstatSync(targetPath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+function retiredCheckoutPath(projectsDurabilityRoot, oldProjectRoot) {
+  const storageRoot = import_node_path.default.join(projectsDurabilityRoot, ".r5d-retired-checkouts");
+  const digest = (0, import_node_crypto.createHash)("sha256").update(oldProjectRoot).digest("hex");
+  return { storageRoot, retiredRoot: import_node_path.default.join(storageRoot, digest) };
+}
+function removeRetiredCheckout(retiredRoot, storageRoot) {
+  if (!directoryEntryExists(retiredRoot)) return;
+  import_node_fs.default.rmSync(retiredRoot, { recursive: true, force: true });
+  fsyncDirectory(storageRoot);
+}
+function preserveProjectCheckoutPathMove(input) {
+  const oldProjectRoot = import_node_path.default.resolve(input.oldProjectRoot);
+  const newProjectRoot = import_node_path.default.resolve(input.newProjectRoot);
+  const projectsDurabilityRoot = import_node_path.default.resolve(input.projectsDurabilityRoot);
+  const outerWorkspaceRoot = import_node_path.default.resolve(input.outerWorkspaceRoot);
+  if (oldProjectRoot === newProjectRoot || pathIsInside(oldProjectRoot, newProjectRoot) || pathIsInside(newProjectRoot, oldProjectRoot)) {
+    throw new Error("Project checkout path move roots overlap");
+  }
+  const branchNames = input.branches.map(({ branchName }) => branchName);
+  if (branchNames.length === 0 || new Set(branchNames).size !== branchNames.length) {
+    throw new Error("Project checkout path move requires unique branches");
+  }
+  (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
+    trustedRoot: projectsDurabilityRoot,
+    candidate: oldProjectRoot,
+    label: "Old project checkout root"
+  });
+  (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
+    trustedRoot: projectsDurabilityRoot,
+    candidate: newProjectRoot,
+    label: "New project checkout root"
+  });
+  for (const branchName of branchNames) (0, import_managed_paths.validateManagedBranchName)(branchName);
+  if (directoryEntryExists(oldProjectRoot)) {
+    (0, import_working_tree_mirror.assertWorkingTreeHasNoPortableGitMetadataAliases)(oldProjectRoot);
+  }
+  const { storageRoot: retirementStorageRoot, retiredRoot } = retiredCheckoutPath(projectsDurabilityRoot, oldProjectRoot);
+  (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
+    trustedRoot: projectsDurabilityRoot,
+    candidate: retirementStorageRoot,
+    label: "Retired project checkout storage"
+  });
+  import_node_fs.default.mkdirSync(retirementStorageRoot, { recursive: true, mode: 448 });
+  (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
+    trustedRoot: projectsDurabilityRoot,
+    candidate: retirementStorageRoot,
+    label: "Retired project checkout storage"
+  });
+  fsyncDirectory(retirementStorageRoot);
+  fsyncDirectory(projectsDurabilityRoot);
+  (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
+    trustedRoot: projectsDurabilityRoot,
+    candidate: retiredRoot,
+    label: "Retired project checkout"
+  });
+  removeRetiredCheckout(retiredRoot, retirementStorageRoot);
+  if (!directoryEntryExists(oldProjectRoot)) return { preservedBranchNames: [] };
+  const preservedBranchNames = [];
+  for (const branch of input.branches) {
+    (0, import_managed_paths.validateManagedBranchName)(branch.branchName);
+    const oldBranchPath = import_node_path.default.join(oldProjectRoot, ...branch.branchName.split("/"));
+    if (!import_node_fs.default.existsSync(oldBranchPath)) continue;
+    const newBranchPath = import_node_path.default.join(newProjectRoot, ...branch.branchName.split("/"));
+    const outerBranchPath = import_node_path.default.resolve(outerWorkspaceRoot, ...branch.outerWorkspaceRelativePath.replace(/\\/g, "/").split("/"));
+    if (!pathIsInside(outerWorkspaceRoot, outerBranchPath)) {
+      throw new Error(`Project checkout path move escapes the outer workspace: ${branch.outerWorkspaceRelativePath}`);
+    }
+    (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({ trustedRoot: projectsDurabilityRoot, candidate: oldBranchPath, label: "Old project checkout branch" });
+    (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({ trustedRoot: projectsDurabilityRoot, candidate: newBranchPath, label: "New project checkout branch" });
+    (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({ trustedRoot: outerWorkspaceRoot, candidate: outerBranchPath, label: "Outer workspace branch" });
+    (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: oldBranchPath, targetRoot: outerBranchPath, sourceMode: "git", deletionMode: "all" });
+    (0, import_working_tree_mirror.mirrorWorkingTree)({ sourceRoot: oldBranchPath, targetRoot: newBranchPath, sourceMode: "all", deletionMode: "all" });
+    (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({ trustedRoot: projectsDurabilityRoot, candidate: newBranchPath, label: "New project checkout branch" });
+    (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({ trustedRoot: outerWorkspaceRoot, candidate: outerBranchPath, label: "Outer workspace branch" });
+    stableTree(outerBranchPath, outerWorkspaceRoot);
+    stableTree(newBranchPath, projectsDurabilityRoot);
+    preservedBranchNames.push(branch.branchName);
+  }
+  for (const branchName of branchNames) {
+    const checkoutPath = import_node_path.default.join(oldProjectRoot, ...branchName.split("/"));
+    if (import_node_fs.default.existsSync(checkoutPath) && (0, import_project_worktrees.projectWorktreeOperationInProgress)(checkoutPath)) {
+      throw new Error(`Project branch ${branchName} has an in-progress Git operation`);
+    }
+  }
+  import_node_fs.default.renameSync(oldProjectRoot, retiredRoot);
+  fsyncAncestorsToRoot(oldProjectRoot, projectsDurabilityRoot);
+  fsyncDirectory(retirementStorageRoot);
+  removeRetiredCheckout(retiredRoot, retirementStorageRoot);
+  return { preservedBranchNames: preservedBranchNames.sort() };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkoutPathMovePublicationComplete,
+  preserveProjectCheckoutPathMove
+});

package/dist/cjs/workspace-preserve-only-policy.cjs

@@ -0,0 +1,36 @@
+"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_preserve_only_policy_exports = {};
+__export(workspace_preserve_only_policy_exports, {
+  creatorLocalProjectBranchIsAuthorized: () => creatorLocalProjectBranchIsAuthorized,
+  workerProjectBranchDisposition: () => workerProjectBranchDisposition
+});
+module.exports = __toCommonJS(workspace_preserve_only_policy_exports);
+function creatorLocalProjectBranchIsAuthorized(input) {
+  return Boolean(input.pendingBranchId && (!input.preserveOnlyBranchId || input.pendingBranchId === input.preserveOnlyBranchId));
+}
+function workerProjectBranchDisposition(input) {
+  if (input.activeConfigured) return "active";
+  return input.locallyPendingCreated ? "creator_local" : "preserve_only";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  creatorLocalProjectBranchIsAuthorized,
+  workerProjectBranchDisposition
+});

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

@@ -0,0 +1,46 @@
+"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_project_config_policy_exports = {};
+__export(workspace_project_config_policy_exports, {
+  busyProjectConfigurationChangeIds: () => busyProjectConfigurationChangeIds,
+  deferredProjectConfigurationPendingBranches: () => deferredProjectConfigurationPendingBranches
+});
+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));
+}
+function busyProjectConfigurationChangeIds(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) => {
+    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();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  busyProjectConfigurationChangeIds,
+  deferredProjectConfigurationPendingBranches
+});

package/dist/cjs/workspace-publication-evidence.cjs

@@ -0,0 +1,46 @@
+"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_publication_evidence_exports = {};
+__export(workspace_publication_evidence_exports, {
+  activeProjectBranchNames: () => activeProjectBranchNames,
+  activeProjectBranchPublicationEvidence: () => activeProjectBranchPublicationEvidence
+});
+module.exports = __toCommonJS(workspace_publication_evidence_exports);
+function projectBranchMountId(projectId, branchName) {
+  return `project:${projectId}:${encodeURIComponent(branchName)}`;
+}
+function activeProjectBranchNames(projectId, branchNames, activeMountIds) {
+  const active = new Set(activeMountIds);
+  return [...branchNames].filter((branchName) => active.has(projectBranchMountId(projectId, branchName))).sort((left, right) => left.localeCompare(right));
+}
+function activeProjectBranchPublicationEvidence(projects, activeMountIds) {
+  const active = new Set(activeMountIds);
+  return projects.flatMap(
+    (project) => project.executionDisabled || project.mirrorWritesDisabled ? [] : project.branches.flatMap(
+      (branch) => active.has(projectBranchMountId(project.projectId, branch.branchName)) ? [{ branchId: branch.branchId, projectId: project.projectId, branchName: branch.branchName }] : []
+    )
+  ).sort(
+    (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName) || left.branchId.localeCompare(right.branchId)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activeProjectBranchNames,
+  activeProjectBranchPublicationEvidence
+});