@ricsam/r5d-worker 0.0.137 → 0.0.139

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

@@ -1,48 +0,0 @@
-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;
-}
-export {
-  PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS,
-  hasActiveVisibleProjectsWorkspaceTarget,
-  pendingCreatedBranchAutomaticSyncDeferral,
-  pendingCreatedBranchKey,
-  projectBranchHasActiveWorkspaceTarget,
-  projectBranchMountBusyDuringExclusiveSync,
-  shouldDeferAutomaticWorkspaceSyncForPendingBranch,
-  workspacePlansMountBusyDuringExclusiveSync
-};

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

@@ -1,13 +0,0 @@
-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");
-    }
-  }
-}
-export {
-  assertProjectBranchDeletionIncarnation
-};

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

@@ -1,84 +0,0 @@
-import { WorkspaceMountHoldAbortedError } from "./workspace-mount-hold-fence.mjs";
-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 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 WorkspaceMountHoldAbortedError(abortReason(signal)));
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(new 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);
-}
-export {
-  acquireWorkspaceCommandMutation,
-  reserveWorkspaceCommandAfterCurrentSync,
-  runReservedWorkspaceCommand,
-  runWorkspaceCommand,
-  shouldSerializeWorkspaceCommand
-};

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

@@ -1,37 +0,0 @@
-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(", ")})`;
-}
-export {
-  commandTargets,
-  describeCommandAdditionalTargets,
-  normalizeCommandAdditionalTargets
-};

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

@@ -1,38 +0,0 @@
-import { isMainThread, parentPort } from "node:worker_threads";
-import {
-  isWorkspaceFilesystemJobKind,
-  serializeWorkspaceFilesystemError
-} from "./workspace-filesystem-job-types.mjs";
-import { workspaceFilesystemJobOperations } from "./workspace-filesystem-jobs.mjs";
-if (isMainThread || !parentPort) {
-  throw new Error("The workspace filesystem executor thread must be started by the worker runtime");
-}
-const port = parentPort;
-function runRequest(request) {
-  if (!isWorkspaceFilesystemJobKind(request.kind)) {
-    return {
-      type: "failure",
-      id: request.id,
-      error: serializeWorkspaceFilesystemError(new Error(`Unknown workspace filesystem job kind: ${String(request.kind)}`))
-    };
-  }
-  const operation = 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: 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/mjs/workspace-filesystem-executor.mjs

@@ -1,287 +0,0 @@
-import path from "node:path";
-import { Worker } from "node:worker_threads";
-import { workerGitProcessEnvironment } from "./git-process-environment.mjs";
-import {
-  describeWorkspaceFilesystemJob,
-  restoreWorkspaceFilesystemError
-} from "./workspace-filesystem-job-types.mjs";
-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 = 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(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 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(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 path.join(path.dirname(__filename), `workspace-filesystem-executor-thread${path.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.mjs");
-    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;
-  }
-};
-export {
-  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
-};

package/dist/mjs/workspace-filesystem-job-types.mjs

