@ricsam/r5d-worker 0.0.122 → 0.0.124

package/dist/mjs/recovery-store.mjs

@@ -39,6 +39,14 @@ class WorkerRecoveryStore {
   close() {
     this.db.close();
   }
+  /**
+   * Run several store operations as one durable commit (one FULL fsync).
+   * Operations that open their own transaction nest as savepoints. A throw
+   * rolls the whole group back; callers treat that as a journal failure.
+   */
+  batch(operations) {
+    return this.db.transaction(operations)();
+  }
   row(requestId) {
     return this.db.query("SELECT * FROM operations WHERE request_id=? OR request_id=(SELECT operation_id FROM aliases WHERE request_id=?)").get(requestId, requestId);
   }

package/dist/mjs/session-file-mutations.mjs

@@ -0,0 +1,37 @@
+class SessionFileMutationTracker {
+  inFlight = /* @__PURE__ */ new Map();
+  /** Register a started mutation; it is forgotten when it settles, however it settles. */
+  track(sessionId, mutation) {
+    let mutations = this.inFlight.get(sessionId);
+    if (!mutations) {
+      mutations = /* @__PURE__ */ new Set();
+      this.inFlight.set(sessionId, mutations);
+    }
+    mutations.add(mutation);
+    const forget = () => {
+      const current = this.inFlight.get(sessionId);
+      if (!current) return;
+      current.delete(mutation);
+      if (current.size === 0) this.inFlight.delete(sessionId);
+    };
+    mutation.then(forget, forget);
+    return mutation;
+  }
+  count(sessionId) {
+    return this.inFlight.get(sessionId)?.size ?? 0;
+  }
+  /**
+   * Resolves once every mutation tracked for the session at the time of the
+   * call has settled. Mutations started later are not joined: the session's
+   * cancellation marker, recorded before this is awaited, makes their
+   * admission recheck refuse them.
+   */
+  settled(sessionId) {
+    const pending = [...this.inFlight.get(sessionId) ?? []];
+    if (pending.length === 0) return Promise.resolve();
+    return Promise.allSettled(pending).then(() => void 0);
+  }
+}
+export {
+  SessionFileMutationTracker
+};

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

@@ -376,6 +376,7 @@ function filesEqual(leftPath, rightPath, entry) {
       const length = Math.min(leftBuffer.length, entry.size - offset);
       const leftRead = fs.readSync(left, leftBuffer, 0, length, offset);
       const rightRead = fs.readSync(right, rightBuffer, 0, length, offset);
+      if (leftRead <= 0 || rightRead <= 0) return false;
       if (leftRead !== rightRead || !leftBuffer.subarray(0, leftRead).equals(rightBuffer.subarray(0, rightRead))) return false;
       offset += leftRead;
     }

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

@@ -1,19 +1,48 @@
+import { WorkspaceMountHoldAbortedError } from "./workspace-mount-hold-fence.mjs";
 function requiresCurrentSyncBarrier(target) {
   return target.type === "workspace" && target.rootProfile === "visible_projects";
 }
-async function reserveWorkspaceCommandAfterCurrentSync(target, coordinator, reserve) {
-  if (!requiresCurrentSyncBarrier(target)) {
-    reserve();
-    return;
-  }
+async function reserveWorkspaceCommandAfterCurrentSync(target, coordinator, reserve, options = {}) {
   while (true) {
-    const currentSync = coordinator.afterCurrent();
-    await currentSync;
-    if (currentSync !== coordinator.afterCurrent()) continue;
+    if (requiresCurrentSyncBarrier(target)) {
+      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(target, 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";
 }

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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,287 @@
+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

@@ -0,0 +1,106 @@
+const WORKSPACE_FILESYSTEM_JOB_KINDS = [
+  "checkout_durability_recovery",
+  "hydration_recovery",
+  "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 "checkout_transition_begin":
+    case "checkout_transition_complete":
+    case "outer_checkout_fsync":
+      return `${kind.replaceAll("_", " ")} of ${input.workspacePath}`;
+    case "hydration_transaction": {
+      const hydration = input;
+      return `hydration of ${summarizeIds(hydration.hydrationMounts.map(({ id }) => id))} (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 (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];
+  return error;
+}
+export {
+  WORKSPACE_FILESYSTEM_JOB_KINDS,
+  describeWorkspaceFilesystemJob,
+  isWorkspaceFilesystemJobKind,
+  restoreWorkspaceFilesystemError,
+  serializeWorkspaceFilesystemError
+};

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

@@ -0,0 +1,51 @@
+import {
+  createLinkedProjectBranch,
+  recoverStaleProjectWorktreeSnapshots,
+  runProjectSnapshotApplyJob,
+  runProjectSnapshotCreateJob,
+  runProjectSnapshotPersistJob,
+  runProjectSnapshotRollbackJob
+} from "./project-worktrees.mjs";
+import {
+  runCheckoutDurabilityRecoveryJob,
+  runCheckoutTransitionBeginJob,
+  runCheckoutTransitionCompleteJob,
+  runHydrationRawJob,
+  runHydrationRecoveryJob,
+  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_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
+};