@ricsam/r5d-worker 0.0.137 → 0.0.139

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

@@ -1,79 +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_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,
-  projectBranchMountBusyDuringExclusiveSync: () => projectBranchMountBusyDuringExclusiveSync,
-  shouldDeferAutomaticWorkspaceSyncForPendingBranch: () => shouldDeferAutomaticWorkspaceSyncForPendingBranch,
-  workspacePlansMountBusyDuringExclusiveSync: () => workspacePlansMountBusyDuringExclusiveSync
-});
-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 projectBranchMountBusyDuringExclusiveSync(input) {
-  return input.executionDisabled || input.worktreeOperationInProgress || input.retainedCanonicalProcessGroup || projectBranchHasActiveWorkspaceTarget(input.projectId, input.branchName, input.activeTargets);
-}
-function workspacePlansMountBusyDuringExclusiveSync(activeTargets, retainedCanonicalProcessGroup = false) {
-  return retainedCanonicalProcessGroup || hasActiveVisibleProjectsWorkspaceTarget(activeTargets);
-}
-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,
-  projectBranchMountBusyDuringExclusiveSync,
-  shouldDeferAutomaticWorkspaceSyncForPendingBranch,
-  workspacePlansMountBusyDuringExclusiveSync
-});

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

@@ -1,37 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var workspace_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

@@ -1,112 +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_command_sync_policy_exports = {};
-__export(workspace_command_sync_policy_exports, {
-  acquireWorkspaceCommandMutation: () => acquireWorkspaceCommandMutation,
-  reserveWorkspaceCommandAfterCurrentSync: () => reserveWorkspaceCommandAfterCurrentSync,
-  runReservedWorkspaceCommand: () => runReservedWorkspaceCommand,
-  runWorkspaceCommand: () => runWorkspaceCommand,
-  shouldSerializeWorkspaceCommand: () => shouldSerializeWorkspaceCommand
-});
-module.exports = __toCommonJS(workspace_command_sync_policy_exports);
-var import_workspace_mount_hold_fence = require("./workspace-mount-hold-fence.cjs");
-function requiresCurrentSyncBarrier(targets) {
-  return targets.some((target) => target.type === "workspace" && target.rootProfile === "visible_projects");
-}
-function asTargetList(target) {
-  return Array.isArray(target) ? target : [target];
-}
-async function reserveWorkspaceCommandAfterCurrentSync(target, coordinator, reserve, options = {}) {
-  const targets = asTargetList(target);
-  while (true) {
-    if (requiresCurrentSyncBarrier(targets)) {
-      const currentSync = coordinator.afterCurrent();
-      await raceWithAbort(currentSync, options.signal);
-      if (currentSync !== coordinator.afterCurrent()) continue;
-    }
-    if (options.signal?.aborted) throw new import_workspace_mount_hold_fence.WorkspaceMountHoldAbortedError(abortReason(options.signal));
-    const hold = coordinator.mountHold(targets, options.signal);
-    if (hold) {
-      await hold;
-      continue;
-    }
-    reserve();
-    return;
-  }
-}
-function raceWithAbort(waited, signal) {
-  if (!signal) return waited;
-  if (signal.aborted) return Promise.reject(new import_workspace_mount_hold_fence.WorkspaceMountHoldAbortedError(abortReason(signal)));
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(new import_workspace_mount_hold_fence.WorkspaceMountHoldAbortedError(abortReason(signal)));
-    signal.addEventListener("abort", onAbort, { once: true });
-    waited.then(
-      () => {
-        signal.removeEventListener("abort", onAbort);
-        resolve();
-      },
-      (error) => {
-        signal.removeEventListener("abort", onAbort);
-        reject(error instanceof Error ? error : new Error(String(error)));
-      }
-    );
-  });
-}
-function abortReason(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error) return reason.message;
-  if (typeof reason === "string" && reason) return reason;
-  return "Workspace command reservation was aborted";
-}
-function shouldSerializeWorkspaceCommand(target) {
-  return target.type === "workspace" && target.rootProfile === "canonical_sync";
-}
-function runWorkspaceCommand(target, coordinator, operation) {
-  return shouldSerializeWorkspaceCommand(target) ? coordinator.runMutation(operation) : Promise.resolve().then(operation);
-}
-async function runReservedWorkspaceCommand(target, coordinator, operation, releaseReservation) {
-  let released = false;
-  const releaseOnce = () => {
-    if (released) return;
-    released = true;
-    releaseReservation();
-  };
-  try {
-    return await runWorkspaceCommand(target, coordinator, async () => {
-      try {
-        return await operation();
-      } finally {
-        releaseOnce();
-      }
-    });
-  } finally {
-    releaseOnce();
-  }
-}
-function acquireWorkspaceCommandMutation(target, coordinator) {
-  return shouldSerializeWorkspaceCommand(target) ? coordinator.acquireMutation() : Promise.resolve(void 0);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  acquireWorkspaceCommandMutation,
-  reserveWorkspaceCommandAfterCurrentSync,
-  runReservedWorkspaceCommand,
-  runWorkspaceCommand,
-  shouldSerializeWorkspaceCommand
-});