@@ -1,116 +0,0 @@
-const WORKSPACE_FILESYSTEM_JOB_KINDS = [
-  "checkout_durability_recovery",
-  "hydration_recovery",
-  "hydration_recovery_inspect",
-  "hydration_preserve_interrupted",
-  "hydration_transaction",
-  "hydration_raw",
-  "checkout_transition_begin",
-  "checkout_transition_complete",
-  "outer_checkout_fsync",
-  "projection_merge",
-  "projection_mirror",
-  "projection_outer_apply",
-  "projection_receipt",
-  "project_snapshot_create",
-  "project_snapshot_apply",
-  "project_snapshot_persist",
-  "project_snapshot_rollback",
-  "project_snapshots_recover",
-  "project_branch_create",
-  "project_checkout_path_move"
-];
-function isWorkspaceFilesystemJobKind(value) {
-  return typeof value === "string" && WORKSPACE_FILESYSTEM_JOB_KINDS.includes(value);
-}
-function summarizeIds(ids) {
-  if (ids.length === 0) return "no mounts";
-  const shown = ids.slice(0, 3).join(", ");
-  return ids.length > 3 ? `${ids.length} mounts (${shown}, \u2026)` : `${ids.length === 1 ? "mount" : "mounts"} ${shown}`;
-}
-function describeWorkspaceFilesystemJob(kind, input) {
-  switch (kind) {
-    case "checkout_durability_recovery":
-    case "hydration_recovery":
-    case "hydration_recovery_inspect":
-    case "checkout_transition_begin":
-    case "checkout_transition_complete":
-    case "outer_checkout_fsync":
-      return `${kind.replaceAll("_", " ")} of ${input.workspacePath}`;
-    case "hydration_preserve_interrupted": {
-      const recovery = input;
-      return `preservation of hydration transaction ${recovery.expectedTransactionId} in ${recovery.workspacePath}`;
-    }
-    case "hydration_transaction": {
-      const hydration = input;
-      const merged = Object.keys(hydration.mergeBases ?? {}).length;
-      return `hydration of ${summarizeIds(hydration.hydrationMounts.map(({ id }) => id))}${merged > 0 ? ` (${merged} merge-hydrated)` : ""} (durability ${summarizeIds(hydration.advancedDurabilityMounts.map(({ id }) => id))})`;
-    }
-    case "hydration_raw":
-      return `pre-clone hydration of ${summarizeIds(input.mounts.map(({ id }) => id))}`;
-    case "projection_merge":
-      return `merge projection of mount ${input.mount.id}`;
-    case "projection_mirror":
-      return `projection of mount ${input.mount.id}`;
-    case "projection_outer_apply": {
-      const apply = input;
-      return `outer-tree apply (${apply.removeMounts.length} removal(s), ${apply.materialize.length} merged subtree(s), ${apply.restoreFromHead.length} deferred restore(s))`;
-    }
-    case "projection_receipt":
-      return `projection receipt for ${summarizeIds(input.fsyncMounts.map(({ id }) => id))}`;
-    case "project_snapshot_create":
-      return `checkout snapshot of ${input.projectRoot}`;
-    case "project_snapshot_apply":
-      return `checkout snapshot restore into ${input.mirrors.map(({ targetPath }) => targetPath).join(", ") || "no checkouts"}`;
-    case "project_snapshot_persist":
-      return `checkout durability of ${input.snapshot.manifest.projectRoot}`;
-    case "project_snapshot_rollback":
-      return `checkout snapshot rollback of ${input.snapshot.manifest.projectRoot}`;
-    case "project_snapshots_recover":
-      return `interrupted checkout snapshot recovery under ${input.temporaryRoot}`;
-    case "project_branch_create": {
-      const create = input;
-      return `branch creation ${create.branchName} from ${create.sourceBranchName} in ${create.projectRoot}`;
-    }
-    case "project_checkout_path_move": {
-      const move = input;
-      return `checkout path move ${move.oldProjectRoot} \u2192 ${move.newProjectRoot}`;
-    }
-  }
-}
-function serializeWorkspaceFilesystemError(error, depth = 0) {
-  if (!(error instanceof Error)) return { name: "Error", message: String(error) };
-  const record = error;
-  const serialized = { name: error.name, message: error.message };
-  if (typeof error.stack === "string") serialized.stack = error.stack;
-  if (typeof record.code === "string") serialized.code = record.code;
-  if (record.branchMayExist === true) serialized.branchMayExist = true;
-  if (record.hydrationRecovery) serialized.hydrationRecovery = structuredClone(record.hydrationRecovery);
-  if (Array.isArray(record.cleanupFailures) && record.cleanupFailures.every((failure) => typeof failure === "string")) {
-    serialized.cleanupFailures = [...record.cleanupFailures];
-  }
-  if (depth < 4) {
-    if (Array.isArray(record.errors)) serialized.errors = record.errors.map((inner) => serializeWorkspaceFilesystemError(inner, depth + 1));
-    if (record.cause !== void 0) serialized.cause = serializeWorkspaceFilesystemError(record.cause, depth + 1);
-  }
-  return serialized;
-}
-function restoreWorkspaceFilesystemError(serialized) {
-  const cause = serialized.cause ? restoreWorkspaceFilesystemError(serialized.cause) : void 0;
-  const options = cause ? { cause } : void 0;
-  const error = serialized.errors ? new AggregateError(serialized.errors.map(restoreWorkspaceFilesystemError), serialized.message, options) : new Error(serialized.message, options);
-  error.name = serialized.name;
-  if (serialized.stack) error.stack = serialized.stack;
-  if (serialized.code !== void 0) error.code = serialized.code;
-  if (serialized.branchMayExist) error.branchMayExist = true;
-  if (serialized.cleanupFailures) error.cleanupFailures = [...serialized.cleanupFailures];
-  if (serialized.hydrationRecovery) error.hydrationRecovery = structuredClone(serialized.hydrationRecovery);
-  return error;
-}
-export {
-  WORKSPACE_FILESYSTEM_JOB_KINDS,
-  describeWorkspaceFilesystemJob,
-  isWorkspaceFilesystemJobKind,
-  restoreWorkspaceFilesystemError,
-  serializeWorkspaceFilesystemError
-};

