flowfn 0.0.1

package/dist/index.mjs

@@ -0,0 +1,3088 @@
+// src/adapters/memory.ts
+import { EventEmitter } from "eventemitter3";
+var MemoryAdapter = class {
+  constructor() {
+    this.queues = /* @__PURE__ */ new Map();
+    this.allJobs = /* @__PURE__ */ new Map();
+    this.streams = /* @__PURE__ */ new Map();
+    this.streamEmitters = /* @__PURE__ */ new Map();
+    this.workflowStates = /* @__PURE__ */ new Map();
+  }
+  async enqueue(queueName, job) {
+    if (!this.queues.has(queueName)) {
+      this.queues.set(queueName, []);
+    }
+    const queue = this.queues.get(queueName);
+    queue.push(job);
+    this.allJobs.set(job.id, job);
+    return job.id;
+  }
+  async dequeue(queueName) {
+    const queue = this.queues.get(queueName);
+    if (!queue || queue.length === 0) return null;
+    return queue.shift() || null;
+  }
+  async ack(queue, jobId) {
+    const job = this.allJobs.get(jobId);
+    if (job) {
+      job.state = "completed";
+      job.finishedOn = Date.now();
+    }
+  }
+  async nack(queueName, jobId, requeue = true) {
+    const job = this.allJobs.get(jobId);
+    if (job && requeue) {
+      job.state = "waiting";
+      const queue = this.queues.get(queueName);
+      if (queue) queue.push(job);
+    }
+  }
+  async getJob(queueName, jobId) {
+    return this.allJobs.get(jobId) || null;
+  }
+  async getJobs(queue, status) {
+    return Array.from(this.allJobs.values()).filter(
+      (job) => job.state === status
+    );
+  }
+  async getAllJobs(queue) {
+    return Array.from(this.allJobs.values());
+  }
+  async cleanJobs(queue, grace, status) {
+    const now2 = Date.now();
+    const jobsToClean = [];
+    for (const [id, job] of this.allJobs.entries()) {
+      if (job.state === status) {
+        const timestamp2 = job.finishedOn || job.timestamp;
+        if (now2 - timestamp2 > grace) {
+          jobsToClean.push(id);
+        }
+      }
+    }
+    for (const id of jobsToClean) {
+      this.allJobs.delete(id);
+    }
+    return jobsToClean.length;
+  }
+  async publish(streamName, message) {
+    if (!this.streams.has(streamName)) {
+      this.streams.set(streamName, []);
+      this.streamEmitters.set(streamName, new EventEmitter());
+    }
+    const stream = this.streams.get(streamName);
+    stream.push(message);
+    this.streamEmitters.get(streamName).emit("message", message);
+    return message.id;
+  }
+  async subscribe(streamName, handler) {
+    if (!this.streamEmitters.has(streamName)) {
+      this.streamEmitters.set(streamName, new EventEmitter());
+      this.streams.set(streamName, []);
+    }
+    const emitter = this.streamEmitters.get(streamName);
+    const wrapper = (msg) => {
+      handler(msg).catch((err) => console.error("Stream handler error", err));
+    };
+    emitter.on("message", wrapper);
+    return {
+      unsubscribe: async () => {
+        emitter.off("message", wrapper);
+      }
+    };
+  }
+  async consume(stream, group, consumer, handler) {
+    return this.subscribe(stream, handler);
+  }
+  async createConsumerGroup(stream, group) {
+  }
+  async saveWorkflowState(workflowId, state) {
+    this.workflowStates.set(workflowId, state);
+  }
+  async loadWorkflowState(workflowId) {
+    return this.workflowStates.get(workflowId) || null;
+  }
+  async getQueueStats(queueName) {
+    const length = this.queues.get(queueName)?.length || 0;
+    const allInQueue = Array.from(this.allJobs.values()).filter(
+      (j) => j.state === "completed"
+    ).length;
+    return {
+      waiting: length,
+      active: 0,
+      completed: allInQueue,
+      failed: 0,
+      delayed: 0,
+      paused: 0
+    };
+  }
+  async getStreamInfo(streamName) {
+    const length = this.streams.get(streamName)?.length || 0;
+    return {
+      name: streamName,
+      length,
+      groups: 0
+    };
+  }
+  async cleanup() {
+    this.queues.clear();
+    this.allJobs.clear();
+    this.streams.clear();
+    this.workflowStates.clear();
+    this.streamEmitters.clear();
+  }
+};
+
+// src/queue/job.ts
+import { v4 as uuidv4 } from "uuid";
+var JobImpl = class {
+  constructor(name, data, opts) {
+    this.state = "waiting";
+    this.progress = 0;
+    this.delay = 0;
+    this.attemptsMade = 0;
+    this.id = opts?.jobId || uuidv4();
+    this.name = name;
+    this.data = data;
+    this.opts = opts || {};
+    this.timestamp = Date.now();
+  }
+  async update(data) {
+    this.data = { ...this.data, ...data };
+  }
+  async log(message) {
+  }
+  async updateProgress(progress) {
+    this.progress = progress;
+  }
+  async moveToCompleted(returnValue) {
+    this.state = "completed";
+    this.returnvalue = returnValue;
+    this.finishedOn = Date.now();
+  }
+  async moveToFailed(error) {
+    this.state = "failed";
+    this.failedReason = error.message;
+    this.finishedOn = Date.now();
+  }
+  async retry() {
+  }
+  async discard() {
+  }
+  async waitUntilFinished() {
+    return Promise.resolve();
+  }
+};
+
+// src/queue/queue.ts
+import EventEmitter2 from "eventemitter3";
+
+// src/patterns/backoff.ts
+function calculateBackoff(attemptsMade, options) {
+  const { type, delay, maxDelay } = options;
+  let resultDelay;
+  switch (type) {
+    case "fixed":
+      resultDelay = delay;
+      break;
+    case "exponential":
+      resultDelay = delay * Math.pow(2, attemptsMade - 1);
+      break;
+    case "custom":
+      resultDelay = delay;
+      break;
+    default:
+      resultDelay = delay;
+  }
+  if (maxDelay && resultDelay > maxDelay) {
+    return maxDelay;
+  }
+  return resultDelay;
+}
+
+// src/queue/queue.ts
+var QueueImpl = class extends EventEmitter2 {
+  constructor(name, adapter, options = {}) {
+    super();
+    this.isProcessing = false;
+    this.currentWorkers = /* @__PURE__ */ new Set();
+    this.name = name;
+    this.adapter = adapter;
+    this.options = options;
+  }
+  async add(name, data, opts) {
+    const job = new JobImpl(name, data, {
+      ...this.options.defaultJobOptions,
+      ...opts
+    });
+    await this.adapter.enqueue(this.name, job);
+    this.emit("waiting", job);
+    return job;
+  }
+  async addBulk(jobs2) {
+    return Promise.all(jobs2.map((j) => this.add(j.name, j.data, j.opts)));
+  }
+  process(arg1, arg2, arg3) {
+    let handler;
+    let concurrency = 1;
+    if (typeof arg1 === "number") {
+      concurrency = arg1;
+      handler = arg2;
+    } else if (typeof arg1 === "string") {
+      if (typeof arg2 === "number") {
+        concurrency = arg2;
+        handler = arg3;
+      } else {
+        handler = arg2;
+      }
+    } else {
+      handler = arg1;
+    }
+    this.resume();
+    for (let i = 0; i < concurrency; i++) {
+      const worker = this.startProcessing(handler);
+      this.currentWorkers.add(worker);
+      worker.finally(() => this.currentWorkers.delete(worker));
+    }
+  }
+  async startProcessing(handler) {
+    while (this.isProcessing) {
+      const jobData = await this.adapter.dequeue(this.name);
+      if (jobData) {
+        const job = Object.assign(
+          new JobImpl(jobData.name, jobData.data, jobData.opts),
+          jobData
+        );
+        if (job.opts.waitFor && job.opts.waitFor.length > 0) {
+          let allDone = true;
+          for (const depId of job.opts.waitFor) {
+            const depJob = await this.adapter.getJob(this.name, depId);
+            if (!depJob || depJob.state !== "completed") {
+              allDone = false;
+              break;
+            }
+          }
+          if (!allDone) {
+            await this.adapter.enqueue(this.name, job);
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            continue;
+          }
+        }
+        try {
+          job.state = "active";
+          job.processedOn = Date.now();
+          this.emit("active", job);
+          const result = await handler(job);
+          await job.moveToCompleted(result);
+          await this.adapter.ack(this.name, job.id);
+          this.emit("completed", job, result);
+        } catch (err) {
+          job.attemptsMade++;
+          job.stacktrace = job.stacktrace || [];
+          job.stacktrace.push(err.stack);
+          const maxAttempts = job.opts.attempts || 1;
+          if (job.attemptsMade < maxAttempts) {
+            job.state = "delayed";
+            const backoff = job.opts.backoff ? calculateBackoff(job.attemptsMade, job.opts.backoff) : 0;
+            job.opts.delay = backoff;
+            await this.adapter.enqueue(this.name, job);
+            this.emit("failed", job, err);
+          } else {
+            await job.moveToFailed(err);
+            await this.adapter.ack(this.name, job.id);
+            this.emit("failed", job, err);
+          }
+        }
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+  }
+  processBatch(arg1, arg2, arg3) {
+    let handler;
+    let batchSize = 10;
+    let maxWait = 1e3;
+    if (typeof arg2 === "function") {
+      handler = arg2;
+    } else {
+      handler = arg3;
+      if (typeof arg2 === "number") {
+        batchSize = arg2;
+      } else {
+        batchSize = arg2.batchSize;
+        maxWait = arg2.maxWait || 1e3;
+      }
+    }
+    this.resume();
+    this.startBatchProcessing(handler, batchSize, maxWait);
+  }
+  async startBatchProcessing(handler, batchSize, maxWait) {
+    while (this.isProcessing) {
+      const batch2 = [];
+      const start = Date.now();
+      while (batch2.length < batchSize && Date.now() - start < maxWait) {
+        const jobData = await this.adapter.dequeue(this.name);
+        if (jobData) {
+          const job = Object.assign(
+            new JobImpl(jobData.name, jobData.data, jobData.opts),
+            jobData
+          );
+          batch2.push(job);
+        } else {
+          await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+      }
+      if (batch2.length > 0) {
+        try {
+          for (const job of batch2) {
+            job.state = "active";
+            job.processedOn = Date.now();
+          }
+          const results = await handler(batch2);
+          for (let i = 0; i < batch2.length; i++) {
+            await batch2[i].moveToCompleted(results[i]);
+            await this.adapter.ack(this.name, batch2[i].id);
+          }
+        } catch (err) {
+          for (const job of batch2) {
+            await job.moveToFailed(err);
+            await this.adapter.ack(this.name, job.id);
+          }
+        }
+      }
+    }
+  }
+  async pause() {
+    this.isProcessing = false;
+  }
+  async resume() {
+    this.isProcessing = true;
+  }
+  async drain() {
+    await Promise.all(this.currentWorkers);
+  }
+  async clean(grace, status) {
+    return this.adapter.cleanJobs(this.name, grace, status);
+  }
+  async getJob(jobId) {
+    const job = await this.adapter.getJob(this.name, jobId);
+    return job;
+  }
+  async getJobs(status) {
+    const jobs2 = await this.adapter.getJobs(this.name, status);
+    return jobs2;
+  }
+  async getJobCounts() {
+    return this.adapter.getQueueStats(this.name);
+  }
+  async close() {
+    this.isProcessing = false;
+    await this.drain();
+  }
+};
+
+// src/stream/stream.ts
+import { v4 as uuidv42 } from "uuid";
+var StreamImpl = class {
+  constructor(name, adapter, options = {}) {
+    this.messages = /* @__PURE__ */ new Map();
+    this.name = name;
+    this.adapter = adapter;
+    this.options = options;
+  }
+  async publish(data, options) {
+    const message = {
+      id: uuidv42(),
+      stream: this.name,
+      data,
+      headers: options?.headers,
+      timestamp: Date.now(),
+      partition: options?.partition,
+      key: options?.key,
+      ack: async () => {
+      },
+      nack: async () => {
+      }
+    };
+    this.messages.set(message.id, message);
+    if (this.options.maxLength && this.messages.size > this.options.maxLength) {
+      await this.trim({ maxLength: this.options.maxLength });
+    }
+    return this.adapter.publish(this.name, message);
+  }
+  async publishBatch(messages2) {
+    return Promise.all(messages2.map((m) => this.publish(m.data, m.options)));
+  }
+  async subscribe(handler, options) {
+    return this.adapter.subscribe(this.name, handler);
+  }
+  createConsumer(consumerId, options) {
+    let subscription = null;
+    let paused = false;
+    return {
+      subscribe: async (handler) => {
+        if (options.fromBeginning && this.messages.size > 0) {
+          const sortedMessages = Array.from(this.messages.values()).sort(
+            (a, b) => a.timestamp - b.timestamp
+          );
+          for (const msg of sortedMessages) {
+            if (!paused) {
+              await handler(msg).catch(console.error);
+            }
+          }
+        }
+        subscription = await this.adapter.consume(
+          this.name,
+          options.groupId,
+          consumerId,
+          handler
+        );
+      },
+      pause: async () => {
+        paused = true;
+      },
+      resume: async () => {
+        paused = false;
+      },
+      close: async () => {
+        if (subscription) await subscription.unsubscribe();
+      }
+    };
+  }
+  async getInfo() {
+    const info = await this.adapter.getStreamInfo(this.name);
+    return {
+      ...info,
+      length: this.messages.size
+    };
+  }
+  async trim(strategy) {
+    const now2 = Date.now();
+    const messagesToDelete = [];
+    if (strategy.maxLength) {
+      const sortedMessages = Array.from(this.messages.entries()).sort(
+        (a, b) => b[1].timestamp - a[1].timestamp
+      );
+      if (sortedMessages.length > strategy.maxLength) {
+        const toRemove = sortedMessages.slice(strategy.maxLength);
+        messagesToDelete.push(...toRemove.map(([id]) => id));
+      }
+    }
+    if (strategy.maxAgeSeconds) {
+      const maxAge = strategy.maxAgeSeconds * 1e3;
+      for (const [id, message] of this.messages.entries()) {
+        if (now2 - message.timestamp > maxAge) {
+          messagesToDelete.push(id);
+        }
+      }
+    }
+    const uniqueToDelete = [...new Set(messagesToDelete)];
+    for (const id of uniqueToDelete) {
+      this.messages.delete(id);
+    }
+    return uniqueToDelete.length;
+  }
+  async getMessages(start, end, count) {
+    const allMessages = Array.from(this.messages.values()).sort(
+      (a, b) => a.timestamp - b.timestamp
+    );
+    let filtered = allMessages.filter((m) => m.id >= start && m.id <= end);
+    if (count !== void 0 && count > 0) {
+      filtered = filtered.slice(0, count);
+    }
+    return filtered;
+  }
+  /**
+   * Replay messages from a specific timestamp
+   */
+  async replay(fromTimestamp, handler) {
+    const messages2 = Array.from(this.messages.values()).filter((m) => m.timestamp >= fromTimestamp).sort((a, b) => a.timestamp - b.timestamp);
+    for (const message of messages2) {
+      await handler(message);
+    }
+    return messages2.length;
+  }
+  /**
+   * Get message count
+   */
+  getMessageCount() {
+    return this.messages.size;
+  }
+  async close() {
+    this.messages.clear();
+  }
+};
+
+// src/workflow/workflow.ts
+import { v4 as uuidv43 } from "uuid";
+
+// src/storage/workflow-storage.ts
+var MemoryWorkflowStorage = class {
+  constructor() {
+    this.executions = /* @__PURE__ */ new Map();
+    this.workflowIndex = /* @__PURE__ */ new Map();
+  }
+  // workflowId -> executionIds
+  async save(workflowId, execution) {
+    this.executions.set(execution.id, { ...execution });
+    if (!this.workflowIndex.has(workflowId)) {
+      this.workflowIndex.set(workflowId, /* @__PURE__ */ new Set());
+    }
+    this.workflowIndex.get(workflowId).add(execution.id);
+  }
+  async get(executionId) {
+    return this.executions.get(executionId) || null;
+  }
+  async list(workflowId, options = {}) {
+    const executionIds = this.workflowIndex.get(workflowId) || /* @__PURE__ */ new Set();
+    let executions = [];
+    for (const id of executionIds) {
+      const execution = this.executions.get(id);
+      if (execution) {
+        if (!options.status || execution.status === options.status) {
+          executions.push(execution);
+        }
+      }
+    }
+    const sortBy = options.sortBy || "createdAt";
+    const sortOrder = options.sortOrder || "desc";
+    executions.sort((a, b) => {
+      const aVal = a[sortBy] || 0;
+      const bVal = b[sortBy] || 0;
+      return sortOrder === "asc" ? aVal - bVal : bVal - aVal;
+    });
+    const offset = options.offset || 0;
+    const limit = options.limit || executions.length;
+    return executions.slice(offset, offset + limit);
+  }
+  async updateStatus(executionId, status) {
+    const execution = this.executions.get(executionId);
+    if (execution) {
+      execution.status = status;
+      execution.updatedAt = Date.now();
+      if (status === "completed" || status === "failed" || status === "cancelled") {
+        execution.completedAt = Date.now();
+      }
+    }
+  }
+  async updateState(executionId, state) {
+    const execution = this.executions.get(executionId);
+    if (execution) {
+      execution.state = { ...execution.state, ...state };
+      execution.updatedAt = Date.now();
+    }
+  }
+  async delete(executionId) {
+    const execution = this.executions.get(executionId);
+    if (execution) {
+      const workflowId = execution.workflowId;
+      const executionIds = this.workflowIndex.get(workflowId);
+      if (executionIds) {
+        executionIds.delete(executionId);
+        if (executionIds.size === 0) {
+          this.workflowIndex.delete(workflowId);
+        }
+      }
+      this.executions.delete(executionId);
+    }
+  }
+  async clean(workflowId, grace) {
+    const now2 = Date.now();
+    const executionIds = this.workflowIndex.get(workflowId) || /* @__PURE__ */ new Set();
+    const toDelete = [];
+    for (const id of executionIds) {
+      const execution = this.executions.get(id);
+      if (execution && execution.completedAt) {
+        if (now2 - execution.completedAt > grace) {
+          toDelete.push(id);
+        }
+      }
+    }
+    for (const id of toDelete) {
+      await this.delete(id);
+    }
+    return toDelete.length;
+  }
+  /**
+   * Clear all executions
+   */
+  clear() {
+    this.executions.clear();
+    this.workflowIndex.clear();
+  }
+};
+
+// src/storage/event-log.ts
+var MemoryEventLog = class {
+  constructor() {
+    this.events = [];
+    this.aggregateVersions = /* @__PURE__ */ new Map();
+    this.subscribers = [];
+  }
+  async append(event) {
+    const version = (this.aggregateVersions.get(event.aggregateId) || 0) + 1;
+    this.aggregateVersions.set(event.aggregateId, version);
+    const fullEvent = {
+      ...event,
+      id: `evt_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+      timestamp: Date.now(),
+      version
+    };
+    this.events.push(fullEvent);
+    for (const subscriber of this.subscribers) {
+      if (this.matchesFilter(fullEvent, subscriber.filter)) {
+        Promise.resolve(subscriber.handler(fullEvent)).catch(
+          (err) => console.error("Event subscriber error:", err)
+        );
+      }
+    }
+    return fullEvent;
+  }
+  async getEvents(filter) {
+    let results = [...this.events];
+    if (filter.aggregateId) {
+      results = results.filter((e) => e.aggregateId === filter.aggregateId);
+    }
+    if (filter.aggregateType) {
+      results = results.filter((e) => e.aggregateType === filter.aggregateType);
+    }
+    if (filter.types && filter.types.length > 0) {
+      results = results.filter((e) => filter.types.includes(e.type));
+    }
+    if (filter.fromVersion !== void 0) {
+      results = results.filter((e) => e.version >= filter.fromVersion);
+    }
+    if (filter.toVersion !== void 0) {
+      results = results.filter((e) => e.version <= filter.toVersion);
+    }
+    if (filter.fromTimestamp !== void 0) {
+      results = results.filter((e) => e.timestamp >= filter.fromTimestamp);
+    }
+    if (filter.toTimestamp !== void 0) {
+      results = results.filter((e) => e.timestamp <= filter.toTimestamp);
+    }
+    results.sort((a, b) => a.version - b.version);
+    const offset = filter.offset || 0;
+    const limit = filter.limit || results.length;
+    return results.slice(offset, offset + limit);
+  }
+  async getAggregateEvents(aggregateId, fromVersion) {
+    return this.getEvents({
+      aggregateId,
+      fromVersion
+    });
+  }
+  async getLatestVersion(aggregateId) {
+    return this.aggregateVersions.get(aggregateId) || 0;
+  }
+  subscribe(handler, filter) {
+    const subscriber = { handler, filter };
+    this.subscribers.push(subscriber);
+    return () => {
+      const index2 = this.subscribers.indexOf(subscriber);
+      if (index2 > -1) {
+        this.subscribers.splice(index2, 1);
+      }
+    };
+  }
+  matchesFilter(event, filter) {
+    if (!filter) return true;
+    if (filter.aggregateId && event.aggregateId !== filter.aggregateId)
+      return false;
+    if (filter.aggregateType && event.aggregateType !== filter.aggregateType)
+      return false;
+    if (filter.types && !filter.types.includes(event.type)) return false;
+    if (filter.fromVersion !== void 0 && event.version < filter.fromVersion)
+      return false;
+    if (filter.toVersion !== void 0 && event.version > filter.toVersion)
+      return false;
+    if (filter.fromTimestamp !== void 0 && event.timestamp < filter.fromTimestamp)
+      return false;
+    if (filter.toTimestamp !== void 0 && event.timestamp > filter.toTimestamp)
+      return false;
+    return true;
+  }
+  /**
+   * Clear all events
+   */
+  clear() {
+    this.events = [];
+    this.aggregateVersions.clear();
+    this.subscribers = [];
+  }
+};
+
+// src/workflow/workflow.ts
+var WorkflowBuilderImpl = class {
+  constructor(name, adapter) {
+    this.steps = [];
+    this.name = name;
+    this.adapter = adapter;
+  }
+  input() {
+    return this;
+  }
+  step(name, handler) {
+    this.steps.push({ type: "step", name, handler });
+    return this;
+  }
+  parallel(steps) {
+    this.steps.push({
+      type: "parallel",
+      steps: steps.map((h, i) => ({
+        type: "step",
+        name: `parallel-${i}`,
+        handler: h
+      }))
+    });
+    return this;
+  }
+  branch(options) {
+    const thenSteps = options.then.steps;
+    const elseSteps = options.else ? options.else.steps : void 0;
+    this.steps.push({
+      type: "branch",
+      condition: options.condition,
+      steps: thenSteps,
+      elseSteps
+    });
+    return this;
+  }
+  saga(name, saga) {
+    this.steps.push({
+      type: "saga",
+      name,
+      handler: saga.execute,
+      compensate: saga.compensate
+    });
+    return this;
+  }
+  delay(duration) {
+    this.steps.push({ type: "delay", options: duration });
+    return this;
+  }
+  delayUntil(condition) {
+    this.steps.push({ type: "delayUntil", condition });
+    return this;
+  }
+  waitForApproval(approver, options) {
+    this.steps.push({
+      type: "wait",
+      name: "approval",
+      options: { approver, ...options }
+    });
+    return this;
+  }
+  waitForEvent(event, options) {
+    this.steps.push({
+      type: "wait",
+      name: "event",
+      options: { event, ...options }
+    });
+    return this;
+  }
+  onError(step, handler) {
+    const s = this.steps.find((s2) => s2.name === step);
+    if (s) {
+    }
+    return this;
+  }
+  compensate(step, handler) {
+    const s = this.steps.find((s2) => s2.name === step);
+    if (s) {
+      s.compensate = handler;
+    }
+    return this;
+  }
+  build() {
+    return new WorkflowImpl(this.name, this.steps, this.adapter);
+  }
+};
+var WorkflowImpl = class {
+  constructor(name, steps, adapter) {
+    this.executionCount = 0;
+    this.successCount = 0;
+    this.totalDuration = 0;
+    this.id = uuidv43();
+    this.name = name;
+    this.steps = steps;
+    this.adapter = adapter;
+    this.storage = new MemoryWorkflowStorage();
+    this.eventLog = new MemoryEventLog();
+  }
+  async execute(input) {
+    const executionId = uuidv43();
+    const execution = {
+      id: executionId,
+      workflowId: this.id,
+      status: "running",
+      input,
+      state: {},
+      startedAt: Date.now(),
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    await this.storage.save(this.id, execution);
+    await this.logEvent(executionId, "execution.started", { input });
+    this.runExecution(execution).catch(console.error);
+    return execution;
+  }
+  async runExecution(execution) {
+    const context = {
+      workflowId: this.id,
+      executionId: execution.id,
+      input: execution.input,
+      state: execution.state || {},
+      metadata: {},
+      set: (k, v) => {
+        context.state[k] = v;
+        this.storage.updateState(execution.id, context.state).catch(console.error);
+      },
+      get: (k) => context.state[k],
+      sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+      waitForEvent: async (event, timeout2) => {
+        await new Promise((r) => setTimeout(r, timeout2 || 100));
+      }
+    };
+    const executedSagas = [];
+    try {
+      await this.executeSteps(this.steps, context, executedSagas);
+      execution.status = "completed";
+      execution.output = context.state;
+      execution.completedAt = Date.now();
+      await this.logEvent(execution.id, "execution.completed", {
+        output: execution.output
+      });
+      this.executionCount++;
+      this.successCount++;
+      this.totalDuration += execution.completedAt - execution.startedAt;
+    } catch (error) {
+      execution.status = "failed";
+      execution.error = error;
+      execution.completedAt = Date.now();
+      await this.logEvent(execution.id, "execution.failed", {
+        error: error.message
+      });
+      await this.compensate(executedSagas, context);
+      this.executionCount++;
+      this.totalDuration += execution.completedAt - execution.startedAt;
+    }
+    await this.storage.save(this.id, execution);
+    await this.adapter.saveWorkflowState(execution.id, execution);
+  }
+  async logEvent(executionId, type, data) {
+    await this.eventLog.append({
+      type,
+      aggregateId: executionId,
+      aggregateType: "workflow_execution",
+      data
+    });
+  }
+  async executeSteps(steps, context, executedSagas) {
+    for (const step of steps) {
+      if (step.type === "step" && step.handler) {
+        await this.logEvent(context.executionId, "step.started", {
+          step: step.name
+        });
+        await step.handler(context);
+        await this.logEvent(context.executionId, "step.completed", {
+          step: step.name
+        });
+      } else if (step.type === "saga" && step.handler) {
+        await this.logEvent(context.executionId, "saga.started", {
+          step: step.name
+        });
+        await step.handler(context);
+        executedSagas.push(step);
+        await this.logEvent(context.executionId, "saga.completed", {
+          step: step.name
+        });
+      } else if (step.type === "parallel" && step.steps) {
+        await this.logEvent(context.executionId, "parallel.started", {
+          count: step.steps.length
+        });
+        await Promise.all(
+          step.steps.map(
+            (s) => s.handler ? s.handler(context) : Promise.resolve()
+          )
+        );
+        await this.logEvent(context.executionId, "parallel.completed", {});
+      } else if (step.type === "branch" && step.condition) {
+        const conditionMet = await step.condition(context);
+        if (conditionMet && step.steps) {
+          await this.executeSteps(step.steps, context, executedSagas);
+        } else if (!conditionMet && step.elseSteps) {
+          await this.executeSteps(step.elseSteps, context, executedSagas);
+        }
+      } else if (step.type === "delay") {
+        const ms = step.options?.ms || 0;
+        await new Promise((r) => setTimeout(r, ms));
+      } else if (step.type === "delayUntil" && step.condition) {
+        const targetTime = await step.condition(context);
+        if (typeof targetTime === "number") {
+          const now2 = Date.now();
+          const delay = Math.max(0, targetTime - now2);
+          if (delay > 0) {
+            await new Promise((r) => setTimeout(r, delay));
+          }
+        }
+      } else if (step.type === "wait") {
+        if (step.options?.timeout) {
+          await new Promise((r) => setTimeout(r, step.options.timeout));
+        }
+      }
+    }
+  }
+  async compensate(executedSagas, context) {
+    for (let i = executedSagas.length - 1; i >= 0; i--) {
+      const step = executedSagas[i];
+      if (step.compensate) {
+        try {
+          await step.compensate(context);
+        } catch (err) {
+          console.error(`Compensation failed for step ${step.name}`, err);
+        }
+      }
+    }
+  }
+  async getExecution(executionId) {
+    const execution = await this.storage.get(executionId);
+    if (!execution) {
+      const adapterExecution = await this.adapter.loadWorkflowState(executionId);
+      if (!adapterExecution) {
+        throw new Error(`Execution ${executionId} not found`);
+      }
+      return adapterExecution;
+    }
+    return execution;
+  }
+  async listExecutions(options) {
+    return this.storage.list(this.id, options);
+  }
+  async cancelExecution(executionId) {
+    const execution = await this.storage.get(executionId);
+    if (!execution) {
+      throw new Error(`Execution ${executionId} not found`);
+    }
+    if (execution.status === "completed" || execution.status === "failed" || execution.status === "cancelled") {
+      throw new Error(`Cannot cancel execution in ${execution.status} state`);
+    }
+    await this.storage.updateStatus(executionId, "cancelled");
+    await this.logEvent(executionId, "execution.cancelled", {});
+  }
+  async retryExecution(executionId) {
+    const execution = await this.storage.get(executionId);
+    if (!execution) {
+      throw new Error(`Execution ${executionId} not found`);
+    }
+    if (execution.status !== "failed") {
+      throw new Error(
+        `Can only retry failed executions, current status: ${execution.status}`
+      );
+    }
+    return this.execute(execution.input);
+  }
+  async getExecutionHistory(executionId) {
+    const events = await this.eventLog.getAggregateEvents(executionId);
+    return events.map((e) => ({
+      timestamp: e.timestamp,
+      type: e.type,
+      step: e.data.step,
+      data: e.data
+    }));
+  }
+  async getMetrics() {
+    const successRate = this.executionCount > 0 ? this.successCount / this.executionCount * 100 : 0;
+    const avgDuration = this.executionCount > 0 ? this.totalDuration / this.executionCount : 0;
+    return {
+      totalExecutions: this.executionCount,
+      successRate,
+      avgDuration
+    };
+  }
+};
+
+// src/core/scheduler.ts
+import parser from "cron-parser";
+var Scheduler = class {
+  constructor() {
+    this.tasks = /* @__PURE__ */ new Map();
+  }
+  async schedule(name, pattern, handler) {
+    await this.cancel(name);
+    const options = typeof pattern === "string" ? { pattern } : pattern;
+    const now2 = Date.now();
+    let nextRun = 0;
+    if (options.pattern) {
+      const interval = parser.parseExpression(options.pattern, {
+        currentDate: options.startDate || /* @__PURE__ */ new Date(),
+        tz: options.timezone
+      });
+      nextRun = interval.next().getTime();
+    } else if (options.every) {
+      nextRun = (options.startDate?.getTime() || now2) + options.every;
+    }
+    this.tasks.set(name, {
+      pattern,
+      handler,
+      nextRun,
+      count: 0,
+      paused: false
+    });
+    this.plan(name);
+  }
+  async repeat(name, options, handler) {
+    return this.schedule(name, options, handler);
+  }
+  plan(name) {
+    const task = this.tasks.get(name);
+    if (!task || task.paused) return;
+    const now2 = Date.now();
+    const delay = Math.max(0, task.nextRun - now2);
+    if (task.timer) clearTimeout(task.timer);
+    task.timer = setTimeout(async () => {
+      if (task.paused) return;
+      try {
+        const options = typeof task.pattern === "string" ? { pattern: task.pattern } : task.pattern;
+        await task.handler(options.data);
+        task.count++;
+        if (options.limit && task.count >= options.limit) {
+          this.tasks.delete(name);
+          return;
+        }
+        if (options.pattern) {
+          const interval = parser.parseExpression(options.pattern, {
+            currentDate: /* @__PURE__ */ new Date(),
+            tz: options.timezone
+          });
+          task.nextRun = interval.next().getTime();
+        } else if (options.every) {
+          task.nextRun = Date.now() + options.every;
+        }
+        if (options.endDate && task.nextRun > options.endDate.getTime()) {
+          this.tasks.delete(name);
+          return;
+        }
+        this.plan(name);
+      } catch (err) {
+        console.error(`Scheduler task "${name}" failed:`, err);
+        this.plan(name);
+      }
+    }, delay);
+  }
+  async list() {
+    return Array.from(this.tasks.entries()).map(([name, task]) => ({
+      name,
+      nextRun: new Date(task.nextRun),
+      count: task.count,
+      paused: task.paused
+    }));
+  }
+  async cancel(name) {
+    const task = this.tasks.get(name);
+    if (task) {
+      if (task.timer) clearTimeout(task.timer);
+      this.tasks.delete(name);
+    }
+  }
+  async pause(name) {
+    const task = this.tasks.get(name);
+    if (task) {
+      task.paused = true;
+      if (task.timer) clearTimeout(task.timer);
+    }
+  }
+  async resume(name) {
+    const task = this.tasks.get(name);
+    if (task && task.paused) {
+      task.paused = false;
+      const options = typeof task.pattern === "string" ? { pattern: task.pattern } : task.pattern;
+      if (options.pattern) {
+        const interval = parser.parseExpression(options.pattern, {
+          currentDate: /* @__PURE__ */ new Date(),
+          tz: options.timezone
+        });
+        task.nextRun = interval.next().getTime();
+      } else if (options.every) {
+        task.nextRun = Date.now() + options.every;
+      }
+      this.plan(name);
+    }
+  }
+  async close() {
+    for (const task of this.tasks.values()) {
+      if (task.timer) clearTimeout(task.timer);
+    }
+    this.tasks.clear();
+  }
+};
+
+// src/core/metrics.ts
+var MetricsManager = class {
+  constructor(adapter) {
+    this.metrics = /* @__PURE__ */ new Map();
+    this.maxDataPoints = 1e3;
+    this.adapter = adapter;
+  }
+  /**
+   * Record a metric data point
+   */
+  record(name, value, tags) {
+    const key = this.getMetricKey(name, tags);
+    if (!this.metrics.has(key)) {
+      this.metrics.set(key, []);
+    }
+    const dataPoints = this.metrics.get(key);
+    dataPoints.push({
+      timestamp: Date.now(),
+      value,
+      tags
+    });
+    if (dataPoints.length > this.maxDataPoints) {
+      this.metrics.set(key, dataPoints.slice(-this.maxDataPoints));
+    }
+  }
+  /**
+   * Get time series for a metric
+   */
+  getTimeSeries(name, options) {
+    const key = this.getMetricKey(name, options?.tags);
+    let dataPoints = this.metrics.get(key) || [];
+    if (options?.since) {
+      dataPoints = dataPoints.filter((dp) => dp.timestamp >= options.since);
+    }
+    if (options?.limit) {
+      dataPoints = dataPoints.slice(-options.limit);
+    }
+    if (dataPoints.length === 0) {
+      return null;
+    }
+    return this.calculateAggregations(dataPoints);
+  }
+  calculateAggregations(dataPoints) {
+    const values = dataPoints.map((dp) => dp.value).sort((a, b) => a - b);
+    const sum = values.reduce((a, b) => a + b, 0);
+    const count = values.length;
+    return {
+      dataPoints,
+      min: values[0],
+      max: values[count - 1],
+      avg: sum / count,
+      sum,
+      count,
+      p50: this.percentile(values, 50),
+      p95: this.percentile(values, 95),
+      p99: this.percentile(values, 99)
+    };
+  }
+  percentile(sorted, p) {
+    const index2 = Math.ceil(sorted.length * p / 100) - 1;
+    return sorted[Math.max(0, index2)];
+  }
+  getMetricKey(name, tags) {
+    if (!tags) return name;
+    const tagStr = Object.entries(tags).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${v}`).join(",");
+    return `${name}{${tagStr}}`;
+  }
+  async getQueueMetrics(name) {
+    const stats = await this.adapter.getQueueStats(name);
+    const throughputMetrics = this.getTimeSeries("queue.throughput", {
+      tags: { queue: name },
+      since: Date.now() - 6e4
+      // Last minute
+    });
+    const durationMetrics = this.getTimeSeries("queue.job.duration", {
+      tags: { queue: name }
+    });
+    return {
+      ...stats,
+      throughput: throughputMetrics?.avg || 0,
+      avgDuration: durationMetrics?.avg || 0,
+      p95Duration: durationMetrics?.p95 || 0
+    };
+  }
+  async getStreamMetrics(name) {
+    const info = await this.adapter.getStreamInfo(name);
+    const throughputMetrics = this.getTimeSeries("stream.throughput", {
+      tags: { stream: name },
+      since: Date.now() - 1e3
+      // Last second
+    });
+    return {
+      ...info,
+      lag: 0,
+      throughput: throughputMetrics?.avg || 0,
+      avgLatency: 0
+    };
+  }
+  async getWorkflowMetrics(name) {
+    const metricsData = this.getTimeSeries("workflow.executions", {
+      tags: { workflow: name }
+    });
+    return {
+      totalExecutions: metricsData?.count || 0,
+      running: 0,
+      completed: 0,
+      failed: 0,
+      successRate: 0,
+      avgDuration: metricsData?.avg || 0
+    };
+  }
+  async getSystemMetrics() {
+    const memUsage = typeof process !== "undefined" && process.memoryUsage ? process.memoryUsage().heapUsed : 0;
+    return {
+      queues: 0,
+      streams: 0,
+      workflows: 0,
+      workers: 0,
+      memoryUsage: memUsage
+    };
+  }
+  /**
+   * Clear old metrics
+   */
+  cleanup(maxAge) {
+    const now2 = Date.now();
+    for (const [key, dataPoints] of this.metrics.entries()) {
+      const filtered = dataPoints.filter((dp) => now2 - dp.timestamp <= maxAge);
+      if (filtered.length === 0) {
+        this.metrics.delete(key);
+      } else {
+        this.metrics.set(key, filtered);
+      }
+    }
+  }
+};
+
+// src/monitoring/health.ts
+var HealthCheckerImpl = class {
+  constructor() {
+    this.checks = /* @__PURE__ */ new Map();
+    this.startTime = Date.now();
+    this.addCheck("uptime", async () => ({
+      name: "uptime",
+      status: "pass",
+      responseTime: 0,
+      details: {
+        uptime: Date.now() - this.startTime,
+        startTime: this.startTime
+      }
+    }));
+    this.addCheck("memory", async () => {
+      if (typeof process !== "undefined" && process.memoryUsage) {
+        const mem = process.memoryUsage();
+        const usedMB = mem.heapUsed / 1024 / 1024;
+        const totalMB = mem.heapTotal / 1024 / 1024;
+        const usagePercent = usedMB / totalMB * 100;
+        return {
+          name: "memory",
+          status: usagePercent > 90 ? "warn" : "pass",
+          message: usagePercent > 90 ? "High memory usage" : void 0,
+          responseTime: 0,
+          details: {
+            heapUsedMB: Math.round(usedMB),
+            heapTotalMB: Math.round(totalMB),
+            usagePercent: Math.round(usagePercent)
+          }
+        };
+      }
+      return {
+        name: "memory",
+        status: "pass",
+        responseTime: 0
+      };
+    });
+  }
+  addCheck(name, checker) {
+    this.checks.set(name, checker);
+  }
+  removeCheck(name) {
+    this.checks.delete(name);
+  }
+  async check() {
+    const results = [];
+    let allHealthy = true;
+    for (const [name, checker] of this.checks.entries()) {
+      try {
+        const start = Date.now();
+        const result = await checker();
+        result.responseTime = Date.now() - start;
+        results.push(result);
+        if (result.status === "fail") {
+          allHealthy = false;
+        }
+      } catch (error) {
+        results.push({
+          name,
+          status: "fail",
+          message: error.message,
+          responseTime: 0
+        });
+        allHealthy = false;
+      }
+    }
+    return {
+      healthy: allHealthy,
+      timestamp: Date.now(),
+      checks: results
+    };
+  }
+};
+var MemoryEventTracker = class {
+  constructor() {
+    this.events = [];
+    this.maxEvents = 1e4;
+  }
+  track(event) {
+    const trackedEvent = {
+      ...event,
+      id: `evt_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+      timestamp: Date.now()
+    };
+    this.events.push(trackedEvent);
+    if (this.events.length > this.maxEvents) {
+      this.events = this.events.slice(-this.maxEvents);
+    }
+  }
+  getEvents(filter) {
+    let filtered = [...this.events];
+    if (filter?.category) {
+      filtered = filtered.filter((e) => e.category === filter.category);
+    }
+    if (filter?.severity) {
+      filtered = filtered.filter((e) => e.severity === filter.severity);
+    }
+    if (filter?.since !== void 0) {
+      filtered = filtered.filter((e) => e.timestamp >= filter.since);
+    }
+    if (filter?.limit) {
+      filtered = filtered.slice(-filter.limit);
+    }
+    return filtered;
+  }
+  cleanup(maxAge) {
+    const now2 = Date.now();
+    const before = this.events.length;
+    this.events = this.events.filter((e) => now2 - e.timestamp <= maxAge);
+    return before - this.events.length;
+  }
+  clear() {
+    this.events = [];
+  }
+};
+
+// src/core/flow-fn.ts
+import EventEmitter3 from "eventemitter3";
+var FlowFnImpl = class extends EventEmitter3 {
+  constructor(config) {
+    super();
+    this.queues = /* @__PURE__ */ new Map();
+    this.streams = /* @__PURE__ */ new Map();
+    this.startTime = Date.now();
+    if (config.adapter === "memory") {
+      this.adapter = new MemoryAdapter();
+    } else if (typeof config.adapter === "string") {
+      throw new Error(
+        `Adapter ${config.adapter} not automatically initialized yet. Pass an instance.`
+      );
+    } else {
+      this.adapter = config.adapter;
+    }
+    this._metrics = new MetricsManager(this.adapter);
+    this._scheduler = new Scheduler();
+    this.healthChecker = new HealthCheckerImpl();
+    this.eventTracker = new MemoryEventTracker();
+    this.setupHealthChecks();
+  }
+  setupHealthChecks() {
+    this.healthChecker.addCheck("queues", async () => {
+      const queueCount = this.queues.size;
+      return {
+        name: "queues",
+        status: "pass",
+        details: {
+          count: queueCount,
+          active: Array.from(this.queues.keys())
+        }
+      };
+    });
+    this.healthChecker.addCheck("adapter", async () => {
+      try {
+        await this.adapter.getQueueStats("health-check");
+        return {
+          name: "adapter",
+          status: "pass",
+          message: "Adapter responding"
+        };
+      } catch (error) {
+        return {
+          name: "adapter",
+          status: "fail",
+          message: error.message
+        };
+      }
+    });
+  }
+  queue(name, options) {
+    if (!this.queues.has(name)) {
+      this.queues.set(name, new QueueImpl(name, this.adapter, options));
+    }
+    return this.queues.get(name);
+  }
+  async listQueues() {
+    return Array.from(this.queues.keys());
+  }
+  stream(name, options) {
+    if (!this.streams.has(name)) {
+      this.streams.set(name, new StreamImpl(name, this.adapter, options));
+    }
+    return this.streams.get(name);
+  }
+  async listStreams() {
+    return Array.from(this.streams.keys());
+  }
+  workflow(name) {
+    return new WorkflowBuilderImpl(name, this.adapter);
+  }
+  async listWorkflows() {
+    return [];
+  }
+  scheduler() {
+    return this._scheduler;
+  }
+  get metrics() {
+    return this._metrics;
+  }
+  async healthCheck() {
+    const health = await this.healthChecker.check();
+    this.eventTracker.track({
+      type: "health.check",
+      category: "system",
+      severity: health.healthy ? "info" : "warn",
+      message: health.healthy ? "System healthy" : "System unhealthy",
+      metadata: { checksCount: health.checks.length }
+    });
+    return health;
+  }
+  /**
+   * Get event tracker
+   */
+  getEventTracker() {
+    return this.eventTracker;
+  }
+  async close() {
+    await this.adapter.cleanup();
+    for (const q of this.queues.values()) await q.close();
+    for (const s of this.streams.values()) await s.close();
+  }
+};
+function createFlow(config) {
+  return new FlowFnImpl(config);
+}
+
+// src/queue/worker.ts
+import EventEmitter4 from "eventemitter3";
+var Worker = class extends EventEmitter4 {
+  constructor(options) {
+    super();
+    this.queues = [];
+    this.flow = options.flow;
+    this.queueNames = options.queues;
+    this.concurrency = options.concurrency || 1;
+  }
+  async run() {
+    for (const name of this.queueNames) {
+      const queue = this.flow.queue(name);
+      this.queues.push(queue);
+      const qConcurrency = typeof this.concurrency === "number" ? this.concurrency : this.concurrency[name] || 1;
+      queue.on("active", (job) => this.emit("active", job));
+      queue.on("completed", (job, result) => this.emit("completed", job, result));
+      queue.on("failed", (job, err) => this.emit("failed", job, err));
+    }
+    this.emit("ready");
+  }
+  // Helper to register handlers
+  register(queueName, handler) {
+    const queue = this.flow.queue(queueName);
+    const qConcurrency = typeof this.concurrency === "number" ? this.concurrency : this.concurrency[queueName] || 1;
+    queue.process(qConcurrency, handler);
+  }
+  async close() {
+    this.emit("closing");
+    await Promise.all(this.queues.map((q) => q.close()));
+  }
+};
+function createWorker(options) {
+  return new Worker(options);
+}
+
+// src/queue/dlq.ts
+var MemoryDLQManager = class {
+  constructor(options = {}) {
+    this.dlqJobs = /* @__PURE__ */ new Map();
+    this.options = {
+      queueName: "dlq",
+      maxRetries: 3,
+      ttl: 7 * 24 * 60 * 60 * 1e3,
+      // 7 days
+      ...options
+    };
+  }
+  async moveToDLQ(job, reason) {
+    const dlqJob = {
+      ...job,
+      originalQueue: job.name,
+      dlqReason: reason,
+      dlqTimestamp: Date.now(),
+      errors: [...job.stacktrace || [], job.failedReason || reason].filter(
+        Boolean
+      )
+    };
+    this.dlqJobs.set(job.id, dlqJob);
+    if (this.options.onDLQ) {
+      await Promise.resolve(this.options.onDLQ(job, reason));
+    }
+    return dlqJob;
+  }
+  async getAll() {
+    return Array.from(this.dlqJobs.values());
+  }
+  async getByQueue(queueName) {
+    return Array.from(this.dlqJobs.values()).filter(
+      (job) => job.originalQueue === queueName
+    );
+  }
+  async retry(jobId) {
+    const dlqJob = this.dlqJobs.get(jobId);
+    if (!dlqJob) {
+      throw new Error(`DLQ job ${jobId} not found`);
+    }
+    this.dlqJobs.delete(jobId);
+    const retriedJob = {
+      ...dlqJob,
+      state: "waiting",
+      attemptsMade: 0,
+      failedReason: void 0,
+      stacktrace: [],
+      processedOn: void 0,
+      finishedOn: void 0
+    };
+    return retriedJob;
+  }
+  async retryAll(queueName) {
+    const jobs2 = await this.getByQueue(queueName);
+    let count = 0;
+    for (const job of jobs2) {
+      try {
+        await this.retry(job.id);
+        count++;
+      } catch (err) {
+        console.error(`Failed to retry job ${job.id}:`, err);
+      }
+    }
+    return count;
+  }
+  async delete(jobId) {
+    this.dlqJobs.delete(jobId);
+  }
+  async clean(maxAge) {
+    const now2 = Date.now();
+    const toDelete = [];
+    for (const [id, job] of this.dlqJobs.entries()) {
+      if (now2 - job.dlqTimestamp > maxAge) {
+        toDelete.push(id);
+      }
+    }
+    for (const id of toDelete) {
+      this.dlqJobs.delete(id);
+    }
+    return toDelete.length;
+  }
+  async getStats() {
+    const byQueue = {};
+    for (const job of this.dlqJobs.values()) {
+      byQueue[job.originalQueue] = (byQueue[job.originalQueue] || 0) + 1;
+    }
+    return {
+      total: this.dlqJobs.size,
+      byQueue
+    };
+  }
+  /**
+   * Clear all DLQ jobs (for testing)
+   */
+  clear() {
+    this.dlqJobs.clear();
+  }
+};
+
+// src/adapters/redis.ts
+import Redis from "ioredis";
+var RedisAdapter = class {
+  constructor(options = {}) {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    if (options.connection instanceof Redis) {
+      this.redis = options.connection;
+    } else {
+      this.redis = new Redis(options.connection || {});
+    }
+    this.prefix = options.prefix || "flowfn:";
+  }
+  key(type, name) {
+    return `${this.prefix}${type}:${name}`;
+  }
+  async enqueue(queueName, job) {
+    const queueKey = this.key("queue", queueName);
+    const jobKey = this.key("job", job.id);
+    await this.redis.set(jobKey, JSON.stringify(job));
+    if (job.opts.delay && job.opts.delay > 0) {
+      const delayedKey = this.key("delayed", queueName);
+      await this.redis.zadd(delayedKey, Date.now() + job.opts.delay, job.id);
+    } else {
+      await this.redis.lpush(queueKey, job.id);
+    }
+    return job.id;
+  }
+  async dequeue(queueName) {
+    const queueKey = this.key("queue", queueName);
+    const delayedKey = this.key("delayed", queueName);
+    const now2 = Date.now();
+    const delayed = await this.redis.zrangebyscore(
+      delayedKey,
+      0,
+      now2,
+      "LIMIT",
+      0,
+      1
+    );
+    if (delayed.length > 0) {
+      const jobId2 = delayed[0];
+      await this.redis.zrem(delayedKey, jobId2);
+      await this.redis.lpush(queueKey, jobId2);
+    }
+    const jobId = await this.redis.rpop(queueKey);
+    if (!jobId) return null;
+    const jobData = await this.redis.get(this.key("job", jobId));
+    if (!jobData) return null;
+    return JSON.parse(jobData);
+  }
+  async ack(queue, jobId) {
+    await this.redis.del(this.key("job", jobId));
+  }
+  async nack(queueName, jobId, requeue = true) {
+    if (requeue) {
+      await this.redis.lpush(this.key("queue", queueName), jobId);
+    }
+  }
+  async publish(streamName, message) {
+    const streamKey = this.key("stream", streamName);
+    const id = await this.redis.xadd(
+      streamKey,
+      "*",
+      "data",
+      JSON.stringify(message.data),
+      "headers",
+      JSON.stringify(message.headers || {})
+    );
+    return id || "";
+  }
+  async subscribe(streamName, handler) {
+    const streamKey = this.key("stream", streamName);
+    let active = true;
+    let lastId = "$";
+    const poll = async () => {
+      if (!active) return;
+      try {
+        const results = await this.redis.xread(
+          "STREAMS",
+          streamKey,
+          lastId,
+          "BLOCK",
+          1e3
+        );
+        if (results) {
+          for (const [stream, messages2] of results) {
+            for (const [id, fields] of messages2) {
+              lastId = id;
+              const dataIdx = fields.indexOf("data");
+              const headersIdx = fields.indexOf("headers");
+              const data = dataIdx > -1 ? JSON.parse(fields[dataIdx + 1]) : {};
+              const headers = headersIdx > -1 ? JSON.parse(fields[headersIdx + 1]) : {};
+              const msg = {
+                id,
+                stream: streamName,
+                data,
+                headers,
+                timestamp: parseInt(id.split("-")[0]),
+                ack: async () => {
+                },
+                nack: async () => {
+                }
+              };
+              handler(msg).catch(console.error);
+            }
+          }
+        }
+      } catch (err) {
+        console.error("Redis stream poll error", err);
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+      if (active) setTimeout(poll, 0);
+    };
+    setTimeout(poll, 0);
+    return {
+      unsubscribe: async () => {
+        active = false;
+      }
+    };
+  }
+  async consume(streamName, group, consumer, handler) {
+    const streamKey = this.key("stream", streamName);
+    try {
+      await this.redis.xgroup("CREATE", streamKey, group, "$", "MKSTREAM");
+    } catch (e) {
+      if (!e.message.includes("BUSYGROUP")) throw e;
+    }
+    let active = true;
+    const poll = async () => {
+      if (!active) return;
+      try {
+        const results = await this.redis.xreadgroup(
+          "GROUP",
+          group,
+          consumer,
+          "COUNT",
+          10,
+          "BLOCK",
+          1e3,
+          "STREAMS",
+          streamKey,
+          ">"
+        );
+        if (results) {
+          for (const [stream, messages2] of results) {
+            for (const [id, fields] of messages2) {
+              const dataIdx = fields.indexOf("data");
+              const headersIdx = fields.indexOf("headers");
+              const data = dataIdx > -1 ? JSON.parse(fields[dataIdx + 1]) : {};
+              const headers = headersIdx > -1 ? JSON.parse(fields[headersIdx + 1]) : {};
+              const msg = {
+                id,
+                stream: streamName,
+                data,
+                headers,
+                timestamp: parseInt(id.split("-")[0]),
+                ack: async () => {
+                  await this.redis.xack(streamKey, group, id);
+                },
+                nack: async (requeue = true) => {
+                }
+              };
+              handler(msg).catch(console.error);
+            }
+          }
+        }
+      } catch (err) {
+        console.error("Redis consumer poll error", err);
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+      if (active) setTimeout(poll, 0);
+    };
+    setTimeout(poll, 0);
+    return {
+      unsubscribe: async () => {
+        active = false;
+      }
+    };
+  }
+  async createConsumerGroup(stream, group) {
+    const streamKey = this.key("stream", stream);
+    try {
+      await this.redis.xgroup("CREATE", streamKey, group, "$", "MKSTREAM");
+    } catch (e) {
+      if (!e.message.includes("BUSYGROUP")) throw e;
+    }
+  }
+  async saveWorkflowState(workflowId, state) {
+    await this.redis.set(
+      this.key("workflow", workflowId),
+      JSON.stringify(state)
+    );
+  }
+  async loadWorkflowState(workflowId) {
+    const data = await this.redis.get(this.key("workflow", workflowId));
+    return data ? JSON.parse(data) : null;
+  }
+  async getJob(queue, jobId) {
+    const jobData = await this.redis.get(this.key("job", jobId));
+    return jobData ? JSON.parse(jobData) : null;
+  }
+  async getJobs(queue, status) {
+    return [];
+  }
+  async getAllJobs(queue) {
+    return [];
+  }
+  async cleanJobs(queue, grace, status) {
+    return 0;
+  }
+  async getQueueStats(queueName) {
+    const length = await this.redis.llen(this.key("queue", queueName));
+    const delayedLength = await this.redis.zcard(
+      this.key("delayed", queueName)
+    );
+    return {
+      waiting: length,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      delayed: delayedLength,
+      paused: 0
+    };
+  }
+  async getStreamInfo(streamName) {
+    return {
+      name: streamName,
+      length: 0,
+      groups: 0
+    };
+  }
+  async cleanup() {
+    for (const subs of this.subscriptions.values()) {
+      for (const sub of subs) {
+        await sub.quit();
+      }
+    }
+    this.subscriptions.clear();
+    await this.redis.quit();
+  }
+};
+
+// src/adapters/postgres/schema.ts
+import { pgTable, varchar, text, jsonb, integer, bigint, timestamp, index, uniqueIndex } from "drizzle-orm/pg-core";
+var jobs = pgTable("flowfn_jobs", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  queue: varchar("queue", { length: 255 }).notNull(),
+  name: varchar("name", { length: 255 }).notNull(),
+  data: jsonb("data").notNull(),
+  opts: jsonb("opts"),
+  state: varchar("state", { length: 50 }).notNull(),
+  // waiting, active, completed, failed, delayed, paused
+  priority: integer("priority").default(0),
+  progress: integer("progress").default(0),
+  returnValue: jsonb("return_value"),
+  timestamp: bigint("timestamp", { mode: "number" }).notNull(),
+  processedOn: bigint("processed_on", { mode: "number" }),
+  finishedOn: bigint("finished_on", { mode: "number" }),
+  delay: bigint("delay", { mode: "number" }).default(0),
+  attemptsMade: integer("attempts_made").default(0),
+  failedReason: text("failed_reason"),
+  stacktrace: jsonb("stacktrace"),
+  createdAt: timestamp("created_at").defaultNow(),
+  updatedAt: timestamp("updated_at").defaultNow()
+}, (table) => ({
+  queueStateIdx: index("idx_queue_state").on(table.queue, table.state),
+  queuePriorityIdx: index("idx_queue_priority").on(table.queue, table.priority),
+  timestampIdx: index("idx_timestamp").on(table.timestamp)
+}));
+var messages = pgTable("flowfn_messages", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  stream: varchar("stream", { length: 255 }).notNull(),
+  data: jsonb("data").notNull(),
+  headers: jsonb("headers"),
+  partition: integer("partition"),
+  offset: bigint("offset", { mode: "number" }),
+  key: varchar("key", { length: 255 }),
+  timestamp: bigint("timestamp", { mode: "number" }).notNull(),
+  createdAt: timestamp("created_at").defaultNow()
+}, (table) => ({
+  streamTimestampIdx: index("idx_stream_timestamp").on(table.stream, table.timestamp)
+}));
+var consumerGroups = pgTable("flowfn_consumer_groups", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  stream: varchar("stream", { length: 255 }).notNull(),
+  groupId: varchar("group_id", { length: 255 }).notNull(),
+  consumerId: varchar("consumer_id", { length: 255 }).notNull(),
+  lastMessageId: varchar("last_message_id", { length: 255 }),
+  lastOffset: bigint("last_offset", { mode: "number" }),
+  lag: integer("lag"),
+  createdAt: timestamp("created_at").defaultNow(),
+  updatedAt: timestamp("updated_at").defaultNow()
+}, (table) => ({
+  streamGroupConsumerIdx: uniqueIndex("idx_stream_group_consumer").on(table.stream, table.groupId, table.consumerId)
+}));
+var workflows = pgTable("flowfn_workflows", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  name: varchar("name", { length: 255 }).notNull(),
+  definition: jsonb("definition").notNull(),
+  version: integer("version").default(1),
+  status: varchar("status", { length: 50 }).notNull(),
+  metadata: jsonb("metadata"),
+  createdAt: timestamp("created_at").defaultNow(),
+  updatedAt: timestamp("updated_at").defaultNow()
+});
+var workflowExecutions = pgTable("flowfn_workflow_executions", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  workflowId: varchar("workflow_id", { length: 255 }).notNull(),
+  workflowName: varchar("workflow_name", { length: 255 }),
+  status: varchar("status", { length: 50 }).notNull(),
+  input: jsonb("input"),
+  state: jsonb("state"),
+  output: jsonb("output"),
+  error: text("error"),
+  currentStep: varchar("current_step", { length: 255 }),
+  completedSteps: jsonb("completed_steps"),
+  startedAt: bigint("started_at", { mode: "number" }).notNull(),
+  updatedAt: bigint("updated_at", { mode: "number" }),
+  completedAt: bigint("completed_at", { mode: "number" }),
+  durationMs: integer("duration_ms")
+}, (table) => ({
+  workflowIdx: index("idx_workflow").on(table.workflowId),
+  statusIdx: index("idx_status").on(table.status)
+}));
+var workflowEvents = pgTable("flowfn_workflow_events", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  executionId: varchar("execution_id", { length: 255 }).notNull(),
+  type: varchar("type", { length: 50 }).notNull(),
+  step: varchar("step", { length: 255 }),
+  timestamp: bigint("timestamp", { mode: "number" }).notNull(),
+  data: jsonb("data")
+}, (table) => ({
+  executionIdx: index("idx_execution").on(table.executionId)
+}));
+
+// src/adapters/postgres/index.ts
+import { eq, and, asc, sql } from "drizzle-orm";
+import { v4 as uuidv44 } from "uuid";
+var PostgresAdapter = class {
+  constructor(options) {
+    this.activeSubscriptions = /* @__PURE__ */ new Map();
+    this.db = options.db;
+    this.pollInterval = options.pollInterval || 1e3;
+  }
+  async enqueue(queueName, job) {
+    await this.db.insert(jobs).values({
+      id: job.id,
+      queue: queueName,
+      name: job.name,
+      data: job.data,
+      opts: job.opts,
+      state: job.opts.delay ? "delayed" : "waiting",
+      timestamp: job.timestamp,
+      delay: job.opts.delay || 0,
+      priority: job.opts.priority || 0,
+      attemptsMade: 0
+    });
+    return job.id;
+  }
+  async dequeue(queueName) {
+    const now2 = Date.now();
+    return await this.db.transaction(async (tx) => {
+      const result = await tx.execute(sql`
+            UPDATE flowfn_jobs
+            SET state = 'active', processed_on = ${now2}
+            WHERE id = (
+                SELECT id
+                FROM flowfn_jobs
+                WHERE queue = ${queueName}
+                AND (
+                    state = 'waiting'
+                    OR (state = 'delayed' AND (timestamp + delay) <= ${now2})
+                )
+                ORDER BY priority DESC, timestamp ASC
+                FOR UPDATE SKIP LOCKED
+                LIMIT 1
+            )
+            RETURNING *
+        `);
+      if (result.length === 0) return null;
+      const row = result[0];
+      return {
+        id: row.id,
+        name: row.name,
+        data: row.data,
+        opts: row.opts,
+        state: row.state,
+        progress: row.progress,
+        returnvalue: row.return_value,
+        timestamp: Number(row.timestamp),
+        processedOn: Number(row.processed_on),
+        finishedOn: Number(row.finished_on),
+        delay: Number(row.delay),
+        attemptsMade: row.attempts_made,
+        failedReason: row.failed_reason,
+        stacktrace: row.stacktrace
+        // Re-bind methods in queue implementation
+      };
+    });
+  }
+  async ack(queue, jobId) {
+    await this.db.update(jobs).set({ state: "completed", finishedOn: Date.now() }).where(eq(jobs.id, jobId));
+  }
+  async nack(queue, jobId, requeue = true) {
+    if (requeue) {
+      await this.db.update(jobs).set({ state: "waiting", processedOn: null }).where(eq(jobs.id, jobId));
+    } else {
+    }
+  }
+  async publish(streamName, message) {
+    await this.db.insert(messages).values({
+      id: message.id,
+      stream: streamName,
+      data: message.data,
+      headers: message.headers,
+      timestamp: message.timestamp,
+      partition: message.partition,
+      key: message.key
+    });
+    return message.id;
+  }
+  async subscribe(streamName, handler) {
+    const subId = uuidv44();
+    this.activeSubscriptions.set(subId, true);
+    let lastTimestamp = Date.now();
+    const poll = async () => {
+      if (!this.activeSubscriptions.get(subId)) return;
+      try {
+        const msgs = await this.db.select().from(messages).where(
+          and(
+            eq(messages.stream, streamName),
+            sql`${messages.timestamp} > ${lastTimestamp}`
+          )
+        ).orderBy(asc(messages.timestamp)).limit(100);
+        for (const row of msgs) {
+          lastTimestamp = Math.max(lastTimestamp, Number(row.timestamp));
+          const msg = {
+            id: row.id,
+            stream: row.stream,
+            data: row.data,
+            headers: row.headers,
+            timestamp: Number(row.timestamp),
+            ack: async () => {
+            },
+            nack: async () => {
+            }
+          };
+          handler(msg).catch(console.error);
+        }
+      } catch (e) {
+        console.error("Postgres stream poll error", e);
+      }
+      if (this.activeSubscriptions.get(subId)) {
+        setTimeout(poll, this.pollInterval);
+      }
+    };
+    setTimeout(poll, 0);
+    return {
+      unsubscribe: async () => {
+        this.activeSubscriptions.set(subId, false);
+      }
+    };
+  }
+  async createConsumerGroup(stream, group) {
+  }
+  async saveWorkflowState(workflowId, state) {
+    await this.db.insert(workflowExecutions).values({
+      id: state.id,
+      workflowId: state.workflowId,
+      status: state.status,
+      input: state.input,
+      output: state.output,
+      error: state.error instanceof Error ? state.error.message : String(state.error),
+      startedAt: state.startedAt,
+      completedAt: state.completedAt
+    }).onConflictDoUpdate({
+      target: workflowExecutions.id,
+      set: {
+        status: state.status,
+        output: state.output,
+        error: state.error instanceof Error ? state.error.message : String(state.error),
+        updatedAt: Date.now(),
+        completedAt: state.completedAt
+      }
+    });
+  }
+  async loadWorkflowState(executionId) {
+    const rows = await this.db.select().from(workflowExecutions).where(eq(workflowExecutions.id, executionId));
+    if (rows.length === 0) return null;
+    const row = rows[0];
+    return {
+      id: row.id,
+      workflowId: row.workflowId,
+      status: row.status,
+      // Cast from DB string to union type
+      input: row.input,
+      output: row.output,
+      error: row.error,
+      startedAt: Number(row.startedAt),
+      completedAt: row.completedAt ? Number(row.completedAt) : void 0
+    };
+  }
+  async getJob(queue, jobId) {
+    const rows = await this.db.select().from(jobs).where(and(eq(jobs.queue, queue), eq(jobs.id, jobId)));
+    if (rows.length === 0) return null;
+    const row = rows[0];
+    return {
+      id: row.id,
+      name: row.name,
+      data: row.data,
+      opts: row.opts,
+      state: row.state,
+      timestamp: Number(row.timestamp),
+      attemptsMade: row.attempts_made
+    };
+  }
+  async getQueueStats(queueName) {
+    const counts = await this.db.select({
+      state: jobs.state,
+      count: sql`count(*)`
+    }).from(jobs).where(eq(jobs.queue, queueName)).groupBy(jobs.state);
+    const stats = {
+      waiting: 0,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      delayed: 0,
+      paused: 0
+    };
+    for (const c of counts) {
+      if (c.state in stats) {
+        stats[c.state] = Number(c.count);
+      }
+    }
+    return stats;
+  }
+  async getStreamInfo(streamName) {
+    return { name: streamName, length: 0, groups: 0 };
+  }
+  async consume(stream, group, consumer, handler) {
+    return this.subscribe(stream, handler);
+  }
+  async getJobs(queue, status) {
+    const rows = await this.db.select().from(jobs).where(and(eq(jobs.queue, queue), eq(jobs.state, status)));
+    return rows.map(
+      (row) => ({
+        id: row.id,
+        name: row.name,
+        data: row.data,
+        opts: row.opts,
+        state: row.state,
+        timestamp: Number(row.timestamp),
+        attemptsMade: row.attempts_made
+      })
+    );
+  }
+  async getAllJobs(queue) {
+    const rows = await this.db.select().from(jobs).where(eq(jobs.queue, queue));
+    return rows.map(
+      (row) => ({
+        id: row.id,
+        name: row.name,
+        data: row.data,
+        opts: row.opts,
+        state: row.state,
+        timestamp: Number(row.timestamp),
+        attemptsMade: row.attempts_made
+      })
+    );
+  }
+  async cleanJobs(queue, grace, status) {
+    const now2 = Date.now();
+    const result = await this.db.delete(jobs).where(
+      and(
+        eq(jobs.queue, queue),
+        eq(jobs.state, status),
+        sql`${jobs.finishedOn} < ${now2 - grace}`
+      )
+    );
+    return result.rowCount || 0;
+  }
+  async cleanup() {
+    this.activeSubscriptions.clear();
+  }
+};
+
+// src/patterns/circuit-breaker.ts
+function circuitBreaker(options, handler) {
+  let state = "CLOSED";
+  let failures = 0;
+  let lastFailureTime = 0;
+  let lastSuccessTime = 0;
+  return async (job) => {
+    const now2 = Date.now();
+    if (state === "OPEN") {
+      if (now2 - lastFailureTime > options.timeout) {
+        state = "HALF_OPEN";
+      } else {
+        throw new Error("Circuit Breaker is OPEN");
+      }
+    }
+    try {
+      const result = await handler(job);
+      if (state === "HALF_OPEN") {
+        state = "CLOSED";
+        failures = 0;
+      }
+      lastSuccessTime = now2;
+      return result;
+    } catch (err) {
+      failures++;
+      lastFailureTime = now2;
+      if (state === "HALF_OPEN" || failures >= options.threshold) {
+        state = "OPEN";
+      }
+      throw err;
+    }
+  };
+}
+
+// src/patterns/rate-limit.ts
+var RateLimiter = class {
+  constructor(options) {
+    this.counters = /* @__PURE__ */ new Map();
+    this.options = {
+      strategy: "throw",
+      ...options
+    };
+  }
+  /**
+   * Check if request is allowed
+   */
+  async check(key = "default") {
+    const now2 = Date.now();
+    let counter = this.counters.get(key);
+    if (!counter || now2 >= counter.resetAt) {
+      counter = {
+        count: 0,
+        resetAt: now2 + this.options.window
+      };
+      this.counters.set(key, counter);
+    }
+    const allowed = counter.count < this.options.limit;
+    const remaining = Math.max(0, this.options.limit - counter.count);
+    const retryAfter = allowed ? void 0 : counter.resetAt - now2;
+    if (allowed) {
+      counter.count++;
+    }
+    return {
+      allowed,
+      remaining,
+      resetAt: counter.resetAt,
+      retryAfter
+    };
+  }
+  /**
+   * Execute a function with rate limiting
+   */
+  async execute(fn, key = "default") {
+    const result = await this.check(key);
+    if (!result.allowed) {
+      switch (this.options.strategy) {
+        case "throw":
+          throw new Error(
+            `Rate limit exceeded. Retry after ${result.retryAfter}ms`
+          );
+        case "delay":
+          await new Promise(
+            (resolve) => setTimeout(resolve, result.retryAfter)
+          );
+          return this.execute(fn, key);
+        case "drop":
+          throw new Error("Request dropped due to rate limit");
+        default:
+          throw new Error("Unknown rate limit strategy");
+      }
+    }
+    return fn();
+  }
+  /**
+   * Clear all rate limit counters
+   */
+  reset() {
+    this.counters.clear();
+  }
+  /**
+   * Clear rate limit counter for specific key
+   */
+  resetKey(key) {
+    this.counters.delete(key);
+  }
+  /**
+   * Get current limit info for a key
+   */
+  getInfo(key = "default") {
+    const now2 = Date.now();
+    const counter = this.counters.get(key);
+    if (!counter || now2 >= counter.resetAt) {
+      return {
+        allowed: true,
+        remaining: this.options.limit,
+        resetAt: now2 + this.options.window
+      };
+    }
+    const allowed = counter.count < this.options.limit;
+    const remaining = Math.max(0, this.options.limit - counter.count);
+    return {
+      allowed,
+      remaining,
+      resetAt: counter.resetAt,
+      retryAfter: allowed ? void 0 : counter.resetAt - now2
+    };
+  }
+};
+function createRateLimiter(options) {
+  return new RateLimiter(options);
+}
+var SlidingWindowRateLimiter = class {
+  constructor(options) {
+    this.requests = /* @__PURE__ */ new Map();
+    this.options = options;
+  }
+  async check(key = "default") {
+    const now2 = Date.now();
+    const windowStart = now2 - this.options.window;
+    let requests = this.requests.get(key) || [];
+    requests = requests.filter((timestamp2) => timestamp2 > windowStart);
+    this.requests.set(key, requests);
+    const allowed = requests.length < this.options.limit;
+    const remaining = Math.max(0, this.options.limit - requests.length);
+    if (allowed) {
+      requests.push(now2);
+    }
+    const oldestRequest = requests[0];
+    const resetAt = oldestRequest ? oldestRequest + this.options.window : now2 + this.options.window;
+    const retryAfter = allowed ? void 0 : resetAt - now2;
+    return {
+      allowed,
+      remaining,
+      resetAt,
+      retryAfter
+    };
+  }
+  async execute(fn, key = "default") {
+    const result = await this.check(key);
+    if (!result.allowed) {
+      switch (this.options.strategy || "throw") {
+        case "throw":
+          throw new Error(
+            `Rate limit exceeded. Retry after ${result.retryAfter}ms`
+          );
+        case "delay":
+          await new Promise(
+            (resolve) => setTimeout(resolve, result.retryAfter)
+          );
+          return this.execute(fn, key);
+        case "drop":
+          throw new Error("Request dropped due to rate limit");
+      }
+    }
+    return fn();
+  }
+  reset() {
+    this.requests.clear();
+  }
+};
+var TokenBucketRateLimiter = class {
+  constructor(options) {
+    this.buckets = /* @__PURE__ */ new Map();
+    this.capacity = options.capacity;
+    this.refillRate = options.refillRate;
+    this.refillInterval = options.refillInterval || 1e3;
+  }
+  refill(key) {
+    const now2 = Date.now();
+    let bucket = this.buckets.get(key);
+    if (!bucket) {
+      bucket = { tokens: this.capacity, lastRefill: now2 };
+      this.buckets.set(key, bucket);
+      return;
+    }
+    const timePassed = now2 - bucket.lastRefill;
+    const intervals = timePassed / this.refillInterval;
+    const tokensToAdd = intervals * this.refillRate;
+    bucket.tokens = Math.min(this.capacity, bucket.tokens + tokensToAdd);
+    bucket.lastRefill = now2;
+  }
+  async check(key = "default", cost = 1) {
+    this.refill(key);
+    const bucket = this.buckets.get(key);
+    const allowed = bucket.tokens >= cost;
+    if (allowed) {
+      bucket.tokens -= cost;
+    }
+    return {
+      allowed,
+      remaining: Math.floor(bucket.tokens),
+      resetAt: bucket.lastRefill + this.refillInterval,
+      retryAfter: allowed ? void 0 : Math.ceil(
+        (cost - bucket.tokens) / this.refillRate * this.refillInterval
+      )
+    };
+  }
+  reset() {
+    this.buckets.clear();
+  }
+};
+
+// src/patterns/batching.ts
+var BatchAccumulator = class {
+  constructor(processor, options) {
+    this.batch = [];
+    this.timer = null;
+    this.pending = [];
+    this.processor = processor;
+    this.options = {
+      minSize: 1,
+      maxWait: 1e3,
+      ...options
+    };
+  }
+  /**
+   * Add an item to the batch
+   */
+  async add(item) {
+    return new Promise((resolve, reject) => {
+      this.batch.push(item);
+      this.pending.push({ resolve, reject });
+      if (this.batch.length >= this.options.maxSize) {
+        this.flush();
+      } else if (!this.timer) {
+        this.timer = setTimeout(() => {
+          this.flush();
+        }, this.options.maxWait);
+      }
+    });
+  }
+  /**
+   * Manually flush the current batch
+   */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.batch.length < this.options.minSize) {
+      return;
+    }
+    const currentBatch = this.batch;
+    const currentPending = this.pending;
+    this.batch = [];
+    this.pending = [];
+    try {
+      const results = await this.processor(currentBatch);
+      for (let i = 0; i < currentPending.length; i++) {
+        currentPending[i].resolve(results[i]);
+      }
+    } catch (error) {
+      for (const pending of currentPending) {
+        pending.reject(error);
+      }
+    }
+  }
+  /**
+   * Get current batch size
+   */
+  size() {
+    return this.batch.length;
+  }
+  /**
+   * Clear the batch without processing
+   */
+  clear() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.batch = [];
+    for (const pending of this.pending) {
+      pending.reject(new Error("Batch cleared"));
+    }
+    this.pending = [];
+  }
+};
+function batch(fn, options) {
+  const accumulator = new BatchAccumulator(fn, options);
+  return (item) => accumulator.add(item);
+}
+function chunk(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+async function processBatches(items, processor, options) {
+  const batches = chunk(items, options.batchSize);
+  const results = [];
+  for (let i = 0; i < batches.length; i++) {
+    const batchResults = await processor(batches[i]);
+    results.push(...batchResults);
+    if (i < batches.length - 1 && options.delayMs) {
+      await new Promise((resolve) => setTimeout(resolve, options.delayMs));
+    }
+  }
+  return results;
+}
+var BatchWriter = class {
+  constructor(writer, options) {
+    this.accumulator = new BatchAccumulator(async (items) => {
+      await writer(items);
+      return new Array(items.length).fill(void 0);
+    }, options);
+  }
+  async write(item) {
+    return this.accumulator.add(item);
+  }
+  async flush() {
+    return this.accumulator.flush();
+  }
+  size() {
+    return this.accumulator.size();
+  }
+  clear() {
+    this.accumulator.clear();
+  }
+};
+async function batchByKey(items, keyFn, processor, options) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    if (!grouped.has(key)) {
+      grouped.set(key, []);
+    }
+    grouped.get(key).push(item);
+  }
+  const results = [];
+  const entries = Array.from(grouped.entries());
+  if (options?.concurrency) {
+    for (let i = 0; i < entries.length; i += options.concurrency) {
+      const batch2 = entries.slice(i, i + options.concurrency);
+      const batchResults = await Promise.all(
+        batch2.map(([key, items2]) => processor(key, items2))
+      );
+      results.push(...batchResults.flat());
+    }
+  } else {
+    for (const [key, keyItems] of entries) {
+      const batchResults = await processor(key, keyItems);
+      results.push(...batchResults);
+    }
+  }
+  return results;
+}
+
+// src/patterns/priority.ts
+var PriorityQueue = class {
+  constructor(mode = "max") {
+    this.heap = [];
+    this.compareFn = mode === "max" ? (a, b) => a - b : (a, b) => b - a;
+  }
+  /**
+   * Add item with priority
+   */
+  enqueue(value, priority) {
+    this.heap.push({ value, priority });
+    this.bubbleUp(this.heap.length - 1);
+  }
+  /**
+   * Remove and return highest priority item
+   */
+  dequeue() {
+    if (this.heap.length === 0) return void 0;
+    if (this.heap.length === 1) return this.heap.pop().value;
+    const result = this.heap[0];
+    this.heap[0] = this.heap.pop();
+    this.bubbleDown(0);
+    return result.value;
+  }
+  /**
+   * Peek at highest priority item without removing
+   */
+  peek() {
+    return this.heap[0]?.value;
+  }
+  /**
+   * Get queue size
+   */
+  size() {
+    return this.heap.length;
+  }
+  /**
+   * Check if queue is empty
+   */
+  isEmpty() {
+    return this.heap.length === 0;
+  }
+  /**
+   * Clear the queue
+   */
+  clear() {
+    this.heap = [];
+  }
+  /**
+   * Convert to array (sorted by priority)
+   */
+  toArray() {
+    const copy = [...this.heap];
+    const result = [];
+    while (this.heap.length > 0) {
+      result.push(this.dequeue());
+    }
+    this.heap = copy;
+    return result;
+  }
+  bubbleUp(index2) {
+    while (index2 > 0) {
+      const parentIndex = Math.floor((index2 - 1) / 2);
+      if (this.compareFn(
+        this.heap[index2].priority,
+        this.heap[parentIndex].priority
+      ) <= 0) {
+        break;
+      }
+      [this.heap[index2], this.heap[parentIndex]] = [
+        this.heap[parentIndex],
+        this.heap[index2]
+      ];
+      index2 = parentIndex;
+    }
+  }
+  bubbleDown(index2) {
+    while (true) {
+      const leftChild = 2 * index2 + 1;
+      const rightChild = 2 * index2 + 2;
+      let largest = index2;
+      if (leftChild < this.heap.length && this.compareFn(
+        this.heap[leftChild].priority,
+        this.heap[largest].priority
+      ) > 0) {
+        largest = leftChild;
+      }
+      if (rightChild < this.heap.length && this.compareFn(
+        this.heap[rightChild].priority,
+        this.heap[largest].priority
+      ) > 0) {
+        largest = rightChild;
+      }
+      if (largest === index2) break;
+      [this.heap[index2], this.heap[largest]] = [
+        this.heap[largest],
+        this.heap[index2]
+      ];
+      index2 = largest;
+    }
+  }
+};
+
+// src/utils/hashing.ts
+import { createHash } from "crypto";
+function hashJob(data, options) {
+  const algorithm = options?.algorithm || "sha256";
+  const hash = createHash(algorithm);
+  const normalized = JSON.stringify(data, Object.keys(data).sort());
+  hash.update(normalized);
+  return hash.digest("hex");
+}
+function generateDeduplicationKey(name, data) {
+  return `${name}:${hashJob(data)}`;
+}
+function areJobsEquivalent(job1, job2) {
+  return hashJob(job1) === hashJob(job2);
+}
+
+// src/utils/id-generator.ts
+import { v4 as uuidv45, v5 as uuidv5, v1 as uuidv1 } from "uuid";
+import { createHash as createHash2, randomBytes } from "crypto";
+function generateId(options = {}) {
+  const {
+    strategy = "uuid-v4",
+    namespace,
+    prefix = "",
+    customGenerator
+  } = options;
+  let id;
+  switch (strategy) {
+    case "uuid-v4":
+      id = uuidv45();
+      break;
+    case "uuid-v5":
+      if (!namespace) {
+        throw new Error("UUID v5 requires a namespace");
+      }
+      const name = `${Date.now()}-${randomBytes(8).toString("hex")}`;
+      id = uuidv5(name, namespace);
+      break;
+    case "uuid-v1":
+      id = uuidv1();
+      break;
+    case "nanoid":
+      id = randomBytes(16).toString("base64url");
+      break;
+    case "incremental":
+      id = `${Date.now()}-${randomBytes(4).toString("hex")}`;
+      break;
+    case "custom":
+      if (!customGenerator) {
+        throw new Error("Custom strategy requires customGenerator function");
+      }
+      id = customGenerator();
+      break;
+    default:
+      id = uuidv45();
+  }
+  return prefix ? `${prefix}${id}` : id;
+}
+function generateJobId(prefix) {
+  return generateId({ prefix: prefix || "job_" });
+}
+function generateExecutionId(prefix) {
+  return generateId({ prefix: prefix || "exec_" });
+}
+function generateMessageId(prefix) {
+  return generateId({ prefix: prefix || "msg_" });
+}
+function generateDeterministicId(content, prefix) {
+  const hash = createHash2("sha256");
+  const data = typeof content === "string" ? content : JSON.stringify(content);
+  hash.update(data);
+  const id = hash.digest("hex").slice(0, 32);
+  return prefix ? `${prefix}${id}` : id;
+}
+
+// src/utils/time.ts
+function toMilliseconds(duration) {
+  let ms = 0;
+  if (duration.milliseconds) ms += duration.milliseconds;
+  if (duration.seconds) ms += duration.seconds * 1e3;
+  if (duration.minutes) ms += duration.minutes * 60 * 1e3;
+  if (duration.hours) ms += duration.hours * 60 * 60 * 1e3;
+  if (duration.days) ms += duration.days * 24 * 60 * 60 * 1e3;
+  if (duration.weeks) ms += duration.weeks * 7 * 24 * 60 * 60 * 1e3;
+  return ms;
+}
+function fromMilliseconds(ms) {
+  const weeks = Math.floor(ms / (7 * 24 * 60 * 60 * 1e3));
+  ms %= 7 * 24 * 60 * 60 * 1e3;
+  const days = Math.floor(ms / (24 * 60 * 60 * 1e3));
+  ms %= 24 * 60 * 60 * 1e3;
+  const hours = Math.floor(ms / (60 * 60 * 1e3));
+  ms %= 60 * 60 * 1e3;
+  const minutes = Math.floor(ms / (60 * 1e3));
+  ms %= 60 * 1e3;
+  const seconds = Math.floor(ms / 1e3);
+  const milliseconds = ms % 1e3;
+  return { weeks, days, hours, minutes, seconds, milliseconds };
+}
+function formatDuration(duration) {
+  const parts = [];
+  if (duration.weeks) parts.push(`${duration.weeks}w`);
+  if (duration.days) parts.push(`${duration.days}d`);
+  if (duration.hours) parts.push(`${duration.hours}h`);
+  if (duration.minutes) parts.push(`${duration.minutes}m`);
+  if (duration.seconds) parts.push(`${duration.seconds}s`);
+  if (duration.milliseconds) parts.push(`${duration.milliseconds}ms`);
+  return parts.join(" ") || "0ms";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function sleepDuration(duration) {
+  return sleep(toMilliseconds(duration));
+}
+function timeout(promise, ms, message) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(
+        () => reject(new Error(message || `Timeout after ${ms}ms`)),
+        ms
+      )
+    )
+  ]);
+}
+function now() {
+  return Date.now();
+}
+function delayUntil(timestamp2) {
+  return Math.max(0, timestamp2 - Date.now());
+}
+function isPast(timestamp2) {
+  return timestamp2 < Date.now();
+}
+function isFuture(timestamp2) {
+  return timestamp2 > Date.now();
+}
+function addDuration(timestamp2, duration) {
+  return timestamp2 + toMilliseconds(duration);
+}
+function parseDuration(str) {
+  const match = str.match(/^(\d+)(ms|s|m|h|d|w)$/);
+  if (!match) {
+    throw new Error(`Invalid duration string: ${str}`);
+  }
+  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;
+    case "w":
+      return value * 7 * 24 * 60 * 60 * 1e3;
+    default:
+      throw new Error(`Unknown unit: ${unit}`);
+  }
+}
+
+// src/utils/serialization.ts
+function serialize(data, options = {}) {
+  const { pretty = false, dateFormat = "iso" } = options;
+  const replacer = (key, value) => {
+    if (value instanceof Date) {
+      return dateFormat === "timestamp" ? value.getTime() : value.toISOString();
+    }
+    if (value === void 0 && !options.includeUndefined) {
+      return null;
+    }
+    if (typeof value === "function") {
+      return void 0;
+    }
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  };
+  return JSON.stringify(data, replacer, pretty ? 2 : void 0);
+}
+function deserialize(json) {
+  return JSON.parse(json, (key, value) => {
+    if (typeof value === "string") {
+      const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+      if (isoDateRegex.test(value)) {
+        return new Date(value);
+      }
+    }
+    return value;
+  });
+}
+function serializeSafe(data, options = {}) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const { pretty = false } = options;
+  const replacer = (key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "function") {
+      return "[Function]";
+    }
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  };
+  return JSON.stringify(data, replacer, pretty ? 2 : void 0);
+}
+function cloneViaSerialization(obj) {
+  return deserialize(serialize(obj));
+}
+function serializeCompressed(data) {
+  const json = serialize(data);
+  return Buffer.from(json).toString("base64");
+}
+function deserializeCompressed(compressed) {
+  const json = Buffer.from(compressed, "base64").toString("utf-8");
+  return deserialize(json);
+}
+function isSerializable(value) {
+  try {
+    serialize(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getSerializedSize(data) {
+  return Buffer.byteLength(serialize(data), "utf-8");
+}
+
+// src/storage/job-storage.ts
+var MemoryJobStorage = class {
+  constructor() {
+    this.jobs = /* @__PURE__ */ new Map();
+    this.deduplicationKeys = /* @__PURE__ */ new Map();
+  }
+  // key -> jobId
+  async save(queue, job) {
+    const key = `${queue}:${job.id}`;
+    this.jobs.set(key, { ...job });
+    if (job.opts.deduplicationKey) {
+      const dedupKey = `${queue}:${job.opts.deduplicationKey}`;
+      this.deduplicationKeys.set(dedupKey, job.id);
+    }
+  }
+  async get(queue, jobId) {
+    const key = `${queue}:${jobId}`;
+    return this.jobs.get(key) || null;
+  }
+  async getByStatus(queue, status) {
+    const result = [];
+    const prefix = `${queue}:`;
+    for (const [key, job] of this.jobs.entries()) {
+      if (key.startsWith(prefix) && job.state === status) {
+        result.push(job);
+      }
+    }
+    return result;
+  }
+  async getAll(queue) {
+    const result = [];
+    const prefix = `${queue}:`;
+    for (const [key, job] of this.jobs.entries()) {
+      if (key.startsWith(prefix)) {
+        result.push(job);
+      }
+    }
+    return result;
+  }
+  async updateStatus(queue, jobId, status) {
+    const key = `${queue}:${jobId}`;
+    const job = this.jobs.get(key);
+    if (job) {
+      job.state = status;
+      if (status === "completed" || status === "failed") {
+        job.finishedOn = Date.now();
+      }
+    }
+  }
+  async update(queue, jobId, updates) {
+    const key = `${queue}:${jobId}`;
+    const job = this.jobs.get(key);
+    if (job) {
+      Object.assign(job, updates);
+    }
+  }
+  async delete(queue, jobId) {
+    const key = `${queue}:${jobId}`;
+    const job = this.jobs.get(key);
+    if (job?.opts.deduplicationKey) {
+      const dedupKey = `${queue}:${job.opts.deduplicationKey}`;
+      this.deduplicationKeys.delete(dedupKey);
+    }
+    this.jobs.delete(key);
+  }
+  async clean(queue, grace, status) {
+    const now2 = Date.now();
+    const prefix = `${queue}:`;
+    const toDelete = [];
+    for (const [key, job] of this.jobs.entries()) {
+      if (key.startsWith(prefix) && job.state === status) {
+        const timestamp2 = job.finishedOn || job.timestamp;
+        if (now2 - timestamp2 > grace) {
+          toDelete.push(key);
+        }
+      }
+    }
+    for (const key of toDelete) {
+      const job = this.jobs.get(key);
+      if (job?.opts.deduplicationKey) {
+        const dedupKey = `${queue}:${job.opts.deduplicationKey}`;
+        this.deduplicationKeys.delete(dedupKey);
+      }
+      this.jobs.delete(key);
+    }
+    return toDelete.length;
+  }
+  async count(queue, status) {
+    const prefix = `${queue}:`;
+    let count = 0;
+    for (const [key, job] of this.jobs.entries()) {
+      if (key.startsWith(prefix)) {
+        if (!status || job.state === status) {
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  async existsByDeduplicationKey(queue, key) {
+    const dedupKey = `${queue}:${key}`;
+    return this.deduplicationKeys.has(dedupKey);
+  }
+  /**
+   * Clear all jobs
+   */
+  clear() {
+    this.jobs.clear();
+    this.deduplicationKeys.clear();
+  }
+};
+export {
+  BatchAccumulator,
+  BatchWriter,
+  FlowFnImpl,
+  HealthCheckerImpl,
+  MemoryAdapter,
+  MemoryDLQManager,
+  MemoryEventLog,
+  MemoryEventTracker,
+  MemoryJobStorage,
+  MemoryWorkflowStorage,
+  MetricsManager,
+  PostgresAdapter,
+  PriorityQueue,
+  RateLimiter,
+  RedisAdapter,
+  Scheduler,
+  SlidingWindowRateLimiter,
+  TokenBucketRateLimiter,
+  Worker,
+  addDuration,
+  areJobsEquivalent,
+  batch,
+  batchByKey,
+  calculateBackoff,
+  chunk,
+  circuitBreaker,
+  cloneViaSerialization,
+  createFlow,
+  createRateLimiter,
+  createWorker,
+  delayUntil,
+  deserialize,
+  deserializeCompressed,
+  formatDuration,
+  fromMilliseconds,
+  generateDeduplicationKey,
+  generateDeterministicId,
+  generateExecutionId,
+  generateId,
+  generateJobId,
+  generateMessageId,
+  getSerializedSize,
+  hashJob,
+  isFuture,
+  isPast,
+  isSerializable,
+  now,
+  parseDuration,
+  processBatches,
+  serialize,
+  serializeCompressed,
+  serializeSafe,
+  sleep,
+  sleepDuration,
+  timeout,
+  toMilliseconds
+};
+//# sourceMappingURL=index.mjs.map