@ricsam/r5d-worker 0.0.137 → 0.0.139

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

@@ -1,71 +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_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-mount-hold-fence.cjs

@@ -1,120 +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_mount_hold_fence_exports = {};
-__export(workspace_mount_hold_fence_exports, {
-  WorkspaceMountHoldAbortedError: () => WorkspaceMountHoldAbortedError,
-  WorkspaceMountHoldFence: () => WorkspaceMountHoldFence
-});
-module.exports = __toCommonJS(workspace_mount_hold_fence_exports);
-class WorkspaceMountHoldAbortedError extends Error {
-  constructor(reason) {
-    super(reason);
-    this.name = "WorkspaceMountHoldAbortedError";
-  }
-}
-class WorkspaceMountHoldFence {
-  holds = /* @__PURE__ */ new Map();
-  waiters = /* @__PURE__ */ new Set();
-  now;
-  constructor(options = {}) {
-    this.now = options.now ?? (() => Date.now());
-  }
-  /** Take one hold on every listed mount; the returned release is idempotent. */
-  hold(mountIds, description) {
-    const ids = [...new Set(mountIds)];
-    for (const id of ids) {
-      const existing = this.holds.get(id);
-      if (existing) {
-        existing.count += 1;
-        continue;
-      }
-      this.holds.set(id, { count: 1, description, sinceMs: this.now() });
-    }
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      for (const id of ids) {
-        const existing = this.holds.get(id);
-        if (!existing) continue;
-        existing.count -= 1;
-        if (existing.count === 0) this.holds.delete(id);
-      }
-      this.wake();
-    };
-  }
-  isHeld(mountIds) {
-    return mountIds.some((id) => this.holds.has(id));
-  }
-  /** Human-readable holder of the first held mount among `mountIds`, for diagnostics. */
-  describeHold(mountIds) {
-    for (const id of mountIds) {
-      const hold = this.holds.get(id);
-      if (hold) return `${hold.description} (held for ${Math.round((this.now() - hold.sinceMs) / 1e3)}s)`;
-    }
-    return null;
-  }
-  /** Every held mount id, sorted, for status reporting. */
-  heldMountIds() {
-    return [...this.holds.keys()].sort();
-  }
-  /**
-   * Resolves in the same turn as the release that leaves none of `mountIds`
-   * held, so the caller can re-check and reserve without an interleaving
-   * hold. Resolves immediately when nothing is held. Rejects with
-   * WorkspaceMountHoldAbortedError when `signal` aborts first.
-   */
-  waitForRelease(mountIds, options = {}) {
-    if (options.signal?.aborted) {
-      return Promise.reject(new WorkspaceMountHoldAbortedError(abortReason(options.signal)));
-    }
-    if (!this.isHeld(mountIds)) return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const waiter = { mountIds, resolve, reject, signal: options.signal };
-      if (options.signal) {
-        const signal = options.signal;
-        waiter.onAbort = () => {
-          this.waiters.delete(waiter);
-          reject(new WorkspaceMountHoldAbortedError(abortReason(signal)));
-        };
-        signal.addEventListener("abort", waiter.onAbort, { once: true });
-      }
-      this.waiters.add(waiter);
-    });
-  }
-  wake() {
-    for (const waiter of [...this.waiters]) {
-      if (this.isHeld(waiter.mountIds)) continue;
-      this.waiters.delete(waiter);
-      if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
-      waiter.resolve();
-    }
-  }
-}
-function abortReason(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error) return reason.message;
-  if (typeof reason === "string" && reason) return reason;
-  return "Workspace mount reservation was aborted";
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WorkspaceMountHoldAbortedError,
-  WorkspaceMountHoldFence
-});

package/dist/cjs/workspace-mutation-gate.cjs

@@ -1,127 +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_mutation_gate_exports = {};
-__export(workspace_mutation_gate_exports, {
-  WorkspaceMutationGate: () => WorkspaceMutationGate
-});
-module.exports = __toCommonJS(workspace_mutation_gate_exports);
-class WorkspaceMutationGate {
-  activeMutations = 0;
-  syncActive = false;
-  waiters = [];
-  acquireMutation() {
-    return new Promise((resolve) => {
-      this.waiters.push({ kind: "mutation", resolve });
-      this.drain();
-    });
-  }
-  async runMutation(operation) {
-    const release = await this.acquireMutation();
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  async runSync(operation) {
-    const release = await new Promise((resolve) => {
-      this.waiters.push({ kind: "sync", resolve });
-      this.drain();
-    });
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  /** A worktree create/delete lease; see the branch lane in the class comment. */
-  acquireBranchMutation() {
-    return new Promise((resolve) => {
-      this.waiters.push({ kind: "branch", resolve });
-      this.drain();
-    });
-  }
-  async runBranchMutation(operation) {
-    const release = await this.acquireBranchMutation();
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  /**
-   * Operations a branch mutation requested now would wait for: the running
-   * sync, if any, plus branch mutations queued behind it. Zero means it runs
-   * at once. Ordinary waiters are not counted because the branch lane admits
-   * ahead of them.
-   */
-  branchMutationQueuePosition() {
-    if (!this.syncActive) return 0;
-    return 1 + this.waiters.filter((waiter) => waiter.kind === "branch").length;
-  }
-  drain() {
-    if (this.syncActive || this.waiters.length === 0) return;
-    for (let index = 0; index < this.waiters.length; ) {
-      const waiter = this.waiters[index];
-      if (waiter?.kind !== "branch") {
-        index += 1;
-        continue;
-      }
-      this.waiters.splice(index, 1);
-      this.activeMutations += 1;
-      waiter.resolve(this.releaseMutation());
-    }
-    const first = this.waiters[0];
-    if (first?.kind === "sync") {
-      if (this.activeMutations > 0) return;
-      this.waiters.shift();
-      this.syncActive = true;
-      first.resolve(this.releaseSync());
-      return;
-    }
-    while (this.waiters[0]?.kind === "mutation") {
-      const waiter = this.waiters.shift();
-      if (!waiter || waiter.kind !== "mutation") break;
-      this.activeMutations += 1;
-      waiter.resolve(this.releaseMutation());
-    }
-  }
-  releaseMutation() {
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      this.activeMutations -= 1;
-      this.drain();
-    };
-  }
-  releaseSync() {
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      this.syncActive = false;
-      this.drain();
-    };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WorkspaceMutationGate
-});

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

@@ -1,195 +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_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

@@ -1,36 +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_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

@@ -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_project_config_policy_exports = {};
-__export(workspace_project_config_policy_exports, {
-  busyProjectConfigurationChanges: () => busyProjectConfigurationChanges,
-  deferredProjectConfigurationPendingBranches: () => deferredProjectConfigurationPendingBranches,
-  describeBusyProjectConfigurationChanges: () => describeBusyProjectConfigurationChanges
-});
-module.exports = __toCommonJS(workspace_project_config_policy_exports);
-function deferredProjectConfigurationPendingBranches(projects) {
-  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 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].flatMap((projectId) => {
-    const current = currentById.get(projectId);
-    const incoming = incomingById.get(projectId);
-    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 = {
-  busyProjectConfigurationChanges,
-  deferredProjectConfigurationPendingBranches,
-  describeBusyProjectConfigurationChanges
-});