@cascade-flow/backend-filesystem 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,10 +1,120 @@
 // src/index.ts
-import { mkdir, writeFile, readFile, readdir, access, unlink, open as openFile } from "node:fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile, readdir, access, unlink as unlink2, open as openFile2 } from "node:fs/promises";
+import { join as join2, dirname as dirname3 } from "node:path";
+
+// src/lib/paths.ts
 import { join, dirname } from "node:path";
+
+class PathHelper {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  getRunDir(workflowSlug, runId) {
+    return join(this.baseDir, workflowSlug, runId);
+  }
+  getWorkflowEventsDir(workflowSlug, runId) {
+    return join(this.getRunDir(workflowSlug, runId), "workflow-events");
+  }
+  getStepEventsDir(workflowSlug, runId) {
+    return join(this.getRunDir(workflowSlug, runId), "step-events");
+  }
+  getStepOutputsDir(workflowSlug, runId) {
+    return join(this.getRunDir(workflowSlug, runId), "step-outputs");
+  }
+  getStepEventDir(workflowSlug, runId, stepId) {
+    const eventsDir = this.getStepEventsDir(workflowSlug, runId);
+    const stepDirPath = dirname(stepId);
+    return stepDirPath === "." ? eventsDir : join(eventsDir, stepDirPath);
+  }
+  getStepOutputDir(workflowSlug, runId, stepId) {
+    const outputsDir = this.getStepOutputsDir(workflowSlug, runId);
+    const stepDirPath = dirname(stepId);
+    return stepDirPath === "." ? outputsDir : join(outputsDir, stepDirPath);
+  }
+  getStepOutputPath(workflowSlug, runId, stepId, attemptNumber) {
+    const outputDir = this.getStepOutputDir(workflowSlug, runId, stepId);
+    const stepName = stepId.split("/").pop();
+    return join(outputDir, `${stepName}-attempt-${attemptNumber}.json`);
+  }
+  getStepLockDir(workflowSlug, runId, stepId) {
+    const locksDir = join(this.getRunDir(workflowSlug, runId), "locks");
+    const stepDirPath = dirname(stepId);
+    return stepDirPath === "." ? locksDir : join(locksDir, stepDirPath);
+  }
+  getStepClaimLockPath(workflowSlug, runId, stepId, attemptNumber) {
+    const lockDir = this.getStepLockDir(workflowSlug, runId, stepId);
+    const stepName = stepId.split("/").pop();
+    return join(lockDir, `${stepName}-attempt-${attemptNumber}.lock`);
+  }
+  getIdempotencyDir() {
+    return join(this.baseDir, ".idempotency");
+  }
+  getRegistryDir() {
+    return join(this.baseDir, ".registry");
+  }
+  getWorkflowRegistryDir(slug) {
+    return join(this.getRegistryDir(), slug);
+  }
+}
+
+// src/lib/ids.ts
 import { createHash } from "node:crypto";
