@ricsam/r5d-worker 0.0.78 → 0.0.79

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

@@ -28,15 +28,45 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var working_tree_mirror_exports = {};
 __export(working_tree_mirror_exports, {
+  assertWorkingTreeHasNoPortableGitMetadataAliases: () => assertWorkingTreeHasNoPortableGitMetadataAliases,
   inspectWorkingTree: () => inspectWorkingTree,
   mirrorWorkingTree: () => mirrorWorkingTree
 });
 module.exports = __toCommonJS(working_tree_mirror_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_git_process_environment = require("./git-process-environment.cjs");
+const HFS_IGNORED_CODE_POINTS = /[\u200c-\u200f\u202a-\u202e\u206a-\u206f\ufeff]/gu;
+const MIRROR_TEMPORARY_FILE_PREFIX = ".r5d-working-tree-mirror-";
+function isPortableGitMetadataSegment(segment) {
+  const hfsFolded = segment.replace(HFS_IGNORED_CODE_POINTS, "").toLowerCase();
+  if (hfsFolded === ".git") return true;
+  const ntfsFolded = segment.toLowerCase();
+  return /^(?:\.git|git~1)[ .]*(?::|$)/u.test(ntfsFolded);
+}
 function isGitMetadataPath(relativePath) {
-  return relativePath.split("/").includes(".git");
+  return relativePath.split(/[\\/]/u).some(isPortableGitMetadataSegment);
+}
+function assertWorkingTreeHasNoPortableGitMetadataAliases(root) {
+  root = import_node_path.default.resolve(root);
+  const rootStatus = import_node_fs.default.lstatSync(root);
+  if (!rootStatus.isDirectory() || rootStatus.isSymbolicLink()) {
+    throw new Error(`Working-tree root is not a regular directory: ${root}`);
+  }
+  const inspectDirectory = (directoryPath, relativeDirectory) => {
+    for (const name of import_node_fs.default.readdirSync(directoryPath).sort()) {
+      const relativePath = relativeDirectory ? import_node_path.default.posix.join(relativeDirectory, name) : name;
+      if (name === ".git") continue;
+      if (isGitMetadataPath(relativePath)) {
+        throw new Error(`Working tree contains a portable Git metadata alias that cannot be moved safely: ${relativePath}`);
+      }
+      const entryPath = import_node_path.default.join(directoryPath, name);
+      const status = import_node_fs.default.lstatSync(entryPath);
+      if (status.isDirectory() && !status.isSymbolicLink()) inspectDirectory(entryPath, relativePath);
+    }
+  };
+  inspectDirectory(root, "");
 }
 function normalizeRelativePath(value) {
   const normalized = value.split(import_node_path.default.sep).join(import_node_path.default.posix.sep).replace(/^\.\/+/, "").replace(/^\/+|\/+$/g, "");
@@ -49,6 +79,41 @@ function assertInside(root, candidate) {
     throw new Error(`Working-tree path escapes its root: ${candidate}`);
   }
 }
+function inspectRelativePathWithoutFollowingAncestors(root, relativePath) {
+  const normalized = normalizeRelativePath(relativePath);
+  if (!normalized) return { kind: "blocked", blockingPath: relativePath };
+  let current = import_node_path.default.resolve(root);
+  const segments = normalized.split("/");
+  for (let index = 0; index < segments.length; index += 1) {
+    current = import_node_path.default.join(current, segments[index]);
+    assertInside(root, current);
+    let stat;
+    try {
+      stat = import_node_fs.default.lstatSync(current);
+    } catch (error) {
+      if (error.code === "ENOENT") return { kind: "missing" };
+      throw error;
+    }
+    if (index < segments.length - 1 && (!stat.isDirectory() || stat.isSymbolicLink())) {
+      return { kind: "blocked", blockingPath: current };
+    }
+    if (index === segments.length - 1) return { kind: "entry", absolutePath: current, stat };
+  }
+  return { kind: "missing" };
+}
+function inspectDirectoryRoot(root, options) {
+  let stat;
+  try {
+    stat = import_node_fs.default.lstatSync(root);
+  } catch (error) {
+    if (options.allowMissing && error.code === "ENOENT") return false;
+    throw error;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`${options.label} is not a regular directory: ${root}`);
+  }
+  return true;
+}
 function gitEligibleRoots(root) {
   const result = Bun.spawnSync(
     [
@@ -85,16 +150,13 @@ function gitEligibleRoots(root) {
 function addEntry(entries, root, relativePath, recurseDirectories) {
   const normalized = normalizeRelativePath(relativePath);
   if (!normalized || entries.has(normalized)) return;
-  const absolutePath = import_node_path.default.join(root, ...normalized.split("/"));
-  assertInside(root, absolutePath);
-  let stat;
-  try {
-    stat = import_node_fs.default.lstatSync(absolutePath);
-  } catch (error) {
-    if (error.code === "ENOENT") return;
-    throw error;
-  }
+  const inspected = inspectRelativePathWithoutFollowingAncestors(root, normalized);
+  if (inspected.kind !== "entry") return;
+  const { absolutePath, stat } = inspected;
   if (stat.isSymbolicLink()) {
+    for (const existing of [...entries.keys()]) {
+      if (existing.startsWith(`${normalized}/`)) entries.delete(existing);
+    }
     entries.set(normalized, { kind: "symlink", mode: stat.mode, target: import_node_fs.default.readlinkSync(absolutePath) });
     return;
   }
@@ -114,9 +176,11 @@ function addParentDirectories(entries, root) {
     let parent = import_node_path.default.posix.dirname(relativePath);
     while (parent !== ".") {
       if (!entries.has(parent)) {
-        const absolutePath = import_node_path.default.join(root, ...parent.split("/"));
-        const stat = import_node_fs.default.lstatSync(absolutePath);
-        entries.set(parent, { kind: "directory", mode: stat.mode });
+        const inspected = inspectRelativePathWithoutFollowingAncestors(root, parent);
+        if (inspected.kind !== "entry" || !inspected.stat.isDirectory() || inspected.stat.isSymbolicLink()) {
+          throw new Error(`Working-tree entry has an unsafe parent directory: ${parent}`);
+        }
+        entries.set(parent, { kind: "directory", mode: inspected.stat.mode });
       }
       parent = import_node_path.default.posix.dirname(parent);
     }
@@ -124,7 +188,8 @@ function addParentDirectories(entries, root) {
 }
 function inspectWorkingTree(root, mode) {
   const entries = /* @__PURE__ */ new Map();
-  if (!import_node_fs.default.existsSync(root)) return entries;
+  root = import_node_path.default.resolve(root);
+  if (!inspectDirectoryRoot(root, { allowMissing: true, label: "Working-tree root" })) return entries;
   if (mode === "all") {
     for (const child of import_node_fs.default.readdirSync(root).sort()) addEntry(entries, root, child, true);
   } else {
@@ -136,32 +201,58 @@ function inspectWorkingTree(root, mode) {
   return entries;
 }
 function removeEntry(targetRoot, relativePath) {
-  const targetPath = import_node_path.default.join(targetRoot, ...relativePath.split("/"));
-  assertInside(targetRoot, targetPath);
-  import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
+  const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+  if (inspected.kind === "missing") return;
+  if (inspected.kind === "blocked") {
+    throw new Error(`Refusing to remove a working-tree path through a symlink or non-directory: ${inspected.blockingPath}`);
+  }
+  import_node_fs.default.rmSync(inspected.absolutePath, { recursive: true, force: true });
 }
 function ensureDirectory(targetRoot, relativePath, mode) {
-  const targetPath = import_node_path.default.join(targetRoot, ...relativePath.split("/"));
-  assertInside(targetRoot, targetPath);
-  if (import_node_fs.default.existsSync(targetPath) && !import_node_fs.default.lstatSync(targetPath).isDirectory()) removeEntry(targetRoot, relativePath);
-  import_node_fs.default.mkdirSync(targetPath, { recursive: true, mode: mode & 511 });
+  const normalized = normalizeRelativePath(relativePath);
+  if (!normalized) throw new Error(`Invalid working-tree directory path: ${relativePath}`);
+  let current = import_node_path.default.resolve(targetRoot);
+  const segments = normalized.split("/");
+  for (let index = 0; index < segments.length; index += 1) {
+    current = import_node_path.default.join(current, segments[index]);
+    assertInside(targetRoot, current);
+    let stat = null;
+    try {
+      stat = import_node_fs.default.lstatSync(current);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (stat && (!stat.isDirectory() || stat.isSymbolicLink())) {
+      import_node_fs.default.rmSync(current, { recursive: true, force: true });
+      stat = null;
+    }
+    if (!stat) import_node_fs.default.mkdirSync(current, { mode: index === segments.length - 1 ? mode & 511 : 493 });
+  }
 }
-function filesEqual(leftPath, rightPath, size) {
+function filesEqual(leftPath, rightPath, entry) {
   let rightStat;
   try {
     rightStat = import_node_fs.default.lstatSync(rightPath);
   } catch {
     return false;
   }
-  if (!rightStat.isFile() || rightStat.size !== size) return false;
-  const left = import_node_fs.default.openSync(leftPath, "r");
-  const right = import_node_fs.default.openSync(rightPath, "r");
+  if (!rightStat.isFile() || rightStat.size !== entry.size || (rightStat.mode & 511) !== (entry.mode & 511)) return false;
+  let left;
+  let right;
+  try {
+    left = import_node_fs.default.openSync(leftPath, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
+    right = import_node_fs.default.openSync(rightPath, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
+  } catch {
+    if (left !== void 0) import_node_fs.default.closeSync(left);
+    if (right !== void 0) import_node_fs.default.closeSync(right);
+    return false;
+  }
   const leftBuffer = Buffer.allocUnsafe(64 * 1024);
   const rightBuffer = Buffer.allocUnsafe(64 * 1024);
   try {
     let offset = 0;
-    while (offset < size) {
-      const length = Math.min(leftBuffer.length, size - offset);
+    while (offset < entry.size) {
+      const length = Math.min(leftBuffer.length, entry.size - offset);
       const leftRead = import_node_fs.default.readSync(left, leftBuffer, 0, length, offset);
       const rightRead = import_node_fs.default.readSync(right, rightBuffer, 0, length, offset);
       if (leftRead !== rightRead || !leftBuffer.subarray(0, leftRead).equals(rightBuffer.subarray(0, rightRead))) return false;
@@ -173,18 +264,73 @@ function filesEqual(leftPath, rightPath, size) {
     import_node_fs.default.closeSync(right);
   }
 }
+function copyRegularFile(sourcePath, targetPath, entry) {
+  const source = import_node_fs.default.openSync(sourcePath, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
+  const temporaryPath = import_node_path.default.join(import_node_path.default.dirname(targetPath), `${MIRROR_TEMPORARY_FILE_PREFIX}${(0, import_node_crypto.randomUUID)()}.tmp`);
+  let target;
+  try {
+    const sourceStat = import_node_fs.default.fstatSync(source);
+    if (!sourceStat.isFile() || sourceStat.size !== entry.size || (sourceStat.mode & 511) !== (entry.mode & 511)) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+    }
+    target = import_node_fs.default.openSync(
+      temporaryPath,
+      import_node_fs.default.constants.O_WRONLY | import_node_fs.default.constants.O_CREAT | import_node_fs.default.constants.O_EXCL | import_node_fs.default.constants.O_NOFOLLOW,
+      entry.mode & 511
+    );
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let offset = 0;
+    while (offset < sourceStat.size) {
+      const bytesRead = import_node_fs.default.readSync(source, buffer, 0, Math.min(buffer.length, sourceStat.size - offset), offset);
+      if (bytesRead <= 0) throw new Error(`Working-tree source ended while it was being mirrored: ${sourcePath}`);
+      let written = 0;
+      while (written < bytesRead) {
+        written += import_node_fs.default.writeSync(target, buffer, written, bytesRead - written, offset + written);
+      }
+      offset += bytesRead;
+    }
+    import_node_fs.default.fchmodSync(target, entry.mode & 511);
+    import_node_fs.default.fsyncSync(target);
+    const finalSourceStat = import_node_fs.default.fstatSync(source);
+    if (!finalSourceStat.isFile() || finalSourceStat.size !== sourceStat.size || (finalSourceStat.mode & 511) !== (sourceStat.mode & 511) || finalSourceStat.mtimeMs !== sourceStat.mtimeMs || finalSourceStat.ctimeMs !== sourceStat.ctimeMs) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+    }
+    import_node_fs.default.closeSync(target);
+    target = void 0;
+    import_node_fs.default.renameSync(temporaryPath, targetPath);
+    const parent = import_node_fs.default.openSync(import_node_path.default.dirname(targetPath), import_node_fs.default.constants.O_RDONLY);
+    try {
+      import_node_fs.default.fsyncSync(parent);
+    } finally {
+      import_node_fs.default.closeSync(parent);
+    }
+  } finally {
+    if (target !== void 0) import_node_fs.default.closeSync(target);
+    import_node_fs.default.closeSync(source);
+    import_node_fs.default.rmSync(temporaryPath, { force: true });
+  }
+}
 function copyEntry(sourceRoot, targetRoot, relativePath, entry) {
-  const sourcePath = import_node_path.default.join(sourceRoot, ...relativePath.split("/"));
   const targetPath = import_node_path.default.join(targetRoot, ...relativePath.split("/"));
-  assertInside(sourceRoot, sourcePath);
   assertInside(targetRoot, targetPath);
   const parent = import_node_path.default.posix.dirname(relativePath);
   if (parent !== ".") ensureDirectory(targetRoot, parent, 493);
+  const source = inspectRelativePathWithoutFollowingAncestors(sourceRoot, relativePath);
+  if (source.kind !== "entry") {
+    throw new Error(`Working-tree source became unsafe while it was being mirrored: ${relativePath}`);
+  }
+  const sourcePath = source.absolutePath;
   if (entry.kind === "directory") {
+    if (!source.stat.isDirectory() || source.stat.isSymbolicLink()) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+    }
     ensureDirectory(targetRoot, relativePath, entry.mode);
     return;
   }
   if (entry.kind === "symlink") {
+    if (!source.stat.isSymbolicLink() || import_node_fs.default.readlinkSync(sourcePath) !== entry.target) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+    }
     let unchanged = false;
     try {
       unchanged = import_node_fs.default.lstatSync(targetPath).isSymbolicLink() && import_node_fs.default.readlinkSync(targetPath) === entry.target;
@@ -197,16 +343,26 @@ function copyEntry(sourceRoot, targetRoot, relativePath, entry) {
     }
     return;
   }
-  if (!filesEqual(sourcePath, targetPath, entry.size)) {
-    if (import_node_fs.default.existsSync(targetPath) && !import_node_fs.default.lstatSync(targetPath).isFile()) removeEntry(targetRoot, relativePath);
-    import_node_fs.default.copyFileSync(sourcePath, targetPath);
+  if (!source.stat.isFile() || source.stat.isSymbolicLink() || source.stat.size !== entry.size) {
+    throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+  }
+  if (!filesEqual(sourcePath, targetPath, entry)) {
+    const target = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (target.kind === "blocked") {
+      throw new Error(`Refusing to copy through a symlink or non-directory: ${target.blockingPath}`);
+    }
+    const targetStat = target.kind === "entry" ? target.stat : null;
+    if (targetStat && !targetStat.isFile()) removeEntry(targetRoot, relativePath);
+    copyRegularFile(sourcePath, targetPath, entry);
   }
-  import_node_fs.default.chmodSync(targetPath, entry.mode & 511);
 }
 function mirrorWorkingTree(input) {
   const sourceRoot = import_node_path.default.resolve(input.sourceRoot);
   const targetRoot = import_node_path.default.resolve(input.targetRoot);
-  import_node_fs.default.mkdirSync(targetRoot, { recursive: true });
+  if (!inspectDirectoryRoot(targetRoot, { allowMissing: true, label: "Working-tree target root" })) {
+    import_node_fs.default.mkdirSync(targetRoot, { recursive: true });
+  }
+  inspectDirectoryRoot(targetRoot, { allowMissing: false, label: "Working-tree target root" });
   const desired = inspectWorkingTree(sourceRoot, input.sourceMode);
   const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all");
   for (const relativePath of [...existing.keys()].sort((left, right) => right.split("/").length - left.split("/").length)) {
@@ -221,6 +377,7 @@ function mirrorWorkingTree(input) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  assertWorkingTreeHasNoPortableGitMetadataAliases,
   inspectWorkingTree,
   mirrorWorkingTree
 });

package/dist/cjs/workspace-automatic-sync-policy.cjs

@@ -0,0 +1,69 @@
+"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_automatic_sync_policy_exports = {};
+__export(workspace_automatic_sync_policy_exports, {
+  PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS: () => PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS,
+  hasActiveVisibleProjectsWorkspaceTarget: () => hasActiveVisibleProjectsWorkspaceTarget,
+  pendingCreatedBranchAutomaticSyncDeferral: () => pendingCreatedBranchAutomaticSyncDeferral,
+  pendingCreatedBranchKey: () => pendingCreatedBranchKey,
+  projectBranchHasActiveWorkspaceTarget: () => projectBranchHasActiveWorkspaceTarget,
+  shouldDeferAutomaticWorkspaceSyncForPendingBranch: () => shouldDeferAutomaticWorkspaceSyncForPendingBranch
+});
+module.exports = __toCommonJS(workspace_automatic_sync_policy_exports);
+const PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS = 12e4;
+function pendingCreatedBranchKey(projectId, branchName) {
+  return `${projectId}\0${branchName}`;
+}
+function hasActiveVisibleProjectsWorkspaceTarget(activeTargets) {
+  for (const target of activeTargets) {
+    if (target.type === "workspace" && target.rootProfile === "visible_projects") return true;
+  }
+  return false;
+}
+function projectBranchHasActiveWorkspaceTarget(projectId, branchName, activeTargets) {
+  for (const target of activeTargets) {
+    if (target.type === "project" && target.projectId === projectId && target.branchName === branchName) return true;
+    if (target.type === "workspace" && target.rootProfile === "visible_projects") return true;
+  }
+  return false;
+}
+function shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches, activeTargets) {
+  if (pendingCreatedBranches.length === 0) return false;
+  const targets = [...activeTargets];
+  return pendingCreatedBranches.some(({ projectId, branchName }) => projectBranchHasActiveWorkspaceTarget(projectId, branchName, targets));
+}
+function pendingCreatedBranchAutomaticSyncDeferral(pendingCreatedBranches, activeTargets, publicationNotBeforeByBranch, nowMs = Date.now()) {
+  if (shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches, activeTargets)) {
+    return { kind: "active_target" };
+  }
+  const notBeforeMs = pendingCreatedBranches.reduce(
+    (latest, { projectId, branchName }) => Math.max(latest, publicationNotBeforeByBranch.get(pendingCreatedBranchKey(projectId, branchName)) ?? 0),
+    0
+  );
+  return notBeforeMs > nowMs ? { kind: "creation_grace", retryAfterMs: notBeforeMs - nowMs } : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS,
+  hasActiveVisibleProjectsWorkspaceTarget,
+  pendingCreatedBranchAutomaticSyncDeferral,
+  pendingCreatedBranchKey,
+  projectBranchHasActiveWorkspaceTarget,
+  shouldDeferAutomaticWorkspaceSyncForPendingBranch
+});

package/dist/cjs/workspace-branch-incarnation-policy.cjs

@@ -0,0 +1,37 @@
+"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_branch_incarnation_policy_exports = {};
+__export(workspace_branch_incarnation_policy_exports, {
+  assertProjectBranchDeletionIncarnation: () => assertProjectBranchDeletionIncarnation
+});
+module.exports = __toCommonJS(workspace_branch_incarnation_policy_exports);
+function assertProjectBranchDeletionIncarnation(input) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(input.requiredBranchId)) {
+    throw new Error("Project branch deletion requires a valid durable branch incarnation");
+  }
+  for (const branch of [input.configuredBranch, input.pendingLocalBranch]) {
+    if (branch && branch.branchId !== input.requiredBranchId) {
+      throw new Error("Project branch deletion belongs to another durable branch incarnation");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertProjectBranchDeletionIncarnation
+});

package/dist/cjs/workspace-command-sync-policy.cjs

@@ -19,10 +19,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var workspace_command_sync_policy_exports = {};
 __export(workspace_command_sync_policy_exports, {
   acquireWorkspaceCommandMutation: () => acquireWorkspaceCommandMutation,
+  reserveWorkspaceCommandAfterCurrentSync: () => reserveWorkspaceCommandAfterCurrentSync,
   runWorkspaceCommand: () => runWorkspaceCommand,
   shouldSerializeWorkspaceCommand: () => shouldSerializeWorkspaceCommand
 });
 module.exports = __toCommonJS(workspace_command_sync_policy_exports);
+function usesVisibleWorkspace(target) {
+  return target.type === "project" || target.rootProfile === "visible_projects";
+}
+async function reserveWorkspaceCommandAfterCurrentSync(target, coordinator, reserve) {
+  if (!usesVisibleWorkspace(target)) {
+    reserve();
+    return;
+  }
+  while (true) {
+    const currentSync = coordinator.afterCurrent();
+    await currentSync;
+    if (currentSync !== coordinator.afterCurrent()) continue;
+    reserve();
+    return;
+  }
+}
 function shouldSerializeWorkspaceCommand(target) {
   return target.type === "workspace" && target.rootProfile === "canonical_sync";
 }
@@ -35,6 +52,7 @@ function acquireWorkspaceCommandMutation(target, coordinator) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   acquireWorkspaceCommandMutation,
+  reserveWorkspaceCommandAfterCurrentSync,
   runWorkspaceCommand,
   shouldSerializeWorkspaceCommand
 });