package/dist/cjs/workspace-command-targets.cjs

@@ -1,63 +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_command_targets_exports = {};
-__export(workspace_command_targets_exports, {
-  commandTargets: () => commandTargets,
-  describeCommandAdditionalTargets: () => describeCommandAdditionalTargets,
-  normalizeCommandAdditionalTargets: () => normalizeCommandAdditionalTargets
-});
-module.exports = __toCommonJS(workspace_command_targets_exports);
-function targetKey(target) {
-  return `${target.projectId}\0${target.branchName}`;
-}
-function normalizeCommandAdditionalTargets(primary, additional, validators) {
-  if (additional === void 0 || additional === null) return [];
-  if (!Array.isArray(additional)) throw new Error("Command additional targets must be a list of project branches");
-  const seen = new Set(primary.type === "project" ? [targetKey(primary)] : []);
-  const normalized = [];
-  for (const entry of additional) {
-    if (!entry || typeof entry !== "object" || entry.type !== "project") {
-      throw new Error("Command additional targets must be project branches");
-    }
-    const { projectId, branchName } = entry;
-    if (typeof projectId !== "string" || typeof branchName !== "string")
-      throw new Error("Command additional target is missing its project or branch");
-    validators.validateProjectId(projectId);
-    validators.validateBranchName(branchName);
-    const target = { type: "project", projectId, branchName };
-    const key = targetKey(target);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    normalized.push(target);
-  }
-  return normalized;
-}
-function commandTargets(primary, additional) {
-  return [primary, ...additional];
-}
-function describeCommandAdditionalTargets(additional) {
-  if (additional.length === 0) return "";
-  return ` (also fencing ${additional.map((target) => `${target.projectId}/${target.branchName}`).join(", ")})`;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  commandTargets,
-  describeCommandAdditionalTargets,
-  normalizeCommandAdditionalTargets
-});

package/dist/cjs/workspace-filesystem-executor-thread.cjs

@@ -1,36 +0,0 @@
-"use strict";
-var import_node_worker_threads = require("node:worker_threads");
-var import_workspace_filesystem_job_types = require("./workspace-filesystem-job-types.cjs");
-var import_workspace_filesystem_jobs = require("./workspace-filesystem-jobs.cjs");
-if (import_node_worker_threads.isMainThread || !import_node_worker_threads.parentPort) {
-  throw new Error("The workspace filesystem executor thread must be started by the worker runtime");
-}
-const port = import_node_worker_threads.parentPort;
-function runRequest(request) {
-  if (!(0, import_workspace_filesystem_job_types.isWorkspaceFilesystemJobKind)(request.kind)) {
-    return {
-      type: "failure",
-      id: request.id,
-      error: (0, import_workspace_filesystem_job_types.serializeWorkspaceFilesystemError)(new Error(`Unknown workspace filesystem job kind: ${String(request.kind)}`))
-    };
-  }
-  const operation = import_workspace_filesystem_jobs.workspaceFilesystemJobOperations[request.kind];
-  const previousEnvironment = process.env;
-  process.env = { ...request.environment };
-  try {
-    const result = operation(request.input, {
-      progress: (progress) => port.postMessage({ type: "progress", id: request.id, progress })
-    });
-    return { type: "result", id: request.id, result };
-  } catch (error) {
-    return { type: "failure", id: request.id, error: (0, import_workspace_filesystem_job_types.serializeWorkspaceFilesystemError)(error) };
-  } finally {
-    process.env = previousEnvironment;
-  }
-}
-port.on("message", (message) => {
-  if (!message || typeof message !== "object") return;
-  const request = message;
-  if (request.type !== "run" || typeof request.id !== "number") return;
-  port.postMessage(runRequest(request));
-});

package/dist/cjs/workspace-filesystem-executor.cjs