+import { getMicrosecondTimestamp } from "@cascade-flow/backend-interface";
+function generateRunId() {
+  return `run_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+}
+function hashIdempotencyKey(key) {
+  return createHash("sha256").update(key).digest("hex");
+}
+function generateEventId(timestamp) {
+  const ts = timestamp ?? getMicrosecondTimestamp();
+  return `${ts}`;
+}
+
+// src/lib/file-utils.ts
+import { mkdir, writeFile, open as openFile, rename, unlink } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+async function writeJsonAtomic(filePath, data) {
+  const dir = dirname2(filePath);
+  await mkdir(dir, { recursive: true });
+  const jsonString = JSON.stringify(data, null, 2);
+  const randomSuffix = createHash2("sha256").update(`${filePath}-${Date.now()}-${Math.random()}`).digest("hex").substring(0, 16);
+  const tempPath = `${filePath}.tmp.${randomSuffix}`;
+  let tempHandle;
+  try {
+    await writeFile(tempPath, jsonString, "utf-8");
+    tempHandle = await openFile(tempPath, "r+");
+    await tempHandle.datasync();
+    await tempHandle.close();
+    tempHandle = undefined;
+    await rename(tempPath, filePath);
+    const dirHandle = await openFile(dir, "r");
+    await dirHandle.datasync();
+    await dirHandle.close();
+  } catch (error) {
+    if (tempHandle) {
+      await tempHandle.close().catch(() => {});
+    }
+    try {
+      await unlink(tempPath);
+    } catch {}
+    throw error;
+  }
+}
+function getWorkflowEventFilename(event) {
+  return `${event.eventId}-${event.type}.json`;
+}
+function getStepEventFilename(event) {
+  const stepName = event.stepId.split("/").pop();
+  return `${event.eventId}-${stepName}-${event.type}.json`;
+}
+
+// src/index.ts
 import {
   Backend,
-  StepRecordSchema,
+  WorkflowVersionSchema,
   eventSchema,
   safeSerialize,
   projectStepRecord,
@@ -12,7 +122,7 @@ import {
   projectRunStateFromEvents,
   extractLogsFromEvents,
   getCurrentAttemptNumber,
-  getMicrosecondTimestamp,
+  getMicrosecondTimestamp as getMicrosecondTimestamp2,
   computeErrorAnalysis,
   computeRetryAnalysis,
   computeSchedulingLatency,
@@ -27,106 +137,42 @@ import { projectStepState as projectStepState2, projectRunStateFromEvents as pro
 
 class FileSystemBackend extends Backend {
   baseDir;
+  paths;
   constructor(baseDir = "./.runs") {
     super();
     this.baseDir = baseDir;
+    this.paths = new PathHelper(baseDir);
   }
   async initialize() {}
-  getRunDir(workflowSlug, runId) {
-    return join(this.baseDir, workflowSlug, runId);
-  }
-  getWorkflowEventsDir(workflowSlug, runId) {
-    return join(this.getRunDir(workflowSlug, runId), "workflow-events");
-  }
-  getStepEventsDir(workflowSlug, runId) {
-    return join(this.getRunDir(workflowSlug, runId), "step-events");
-  }
-  getStepOutputsDir(workflowSlug, runId) {
-    return join(this.getRunDir(workflowSlug, runId), "step-outputs");
-  }
   getStepOutputPath(workflowSlug, runId, stepId, attemptNumber) {
-    return join(this.getStepOutputsDir(workflowSlug, runId), `${stepId}-attempt-${attemptNumber}.json`);
-  }
-  getStepsDir(workflowSlug, runId) {
-    return join(this.getRunDir(workflowSlug, runId), "steps");
-  }
-  getStepFile(workflowSlug, runId, stepName) {
-    return join(this.getStepsDir(workflowSlug, runId), `${stepName}.json`);
-  }
-  getStepLogsFile(workflowSlug, runId, stepName) {
-    return join(this.getStepsDir(workflowSlug, runId), `${stepName}.logs.json`);
-  }
-  getIdempotencyDir() {
-    return join(this.baseDir, ".idempotency");
-  }
-  generateRunId() {
-    return `run_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
-  }
-  hashIdempotencyKey(key) {
-    return createHash("sha256").update(key).digest("hex");
-  }
-  generateEventId(timestamp) {
-    const ts = timestamp ?? getMicrosecondTimestamp();
-    return `${ts}`;
-  }
-  getWorkflowEventFilename(event) {
-    return `${event.eventId}-${event.type}.json`;
-  }
-  getStepEventFilename(event) {
-    return `${event.eventId}-${event.stepId}-${event.type}.json`;
-  }
-  getStepClaimLockPath(workflowSlug, runId, stepId, attemptNumber) {
-    return join(this.getRunDir(workflowSlug, runId), "locks", `${stepId}-attempt-${attemptNumber}.lock`);
-  }
-  async writeJsonAtomic(filePath, data) {
-    const dir = dirname(filePath);
-    await mkdir(dir, { recursive: true });
-    const jsonString = JSON.stringify(data, null, 2);
-    await writeFile(filePath, jsonString, "utf-8");
-  }
-  async readStepRecord(workflowSlug, runId, stepName) {
-    try {
-      const filePath = this.getStepFile(workflowSlug, runId, stepName);
-      const content = await readFile(filePath, "utf-8");
-      const parsed = JSON.parse(content);
-      return StepRecordSchema.parse(parsed);
-    } catch {
-      return null;
-    }
-  }
-  createStateChange(status, message) {
-    return {
-      status,
-      timestamp: getMicrosecondTimestamp(),
-      message
-    };
+    return this.paths.getStepOutputPath(workflowSlug, runId, stepId, attemptNumber);
   }
   async initializeRun(workflowSlug, runId) {
-    const workflowEventsDir = this.getWorkflowEventsDir(workflowSlug, runId);
-    const stepEventsDir = this.getStepEventsDir(workflowSlug, runId);
-    await mkdir(workflowEventsDir, { recursive: true });
-    await mkdir(stepEventsDir, { recursive: true });
+    const workflowEventsDir = this.paths.getWorkflowEventsDir(workflowSlug, runId);
+    const stepEventsDir = this.paths.getStepEventsDir(workflowSlug, runId);
+    await mkdir2(workflowEventsDir, { recursive: true });
+    await mkdir2(stepEventsDir, { recursive: true });
   }
   async appendEvent(workflowSlug, runId, event) {
     if (!event.eventId) {
-      event.eventId = this.generateEventId();
+      event.eventId = generateEventId();
     }
     if (!event.timestampUs) {
-      event.timestampUs = getMicrosecondTimestamp();
+      event.timestampUs = getMicrosecondTimestamp2();
     }
     eventSchema.parse(event);
-    const eventsDir = event.category === "workflow" ? this.getWorkflowEventsDir(workflowSlug, runId) : this.getStepEventsDir(workflowSlug, runId);
+    const eventsDir = event.category === "workflow" ? this.paths.getWorkflowEventsDir(workflowSlug, runId) : this.paths.getStepEventDir(workflowSlug, runId, event.stepId);
     const getFilename = (evt) => {
       if (evt.category === "workflow") {
-        return this.getWorkflowEventFilename(evt);
+        return getWorkflowEventFilename(evt);
       } else {
-        return this.getStepEventFilename(evt);
+        return getStepEventFilename(evt);
       }
     };
-    await mkdir(eventsDir, { recursive: true });
+    await mkdir2(eventsDir, { recursive: true });
     let timestamp = parseInt(event.eventId);
     let filename = getFilename(event);
-    let filePath = join(eventsDir, filename);
+    let filePath = join2(eventsDir, filename);
     while (true) {
       try {
         await access(filePath);
@@ -134,12 +180,12 @@ class FileSystemBackend extends Backend {
         event.eventId = `${timestamp}`;
         event.timestampUs = timestamp;
         filename = getFilename(event);
-        filePath = join(eventsDir, filename);
+        filePath = join2(eventsDir, filename);
       } catch {
         break;
       }
     }
-    await this.writeJsonAtomic(filePath, event);
+    await writeJsonAtomic(filePath, event);
   }
   async loadEvents(workflowSlug, runId, options) {
     try {
@@ -147,28 +193,26 @@ class FileSystemBackend extends Backend {
       const directories = [];
       if (!options?.category || options.category === "workflow") {
         directories.push({
-          dir: this.getWorkflowEventsDir(workflowSlug, runId),
+          dir: this.paths.getWorkflowEventsDir(workflowSlug, runId),
           category: "workflow"
         });
       }
       if (!options?.category || options.category === "step") {
         directories.push({
-          dir: this.getStepEventsDir(workflowSlug, runId),
+          dir: this.paths.getStepEventsDir(workflowSlug, runId),
           category: "step"
         });
       }
       for (const { dir, category } of directories) {
         try {
-          const files = await readdir(dir);
-          const eventFiles = files.filter((f) => f.endsWith(".json"));
-          for (const file of eventFiles) {
-            const content = await readFile(join(dir, file), "utf-8");
-            const event = eventSchema.parse(JSON.parse(content));
-            if (category === "step" && options?.stepId) {
-              if (event.category === "step" && event.stepId === options.stepId) {
-                events.push(event);
-              }
-            } else {
+          if (category === "step") {
+            await this.loadEventsRecursive(dir, events, options?.stepId);
+          } else {
+            const files = await readdir(dir);
+            const eventFiles = files.filter((f) => f.endsWith(".json"));
+            for (const file of eventFiles) {
+              const content = await readFile(join2(dir, file), "utf-8");
+              const event = eventSchema.parse(JSON.parse(content));
               events.push(event);
             }
           }
@@ -187,13 +231,60 @@ class FileSystemBackend extends Backend {
       return [];
     }
   }
+  async loadEventsRecursive(dir, events, stepIdFilter) {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join2(dir, entry.name);
+        if (entry.isDirectory()) {
+          await this.loadEventsRecursive(fullPath, events, stepIdFilter);
+        } else if (entry.name.endsWith(".json")) {
+          const content = await readFile(fullPath, "utf-8");
+          const event = eventSchema.parse(JSON.parse(content));
+          if (stepIdFilter) {
+            if (event.category === "step" && event.stepId === stepIdFilter) {
+              events.push(event);
+            }
+          } else {
+            events.push(event);
+          }
+        }
+      }
+    } catch (err) {}
+  }
+  async discoverStepIdsFromEvents(stepEventsDir) {
+    const stepIds = new Set;
+    const scanDirectory = async (dir) => {
+      try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join2(dir, entry.name);
+          if (entry.isDirectory()) {
+            await scanDirectory(fullPath);
+          } else if (entry.name.endsWith(".json")) {
+            try {
+              const content = await readFile(fullPath, "utf-8");
+              const event = JSON.parse(content);
+              if (event.category === "step" && event.stepId) {
+                stepIds.add(event.stepId);
+              }
+            } catch {
+              continue;
+            }
+          }
+        }
+      } catch {}
+    };
+    await scanDirectory(stepEventsDir);
+    return stepIds;
+  }
   async saveStepStart(workflowSlug, runId, stepId, workerId, metadata) {
     const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
     const attemptNumber = getCurrentAttemptNumber(events) + 1;
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "step",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
@@ -216,7 +307,7 @@ class FileSystemBackend extends Backend {
         const logTimestamp = log.timestamp;
         const logEvent = {
           category: "step",
-          eventId: this.generateEventId(logTimestamp),
+          eventId: generateEventId(logTimestamp),
           timestampUs: logTimestamp,
           workflowSlug,
           runId,
@@ -231,10 +322,10 @@ class FileSystemBackend extends Backend {
     }
     const serialized = safeSerialize(output);
     const outputString = serialized.success ? serialized.data : serialized.fallback;
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "step",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
@@ -248,10 +339,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveStepFailed(workflowSlug, runId, stepId, error, metadata) {
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const event = {
       category: "step",
-      eventId: this.generateEventId(now),
+      eventId: generateEventId(now),
       timestampUs: now,
       workflowSlug,
       runId,
@@ -268,13 +359,13 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveStepFailedAndScheduleRetry(workflowSlug, runId, stepId, error, failureMetadata, scheduleMetadata) {
-    const failedTimestamp = getMicrosecondTimestamp();
+    const failedTimestamp = getMicrosecondTimestamp2();
     const retryingTimestamp = failedTimestamp + 1;
     const scheduledTimestamp = failedTimestamp + 2;
     const failedEvent = {
       category: "step",
       type: "StepFailed",
-      eventId: this.generateEventId(failedTimestamp),
+      eventId: generateEventId(failedTimestamp),
       timestampUs: failedTimestamp,
       workflowSlug,
       runId,
@@ -291,7 +382,7 @@ class FileSystemBackend extends Backend {
     const retryingEvent = {
       category: "step",
       type: "StepRetrying",
-      eventId: this.generateEventId(retryingTimestamp),
+      eventId: generateEventId(retryingTimestamp),
       timestampUs: retryingTimestamp,
       workflowSlug,
       runId,
@@ -305,7 +396,7 @@ class FileSystemBackend extends Backend {
     const scheduledEvent = {
       category: "step",
       type: "StepScheduled",
-      eventId: this.generateEventId(scheduledTimestamp),
+      eventId: generateEventId(scheduledTimestamp),
       timestampUs: scheduledTimestamp,
       workflowSlug,
       runId,
@@ -318,10 +409,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, scheduledEvent);
   }
   async saveStepSkipped(workflowSlug, runId, stepId, metadata) {
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const event = {
       category: "step",
-      eventId: this.generateEventId(now),
+      eventId: generateEventId(now),
       timestampUs: now,
       workflowSlug,
       runId,
@@ -337,10 +428,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveStepScheduled(workflowSlug, runId, stepId, metadata) {
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const event = {
       category: "step",
-      eventId: this.generateEventId(now),
+      eventId: generateEventId(now),
       timestampUs: now,
       workflowSlug,
       runId,
@@ -354,10 +445,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveStepHeartbeat(workflowSlug, runId, stepId, workerId, attemptNumber) {
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const event = {
       category: "step",
-      eventId: this.generateEventId(now),
+      eventId: generateEventId(now),
       timestampUs: now,
       workflowSlug,
       runId,
@@ -369,10 +460,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveStepReclaimed(workflowSlug, runId, stepId, metadata) {
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const event = {
       category: "step",
-      eventId: this.generateEventId(now),
+      eventId: generateEventId(now),
       timestampUs: now,
       workflowSlug,
       runId,
@@ -390,10 +481,10 @@ class FileSystemBackend extends Backend {
   async saveWorkflowComplete(workflowSlug, runId, output, metadata) {
     const serialized = safeSerialize(output);
     const outputString = serialized.success ? serialized.data : serialized.fallback;
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "workflow",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
@@ -441,7 +532,7 @@ class FileSystemBackend extends Backend {
   }
   async runExists(workflowSlug, runId) {
     try {
-      const runDir = this.getRunDir(workflowSlug, runId);
+      const runDir = this.paths.getRunDir(workflowSlug, runId);
       await access(runDir);
       return true;
     } catch {
@@ -449,14 +540,15 @@ class FileSystemBackend extends Backend {
     }
   }
   async saveWorkflowStart(workflowSlug, runId, metadata) {
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "workflow",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
       type: "WorkflowStarted",
+      versionId: metadata.versionId,
       workflowAttemptNumber: metadata.workflowAttemptNumber,
       hasInputSchema: metadata.hasInputSchema,
       hasInput: metadata.hasInput
@@ -464,10 +556,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveWorkflowInputValidation(workflowSlug, runId, result) {
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "workflow",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
@@ -477,10 +569,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveWorkflowFailed(workflowSlug, runId, error, metadata, failureReason) {
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "workflow",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
@@ -495,10 +587,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveWorkflowResumed(workflowSlug, runId, metadata) {
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "workflow",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
@@ -510,10 +602,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveWorkflowCancelled(workflowSlug, runId, metadata) {
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "workflow",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
@@ -526,10 +618,10 @@ class FileSystemBackend extends Backend {
     await this.appendEvent(workflowSlug, runId, event);
   }
   async saveWorkflowRetryStarted(workflowSlug, runId, metadata) {
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "workflow",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
@@ -570,14 +662,15 @@ class FileSystemBackend extends Backend {
     return failedSteps;
   }
   async saveRunSubmitted(workflowSlug, runId, metadata) {
-    const timestamp = getMicrosecondTimestamp();
+    const timestamp = getMicrosecondTimestamp2();
     const event = {
       category: "workflow",
-      eventId: this.generateEventId(timestamp),
+      eventId: generateEventId(timestamp),
       timestampUs: timestamp,
       workflowSlug,
       runId,
       type: "RunSubmitted",
+      versionId: metadata.versionId,
       availableAtUs: metadata.availableAt,
       priority: metadata.priority,
       input: metadata.input,
@@ -591,35 +684,42 @@ class FileSystemBackend extends Backend {
   }
   async submitRun(submission) {
     if (submission.idempotencyKey) {
-      const hash = this.hashIdempotencyKey(submission.idempotencyKey);
-      const idempotencyFile = join(this.getIdempotencyDir(), `${hash}.json`);
+      const hash = hashIdempotencyKey(submission.idempotencyKey);
+      const idempotencyFile = join2(this.paths.getIdempotencyDir(), `${hash}.json`);
       try {
         const content = await readFile(idempotencyFile, "utf-8");
         const existing = JSON.parse(content);
         return { runId: existing.runId, isNew: false };
       } catch {}
     }
-    const runId = submission.runId || this.generateRunId();
-    const now = getMicrosecondTimestamp();
+    const runId = submission.runId || generateRunId();
+    const now = getMicrosecondTimestamp2();
     const availableAt = submission.availableAt || now;
     const priority = submission.priority || 0;
     await this.initializeRun(submission.workflowSlug, runId);
+    const workflowMetadata = await this.getWorkflowMetadata(submission.workflowSlug);
+    const hasInputSchema = !!workflowMetadata?.inputSchemaJSON;
+    const currentVersion = await this.getCurrentWorkflowVersion(submission.workflowSlug);
+    if (!currentVersion) {
+      throw new Error(`Workflow ${submission.workflowSlug} not registered. Please ensure the worker has started and registered workflows.`);
+    }
     await this.saveRunSubmitted(submission.workflowSlug, runId, {
+      versionId: currentVersion.versionId,
       availableAt,
       priority,
       input: submission.input !== undefined ? JSON.stringify(submission.input) : undefined,
-      hasInputSchema: false,
+      hasInputSchema,
       timeout: submission.timeout,
       idempotencyKey: submission.idempotencyKey,
       metadata: submission.metadata,
       tags: submission.tags
     });
     if (submission.idempotencyKey) {
-      const hash = this.hashIdempotencyKey(submission.idempotencyKey);
-      const idempotencyDir = this.getIdempotencyDir();
-      await mkdir(idempotencyDir, { recursive: true });
-      const idempotencyFile = join(idempotencyDir, `${hash}.json`);
-      await this.writeJsonAtomic(idempotencyFile, { runId, createdAt: now });
+      const hash = hashIdempotencyKey(submission.idempotencyKey);
+      const idempotencyDir = this.paths.getIdempotencyDir();
+      await mkdir2(idempotencyDir, { recursive: true });
+      const idempotencyFile = join2(idempotencyDir, `${hash}.json`);
+      await writeJsonAtomic(idempotencyFile, { runId, createdAt: now });
     }
     return { runId, isNew: true };
   }
@@ -632,7 +732,7 @@ class FileSystemBackend extends Backend {
           continue;
         if (options?.workflowSlug && workflowSlug !== options.workflowSlug)
           continue;
-        const workflowDir = join(this.baseDir, workflowSlug);
+        const workflowDir = join2(this.baseDir, workflowSlug);
         const runDirs = await readdir(workflowDir);
         for (const runId of runDirs) {
           try {
@@ -667,7 +767,7 @@ class FileSystemBackend extends Backend {
     for (const workflow of workflows) {
       if (workflow.startsWith("."))
         continue;
-      const runDir = this.getRunDir(workflow, runId);
+      const runDir = this.paths.getRunDir(workflow, runId);
       try {
         await access(runDir);
       } catch {
@@ -677,7 +777,7 @@ class FileSystemBackend extends Backend {
       if (events.length === 0)
         continue;
       const state = projectRunStateFromEvents(events, workflow);
-      const duration = getMicrosecondTimestamp() - state.createdAt;
+      const duration = getMicrosecondTimestamp2() - state.createdAt;
       const stepRecords = await this.loadRun(workflow, runId);
       const completedSteps = stepRecords.filter((r) => r.status === "completed").length;
       await this.saveWorkflowCancelled(workflow, runId, {
@@ -695,7 +795,7 @@ class FileSystemBackend extends Backend {
       for (const workflowSlug of workflows) {
         if (workflowSlug.startsWith("."))
           continue;
-        const runDir = this.getRunDir(workflowSlug, runId);
+        const runDir = this.paths.getRunDir(workflowSlug, runId);
         try {
           await access(runDir);
         } catch {
@@ -718,7 +818,7 @@ class FileSystemBackend extends Backend {
       for (const workflowSlug of workflows) {
         if (workflowSlug.startsWith("."))
           continue;
-        const workflowDir = join(this.baseDir, workflowSlug);
+        const workflowDir = join2(this.baseDir, workflowSlug);
         const runDirs = await readdir(workflowDir);
         for (const runId of runDirs) {
           try {
@@ -741,7 +841,7 @@ class FileSystemBackend extends Backend {
     }
   }
   async listScheduledSteps(options) {
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const availableBefore = options?.availableBefore || now;
     const scheduledSteps = [];
     try {
@@ -751,25 +851,17 @@ class FileSystemBackend extends Backend {
           continue;
         if (options?.workflowSlug && workflowSlug !== options.workflowSlug)
           continue;
-        const workflowDir = join(this.baseDir, workflowSlug);
+        const workflowDir = join2(this.baseDir, workflowSlug);
         const runDirs = await readdir(workflowDir);
         for (const runId of runDirs) {
           try {
-            const stepEventsDir = this.getStepEventsDir(workflowSlug, runId);
+            const stepEventsDir = this.paths.getStepEventsDir(workflowSlug, runId);
             try {
               await access(stepEventsDir);
             } catch {
               continue;
             }
-            const eventFiles = await readdir(stepEventsDir);
-            const stepIds = new Set;
-            for (const file of eventFiles) {
-              const parts = file.replace(".json", "").split("-");
-              if (parts.length >= 3) {
-                const stepId = parts.slice(1, -1).join("-");
-                stepIds.add(stepId);
-              }
-            }
+            const stepIds = await this.discoverStepIdsFromEvents(stepEventsDir);
             for (const stepId of stepIds) {
               const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
               if (events.length === 0)
@@ -802,7 +894,7 @@ class FileSystemBackend extends Backend {
       if (events.length === 0)
         return false;
       const state = projectStepState(events, workflowSlug);
-      const now = getMicrosecondTimestamp();
+      const now = getMicrosecondTimestamp2();
       return state.status === "scheduled" && state.availableAt !== undefined && state.availableAt <= now;
     } catch {
       return false;
@@ -813,17 +905,17 @@ class FileSystemBackend extends Backend {
     if (initialEvents.length === 0) {
       return null;
     }
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const initialState = projectStepState(initialEvents, workflowSlug);
     if (initialState.status !== "scheduled" || initialState.availableAt === undefined || initialState.availableAt > now) {
       return null;
     }
     const attemptNumber = initialState.attemptNumber;
-    const lockPath = this.getStepClaimLockPath(workflowSlug, runId, stepId, attemptNumber);
-    await mkdir(dirname(lockPath), { recursive: true });
+    const lockPath = this.paths.getStepClaimLockPath(workflowSlug, runId, stepId, attemptNumber);
+    await mkdir2(dirname3(lockPath), { recursive: true });
     let lockHandle = null;
     try {
-      lockHandle = await openFile(lockPath, "wx");
+      lockHandle = await openFile2(lockPath, "wx");
     } catch (error) {
       if (error.code === "EEXIST") {
         return null;
@@ -836,14 +928,14 @@ class FileSystemBackend extends Backend {
         return null;
       }
       const currentState = projectStepState(currentEvents, workflowSlug);
-      const claimable = currentState.status === "scheduled" && currentState.availableAt !== undefined && currentState.availableAt <= getMicrosecondTimestamp() && currentState.attemptNumber === attemptNumber;
+      const claimable = currentState.status === "scheduled" && currentState.availableAt !== undefined && currentState.availableAt <= getMicrosecondTimestamp2() && currentState.attemptNumber === attemptNumber;
       if (!claimable) {
         return null;
       }
-      const timestamp = getMicrosecondTimestamp();
+      const timestamp = getMicrosecondTimestamp2();
       const event = {
         category: "step",
-        eventId: this.generateEventId(timestamp),
+        eventId: generateEventId(timestamp),
         timestampUs: timestamp,
         workflowSlug,
         runId,
@@ -861,7 +953,7 @@ class FileSystemBackend extends Backend {
           await lockHandle.close();
         } catch {}
         try {
-          await unlink(lockPath);
+          await unlink2(lockPath);
         } catch (error) {
           if (error.code !== "ENOENT") {
             throw error;
@@ -872,31 +964,23 @@ class FileSystemBackend extends Backend {
   }
   async reclaimStaleSteps(staleThreshold, reclaimedBy) {
     const reclaimed = [];
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     try {
       const workflows = await readdir(this.baseDir);
       for (const workflowSlug of workflows) {
         if (workflowSlug.startsWith("."))
           continue;
-        const workflowDir = join(this.baseDir, workflowSlug);
+        const workflowDir = join2(this.baseDir, workflowSlug);
         const runDirs = await readdir(workflowDir);
         for (const runId of runDirs) {
           try {
-            const stepEventsDir = this.getStepEventsDir(workflowSlug, runId);
+            const stepEventsDir = this.paths.getStepEventsDir(workflowSlug, runId);
             try {
               await access(stepEventsDir);
             } catch {
               continue;
             }
-            const eventFiles = await readdir(stepEventsDir);
-            const stepIds = new Set;
-            for (const file of eventFiles) {
-              const parts = file.replace(".json", "").split("-");
-              if (parts.length >= 3) {
-                const stepId = parts.slice(1, -1).join("-");
-                stepIds.add(stepId);
-              }
-            }
+            const stepIds = await this.discoverStepIdsFromEvents(stepEventsDir);
             for (const stepId of stepIds) {
               const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
               if (events.length === 0)
@@ -918,7 +1002,7 @@ class FileSystemBackend extends Backend {
                 await this.saveStepScheduled(workflowSlug, runId, stepId, {
                   availableAt: now,
                   reason: "retry",
-                  attemptNumber: state.attemptNumber,
+                  attemptNumber: state.attemptNumber + 1,
                   retryDelayMs: 0
                 });
                 reclaimed.push({ workflowSlug, runId, stepId });
@@ -934,33 +1018,27 @@ class FileSystemBackend extends Backend {
       return reclaimed;
     }
   }
-  getRegistryDir() {
-    return join(this.baseDir, ".registry");
-  }
-  getWorkflowRegistryDir(slug) {
-    return join(this.getRegistryDir(), slug);
-  }
   async registerWorkflow(registration) {
-    const registryDir = this.getWorkflowRegistryDir(registration.slug);
+    const registryDir = this.paths.getWorkflowRegistryDir(registration.slug);
     try {
-      await mkdir(registryDir, { recursive: true });
-      const metadataPath = join(registryDir, "metadata.json");
+      await mkdir2(registryDir, { recursive: true });
+      const metadataPath = join2(registryDir, "metadata.json");
       const metadata = {
         slug: registration.slug,
         name: registration.name,
         location: registration.location,
         inputSchemaJSON: registration.inputSchemaJSON
       };
-      await writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
-      const stepsPath = join(registryDir, "steps.json");
-      await writeFile(stepsPath, JSON.stringify(registration.steps, null, 2), "utf-8");
+      await writeFile2(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+      const stepsPath = join2(registryDir, "steps.json");
+      await writeFile2(stepsPath, JSON.stringify(registration.steps, null, 2), "utf-8");
     } catch (error) {
       console.error(`Failed to register workflow ${registration.slug}:`, error);
       throw new Error(`Failed to register workflow: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
   async getWorkflowMetadata(slug) {
-    const metadataPath = join(this.getWorkflowRegistryDir(slug), "metadata.json");
+    const metadataPath = join2(this.paths.getWorkflowRegistryDir(slug), "metadata.json");
     try {
       const content = await readFile(metadataPath, "utf-8");
       return JSON.parse(content);
@@ -973,7 +1051,7 @@ class FileSystemBackend extends Backend {
     }
   }
   async listWorkflowMetadata() {
-    const registryDir = this.getRegistryDir();
+    const registryDir = this.paths.getRegistryDir();
     try {
       try {
         await access(registryDir);
@@ -997,7 +1075,7 @@ class FileSystemBackend extends Backend {
     }
   }
   async getWorkflowSteps(slug) {
-    const stepsPath = join(this.getWorkflowRegistryDir(slug), "steps.json");
+    const stepsPath = join2(this.paths.getWorkflowRegistryDir(slug), "steps.json");
     try {
       const content = await readFile(stepsPath, "utf-8");
       return JSON.parse(content);
@@ -1010,7 +1088,7 @@ class FileSystemBackend extends Backend {
     }
   }
   async listRunIds(workflowSlug) {
-    const workflowDir = join(this.baseDir, workflowSlug);
+    const workflowDir = join2(this.baseDir, workflowSlug);
     try {
       try {
         await access(workflowDir);
@@ -1030,9 +1108,92 @@ class FileSystemBackend extends Backend {
       throw new Error(`Failed to list run IDs: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
+  async createWorkflowVersion(version) {
+    const versionDir = join2(this.paths.getWorkflowRegistryDir(version.workflowSlug), "versions", version.versionId);
+    try {
+      await mkdir2(versionDir, { recursive: true });
+      const versionPath = join2(versionDir, "version.json");
+      try {
+        await access(versionPath);
+        return;
+      } catch {}
+      await writeFile2(versionPath, JSON.stringify(version, null, 2), "utf-8");
+    } catch (error) {
+      console.error(`Failed to create workflow version ${version.versionId}:`, error);
+      throw new Error(`Failed to create workflow version: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async getWorkflowVersion(workflowSlug, versionId) {
+    const versionPath = join2(this.paths.getWorkflowRegistryDir(workflowSlug), "versions", versionId, "version.json");
+    try {
+      const content = await readFile(versionPath, "utf-8");
+      const parsed = JSON.parse(content);
+      return WorkflowVersionSchema.parse(parsed);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return null;
+      }
+      console.error(`Failed to get workflow version ${versionId}:`, error);
+      throw new Error(`Failed to load workflow version: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async getCurrentWorkflowVersion(workflowSlug) {
+    const versionsDir = join2(this.paths.getWorkflowRegistryDir(workflowSlug), "versions");
+    try {
+      try {
+        await access(versionsDir);
+      } catch {
+        return null;
+      }
+      const entries = await readdir(versionsDir, { withFileTypes: true });
+      const versions = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const version = await this.getWorkflowVersion(workflowSlug, entry.name);
+          if (version) {
+            versions.push(version);
+          }
+        }
+      }
+      if (versions.length === 0) {
+        return null;
+      }
+      versions.sort((a, b) => b.createdAt - a.createdAt);
+      return versions[0] ?? null;
+    } catch (error) {
+      console.error(`Failed to get current workflow version for ${workflowSlug}:`, error);
+      throw new Error(`Failed to get current workflow version: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async listWorkflowVersions(workflowSlug, options) {
+    const versionsDir = join2(this.paths.getWorkflowRegistryDir(workflowSlug), "versions");
+    try {
+      try {
+        await access(versionsDir);
+      } catch {
+        return [];
+      }
+      const entries = await readdir(versionsDir, { withFileTypes: true });
+      const versions = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const version = await this.getWorkflowVersion(workflowSlug, entry.name);
+          if (version) {
+            versions.push(version);
+          }
+        }
+      }
+      versions.sort((a, b) => b.createdAt - a.createdAt);
+      const limit = options?.limit ?? versions.length;
+      return versions.slice(0, limit);
+    } catch (error) {
+      console.error(`Failed to list workflow versions for ${workflowSlug}:`, error);
+      throw new Error(`Failed to list workflow versions: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
   async close() {}
   async loadEventsForAnalytics(options) {
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const startUs = options?.startUs ?? now - 24 * 60 * 60 * 1000 * 1000;
     const endUs = options?.endUs ?? now;
     const allStepEvents = [];
@@ -1211,7 +1372,7 @@ class FileSystemBackend extends Backend {
   }
   async getThroughput(options) {
     const { stepEvents, workflowEvents } = await this.loadEventsForAnalytics(options);
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const startUs = options?.startUs ?? now - 24 * 60 * 60 * 1000 * 1000;
     const endUs = options?.endUs ?? now;
     const timeRangeUs = endUs - startUs;
@@ -1329,7 +1490,7 @@ class FileSystemBackend extends Backend {
     return computeSuccessRate(stepEvents, workflowEvents, options?.workflowSlug, options?.stepId);
   }
   async getAnalyticsSummary(options) {
-    const now = getMicrosecondTimestamp();
+    const now = getMicrosecondTimestamp2();
     const startUs = options?.startUs ?? now - 24 * 60 * 60 * 1000 * 1000;
     const endUs = options?.endUs ?? now;
     const [
@@ -1378,4 +1539,4 @@ export {
   FileSystemBackend
 };
 
-//# debugId=0253EE6D5A19700564756E2164756E21
+//# debugId=7E7E3DE80AE950DB64756E2164756E21