@cascade-flow/backend-filesystem 0.1.0

package/dist/index.js

@@ -0,0 +1,1381 @@
+// src/index.ts
+import { mkdir, writeFile, readFile, readdir, access, unlink, open as openFile } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { createHash } from "node:crypto";
+import {
+  Backend,
+  StepRecordSchema,
+  eventSchema,
+  safeSerialize,
+  projectStepRecord,
+  projectStepState,
+  projectRunStateFromEvents,
+  extractLogsFromEvents,
+  getCurrentAttemptNumber,
+  getMicrosecondTimestamp,
+  computeErrorAnalysis,
+  computeRetryAnalysis,
+  computeSchedulingLatency,
+  computeStepDuration,
+  computeWorkflowDuration,
+  computeErrorFingerprints,
+  computeWorkerStability,
+  computeThroughput,
+  computeSuccessRate
+} from "@cascade-flow/backend-interface";
+import { projectStepState as projectStepState2, projectRunStateFromEvents as projectRunStateFromEvents2, projectStepRecord as projectStepRecord2 } from "@cascade-flow/backend-interface";
+
+class FileSystemBackend extends Backend {
+  baseDir;
+  constructor(baseDir = "./.runs") {
+    super();
+    this.baseDir = 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
+    };
+  }
+  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 });
+  }
+  async appendEvent(workflowSlug, runId, event) {
+    if (!event.eventId) {
+      event.eventId = this.generateEventId();
+    }
+    if (!event.timestampUs) {
+      event.timestampUs = getMicrosecondTimestamp();
+    }
+    eventSchema.parse(event);
+    const eventsDir = event.category === "workflow" ? this.getWorkflowEventsDir(workflowSlug, runId) : this.getStepEventsDir(workflowSlug, runId);
+    const getFilename = (evt) => {
+      if (evt.category === "workflow") {
+        return this.getWorkflowEventFilename(evt);
+      } else {
+        return this.getStepEventFilename(evt);
+      }
+    };
+    await mkdir(eventsDir, { recursive: true });
+    let timestamp = parseInt(event.eventId);
+    let filename = getFilename(event);
+    let filePath = join(eventsDir, filename);
+    while (true) {
+      try {
+        await access(filePath);
+        timestamp++;
+        event.eventId = `${timestamp}`;
+        event.timestampUs = timestamp;
+        filename = getFilename(event);
+        filePath = join(eventsDir, filename);
+      } catch {
+        break;
+      }
+    }
+    await this.writeJsonAtomic(filePath, event);
+  }
+  async loadEvents(workflowSlug, runId, options) {
+    try {
+      const events = [];
+      const directories = [];
+      if (!options?.category || options.category === "workflow") {
+        directories.push({
+          dir: this.getWorkflowEventsDir(workflowSlug, runId),
+          category: "workflow"
+        });
+      }
+      if (!options?.category || options.category === "step") {
+        directories.push({
+          dir: this.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 {
+              events.push(event);
+            }
+          }
+        } catch (err) {
+          continue;
+        }
+      }
+      events.sort((a, b) => {
+        if (a.timestampUs !== b.timestampUs) {
+          return a.timestampUs - b.timestampUs;
+        }
+        return a.eventId.localeCompare(b.eventId);
+      });
+      return events;
+    } catch {
+      return [];
+    }
+  }
+  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 event = {
+      category: "step",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      stepId,
+      type: "StepStarted",
+      workerId,
+      dependencies: metadata.dependencies,
+      attemptNumber
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveStepComplete(workflowSlug, runId, stepId, output, metadata, exportOutput = false) {
+    const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
+    const attemptNumber = getCurrentAttemptNumber(events);
+    if (attemptNumber === 0) {
+      throw new Error(`Cannot complete step that hasn't started: ${stepId}`);
+    }
+    if (metadata.logs && metadata.logs.length > 0) {
+      for (const log of metadata.logs) {
+        const logTimestamp = log.timestamp;
+        const logEvent = {
+          category: "step",
+          eventId: this.generateEventId(logTimestamp),
+          timestampUs: logTimestamp,
+          workflowSlug,
+          runId,
+          stepId,
+          type: "LogEntry",
+          stream: log.stream,
+          message: log.message,
+          attemptNumber
+        };
+        await this.appendEvent(workflowSlug, runId, logEvent);
+      }
+    }
+    const serialized = safeSerialize(output);
+    const outputString = serialized.success ? serialized.data : serialized.fallback;
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      stepId,
+      type: "StepCompleted",
+      output: outputString,
+      durationUs: metadata.duration,
+      attemptNumber,
+      exportOutput
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveStepFailed(workflowSlug, runId, stepId, error, metadata) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      type: "StepFailed",
+      error,
+      errorFingerprints: computeErrorFingerprints(error, error.stack),
+      durationUs: metadata.duration,
+      attemptNumber: metadata.attemptNumber,
+      terminal: metadata.terminal,
+      nextRetryAtUs: metadata.nextRetryAt,
+      failureReason: metadata.failureReason
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveStepFailedAndScheduleRetry(workflowSlug, runId, stepId, error, failureMetadata, scheduleMetadata) {
+    const failedTimestamp = getMicrosecondTimestamp();
+    const retryingTimestamp = failedTimestamp + 1;
+    const scheduledTimestamp = failedTimestamp + 2;
+    const failedEvent = {
+      category: "step",
+      type: "StepFailed",
+      eventId: this.generateEventId(failedTimestamp),
+      timestampUs: failedTimestamp,
+      workflowSlug,
+      runId,
+      stepId,
+      error,
+      errorFingerprints: computeErrorFingerprints(error, error.stack),
+      durationUs: failureMetadata.duration,
+      attemptNumber: failureMetadata.attemptNumber,
+      terminal: false,
+      nextRetryAtUs: failureMetadata.nextRetryAt,
+      failureReason: failureMetadata.failureReason
+    };
+    await this.appendEvent(workflowSlug, runId, failedEvent);
+    const retryingEvent = {
+      category: "step",
+      type: "StepRetrying",
+      eventId: this.generateEventId(retryingTimestamp),
+      timestampUs: retryingTimestamp,
+      workflowSlug,
+      runId,
+      stepId,
+      attemptNumber: failureMetadata.attemptNumber,
+      nextAttempt: scheduleMetadata.nextAttemptNumber,
+      maxRetries: scheduleMetadata.maxRetries,
+      error
+    };
+    await this.appendEvent(workflowSlug, runId, retryingEvent);
+    const scheduledEvent = {
+      category: "step",
+      type: "StepScheduled",
+      eventId: this.generateEventId(scheduledTimestamp),
+      timestampUs: scheduledTimestamp,
+      workflowSlug,
+      runId,
+      stepId,
+      availableAtUs: scheduleMetadata.availableAt,
+      reason: "retry",
+      attemptNumber: scheduleMetadata.nextAttemptNumber,
+      retryDelayMs: scheduleMetadata.retryDelayMs
+    };
+    await this.appendEvent(workflowSlug, runId, scheduledEvent);
+  }
+  async saveStepSkipped(workflowSlug, runId, stepId, metadata) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      type: "StepSkipped",
+      skipType: metadata.skipType,
+      reason: metadata.reason,
+      metadata: metadata.metadata,
+      durationUs: metadata.duration,
+      attemptNumber: metadata.attemptNumber,
+      cascadedFrom: metadata.cascadedFrom
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveStepScheduled(workflowSlug, runId, stepId, metadata) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      type: "StepScheduled",
+      availableAtUs: metadata.availableAt,
+      reason: metadata.reason,
+      attemptNumber: metadata.attemptNumber,
+      retryDelayMs: metadata.retryDelayMs
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveStepHeartbeat(workflowSlug, runId, stepId, workerId, attemptNumber) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      type: "StepHeartbeat",
+      workerId,
+      attemptNumber
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveStepReclaimed(workflowSlug, runId, stepId, metadata) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      type: "StepReclaimed",
+      originalWorkerId: metadata.originalWorkerId,
+      reclaimedBy: metadata.reclaimedBy,
+      lastHeartbeatUs: metadata.lastHeartbeat,
+      staleThresholdUs: metadata.staleThreshold,
+      staleDurationUs: metadata.staleDuration,
+      attemptNumber: metadata.attemptNumber
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveWorkflowComplete(workflowSlug, runId, output, metadata) {
+    const serialized = safeSerialize(output);
+    const outputString = serialized.success ? serialized.data : serialized.fallback;
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "workflow",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      type: "WorkflowCompleted",
+      workflowAttemptNumber: metadata.workflowAttemptNumber,
+      output: outputString,
+      durationUs: metadata.duration,
+      totalSteps: metadata.totalSteps
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveStepLogs(workflowSlug, runId, stepId, logs) {}
+  async loadStepLogs(workflowSlug, runId, stepId, attemptNumber) {
+    const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
+    let logs = extractLogsFromEvents(events);
+    if (attemptNumber !== undefined) {
+      logs = logs.filter((log) => log.attemptNumber === attemptNumber);
+    }
+    return logs.length > 0 ? logs : null;
+  }
+  async loadRun(workflowSlug, runId) {
+    try {
+      const events = await this.loadEvents(workflowSlug, runId, { category: "step" });
+      if (events.length === 0) {
+        return [];
+      }
+      const eventsByStep = new Map;
+      for (const event of events) {
+        if (event.category === "step") {
+          if (!eventsByStep.has(event.stepId)) {
+            eventsByStep.set(event.stepId, []);
+          }
+          eventsByStep.get(event.stepId).push(event);
+        }
+      }
+      const records = [];
+      for (const [stepId, stepEvents] of eventsByStep) {
+        const record = projectStepRecord(stepEvents);
+        records.push(record);
+      }
+      return records;
+    } catch {
+      return [];
+    }
+  }
+  async runExists(workflowSlug, runId) {
+    try {
+      const runDir = this.getRunDir(workflowSlug, runId);
+      await access(runDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async saveWorkflowStart(workflowSlug, runId, metadata) {
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "workflow",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      type: "WorkflowStarted",
+      workflowAttemptNumber: metadata.workflowAttemptNumber,
+      hasInputSchema: metadata.hasInputSchema,
+      hasInput: metadata.hasInput
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveWorkflowInputValidation(workflowSlug, runId, result) {
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "workflow",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      type: "WorkflowInputValidation",
+      ...result
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveWorkflowFailed(workflowSlug, runId, error, metadata, failureReason) {
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "workflow",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      type: "WorkflowFailed",
+      workflowAttemptNumber: metadata.workflowAttemptNumber,
+      error,
+      durationUs: metadata.duration,
+      completedSteps: metadata.completedSteps,
+      failedStep: metadata.failedStep,
+      failureReason
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveWorkflowResumed(workflowSlug, runId, metadata) {
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "workflow",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      type: "WorkflowResumed",
+      originalRunId: metadata.originalRunId,
+      resumedSteps: metadata.resumedSteps,
+      pendingSteps: metadata.pendingSteps
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveWorkflowCancelled(workflowSlug, runId, metadata) {
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "workflow",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      type: "WorkflowCancelled",
+      workflowAttemptNumber: metadata.workflowAttemptNumber,
+      reason: metadata.reason,
+      durationUs: metadata.duration,
+      completedSteps: metadata.completedSteps
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async saveWorkflowRetryStarted(workflowSlug, runId, metadata) {
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "workflow",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      type: "WorkflowRetryStarted",
+      workflowAttemptNumber: metadata.workflowAttemptNumber,
+      previousAttemptNumber: metadata.previousAttemptNumber,
+      retriedSteps: metadata.retriedSteps,
+      reason: metadata.reason
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async getFailedSteps(workflowSlug, runId) {
+    const events = await this.loadEvents(workflowSlug, runId, {
+      category: "step"
+    });
+    if (events.length === 0 || !("category" in events[0])) {
+      return [];
+    }
+    const eventsByStep = new Map;
+    for (const event of events) {
+      if (event.category === "step") {
+        const stepEvents = eventsByStep.get(event.stepId) || [];
+        stepEvents.push(event);
+        eventsByStep.set(event.stepId, stepEvents);
+      }
+    }
+    const failedSteps = [];
+    for (const [stepId, stepEvents] of eventsByStep) {
+      const state = projectStepState(stepEvents, workflowSlug);
+      if (state.status === "failed" && state.terminal && state.error) {
+        failedSteps.push({
+          stepId,
+          error: state.error,
+          attemptNumber: state.attemptNumber
+        });
+      }
+    }
+    return failedSteps;
+  }
+  async saveRunSubmitted(workflowSlug, runId, metadata) {
+    const timestamp = getMicrosecondTimestamp();
+    const event = {
+      category: "workflow",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug,
+      runId,
+      type: "RunSubmitted",
+      availableAtUs: metadata.availableAt,
+      priority: metadata.priority,
+      input: metadata.input,
+      hasInputSchema: metadata.hasInputSchema,
+      timeoutUs: metadata.timeout,
+      idempotencyKey: metadata.idempotencyKey,
+      metadata: metadata.metadata,
+      tags: metadata.tags
+    };
+    await this.appendEvent(workflowSlug, runId, event);
+  }
+  async submitRun(submission) {
+    if (submission.idempotencyKey) {
+      const hash = this.hashIdempotencyKey(submission.idempotencyKey);
+      const idempotencyFile = join(this.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 availableAt = submission.availableAt || now;
+    const priority = submission.priority || 0;
+    await this.initializeRun(submission.workflowSlug, runId);
+    await this.saveRunSubmitted(submission.workflowSlug, runId, {
+      availableAt,
+      priority,
+      input: submission.input !== undefined ? JSON.stringify(submission.input) : undefined,
+      hasInputSchema: false,
+      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 });
+    }
+    return { runId, isNew: true };
+  }
+  async listRuns(options) {
+    try {
+      const allRuns = [];
+      const workflows = await readdir(this.baseDir);
+      for (const workflowSlug of workflows) {
+        if (workflowSlug.startsWith("."))
+          continue;
+        if (options?.workflowSlug && workflowSlug !== options.workflowSlug)
+          continue;
+        const workflowDir = join(this.baseDir, workflowSlug);
+        const runDirs = await readdir(workflowDir);
+        for (const runId of runDirs) {
+          try {
+            const events = await this.loadEvents(workflowSlug, runId, { category: "workflow" });
+            if (events.length === 0)
+              continue;
+            const state = projectRunStateFromEvents(events, workflowSlug);
+            if (options?.status && options.status.length > 0) {
+              if (!options.status.includes(state.status))
+                continue;
+            }
+            if (options?.tags && options.tags.length > 0) {
+              const stateTags = state.tags || [];
+              const hasAllTags = options.tags.every((tag) => stateTags.includes(tag));
+              if (!hasAllTags)
+                continue;
+            }
+            allRuns.push(state);
+          } catch {
+            continue;
+          }
+        }
+      }
+      allRuns.sort((a, b) => b.createdAt - a.createdAt);
+      return options?.limit ? allRuns.slice(0, options.limit) : allRuns;
+    } catch {
+      return [];
+    }
+  }
+  async cancelRun(runId, reason) {
+    const workflows = await readdir(this.baseDir);
+    for (const workflow of workflows) {
+      if (workflow.startsWith("."))
+        continue;
+      const runDir = this.getRunDir(workflow, runId);
+      try {
+        await access(runDir);
+      } catch {
+        continue;
+      }
+      const events = await this.loadEvents(workflow, runId, { category: "workflow" });
+      if (events.length === 0)
+        continue;
+      const state = projectRunStateFromEvents(events, workflow);
+      const duration = getMicrosecondTimestamp() - state.createdAt;
+      const stepRecords = await this.loadRun(workflow, runId);
+      const completedSteps = stepRecords.filter((r) => r.status === "completed").length;
+      await this.saveWorkflowCancelled(workflow, runId, {
+        workflowAttemptNumber: state.workflowAttemptNumber || 1,
+        reason,
+        duration,
+        completedSteps
+      });
+      return;
+    }
+  }
+  async getRun(runId) {
+    try {
+      const workflows = await readdir(this.baseDir);
+      for (const workflowSlug of workflows) {
+        if (workflowSlug.startsWith("."))
+          continue;
+        const runDir = this.getRunDir(workflowSlug, runId);
+        try {
+          await access(runDir);
+        } catch {
+          continue;
+        }
+        const events = await this.loadEvents(workflowSlug, runId, { category: "workflow" });
+        if (events.length === 0)
+          return null;
+        return projectRunStateFromEvents(events, workflowSlug);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async listActiveWorkflows() {
+    const activeWorkflows = [];
+    try {
+      const workflows = await readdir(this.baseDir);
+      for (const workflowSlug of workflows) {
+        if (workflowSlug.startsWith("."))
+          continue;
+        const workflowDir = join(this.baseDir, workflowSlug);
+        const runDirs = await readdir(workflowDir);
+        for (const runId of runDirs) {
+          try {
+            const workflowEvents = await this.loadEvents(workflowSlug, runId, { category: "workflow" });
+            if (workflowEvents.length === 0)
+              continue;
+            const runState = projectRunStateFromEvents(workflowEvents, workflowSlug);
+            if (runState.status === "pending" || runState.status === "claimed" || runState.status === "running") {
+              activeWorkflows.push(workflowSlug);
+              break;
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+      return Array.from(new Set(activeWorkflows));
+    } catch {
+      return [];
+    }
+  }
+  async listScheduledSteps(options) {
+    const now = getMicrosecondTimestamp();
+    const availableBefore = options?.availableBefore || now;
+    const scheduledSteps = [];
+    try {
+      const workflows = await readdir(this.baseDir);
+      for (const workflowSlug of workflows) {
+        if (workflowSlug.startsWith("."))
+          continue;
+        if (options?.workflowSlug && workflowSlug !== options.workflowSlug)
+          continue;
+        const workflowDir = join(this.baseDir, workflowSlug);
+        const runDirs = await readdir(workflowDir);
+        for (const runId of runDirs) {
+          try {
+            const stepEventsDir = this.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);
+              }
+            }
+            for (const stepId of stepIds) {
+              const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
+              if (events.length === 0)
+                continue;
+              const state = projectStepState(events, workflowSlug);
+              if (state.status === "scheduled" && state.availableAt && state.availableAt <= availableBefore) {
+                scheduledSteps.push({
+                  workflowSlug,
+                  runId,
+                  stepId,
+                  availableAt: state.availableAt
+                });
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+      scheduledSteps.sort((a, b) => a.availableAt - b.availableAt);
+      const limited = options?.limit ? scheduledSteps.slice(0, options.limit) : scheduledSteps;
+      return limited.map(({ workflowSlug, runId, stepId }) => ({ workflowSlug, runId, stepId }));
+    } catch {
+      return [];
+    }
+  }
+  async isStepClaimable(workflowSlug, runId, stepId) {
+    try {
+      const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
+      if (events.length === 0)
+        return false;
+      const state = projectStepState(events, workflowSlug);
+      const now = getMicrosecondTimestamp();
+      return state.status === "scheduled" && state.availableAt !== undefined && state.availableAt <= now;
+    } catch {
+      return false;
+    }
+  }
+  async claimScheduledStep(workflowSlug, runId, stepId, workerId, metadata) {
+    const initialEvents = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
+    if (initialEvents.length === 0) {
+      return null;
+    }
+    const now = getMicrosecondTimestamp();
+    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 });
+    let lockHandle = null;
+    try {
+      lockHandle = await openFile(lockPath, "wx");
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        return null;
+      }
+      throw error;
+    }
+    try {
+      const currentEvents = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
+      if (currentEvents.length === 0) {
+        return null;
+      }
+      const currentState = projectStepState(currentEvents, workflowSlug);
+      const claimable = currentState.status === "scheduled" && currentState.availableAt !== undefined && currentState.availableAt <= getMicrosecondTimestamp() && currentState.attemptNumber === attemptNumber;
+      if (!claimable) {
+        return null;
+      }
+      const timestamp = getMicrosecondTimestamp();
+      const event = {
+        category: "step",
+        eventId: this.generateEventId(timestamp),
+        timestampUs: timestamp,
+        workflowSlug,
+        runId,
+        stepId,
+        type: "StepStarted",
+        workerId,
+        dependencies: metadata.dependencies,
+        attemptNumber
+      };
+      await this.appendEvent(workflowSlug, runId, event);
+      return { attemptNumber };
+    } finally {
+      if (lockHandle) {
+        try {
+          await lockHandle.close();
+        } catch {}
+        try {
+          await unlink(lockPath);
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      }
+    }
+  }
+  async reclaimStaleSteps(staleThreshold, reclaimedBy) {
+    const reclaimed = [];
+    const now = getMicrosecondTimestamp();
+    try {
+      const workflows = await readdir(this.baseDir);
+      for (const workflowSlug of workflows) {
+        if (workflowSlug.startsWith("."))
+          continue;
+        const workflowDir = join(this.baseDir, workflowSlug);
+        const runDirs = await readdir(workflowDir);
+        for (const runId of runDirs) {
+          try {
+            const stepEventsDir = this.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);
+              }
+            }
+            for (const stepId of stepIds) {
+              const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
+              if (events.length === 0)
+                continue;
+              const state = projectStepState(events, workflowSlug);
+              if (state.status !== "running")
+                continue;
+              const lastHeartbeat = state.lastHeartbeat || state.startTime || 0;
+              const staleDuration = now - lastHeartbeat;
+              if (staleDuration > staleThreshold) {
+                await this.saveStepReclaimed(workflowSlug, runId, stepId, {
+                  originalWorkerId: state.claimedBy || "unknown",
+                  reclaimedBy,
+                  lastHeartbeat,
+                  staleThreshold,
+                  staleDuration,
+                  attemptNumber: state.attemptNumber
+                });
+                await this.saveStepScheduled(workflowSlug, runId, stepId, {
+                  availableAt: now,
+                  reason: "retry",
+                  attemptNumber: state.attemptNumber,
+                  retryDelayMs: 0
+                });
+                reclaimed.push({ workflowSlug, runId, stepId });
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+      return reclaimed;
+    } catch {
+      return reclaimed;
+    }
+  }
+  getRegistryDir() {
+    return join(this.baseDir, ".registry");
+  }
+  getWorkflowRegistryDir(slug) {
+    return join(this.getRegistryDir(), slug);
+  }
+  async registerWorkflow(registration) {
+    const registryDir = this.getWorkflowRegistryDir(registration.slug);
+    try {
+      await mkdir(registryDir, { recursive: true });
+      const metadataPath = join(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");
+    } 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");
+    try {
+      const content = await readFile(metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return null;
+      }
+      console.error(`Failed to get workflow metadata for ${slug}:`, error);
+      throw new Error(`Failed to load workflow metadata: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async listWorkflowMetadata() {
+    const registryDir = this.getRegistryDir();
+    try {
+      try {
+        await access(registryDir);
+      } catch {
+        return [];
+      }
+      const entries = await readdir(registryDir, { withFileTypes: true });
+      const workflows = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const metadata = await this.getWorkflowMetadata(entry.name);
+          if (metadata) {
+            workflows.push(metadata);
+          }
+        }
+      }
+      return workflows;
+    } catch (error) {
+      console.error("Failed to list workflows:", error);
+      throw new Error(`Failed to list workflows: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async getWorkflowSteps(slug) {
+    const stepsPath = join(this.getWorkflowRegistryDir(slug), "steps.json");
+    try {
+      const content = await readFile(stepsPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return [];
+      }
+      console.error(`Failed to get workflow steps for ${slug}:`, error);
+      throw new Error(`Failed to load workflow steps: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async listRunIds(workflowSlug) {
+    const workflowDir = join(this.baseDir, workflowSlug);
+    try {
+      try {
+        await access(workflowDir);
+      } catch {
+        return [];
+      }
+      const entries = await readdir(workflowDir, { withFileTypes: true });
+      const runIds = [];
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== ".registry") {
+          runIds.push(entry.name);
+        }
+      }
+      return runIds;
+    } catch (error) {
+      console.error(`Failed to list run IDs for workflow ${workflowSlug}:`, error);
+      throw new Error(`Failed to list run IDs: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async close() {}
+  async loadEventsForAnalytics(options) {
+    const now = getMicrosecondTimestamp();
+    const startUs = options?.startUs ?? now - 24 * 60 * 60 * 1000 * 1000;
+    const endUs = options?.endUs ?? now;
+    const allStepEvents = [];
+    const allWorkflowEvents = [];
+    const workflowsToScan = [];
+    if (options?.workflowSlug) {
+      workflowsToScan.push(options.workflowSlug);
+    } else {
+      try {
+        const entries = await readdir(this.baseDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && entry.name !== ".registry") {
+            workflowsToScan.push(entry.name);
+          }
+        }
+      } catch (error) {
+        return { stepEvents: [], workflowEvents: [] };
+      }
+    }
+    for (const workflowSlug of workflowsToScan) {
+      const runIds = options?.runIds ?? await this.listRunIds(workflowSlug);
+      for (const runId of runIds) {
+        try {
+          const stepEvents = await this.loadEvents(workflowSlug, runId, {
+            category: "step",
+            stepId: options?.stepId
+          });
+          const filteredStepEvents = stepEvents.filter((e) => e.timestampUs >= startUs && e.timestampUs <= endUs);
+          allStepEvents.push(...filteredStepEvents);
+          if (!options?.stepId) {
+            const workflowEvents = await this.loadEvents(workflowSlug, runId, {
+              category: "workflow"
+            });
+            const filteredWorkflowEvents = workflowEvents.filter((e) => e.timestampUs >= startUs && e.timestampUs <= endUs);
+            allWorkflowEvents.push(...filteredWorkflowEvents);
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+    return { stepEvents: allStepEvents, workflowEvents: allWorkflowEvents };
+  }
+  async getErrorAnalysis(options) {
+    const { stepEvents } = await this.loadEventsForAnalytics(options);
+    return computeErrorAnalysis(stepEvents, options?.workflowSlug, options?.stepId);
+  }
+  async getErrorsList(options) {
+    const { stepEvents } = await this.loadEventsForAnalytics({
+      startUs: options?.timeRange?.start,
+      endUs: options?.timeRange?.end,
+      workflowSlug: options?.workflowSlug
+    });
+    const strategy = options?.groupingStrategy || "exact";
+    const limit = options?.limit || 50;
+    const offset = options?.offset || 0;
+    const failedEvents = stepEvents.filter((e) => e.type === "StepFailed");
+    const errorGroups = new Map;
+    for (const event of failedEvents) {
+      const stackHash = strategy === "exact" ? event.errorFingerprints.stackExactHash : strategy === "normalized" ? event.errorFingerprints.stackNormalizedHash : event.errorFingerprints.stackPortableHash;
+      const fingerprint = `${event.errorFingerprints.nameHash}:${event.errorFingerprints.messageHash}:${stackHash}`;
+      const existing = errorGroups.get(fingerprint);
+      if (existing) {
+        existing.count++;
+        existing.affectedRuns.add(event.runId);
+        existing.firstSeen = Math.min(existing.firstSeen, event.timestampUs);
+        existing.lastSeen = Math.max(existing.lastSeen, event.timestampUs);
+      } else {
+        errorGroups.set(fingerprint, {
+          errorMessage: event.error.message,
+          errorName: event.error.name || "Error",
+          sampleStack: event.error.stack || "",
+          count: 1,
+          affectedRuns: new Set([event.runId]),
+          firstSeen: event.timestampUs,
+          lastSeen: event.timestampUs
+        });
+      }
+    }
+    const allErrors = Array.from(errorGroups.entries()).map(([fingerprint, data]) => ({
+      fingerprint,
+      errorMessage: data.errorMessage,
+      errorName: data.errorName,
+      sampleStack: data.sampleStack,
+      count: data.count,
+      affectedRuns: data.affectedRuns.size,
+      firstSeen: data.firstSeen,
+      lastSeen: data.lastSeen
+    }));
+    allErrors.sort((a, b) => b.count - a.count);
+    const total = allErrors.length;
+    const errors = allErrors.slice(offset, offset + limit);
+    return { errors, total };
+  }
+  async getErrorDetail(fingerprint, groupingStrategy, options) {
+    const parts = fingerprint.split(":");
+    if (parts.length !== 3) {
+      throw new Error(`Invalid fingerprint format: ${fingerprint}`);
+    }
+    const [nameHash, messageHash, stackHash] = parts;
+    const { stepEvents } = await this.loadEventsForAnalytics({
+      startUs: options?.timeRange?.start,
+      endUs: options?.timeRange?.end
+    });
+    const limit = options?.limit || 100;
+    const offset = options?.offset || 0;
+    const matchingEvents = stepEvents.filter((e) => {
+      if (e.type !== "StepFailed")
+        return false;
+      if (e.errorFingerprints.nameHash !== nameHash)
+        return false;
+      if (e.errorFingerprints.messageHash !== messageHash)
+        return false;
+      const eventStackHash = groupingStrategy === "exact" ? e.errorFingerprints.stackExactHash : groupingStrategy === "normalized" ? e.errorFingerprints.stackNormalizedHash : e.errorFingerprints.stackPortableHash;
+      return eventStackHash === stackHash;
+    });
+    if (matchingEvents.length === 0) {
+      return {
+        fingerprint,
+        errorMessage: "",
+        errorName: "",
+        sampleStack: "",
+        totalCount: 0,
+        affectedRuns: 0,
+        firstSeen: 0,
+        lastSeen: 0,
+        occurrences: [],
+        total: 0
+      };
+    }
+    const affectedRunsSet = new Set(matchingEvents.map((e) => e.runId));
+    const firstSeen = Math.min(...matchingEvents.map((e) => e.timestampUs));
+    const lastSeen = Math.max(...matchingEvents.map((e) => e.timestampUs));
+    matchingEvents.sort((a, b) => b.timestampUs - a.timestampUs);
+    const paginatedEvents = matchingEvents.slice(offset, offset + limit);
+    const occurrences = paginatedEvents.map((e) => ({
+      workflowSlug: e.workflowSlug,
+      runId: e.runId,
+      stepId: e.stepId,
+      attemptNumber: e.attemptNumber,
+      timestampUs: e.timestampUs
+    }));
+    const sampleEvent = matchingEvents[0];
+    return {
+      fingerprint,
+      errorMessage: sampleEvent.error.message,
+      errorName: sampleEvent.error.name || "Error",
+      sampleStack: sampleEvent.error.stack || "",
+      totalCount: matchingEvents.length,
+      affectedRuns: affectedRunsSet.size,
+      firstSeen,
+      lastSeen,
+      occurrences,
+      total: matchingEvents.length
+    };
+  }
+  async getRetryAnalysis(options) {
+    const { stepEvents } = await this.loadEventsForAnalytics(options);
+    return computeRetryAnalysis(stepEvents);
+  }
+  async getSchedulingLatency(options) {
+    const { stepEvents } = await this.loadEventsForAnalytics(options);
+    return computeSchedulingLatency(stepEvents, options?.workflowSlug, options?.stepId);
+  }
+  async getStepDuration(options) {
+    const { stepEvents } = await this.loadEventsForAnalytics(options);
+    return computeStepDuration(stepEvents, options?.workflowSlug, options?.stepId);
+  }
+  async getWorkflowDuration(options) {
+    const { workflowEvents } = await this.loadEventsForAnalytics(options);
+    return computeWorkflowDuration(workflowEvents, options?.workflowSlug);
+  }
+  async getWorkerStability(options) {
+    const { stepEvents } = await this.loadEventsForAnalytics(options);
+    return computeWorkerStability(stepEvents);
+  }
+  async getThroughput(options) {
+    const { stepEvents, workflowEvents } = await this.loadEventsForAnalytics(options);
+    const now = getMicrosecondTimestamp();
+    const startUs = options?.startUs ?? now - 24 * 60 * 60 * 1000 * 1000;
+    const endUs = options?.endUs ?? now;
+    const timeRangeUs = endUs - startUs;
+    return computeThroughput(stepEvents, workflowEvents, timeRangeUs, options?.workflowSlug);
+  }
+  async getQueueDepth(options) {
+    const runs = await this.listRuns({
+      workflowSlug: options?.workflowSlug,
+      status: ["pending", "running"]
+    });
+    let pendingRuns = 0;
+    let runningRuns = 0;
+    let scheduledSteps = 0;
+    let runningSteps = 0;
+    let oldestScheduledStepUs;
+    let oldestPendingRunUs;
+    for (const run of runs) {
+      if (run.status === "pending") {
+        pendingRuns++;
+        if (!oldestPendingRunUs || run.createdAt < oldestPendingRunUs) {
+          oldestPendingRunUs = run.createdAt;
+        }
+      } else if (run.status === "running") {
+        runningRuns++;
+        try {
+          const stepEvents = await this.loadEvents(run.workflowSlug, run.runId, { category: "step" });
+          const eventsByStep = new Map;
+          for (const event of stepEvents) {
+            const events = eventsByStep.get(event.stepId) || [];
+            events.push(event);
+            eventsByStep.set(event.stepId, events);
+          }
+          for (const [stepId, events] of eventsByStep.entries()) {
+            const state = projectStepState(events, run.workflowSlug);
+            if (state.status === "scheduled") {
+              scheduledSteps++;
+              if (state.availableAt && (!oldestScheduledStepUs || state.availableAt < oldestScheduledStepUs)) {
+                oldestScheduledStepUs = state.availableAt;
+              }
+            } else if (state.status === "running") {
+              runningSteps++;
+            }
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+    return {
+      workflowSlug: options?.workflowSlug,
+      pendingRuns,
+      runningRuns,
+      scheduledSteps,
+      runningSteps,
+      oldestScheduledStepUs,
+      oldestPendingRunUs
+    };
+  }
+  async getQueueDepthByWorkflow() {
+    const runs = await this.listRuns({ status: ["pending", "running"] });
+    const workflowMap = new Map;
+    for (const run of runs) {
+      const existing = workflowMap.get(run.workflowSlug) || {
+        pendingRuns: 0,
+        scheduledSteps: 0
+      };
+      if (run.status === "pending") {
+        existing.pendingRuns++;
+        if (!existing.oldestPendingItemUs || run.createdAt < existing.oldestPendingItemUs) {
+          existing.oldestPendingItemUs = run.createdAt;
+        }
+      } else if (run.status === "running") {
+        try {
+          const stepEvents = await this.loadEvents(run.workflowSlug, run.runId, {
+            category: "step"
+          });
+          const eventsByStep = new Map;
+          for (const event of stepEvents) {
+            const events = eventsByStep.get(event.stepId) || [];
+            events.push(event);
+            eventsByStep.set(event.stepId, events);
+          }
+          for (const [stepId, events] of eventsByStep.entries()) {
+            const state = projectStepState(events, run.workflowSlug);
+            if (state.status === "scheduled") {
+              existing.scheduledSteps++;
+              if (state.availableAt && (!existing.oldestPendingItemUs || state.availableAt < existing.oldestPendingItemUs)) {
+                existing.oldestPendingItemUs = state.availableAt;
+              }
+            }
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+      workflowMap.set(run.workflowSlug, existing);
+    }
+    const allMetadata = await this.listWorkflowMetadata();
+    const metadataMap = new Map(allMetadata.map((m) => [m.slug, m]));
+    const result = Array.from(workflowMap.entries()).map(([workflowSlug, data]) => ({
+      workflowSlug,
+      workflowName: metadataMap.get(workflowSlug)?.name,
+      pendingRuns: data.pendingRuns,
+      scheduledSteps: data.scheduledSteps,
+      oldestPendingItemUs: data.oldestPendingItemUs
+    })).filter((item) => item.pendingRuns > 0 || item.scheduledSteps > 0).sort((a, b) => {
+      const aTotal = a.pendingRuns + a.scheduledSteps;
+      const bTotal = b.pendingRuns + b.scheduledSteps;
+      return bTotal - aTotal;
+    });
+    return result;
+  }
+  async getSuccessRate(options) {
+    const { stepEvents, workflowEvents } = await this.loadEventsForAnalytics(options);
+    return computeSuccessRate(stepEvents, workflowEvents, options?.workflowSlug, options?.stepId);
+  }
+  async getAnalyticsSummary(options) {
+    const now = getMicrosecondTimestamp();
+    const startUs = options?.startUs ?? now - 24 * 60 * 60 * 1000 * 1000;
+    const endUs = options?.endUs ?? now;
+    const [
+      errorAnalysis,
+      retryAnalysis,
+      schedulingLatency,
+      stepDuration,
+      workflowDuration,
+      workerStability,
+      throughput,
+      queueDepth,
+      successRate
+    ] = await Promise.all([
+      this.getErrorAnalysis(options),
+      this.getRetryAnalysis(options),
+      this.getSchedulingLatency(options),
+      this.getStepDuration(options),
+      this.getWorkflowDuration(options),
+      this.getWorkerStability(options),
+      this.getThroughput(options),
+      this.getQueueDepth(options),
+      this.getSuccessRate(options)
+    ]);
+    return {
+      timeRange: {
+        startUs,
+        endUs,
+        durationUs: endUs - startUs
+      },
+      errorAnalysis,
+      retryAnalysis,
+      schedulingLatency,
+      stepDuration,
+      workflowDuration,
+      workerStability,
+      throughput,
+      queueDepth,
+      successRate
+    };
+  }
+}
+export {
+  projectStepState2 as projectStepState,
+  projectStepRecord2 as projectStepRecord,
+  projectRunStateFromEvents2 as projectRunStateFromEvents,
+  FileSystemBackend
+};
+
+//# debugId=0253EE6D5A19700564756E2164756E21