@@ -1,327 +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_filesystem_executor_exports = {};
-__export(workspace_filesystem_executor_exports, {
-  WORKSPACE_FILESYSTEM_EXECUTOR_MAX_QUEUED: () => WORKSPACE_FILESYSTEM_EXECUTOR_MAX_QUEUED,
-  WORKSPACE_FILESYSTEM_EXECUTOR_QUEUE_TIMEOUT_MS: () => WORKSPACE_FILESYSTEM_EXECUTOR_QUEUE_TIMEOUT_MS,
-  WORKSPACE_FILESYSTEM_EXECUTOR_STALL_LOG_INTERVAL_MS: () => WORKSPACE_FILESYSTEM_EXECUTOR_STALL_LOG_INTERVAL_MS,
-  WorkspaceFilesystemExecutor: () => WorkspaceFilesystemExecutor,
-  WorkspaceFilesystemExecutorError: () => WorkspaceFilesystemExecutorError,
-  WorkspaceFilesystemExecutorThreadExitedError: () => WorkspaceFilesystemExecutorThreadExitedError,
-  installWorkspaceFilesystemExecutorFailureHandler: () => installWorkspaceFilesystemExecutorFailureHandler,
-  workspaceFilesystemExecutor: () => workspaceFilesystemExecutor,
-  workspaceFilesystemExecutorTestHarness: () => workspaceFilesystemExecutorTestHarness,
-  workspaceFilesystemExecutorThreadModulePath: () => workspaceFilesystemExecutorThreadModulePath
-});
-module.exports = __toCommonJS(workspace_filesystem_executor_exports);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_node_worker_threads = require("node:worker_threads");
-var import_git_process_environment = require("./git-process-environment.cjs");
-var import_workspace_filesystem_job_types = require("./workspace-filesystem-job-types.cjs");
-const WORKSPACE_FILESYSTEM_EXECUTOR_MAX_QUEUED = 32;
-const WORKSPACE_FILESYSTEM_EXECUTOR_QUEUE_TIMEOUT_MS = 5 * 6e4;
-const WORKSPACE_FILESYSTEM_EXECUTOR_STALL_LOG_INTERVAL_MS = 3e4;
-class WorkspaceFilesystemExecutorError extends Error {
-  name = "WorkspaceFilesystemExecutorError";
-}
-class WorkspaceFilesystemExecutorThreadExitedError extends WorkspaceFilesystemExecutorError {
-  constructor(exitCode, description, cause) {
-    super(
-      `Workspace filesystem executor thread exited${exitCode === null ? "" : ` with code ${exitCode}`} while running ${description}; the filesystem state is whatever a process crash would have left`,
-      cause === void 0 ? void 0 : { cause }
-    );
-    this.exitCode = exitCode;
-    this.description = description;
-  }
-  exitCode;
-  description;
-}
-class WorkspaceFilesystemExecutor {
-  threadModulePath;
-  log;
-  now;
-  maxQueued;
-  queueTimeoutMs;
-  stallLogIntervalMs;
-  worker = null;
-  queue = [];
-  running = null;
-  nextJobId = 1;
-  failed = null;
-  closed = false;
-  /** Invoked once when the executor fails closed (thread exit under a running job). */
-  onFailure;
-  constructor(options) {
-    this.threadModulePath = options.threadModulePath;
-    this.log = options.log ?? ((line) => process.stderr.write(`${line}
-`));
-    this.now = options.now ?? (() => Date.now());
-    this.maxQueued = options.maxQueued ?? WORKSPACE_FILESYSTEM_EXECUTOR_MAX_QUEUED;
-    this.queueTimeoutMs = options.queueTimeoutMs ?? WORKSPACE_FILESYSTEM_EXECUTOR_QUEUE_TIMEOUT_MS;
-    this.stallLogIntervalMs = options.stallLogIntervalMs ?? WORKSPACE_FILESYSTEM_EXECUTOR_STALL_LOG_INTERVAL_MS;
-  }
-  /**
-   * Run one job to completion on the executor thread. Resolves with the
-   * job's result; rejects with the job's own error (properties preserved),
-   * with a queue-wait or capacity error when the job never started, or with
-   * WorkspaceFilesystemExecutorThreadExitedError when the thread died under it.
-   */
-  run(kind, input, options = {}) {
-    const description = (0, import_workspace_filesystem_job_types.describeWorkspaceFilesystemJob)(kind, input);
-    if (this.closed)
-      return Promise.reject(new WorkspaceFilesystemExecutorError(`Workspace filesystem executor is closed; refusing ${description}`));
-    if (this.failed) return Promise.reject(new WorkspaceFilesystemExecutorError(`${this.failed}; refusing ${description}`));
-    if (this.queue.length >= this.maxQueued) {
-      return Promise.reject(
-        new WorkspaceFilesystemExecutorError(
-          `Workspace filesystem executor queue is full (${this.queue.length} waiting behind ${this.describeRunning()}); refusing ${description}`
-        )
-      );
-    }
-    return new Promise((resolve, reject) => {
-      const job = {
-        id: this.nextJobId++,
-        kind,
-        input,
-        description,
-        onProgress: options.onProgress,
-        resolve: (result) => resolve(result),
-        reject,
-        queuedAtMs: this.now(),
-        queueTimer: void 0
-      };
-      this.queue.push(job);
-      if (this.running) {
-        job.queueTimer = setTimeout(() => this.expireQueued(job), this.queueTimeoutMs);
-      }
-      this.dispatch();
-    });
-  }
-  status() {
-    const running = this.running;
-    return {
-      running: running ? {
-        kind: running.kind,
-        description: running.description,
-        startedAtMs: running.startedAtMs,
-        ageMs: this.now() - running.startedAtMs
-      } : null,
-      queued: this.queue.length,
-      failed: this.failed
-    };
-  }
-  /**
-   * Stop accepting jobs, fail everything still queued and ask the thread to
-   * stop. A running job settles when the thread actually exits; a thread
-   * blocked in the kernel only exits with the process, which is the point.
-   */
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    for (const job of this.queue.splice(0)) {
-      if (job.queueTimer) clearTimeout(job.queueTimer);
-      job.reject(new WorkspaceFilesystemExecutorError(`Workspace filesystem executor is closed; ${job.description} did not start`));
-    }
-    const worker = this.worker;
-    if (worker && !this.running) {
-      this.worker = null;
-      void worker.terminate();
-    } else if (worker) {
-      void worker.terminate();
-    }
-  }
-  describeRunning() {
-    const running = this.running;
-    if (!running) return "an idle executor";
-    return `${running.description} (running for ${Math.round((this.now() - running.startedAtMs) / 1e3)}s)`;
-  }
-  expireQueued(job) {
-    const index = this.queue.indexOf(job);
-    if (index < 0) return;
-    this.queue.splice(index, 1);
-    job.queueTimer = void 0;
-    job.reject(
-      new WorkspaceFilesystemExecutorError(
-        `Workspace filesystem executor is blocked: ${this.describeRunning()} while ${job.description} waited ${Math.round((this.now() - job.queuedAtMs) / 1e3)}s for its turn; filesystem I/O may be stalled`
-      )
-    );
-  }
-  dispatch() {
-    if (this.running || this.closed || this.failed) return;
-    const job = this.queue.shift();
-    if (!job) {
-      this.worker?.unref();
-      return;
-    }
-    if (job.queueTimer) {
-      clearTimeout(job.queueTimer);
-      job.queueTimer = void 0;
-    }
-    let worker;
-    try {
-      worker = this.ensureWorker();
-    } catch (error) {
-      job.reject(error instanceof Error ? error : new Error(String(error)));
-      this.dispatch();
-      return;
-    }
-    const environment = {};
-    for (const [key, value] of Object.entries((0, import_git_process_environment.workerGitProcessEnvironment)(process.env))) if (value !== void 0) environment[key] = value;
-    const request = { type: "run", id: job.id, kind: job.kind, input: job.input, environment };
-    const startedAtMs = this.now();
-    const running = {
-      ...job,
-      startedAtMs,
-      stallTimer: setInterval(() => {
-        this.log(
-          `[r5d-worker] workspace filesystem job ${running.kind} (${running.description}) has run for ${Math.round((this.now() - startedAtMs) / 1e3)}s; filesystem I/O may be stalled (${this.queue.length} job(s) queued behind it)`
-        );
-      }, this.stallLogIntervalMs)
-    };
-    running.stallTimer.unref();
-    this.running = running;
-    worker.ref();
-    try {
-      worker.postMessage(request);
-    } catch (error) {
-      this.settleRunning(running, () => running.reject(error instanceof Error ? error : new Error(String(error))));
-    }
-  }
-  settleRunning(job, settle) {
-    if (this.running !== job) return;
-    clearInterval(job.stallTimer);
-    this.running = null;
-    settle();
-    this.dispatch();
-  }
-  ensureWorker() {
-    if (this.worker) return this.worker;
-    const worker = new import_node_worker_threads.Worker(this.threadModulePath);
-    this.worker = worker;
-    worker.on("message", (message) => this.onReply(worker, message));
-    worker.on("error", (error) => {
-      this.log(`[r5d-worker] workspace filesystem executor thread error: ${error.stack ?? error.message}`);
-      this.lastThreadError = error;
-    });
-    worker.on("exit", (code) => this.onExit(worker, code));
-    worker.unref();
-    return worker;
-  }
-  lastThreadError;
-  onReply(worker, message) {
-    if (this.worker !== worker) return;
-    const running = this.running;
-    if (!running || !message || typeof message !== "object" || message.id !== running.id) return;
-    if (message.type === "progress") {
-      running.onProgress?.(message.progress);
-      return;
-    }
-    if (message.type === "result") {
-      this.settleRunning(running, () => running.resolve(message.result));
-      return;
-    }
-    if (message.type === "failure") {
-      this.settleRunning(running, () => running.reject((0, import_workspace_filesystem_job_types.restoreWorkspaceFilesystemError)(message.error)));
-    }
-  }
-  onExit(worker, code) {
-    if (this.worker !== worker) return;
-    this.worker = null;
-    const cause = this.lastThreadError;
-    this.lastThreadError = void 0;
-    const running = this.running;
-    if (!running) {
-      if (!this.closed) this.dispatch();
-      return;
-    }
-    const failure = new WorkspaceFilesystemExecutorThreadExitedError(code, running.description, cause);
-    if (!this.closed) {
-      this.failed = `Workspace filesystem executor thread exited with code ${code} while running ${running.description}; the worker must restart and recover before it mutates the workspace again`;
-      this.log(`[r5d-worker] ${this.failed}`);
-    }
-    this.settleRunning(running, () => running.reject(failure));
-    for (const job of this.queue.splice(0)) {
-      if (job.queueTimer) clearTimeout(job.queueTimer);
-      job.reject(
-        new WorkspaceFilesystemExecutorError(
-          `${this.failed ?? "Workspace filesystem executor is closed"}; ${job.description} did not start`
-        )
-      );
-    }
-    if (!this.closed) this.onFailure?.(failure);
-  }
-}
-function workspaceFilesystemExecutorThreadModulePath() {
-  return import_node_path.default.join(import_node_path.default.dirname(__filename), `workspace-filesystem-executor-thread${import_node_path.default.extname(__filename)}`);
-}
-let processExecutor = null;
-let inlineRunner = null;
-function workspaceFilesystemExecutor() {
-  if (inlineRunner) return inlineRunner;
-  processExecutor ??= new WorkspaceFilesystemExecutor({ threadModulePath: workspaceFilesystemExecutorThreadModulePath() });
-  return processExecutor;
-}
-function installWorkspaceFilesystemExecutorFailureHandler(handler) {
-  processExecutor ??= new WorkspaceFilesystemExecutor({ threadModulePath: workspaceFilesystemExecutorThreadModulePath() });
-  processExecutor.onFailure = handler;
-}
-const workspaceFilesystemExecutorTestHarness = {
-  async runJobsInline(body) {
-    const { workspaceFilesystemJobOperations } = await import("./workspace-filesystem-jobs.cjs");
-    const previous = inlineRunner;
-    inlineRunner = {
-      async run(kind, input, options = {}) {
-        await Promise.resolve();
-        const operation = workspaceFilesystemJobOperations[kind];
-        return operation(input, { progress: (progress) => options.onProgress?.(progress) });
-      }
-    };
-    try {
-      return await body();
-    } finally {
-      inlineRunner = previous;
-    }
-  },
-  processExecutor() {
-    return processExecutor;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WORKSPACE_FILESYSTEM_EXECUTOR_MAX_QUEUED,
-  WORKSPACE_FILESYSTEM_EXECUTOR_QUEUE_TIMEOUT_MS,
-  WORKSPACE_FILESYSTEM_EXECUTOR_STALL_LOG_INTERVAL_MS,
-  WorkspaceFilesystemExecutor,
-  WorkspaceFilesystemExecutorError,
-  WorkspaceFilesystemExecutorThreadExitedError,
-  installWorkspaceFilesystemExecutorFailureHandler,
-  workspaceFilesystemExecutor,
-  workspaceFilesystemExecutorTestHarness,
-  workspaceFilesystemExecutorThreadModulePath
-});