package/dist/mjs/workspace-filesystem-jobs.mjs

@@ -1,55 +0,0 @@
-import {
-  createLinkedProjectBranch,
-  recoverStaleProjectWorktreeSnapshots,
-  runProjectSnapshotApplyJob,
-  runProjectSnapshotCreateJob,
-  runProjectSnapshotPersistJob,
-  runProjectSnapshotRollbackJob
-} from "./project-worktrees.mjs";
-import {
-  runCheckoutDurabilityRecoveryJob,
-  runCheckoutTransitionBeginJob,
-  runCheckoutTransitionCompleteJob,
-  runHydrationRawJob,
-  runHydrationRecoveryJob,
-  runHydrationRecoveryInspectJob,
-  runHydrationPreserveInterruptedJob,
-  runHydrationTransactionJob,
-  runOuterCheckoutFsyncJob,
-  runProjectionMirrorJob,
-  runProjectionOuterApplyJob,
-  runProjectionReceiptJob
-} from "./workspace-git-sync.mjs";
-import { mergeWorkspaceProjectionMount } from "./workspace-merge-projection.mjs";
-import { preserveProjectCheckoutPathMove } from "./workspace-path-move.mjs";
-const workspaceFilesystemJobOperations = {
-  checkout_durability_recovery: (input) => runCheckoutDurabilityRecoveryJob(input),
-  hydration_recovery: (input) => runHydrationRecoveryJob(input),
-  hydration_recovery_inspect: (input) => runHydrationRecoveryInspectJob(input),
-  hydration_preserve_interrupted: (input) => runHydrationPreserveInterruptedJob(input),
-  hydration_transaction: (input) => runHydrationTransactionJob(input),
-  hydration_raw: (input) => runHydrationRawJob(input),
-  checkout_transition_begin: (input) => runCheckoutTransitionBeginJob(input),
-  checkout_transition_complete: (input) => runCheckoutTransitionCompleteJob(input),
-  outer_checkout_fsync: (input) => runOuterCheckoutFsyncJob(input),
-  projection_merge: (input) => mergeWorkspaceProjectionMount(input),
-  projection_mirror: (input) => runProjectionMirrorJob(input),
-  projection_outer_apply: (input) => runProjectionOuterApplyJob(input),
-  projection_receipt: (input) => runProjectionReceiptJob(input),
-  project_snapshot_create: (input, context) => runProjectSnapshotCreateJob(input, context),
-  project_snapshot_apply: (input) => runProjectSnapshotApplyJob(input),
-  project_snapshot_persist: (input) => runProjectSnapshotPersistJob(input),
-  project_snapshot_rollback: (input) => runProjectSnapshotRollbackJob(input),
-  project_snapshots_recover: (input, context) => recoverStaleProjectWorktreeSnapshots({
-    projectsRoot: input.projectsRoot,
-    temporaryRoot: input.temporaryRoot,
-    currentProcessId: input.currentProcessId,
-    currentOwnerSessionId: input.currentOwnerSessionId,
-    onProgress: context.progress
-  }),
-  project_branch_create: (input) => createLinkedProjectBranch(input),
-  project_checkout_path_move: (input) => preserveProjectCheckoutPathMove(input)
-};
-export {
-  workspaceFilesystemJobOperations
-};