@stepflowjs/core 0.0.1

package/dist/index.js

@@ -0,0 +1,1256 @@
+import { EventEmitter } from 'events';
+import { nanoid } from 'nanoid';
+import ms from 'ms';
+import { createHmac } from 'crypto';
+
+// src/stepflow.ts
+
+// src/workflow.ts
+function createWorkflow(options, handler) {
+  const config = {
+    id: options.id,
+    version: options.version,
+    retries: options.retries ?? 0,
+    retryDelay: options.retryDelay ?? 1e3,
+    timeout: options.timeout,
+    cron: options.cron
+  };
+  return {
+    id: options.id,
+    config,
+    handler
+  };
+}
+var WorkflowRegistry = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  workflows = /* @__PURE__ */ new Map();
+  /**
+   * Register a workflow
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  register(workflow) {
+    const version = workflow.config.version ?? "1.0.0";
+    const id = workflow.id;
+    if (!this.workflows.has(id)) {
+      this.workflows.set(id, /* @__PURE__ */ new Map());
+    }
+    const versions = this.workflows.get(id);
+    if (versions.has(version)) {
+      throw new Error(
+        `Workflow "${id}" version "${version}" is already registered`
+      );
+    }
+    versions.set(version, workflow);
+  }
+  /**
+   * Get a workflow by ID and optional version
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get(id, version) {
+    const versions = this.workflows.get(id);
+    if (!versions) return void 0;
+    if (version) {
+      return versions.get(version);
+    }
+    return this.getLatest(id);
+  }
+  /**
+   * Get the latest version of a workflow
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  getLatest(id) {
+    const versions = this.workflows.get(id);
+    if (!versions || versions.size === 0) return void 0;
+    const sortedVersions = Array.from(versions.keys()).sort(
+      this.compareVersions
+    );
+    return versions.get(sortedVersions[sortedVersions.length - 1]);
+  }
+  /**
+   * Compare semantic versions
+   */
+  compareVersions(a, b) {
+    const partsA = a.split(".").map(Number);
+    const partsB = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+      const numA = partsA[i] ?? 0;
+      const numB = partsB[i] ?? 0;
+      if (numA !== numB) return numA - numB;
+    }
+    return 0;
+  }
+  /**
+   * Check if a workflow exists
+   */
+  has(id) {
+    const versions = this.workflows.get(id);
+    return versions !== void 0 && versions.size > 0;
+  }
+  /**
+   * Get all registered workflows (latest version of each)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  all() {
+    const result = [];
+    for (const versions of this.workflows.values()) {
+      const sortedVersions = Array.from(versions.keys()).sort(
+        this.compareVersions
+      );
+      const latest = versions.get(sortedVersions[sortedVersions.length - 1]);
+      if (latest) result.push(latest);
+    }
+    return result;
+  }
+  /**
+   * Get all versions of a workflow
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  allVersions(id) {
+    const versions = this.workflows.get(id);
+    if (!versions) return [];
+    return Array.from(versions.values());
+  }
+  /**
+   * Get all workflows with cron schedules
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  scheduled() {
+    return this.all().filter((w) => w.config.cron);
+  }
+  /**
+   * Unregister a workflow or specific version
+   */
+  unregister(id, version) {
+    if (version) {
+      const versions = this.workflows.get(id);
+      return versions?.delete(version) ?? false;
+    }
+    return this.workflows.delete(id);
+  }
+  /**
+   * Clear all workflows
+   */
+  clear() {
+    this.workflows.clear();
+  }
+};
+function parseDuration(duration) {
+  if (typeof duration === "number") {
+    return duration;
+  }
+  const match = duration.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (match) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      case "d":
+        return value * 24 * 60 * 60 * 1e3;
+      default:
+        throw new Error(`Invalid duration unit: ${unit}`);
+    }
+  }
+  const parsed = ms(duration);
+  if (typeof parsed !== "number") {
+    throw new Error(`Invalid duration: ${duration}`);
+  }
+  return parsed;
+}
+function formatDuration(ms2) {
+  if (ms2 < 1e3) {
+    return `${ms2}ms`;
+  }
+  const seconds = Math.floor(ms2 / 1e3);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    const remainingSeconds = seconds % 60;
+    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  const remainingHours = hours % 24;
+  return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
+}
+function createContext(options) {
+  const {
+    event,
+    executionId,
+    runId,
+    attempt,
+    startedAt,
+    storage,
+    onTimelineEvent
+  } = options;
+  const metadata = {};
+  const addTimelineEvent = (type, data, stepName) => {
+    const timelineEvent = {
+      id: nanoid(),
+      type,
+      timestamp: /* @__PURE__ */ new Date(),
+      data,
+      stepName
+    };
+    onTimelineEvent?.(timelineEvent);
+    return timelineEvent;
+  };
+  const step = {
+    async run(name, fn, options2) {
+      const cacheKey = options2?.idempotencyKey ?? name;
+      const cached = await storage.execution.getStepResult(
+        executionId,
+        cacheKey
+      );
+      if (cached) {
+        addTimelineEvent("step:cached", cached.data, name);
+        return cached.data;
+      }
+      addTimelineEvent("step:start", { name }, name);
+      const stepStartedAt = /* @__PURE__ */ new Date();
+      try {
+        let result;
+        if (options2?.timeout) {
+          const timeoutMs = parseDuration(options2.timeout);
+          result = await Promise.race([
+            Promise.resolve(fn()),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(new StepTimeoutError(name, timeoutMs)),
+                timeoutMs
+              )
+            )
+          ]);
+        } else {
+          result = await fn();
+        }
+        const completedAt = /* @__PURE__ */ new Date();
+        const durationMs = completedAt.getTime() - stepStartedAt.getTime();
+        await storage.execution.saveStepResult(executionId, cacheKey, {
+          data: result,
+          startedAt: stepStartedAt,
+          completedAt,
+          durationMs
+        });
+        addTimelineEvent("step:complete", result, name);
+        return result;
+      } catch (error) {
+        addTimelineEvent(
+          "step:failed",
+          {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+          },
+          name
+        );
+        throw error;
+      }
+    },
+    async parallel(name, fns, options2) {
+      const cacheKey = options2?.idempotencyKey ?? name;
+      const cached = await storage.execution.getStepResult(
+        executionId,
+        cacheKey
+      );
+      if (cached) {
+        addTimelineEvent("step:cached", cached.data, name);
+        return cached.data;
+      }
+      addTimelineEvent(
+        "step:start",
+        { name, parallel: true, count: fns.length },
+        name
+      );
+      const stepStartedAt = /* @__PURE__ */ new Date();
+      try {
+        let results;
+        if (options2?.timeout) {
+          const timeoutMs = parseDuration(options2.timeout);
+          results = await Promise.race([
+            Promise.all(fns.map((fn) => fn())),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(new StepTimeoutError(name, timeoutMs)),
+                timeoutMs
+              )
+            )
+          ]);
+        } else {
+          results = await Promise.all(fns.map((fn) => fn()));
+        }
+        const completedAt = /* @__PURE__ */ new Date();
+        const durationMs = completedAt.getTime() - stepStartedAt.getTime();
+        await storage.execution.saveStepResult(executionId, cacheKey, {
+          data: results,
+          startedAt: stepStartedAt,
+          completedAt,
+          durationMs
+        });
+        addTimelineEvent("step:complete", results, name);
+        return results;
+      } catch (error) {
+        addTimelineEvent("step:failed", error, name);
+        throw error;
+      }
+    },
+    async invoke(workflowId, payload, invokeOptions) {
+      const stepName = `invoke:${workflowId}`;
+      const cached = await storage.execution.getStepResult(
+        executionId,
+        stepName
+      );
+      if (cached) {
+        addTimelineEvent("step:cached", cached.data, stepName);
+        return cached.data;
+      }
+      const childExecutionId = nanoid();
+      addTimelineEvent(
+        "invoke:start",
+        { workflowId, childExecutionId, payload, options: invokeOptions },
+        stepName
+      );
+      throw new InvokeInterrupt(
+        stepName,
+        workflowId,
+        payload,
+        childExecutionId,
+        invokeOptions
+      );
+    },
+    async sendEvent(eventId, data) {
+      await storage.events.publish(eventId, data);
+      addTimelineEvent("event:received", { eventId, data });
+    }
+  };
+  const log = {
+    info(message, data) {
+      addTimelineEvent("log:info", { message, ...data });
+    },
+    warn(message, data) {
+      addTimelineEvent("log:warn", { message, ...data });
+    },
+    error(message, data) {
+      addTimelineEvent("log:error", { message, ...data });
+    },
+    debug(message, data) {
+      addTimelineEvent("log:debug", { message, ...data });
+    }
+  };
+  const context = {
+    event,
+    execution: {
+      id: executionId,
+      runId,
+      attempt,
+      startedAt
+    },
+    step,
+    log,
+    async sleep(name, duration) {
+      const cached = await storage.execution.getStepResult(executionId, name);
+      if (cached) {
+        addTimelineEvent("sleep:complete", { name, cached: true }, name);
+        return;
+      }
+      const durationMs = parseDuration(duration);
+      const wakeAt = new Date(Date.now() + durationMs);
+      addTimelineEvent("sleep:start", { name, durationMs, wakeAt }, name);
+      await storage.execution.update(executionId, {
+        status: "sleeping",
+        metadata: {
+          ...metadata,
+          _sleepName: name,
+          _sleepWakeAt: wakeAt.toISOString()
+        }
+      });
+      await storage.queue.schedule(
+        {
+          id: nanoid(),
+          workflowId: event.name,
+          eventName: `__resume:${executionId}`,
+          payload: { sleepName: name },
+          metadata: { executionId, type: "sleep-wake" },
+          priority: 0,
+          attempts: 0,
+          maxAttempts: 1,
+          createdAt: /* @__PURE__ */ new Date()
+        },
+        wakeAt
+      );
+      await storage.execution.saveStepResult(executionId, name, {
+        data: { sleptUntil: wakeAt },
+        startedAt: /* @__PURE__ */ new Date(),
+        completedAt: wakeAt,
+        durationMs
+      });
+      throw new SleepInterrupt(name, wakeAt);
+    },
+    async sleepUntil(name, timestamp) {
+      const now = /* @__PURE__ */ new Date();
+      const durationMs = Math.max(0, timestamp.getTime() - now.getTime());
+      return context.sleep(name, durationMs);
+    },
+    async waitForEvent(name, eventId, waitOptions) {
+      const cached = await storage.execution.getStepResult(executionId, name);
+      if (cached) {
+        addTimelineEvent("step:cached", cached.data, name);
+        return cached.data;
+      }
+      const timeoutMs = waitOptions?.timeout ? parseDuration(waitOptions.timeout) : 24 * 60 * 60 * 1e3;
+      const timeoutAt = new Date(Date.now() + timeoutMs);
+      addTimelineEvent("event:wait", { name, eventId, timeoutAt }, name);
+      await storage.events.subscribe(eventId, executionId, timeoutAt);
+      await storage.execution.update(executionId, {
+        status: "waiting",
+        metadata: {
+          ...metadata,
+          _waitEventId: eventId,
+          _waitTimeoutAt: timeoutAt.toISOString()
+        }
+      });
+      await storage.queue.schedule(
+        {
+          id: nanoid(),
+          workflowId: event.name,
+          eventName: `__timeout:${executionId}`,
+          payload: { eventId, stepName: name },
+          metadata: { executionId, type: "event-timeout" },
+          priority: 0,
+          attempts: 0,
+          maxAttempts: 1,
+          createdAt: /* @__PURE__ */ new Date()
+        },
+        timeoutAt
+      );
+      throw new WaitForEventInterrupt(name, eventId, timeoutAt);
+    },
+    async setMetadata(key, value) {
+      metadata[key] = value;
+      addTimelineEvent("metadata:update", { [key]: value });
+      await storage.execution.update(executionId, { metadata });
+      await storage.realtime.publish(`execution:${executionId}`, { metadata });
+    },
+    getMetadata(key) {
+      return metadata[key];
+    }
+  };
+  return context;
+}
+var StepTimeoutError = class extends Error {
+  constructor(stepName, timeoutMs) {
+    super(`Step "${stepName}" timed out after ${timeoutMs}ms`);
+    this.stepName = stepName;
+    this.timeoutMs = timeoutMs;
+    this.name = "StepTimeoutError";
+  }
+};
+var SleepInterrupt = class extends Error {
+  constructor(stepName, wakeAt) {
+    super(`Sleep interrupt: ${stepName}`);
+    this.stepName = stepName;
+    this.wakeAt = wakeAt;
+    this.name = "SleepInterrupt";
+  }
+};
+var WaitForEventInterrupt = class extends Error {
+  constructor(stepName, eventId, timeoutAt) {
+    super(`WaitForEvent interrupt: ${stepName}`);
+    this.stepName = stepName;
+    this.eventId = eventId;
+    this.timeoutAt = timeoutAt;
+    this.name = "WaitForEventInterrupt";
+  }
+};
+var InvokeInterrupt = class extends Error {
+  constructor(stepName, workflowId, payload, childExecutionId, options) {
+    super(`Invoke interrupt: ${stepName} -> ${workflowId}`);
+    this.stepName = stepName;
+    this.workflowId = workflowId;
+    this.payload = payload;
+    this.childExecutionId = childExecutionId;
+    this.options = options;
+    this.name = "InvokeInterrupt";
+  }
+};
+
+// src/worker.ts
+var Worker = class extends EventEmitter {
+  storage;
+  registry;
+  concurrency;
+  pollInterval;
+  workerId;
+  logging;
+  running = false;
+  activeJobs = 0;
+  pollTimeout;
+  constructor(options) {
+    super();
+    this.storage = options.storage;
+    this.registry = options.registry;
+    this.concurrency = options.concurrency ?? 1;
+    this.pollInterval = options.pollInterval ?? 1e3;
+    this.workerId = options.workerId ?? `worker-${nanoid(8)}`;
+    this.logging = options.logging ?? false;
+  }
+  /**
+   * Start the worker
+   */
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    this.log("Worker started", { concurrency: this.concurrency });
+    this.poll();
+  }
+  /**
+   * Stop the worker gracefully
+   */
+  async stop() {
+    this.running = false;
+    if (this.pollTimeout) {
+      clearTimeout(this.pollTimeout);
+    }
+    while (this.activeJobs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    this.log("Worker stopped");
+  }
+  /**
+   * Poll for jobs
+   */
+  async poll() {
+    if (!this.running) return;
+    while (this.running && this.activeJobs < this.concurrency) {
+      const job = await this.storage.queue.pop({
+        workerId: this.workerId,
+        lockDuration: 3e4
+      });
+      if (!job) break;
+      this.activeJobs++;
+      this.processJob(job).finally(() => {
+        this.activeJobs--;
+      });
+    }
+    this.pollTimeout = setTimeout(() => this.poll(), this.pollInterval);
+  }
+  /**
+   * Process a single job
+   */
+  async processJob(job) {
+    this.log("Processing job", { jobId: job.id, workflowId: job.workflowId });
+    try {
+      if (job.eventName.startsWith("__resume:")) {
+        await this.handleResume(job);
+        return;
+      }
+      if (job.eventName.startsWith("__timeout:")) {
+        await this.handleTimeout(job);
+        return;
+      }
+      if (job.eventName.startsWith("__invoke-complete:")) {
+        await this.handleInvokeComplete(job);
+        return;
+      }
+      const executionId = job.metadata.executionId;
+      let workflowVersion;
+      if (executionId) {
+        const execution = await this.storage.execution.get(executionId);
+        workflowVersion = execution?.workflowVersion;
+      }
+      const workflow = this.registry.get(job.workflowId, workflowVersion);
+      if (!workflow) {
+        this.log("Workflow not found", { workflowId: job.workflowId });
+        await this.storage.queue.ack(job.id);
+        return;
+      }
+      await this.executeWorkflow(workflow, job);
+    } catch (error) {
+      this.log("Job processing error", { error });
+      this.emit("error", { error });
+      await this.storage.queue.nack(job.id, {
+        delay: 1e3 * Math.pow(2, job.attempts)
+        // Exponential backoff
+      });
+    }
+  }
+  /**
+   * Execute a workflow
+   */
+  async executeWorkflow(workflow, job) {
+    const runId = job.metadata.runId ?? nanoid();
+    const executionId = job.metadata.executionId ?? nanoid();
+    const attempt = job.attempts + 1;
+    let execution = await this.storage.execution.get(executionId);
+    if (!execution) {
+      execution = {
+        id: executionId,
+        runId,
+        workflowId: workflow.id,
+        workflowVersion: workflow.config.version ?? "1.0.0",
+        eventName: job.eventName,
+        payload: job.payload,
+        status: "running",
+        steps: [],
+        metadata: job.metadata,
+        attempt,
+        startedAt: /* @__PURE__ */ new Date(),
+        timeline: []
+      };
+      await this.storage.execution.create(execution);
+    } else {
+      await this.storage.execution.update(executionId, {
+        status: "running",
+        attempt
+      });
+    }
+    this.emit("execution:start", {
+      executionId,
+      workflowId: workflow.id,
+      eventName: job.eventName
+    });
+    const event = {
+      id: job.id,
+      name: job.eventName,
+      data: job.payload,
+      timestamp: job.createdAt,
+      metadata: job.metadata
+    };
+    const context = createContext({
+      event,
+      executionId,
+      runId,
+      attempt,
+      startedAt: execution.startedAt,
+      storage: this.storage,
+      onTimelineEvent: (timelineEvent) => {
+        this.handleTimelineEvent(executionId, timelineEvent);
+      }
+    });
+    try {
+      const result = await workflow.handler(context);
+      await this.storage.execution.update(executionId, {
+        status: "completed",
+        result,
+        completedAt: /* @__PURE__ */ new Date()
+      });
+      await this.storage.queue.ack(job.id);
+      this.emit("execution:complete", { executionId, result });
+      this.log("Workflow completed", { executionId, workflowId: workflow.id });
+      await this.storage.realtime.publish(`execution:${executionId}`, {
+        status: "completed",
+        result
+      });
+      const parentExecutionId = job.metadata.parentExecutionId;
+      const parentStepName = job.metadata.parentStepName;
+      if (parentExecutionId && parentStepName) {
+        await this.storage.queue.push({
+          id: nanoid(),
+          workflowId: job.workflowId,
+          eventName: `__invoke-complete:${parentExecutionId}`,
+          payload: {
+            parentExecutionId,
+            parentStepName,
+            childExecutionId: executionId,
+            result
+          },
+          metadata: {
+            executionId: parentExecutionId,
+            type: "invoke-complete"
+          },
+          priority: 0,
+          attempts: 0,
+          maxAttempts: 1,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+    } catch (error) {
+      if (error instanceof SleepInterrupt) {
+        await this.storage.queue.ack(job.id);
+        this.emit("execution:sleeping", {
+          executionId,
+          wakeAt: error.wakeAt
+        });
+        this.log("Workflow sleeping", {
+          executionId,
+          stepName: error.stepName,
+          wakeAt: error.wakeAt
+        });
+        return;
+      }
+      if (error instanceof WaitForEventInterrupt) {
+        await this.storage.queue.ack(job.id);
+        this.emit("execution:waiting", {
+          executionId,
+          eventId: error.eventId,
+          timeoutAt: error.timeoutAt
+        });
+        this.log("Workflow waiting for event", {
+          executionId,
+          stepName: error.stepName,
+          eventId: error.eventId
+        });
+        return;
+      }
+      if (error instanceof InvokeInterrupt) {
+        await this.storage.queue.ack(job.id);
+        const childJob = {
+          id: nanoid(),
+          workflowId: error.workflowId,
+          eventName: error.workflowId,
+          payload: error.payload,
+          metadata: {
+            ...error.options?.metadata ?? {},
+            parentExecutionId: executionId,
+            parentStepName: error.stepName,
+            runId,
+            executionId: error.childExecutionId
+          },
+          priority: 0,
+          attempts: 0,
+          maxAttempts: workflow.config.retries ?? 0,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        await this.storage.queue.push(childJob);
+        const invokeMetadata = {
+          ...execution.metadata,
+          _invokeWorkflowId: error.workflowId,
+          _invokeChildExecutionId: error.childExecutionId,
+          _invokeStepName: error.stepName
+        };
+        await this.storage.execution.update(executionId, {
+          status: "waiting",
+          metadata: invokeMetadata
+        });
+        await this.storage.realtime.publish(`execution:${executionId}`, {
+          status: "waiting",
+          metadata: invokeMetadata
+        });
+        this.emit("execution:invoking", {
+          executionId,
+          childExecutionId: error.childExecutionId,
+          childWorkflowId: error.workflowId
+        });
+        this.log("Workflow invoking child", {
+          executionId,
+          stepName: error.stepName,
+          childWorkflowId: error.workflowId,
+          childExecutionId: error.childExecutionId
+        });
+        return;
+      }
+      const err = error;
+      const willRetry = workflow.config.retries !== void 0 && attempt <= workflow.config.retries;
+      await this.storage.execution.update(executionId, {
+        status: willRetry ? "pending" : "failed",
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack
+        }
+      });
+      if (willRetry) {
+        const delay = workflow.config.retryDelay ? parseDuration(workflow.config.retryDelay) : 1e3;
+        await this.storage.queue.nack(job.id, {
+          delay: delay * Math.pow(2, attempt - 1)
+        });
+      } else {
+        await this.storage.queue.ack(job.id);
+      }
+      this.emit("execution:failed", { executionId, error: err, willRetry });
+      this.log("Workflow failed", {
+        executionId,
+        error: err.message,
+        willRetry
+      });
+      await this.storage.realtime.publish(`execution:${executionId}`, {
+        status: "failed",
+        error: { name: err.name, message: err.message }
+      });
+    }
+  }
+  /**
+   * Handle resume from sleep
+   */
+  async handleResume(job) {
+    const executionId = job.metadata.executionId;
+    const execution = await this.storage.execution.get(executionId);
+    if (!execution) {
+      await this.storage.queue.ack(job.id);
+      return;
+    }
+    const workflow = this.registry.get(
+      execution.workflowId,
+      execution.workflowVersion
+    );
+    if (!workflow) {
+      await this.storage.queue.ack(job.id);
+      return;
+    }
+    this.log("Resuming workflow from sleep", { executionId });
+    await this.executeWorkflow(workflow, {
+      ...job,
+      workflowId: execution.workflowId,
+      eventName: execution.eventName,
+      payload: execution.payload,
+      metadata: { ...execution.metadata, executionId, runId: execution.runId }
+    });
+  }
+  /**
+   * Handle event timeout
+   */
+  async handleTimeout(job) {
+    const executionId = job.metadata.executionId;
+    const stepName = job.payload.stepName;
+    const execution = await this.storage.execution.get(executionId);
+    if (!execution || execution.status !== "waiting") {
+      await this.storage.queue.ack(job.id);
+      return;
+    }
+    this.log("Event wait timeout", { executionId, stepName });
+    await this.storage.execution.saveStepResult(executionId, stepName, {
+      data: { eventData: null, timeout: true },
+      startedAt: /* @__PURE__ */ new Date(),
+      completedAt: /* @__PURE__ */ new Date(),
+      durationMs: 0
+    });
+    const workflow = this.registry.get(
+      execution.workflowId,
+      execution.workflowVersion
+    );
+    if (workflow) {
+      await this.executeWorkflow(workflow, {
+        ...job,
+        workflowId: execution.workflowId,
+        eventName: execution.eventName,
+        payload: execution.payload,
+        metadata: {
+          ...execution.metadata,
+          executionId,
+          runId: execution.runId
+        }
+      });
+    }
+    await this.storage.queue.ack(job.id);
+  }
+  /**
+   * Handle child workflow completion
+   */
+  async handleInvokeComplete(job) {
+    const executionId = job.metadata.executionId;
+    const execution = await this.storage.execution.get(executionId);
+    if (!execution) {
+      await this.storage.queue.ack(job.id);
+      return;
+    }
+    const payload = job.payload;
+    await this.storage.execution.saveStepResult(
+      executionId,
+      payload.parentStepName,
+      {
+        data: payload.result,
+        startedAt: /* @__PURE__ */ new Date(),
+        completedAt: /* @__PURE__ */ new Date(),
+        durationMs: 0
+      }
+    );
+    const workflow = this.registry.get(
+      execution.workflowId,
+      execution.workflowVersion
+    );
+    if (workflow) {
+      await this.executeWorkflow(workflow, {
+        ...job,
+        workflowId: execution.workflowId,
+        eventName: execution.eventName,
+        payload: execution.payload,
+        metadata: {
+          ...execution.metadata,
+          executionId,
+          runId: execution.runId
+        }
+      });
+    }
+    await this.storage.queue.ack(job.id);
+  }
+  /**
+   * Handle timeline events
+   */
+  handleTimelineEvent(executionId, event) {
+    if (event.type === "step:complete") {
+      this.emit("step:complete", {
+        executionId,
+        stepName: event.stepName,
+        result: event.data
+      });
+    }
+    if (event.type === "step:failed") {
+      this.emit("step:failed", {
+        executionId,
+        stepName: event.stepName,
+        error: event.data
+      });
+    }
+    this.storage.realtime.publish(`execution:${executionId}`, event);
+  }
+  /**
+   * Log helper
+   */
+  log(message, data) {
+    if (this.logging) {
+      console.log(`[${this.workerId}] ${message}`, data ?? "");
+    }
+  }
+};
+function createAccessToken(data, secret, expirySeconds) {
+  const payload = {
+    runId: data.runId,
+    executionId: data.executionId,
+    exp: Math.floor(Date.now() / 1e3) + expirySeconds
+  };
+  const payloadStr = Buffer.from(JSON.stringify(payload)).toString("base64url");
+  const signature = createHmac("sha256", secret).update(payloadStr).digest("base64url");
+  return `${payloadStr}.${signature}`;
+}
+function verifyAccessToken(token, secret) {
+  const parts = token.split(".");
+  if (parts.length !== 2) {
+    return null;
+  }
+  const [payloadStr, signature] = parts;
+  const expectedSignature = createHmac("sha256", secret).update(payloadStr).digest("base64url");
+  if (signature !== expectedSignature) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(
+      Buffer.from(payloadStr, "base64url").toString()
+    );
+    if (payload.exp < Math.floor(Date.now() / 1e3)) {
+      return null;
+    }
+    return payload;
+  } catch {
+    return null;
+  }
+}
+
+// src/stepflow.ts
+var Stepflow = class extends EventEmitter {
+  storage;
+  registry;
+  worker;
+  triggers = /* @__PURE__ */ new Map();
+  logging;
+  tokenSecret;
+  tokenExpiry;
+  constructor(options) {
+    super();
+    this.storage = options.storage;
+    this.logging = options.logging ?? false;
+    this.tokenSecret = options.tokenSecret ?? nanoid(32);
+    this.tokenExpiry = options.tokenExpiry ?? 3600;
+    this.registry = new WorkflowRegistry();
+    this.worker = new Worker({
+      storage: this.storage,
+      registry: this.registry,
+      concurrency: options.concurrency ?? 1,
+      logging: this.logging
+    });
+    this.worker.on(
+      "execution:start",
+      (data) => this.emit("execution:start", data)
+    );
+    this.worker.on(
+      "execution:complete",
+      (data) => this.emit("execution:complete", data)
+    );
+    this.worker.on(
+      "execution:failed",
+      (data) => this.emit("execution:failed", data)
+    );
+    this.worker.on(
+      "execution:sleeping",
+      (data) => this.emit("execution:sleeping", data)
+    );
+    this.worker.on(
+      "execution:waiting",
+      (data) => this.emit("execution:waiting", data)
+    );
+    this.worker.on("step:complete", (data) => this.emit("step:complete", data));
+    this.worker.on("step:failed", (data) => this.emit("step:failed", data));
+    this.worker.on("error", (data) => this.emit("error", data));
+  }
+  /**
+   * Register a workflow
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  register(workflow) {
+    this.registry.register(workflow);
+    this.log("Registered workflow", { id: workflow.id });
+    return this;
+  }
+  /**
+   * Register multiple workflows
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  registerAll(workflows) {
+    for (const workflow of workflows) {
+      this.register(workflow);
+    }
+    return this;
+  }
+  /**
+   * Add a trigger
+   */
+  addTrigger(name, trigger) {
+    this.triggers.set(name, trigger);
+    return this;
+  }
+  /**
+   * Start the orchestrator
+   */
+  async start() {
+    await this.storage.connect();
+    await this.worker.start();
+    for (const [name, trigger] of this.triggers) {
+      await trigger.start(this.handleTrigger.bind(this));
+      this.log("Started trigger", { name, type: trigger.type });
+    }
+    this.log("Stepflow started");
+  }
+  /**
+   * Stop the orchestrator
+   */
+  async stop() {
+    for (const [name, trigger] of this.triggers) {
+      await trigger.stop();
+    }
+    await this.worker.stop();
+    await this.storage.disconnect();
+    this.log("Stepflow stopped");
+  }
+  /**
+   * Trigger a workflow execution
+   */
+  async trigger(workflowId, payload, options) {
+    const workflow = this.registry.get(workflowId);
+    if (!workflow) {
+      throw new Error(`Workflow "${workflowId}" not found`);
+    }
+    if (options?.idempotencyKey) {
+      const existing = await this.storage.execution.getByIdempotencyKey(
+        workflowId,
+        options.idempotencyKey
+      );
+      if (existing) {
+        this.log("Deduplicated workflow trigger", {
+          workflowId,
+          runId: existing.runId,
+          executionId: existing.id,
+          idempotencyKey: options.idempotencyKey
+        });
+        return {
+          runId: existing.runId,
+          executionId: existing.id,
+          publicAccessToken: this.createPublicToken(
+            existing.runId,
+            existing.id
+          ),
+          deduplicated: true
+        };
+      }
+    }
+    const runId = options?.runId ?? nanoid();
+    const executionId = nanoid();
+    const job = {
+      id: nanoid(),
+      workflowId,
+      eventName: workflowId,
+      payload,
+      metadata: {
+        ...options?.metadata,
+        workflowVersion: workflow.config.version ?? "1.0.0",
+        idempotencyKey: options?.idempotencyKey,
+        runId,
+        executionId
+      },
+      priority: 0,
+      attempts: 0,
+      maxAttempts: workflow.config.retries ?? 0,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    if (options?.delay) {
+      await this.storage.queue.schedule(
+        job,
+        new Date(Date.now() + options.delay)
+      );
+    } else {
+      await this.storage.queue.push(job);
+    }
+    const publicAccessToken = createAccessToken(
+      { runId, executionId },
+      this.tokenSecret,
+      this.tokenExpiry
+    );
+    this.log("Triggered workflow", { workflowId, runId, executionId });
+    return {
+      runId,
+      executionId,
+      publicAccessToken
+    };
+  }
+  /**
+   * Get a run by ID
+   */
+  async getRun(runId, options) {
+    if (options?.accessToken) {
+      const payload = verifyAccessToken(options.accessToken, this.tokenSecret);
+      if (!payload || payload.runId !== runId) {
+        throw new Error("Invalid access token");
+      }
+    }
+    const executions = await this.storage.execution.list({ runId, limit: 1 });
+    return executions[0] ?? null;
+  }
+  /**
+   * Get execution by ID
+   */
+  async getExecution(executionId) {
+    return this.storage.execution.get(executionId);
+  }
+  /**
+   * List executions
+   */
+  async listRuns(options) {
+    return this.storage.execution.list(options ?? {});
+  }
+  /**
+   * Notify an event (for waitForEvent)
+   */
+  async notify(eventId, data) {
+    const waiters = await this.storage.events.getWaiters(eventId);
+    const count = await this.storage.events.publish(eventId, data);
+    for (const waiter of waiters) {
+      const execution = await this.storage.execution.get(waiter.executionId);
+      if (execution && execution.status === "waiting") {
+        const stepName = execution.metadata._waitEventId;
+        await this.storage.execution.saveStepResult(
+          waiter.executionId,
+          stepName,
+          {
+            data: { eventData: data, timeout: false },
+            startedAt: /* @__PURE__ */ new Date(),
+            completedAt: /* @__PURE__ */ new Date(),
+            durationMs: 0
+          }
+        );
+        await this.storage.queue.push({
+          id: nanoid(),
+          workflowId: execution.workflowId,
+          eventName: `__resume:${waiter.executionId}`,
+          payload: { eventId, data },
+          metadata: { executionId: waiter.executionId, type: "event-resume" },
+          priority: 0,
+          attempts: 0,
+          maxAttempts: 1,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    return {
+      waiters: count,
+      executions: waiters.map((w) => w.executionId)
+    };
+  }
+  /**
+   * Create a public access token for a run
+   */
+  createPublicToken(runId, executionId) {
+    return createAccessToken(
+      { runId, executionId },
+      this.tokenSecret,
+      this.tokenExpiry
+    );
+  }
+  /**
+   * Subscribe to run updates
+   */
+  subscribeToRun(runId, callback) {
+    return this.storage.realtime.subscribe(`run:${runId}`, (data) => {
+      callback(data);
+    });
+  }
+  /**
+   * Subscribe to execution updates
+   */
+  subscribeToExecution(executionId, callback) {
+    return this.storage.realtime.subscribe(
+      `execution:${executionId}`,
+      callback
+    );
+  }
+  /**
+   * Handle trigger events
+   */
+  async handleTrigger(event) {
+    const workflow = this.registry.get(event.source);
+    if (!workflow) {
+      this.log("No workflow found for trigger", { source: event.source });
+      return;
+    }
+    await this.trigger(workflow.id, event.data, {
+      metadata: {
+        triggerType: event.type,
+        ...event.metadata
+      }
+    });
+  }
+  /**
+   * Get a trigger by name
+   */
+  getTrigger(type, ...args) {
+    for (const [name, trigger] of this.triggers) {
+      if (trigger.type === type) {
+        return trigger;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Health check
+   */
+  async healthCheck() {
+    return this.storage.healthCheck();
+  }
+  /**
+   * Get workflow registry
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Log helper
+   */
+  log(message, data) {
+    if (this.logging) {
+      console.log(`[Stepflow] ${message}`, data ?? "");
+    }
+  }
+};
+
+export { InvokeInterrupt, SleepInterrupt, StepTimeoutError, Stepflow, WaitForEventInterrupt, Worker, WorkflowRegistry, createAccessToken, createContext, createWorkflow, formatDuration, parseDuration, verifyAccessToken };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map