dotdo 0.0.1 → 0.1.0

package/dist/workflows/compat/inngest/index.js

@@ -0,0 +1,989 @@
+/**
+ * Inngest Compat Layer - 100% API Compatible with inngest
+ *
+ * Drop-in replacement for Inngest that runs on dotdo's
+ * durable execution infrastructure.
+ *
+ * @example
+ * ```typescript
+ * import { Inngest } from '@dotdo/inngest'
+ *
+ * const inngest = new Inngest({ id: 'my-app' })
+ *
+ * export const processOrder = inngest.createFunction(
+ *   { id: 'process-order' },
+ *   { event: 'order/created' },
+ *   async ({ event, step }) => {
+ *     const user = await step.run('fetch-user', async () => {
+ *       return await fetchUser(event.data.userId)
+ *     })
+ *
+ *     await step.sleep('wait-a-bit', '1h')
+ *
+ *     await step.run('send-email', async () => {
+ *       await sendEmail(user.email, 'Order confirmed!')
+ *     })
+ *   }
+ * )
+ * ```
+ */
+import { WaitForEventManager, WaitTimeoutError } from '../../WaitForEventManager';
+import { DurableWorkflowRuntime, InMemoryStepStorage } from '../../runtime';
+import { parseDuration, ensureError } from '../utils';
+// ============================================================================
+// ERROR TYPES - Match Inngest SDK exactly
+// ============================================================================
+/**
+ * Error that should not be retried
+ */
+export class NonRetriableError extends Error {
+    isNonRetriableError = true;
+    cause;
+    constructor(message, options) {
+        super(message);
+        this.name = 'NonRetriableError';
+        this.cause = options?.cause;
+    }
+}
+/**
+ * Error that specifies when to retry
+ */
+export class RetryAfterError extends Error {
+    isRetryAfterError = true;
+    retryAfter;
+    cause;
+    constructor(message, retryAfter, options) {
+        super(message);
+        this.name = 'RetryAfterError';
+        this.retryAfter = retryAfter;
+        this.cause = options?.cause;
+    }
+}
+/**
+ * Error from a step execution
+ */
+export class StepError extends Error {
+    isStepError = true;
+    stepId;
+    cause;
+    constructor(message, stepId, options) {
+        super(message);
+        this.name = 'StepError';
+        this.stepId = stepId;
+        this.cause = options?.cause;
+    }
+}
+/**
+ * Error thrown when a function is cancelled
+ */
+export class CancellationError extends Error {
+    isCancellationError = true;
+    runId;
+    reason;
+    constructor(runId, reason) {
+        super(reason ? `Function run ${runId} was cancelled: ${reason}` : `Function run ${runId} was cancelled`);
+        this.name = 'CancellationError';
+        this.runId = runId;
+        this.reason = reason;
+    }
+}
+/**
+ * Error thrown when step.invoke times out
+ */
+export class InvokeTimeoutError extends Error {
+    isInvokeTimeoutError = true;
+    functionId;
+    timeout;
+    constructor(functionId, timeout) {
+        super(`Invoked function ${functionId} timed out after ${timeout}ms`);
+        this.name = 'InvokeTimeoutError';
+        this.functionId = functionId;
+        this.timeout = timeout;
+    }
+}
+// ============================================================================
+// UTILITIES
+// Note: parseDuration and ensureError are imported from '../utils'
+// ============================================================================
+function generateRunId() {
+    return `run_${crypto.randomUUID().replace(/-/g, '')}`;
+}
+function generateEventId() {
+    return `evt_${crypto.randomUUID().replace(/-/g, '')}`;
+}
+/**
+ * Get value from object using dot notation path
+ */
+function getValueByPath(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Evaluate simple expression against event context
+ */
+function evaluateExpression(expression, context) {
+    // Simple expression evaluation for common patterns
+    // Format: "event.data.field == async.data.field"
+    const equalMatch = expression.match(/^(.+?)\s*==\s*(.+)$/);
+    if (equalMatch) {
+        const leftPath = equalMatch[1].trim();
+        const rightPath = equalMatch[2].trim();
+        const leftValue = getValueByPath(context, leftPath);
+        const rightValue = getValueByPath(context, rightPath);
+        return leftValue === rightValue;
+    }
+    return false;
+}
+const defaultLogger = {
+    info: console.log.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    debug: console.debug.bind(console),
+};
+class ThrottleManager {
+    /** Map of throttle key -> array of timestamps */
+    buckets = new Map();
+    /** Queue of pending executions by throttle key */
+    queues = new Map();
+    /**
+     * Acquire a throttle slot
+     * @returns Promise that resolves when slot is available
+     */
+    async acquire(key, count, periodMs) {
+        const now = Date.now();
+        // Get or create bucket
+        let bucket = this.buckets.get(key) || [];
+        // Remove expired entries
+        bucket = bucket.filter((ts) => now - ts < periodMs);
+        // Check if we have capacity
+        if (bucket.length < count) {
+            bucket.push(now);
+            this.buckets.set(key, bucket);
+            return;
+        }
+        // Queue this request
+        return new Promise((resolve, reject) => {
+            const queue = this.queues.get(key) || [];
+            queue.push({ resolve, reject, count, periodMs, addedAt: now });
+            this.queues.set(key, queue);
+            // Schedule retry when oldest entry expires
+            const oldestTs = bucket[0];
+            const waitTime = periodMs - (now - oldestTs) + 1;
+            this.scheduleQueueProcess(key, waitTime);
+        });
+    }
+    scheduleQueueProcess(key, waitTime) {
+        setTimeout(() => {
+            this.processQueue(key);
+            // If there are still items in queue, schedule again
+            const queue = this.queues.get(key);
+            if (queue && queue.length > 0) {
+                const item = queue[0];
+                // Calculate remaining time properly based on when item was added
+                const elapsed = Date.now() - item.addedAt;
+                const remaining = Math.max(0, item.periodMs - elapsed);
+                this.scheduleQueueProcess(key, remaining);
+            }
+        }, waitTime);
+    }
+    processQueue(key) {
+        const queue = this.queues.get(key);
+        if (!queue || queue.length === 0)
+            return;
+        const item = queue[0];
+        const { count, periodMs } = item;
+        const now = Date.now();
+        let bucket = this.buckets.get(key) || [];
+        bucket = bucket.filter((ts) => now - ts < periodMs);
+        if (bucket.length < count) {
+            queue.shift();
+            bucket.push(now);
+            this.buckets.set(key, bucket);
+            this.queues.set(key, queue);
+            item.resolve();
+        }
+    }
+}
+// ============================================================================
+// CONCURRENCY MANAGER
+// ============================================================================
+class ConcurrencyManager {
+    /** Map of concurrency key -> current count */
+    active = new Map();
+    /** Queue of pending executions by concurrency key */
+    queues = new Map();
+    /**
+     * Acquire a concurrency slot
+     * @returns Promise that resolves when slot is available
+     */
+    async acquire(key, limit) {
+        const current = this.active.get(key) || 0;
+        if (current < limit) {
+            this.active.set(key, current + 1);
+            return;
+        }
+        // Queue this request
+        return new Promise((resolve, reject) => {
+            const queue = this.queues.get(key) || [];
+            queue.push({ resolve, reject });
+            this.queues.set(key, queue);
+        });
+    }
+    /**
+     * Release a concurrency slot
+     */
+    release(key) {
+        const current = this.active.get(key) || 0;
+        if (current > 0) {
+            this.active.set(key, current - 1);
+        }
+        // Process queue
+        const queue = this.queues.get(key);
+        if (queue && queue.length > 0) {
+            const item = queue.shift();
+            if (item) {
+                this.active.set(key, (this.active.get(key) || 0) + 1);
+                this.queues.set(key, queue);
+                item.resolve();
+            }
+        }
+    }
+    /**
+     * Reject all queued items (for cancellation)
+     */
+    rejectQueued(key, error) {
+        const queue = this.queues.get(key) || [];
+        for (const item of queue) {
+            item.reject(error);
+        }
+        this.queues.set(key, []);
+    }
+}
+class BatchManager {
+    batches = new Map();
+    /**
+     * Add event to batch, returns promise that resolves with all batched events
+     */
+    addEvent(key, event, config, onBatchReady) {
+        let batch = this.batches.get(key);
+        if (!batch) {
+            batch = {
+                events: [],
+                timeoutId: null,
+                resolve: null,
+            };
+            this.batches.set(key, batch);
+        }
+        batch.events.push(event);
+        // Check if batch is full
+        if (batch.events.length >= config.maxSize) {
+            this.flushBatch(key, onBatchReady);
+            return;
+        }
+        // Set/reset timeout if not already set
+        if (!batch.timeoutId) {
+            const timeoutMs = parseDuration(config.timeout);
+            batch.timeoutId = setTimeout(() => {
+                this.flushBatch(key, onBatchReady);
+            }, timeoutMs);
+        }
+    }
+    flushBatch(key, onBatchReady) {
+        const batch = this.batches.get(key);
+        if (!batch || batch.events.length === 0)
+            return;
+        if (batch.timeoutId) {
+            clearTimeout(batch.timeoutId);
+        }
+        const events = batch.events;
+        this.batches.delete(key);
+        onBatchReady(events);
+    }
+}
+// ============================================================================
+// INNGEST FUNCTION
+// ============================================================================
+export class InngestFunction {
+    id;
+    name;
+    config;
+    trigger;
+    handler;
+    inngest;
+    constructor(inngest, config, trigger, handler) {
+        this.inngest = inngest;
+        this.config = config;
+        this.trigger = trigger;
+        this.handler = handler;
+        this.id = config.id;
+        this.name = config.name ?? config.id;
+    }
+    /**
+     * Get the event name this function listens for
+     */
+    get eventName() {
+        if (typeof this.trigger === 'string') {
+            return this.trigger;
+        }
+        if ('event' in this.trigger) {
+            return this.trigger.event;
+        }
+        return null;
+    }
+    /**
+     * Get the cron expression if this is a scheduled function
+     */
+    get cronExpression() {
+        if (typeof this.trigger === 'object' && 'cron' in this.trigger) {
+            return this.trigger.cron;
+        }
+        return null;
+    }
+    /**
+     * Invoke this function with an event
+     */
+    async invoke(event) {
+        return this.inngest.invokeFunction(this, event);
+    }
+}
+// ============================================================================
+// INNGEST CLIENT
+// ============================================================================
+export class Inngest {
+    id;
+    config;
+    runtime;
+    waitManager;
+    stepResults = new Map();
+    functions = new Map();
+    eventHandlers = new Map();
+    middleware;
+    logger;
+    // Run tracking
+    activeRuns = new Map();
+    runCancellations = new Map();
+    // Background task tracking for promise race condition prevention
+    runningTasks = new Map();
+    failedRuns = new Map();
+    // Throttle manager
+    throttleManager = new ThrottleManager();
+    // Concurrency manager
+    concurrencyManager = new ConcurrencyManager();
+    // Batch manager
+    batchManager = new BatchManager();
+    // Cancel event subscriptions: eventName -> Set of { functionId, cancelConfig }
+    cancelSubscriptions = new Map();
+    constructor(config) {
+        this.id = config.id;
+        this.config = config;
+        this.logger = config.logger ?? defaultLogger;
+        this.middleware = config.middleware ?? [];
+        this.runtime = new DurableWorkflowRuntime({
+            storage: config.storage ?? new InMemoryStepStorage(),
+        });
+        // Create wait manager if DO state is provided
+        this.waitManager = config.state ? new WaitForEventManager(config.state) : null;
+        // Initialize middleware
+        for (const mw of this.middleware) {
+            mw.init?.();
+        }
+    }
+    /**
+     * Create a new function
+     */
+    createFunction(config, trigger, handler) {
+        const fn = new InngestFunction(this, config, trigger, handler);
+        this.functions.set(fn.id, fn);
+        // Register event handler
+        const eventName = fn.eventName;
+        if (eventName) {
+            if (!this.eventHandlers.has(eventName)) {
+                this.eventHandlers.set(eventName, new Set());
+            }
+            this.eventHandlers.get(eventName).add(fn);
+        }
+        // Register cancel subscriptions
+        if (config.cancelOn) {
+            for (const cancelConfig of config.cancelOn) {
+                if (!this.cancelSubscriptions.has(cancelConfig.event)) {
+                    this.cancelSubscriptions.set(cancelConfig.event, new Set());
+                }
+                this.cancelSubscriptions.get(cancelConfig.event).add({
+                    functionId: fn.id,
+                    config: cancelConfig,
+                });
+            }
+        }
+        return fn;
+    }
+    /**
+     * Send one or more events
+     */
+    async send(events) {
+        const eventArray = Array.isArray(events) ? events : [events];
+        // Apply middleware
+        let processedEvents = eventArray;
+        for (const mw of this.middleware) {
+            if (mw.onSendEvent) {
+                processedEvents = await mw.onSendEvent(processedEvents);
+            }
+        }
+        const ids = [];
+        for (const payload of processedEvents) {
+            const eventId = payload.id ?? generateEventId();
+            ids.push(eventId);
+            const event = {
+                ...payload,
+                id: eventId,
+                ts: payload.ts ?? Date.now(),
+            };
+            // Check for cancellation events
+            await this.processCancellationEvent(event);
+            // Trigger handlers for this event
+            const handlers = this.eventHandlers.get(event.name);
+            if (handlers) {
+                handlers.forEach((fn) => {
+                    // Check if function uses batching
+                    if (fn.config.batchEvents) {
+                        this.handleBatchedEvent(fn, event);
+                    }
+                    else {
+                        // Execute in background with proper error tracking
+                        const runId = generateRunId();
+                        const runPromise = this.invokeFunction(fn, event)
+                            .catch((error) => {
+                            this.logger.error(`Function ${fn.id} failed:`, error);
+                            // Track failed run for debugging and observability
+                            this.failedRuns.set(runId, { error: error, timestamp: Date.now() });
+                            // Clean up old failed runs after 1 hour
+                            setTimeout(() => this.failedRuns.delete(runId), 3600000);
+                            throw error; // Re-throw so callers can handle if needed
+                        })
+                            .finally(() => {
+                            // Clean up running task reference
+                            this.runningTasks.delete(runId);
+                        });
+                        this.runningTasks.set(runId, runPromise);
+                    }
+                });
+            }
+            // Deliver to any waiting step.waitForEvent calls
+            if (this.waitManager) {
+                await this.waitManager.deliverEvent(null, event.name, event);
+            }
+        }
+        return { ids };
+    }
+    /**
+     * Handle batched event
+     */
+    handleBatchedEvent(fn, event) {
+        const config = fn.config.batchEvents;
+        const keyPath = config.key;
+        // Calculate batch key
+        let batchKey = fn.id;
+        if (keyPath) {
+            const keyValue = getValueByPath({ event }, keyPath);
+            batchKey = `${fn.id}:${String(keyValue)}`;
+        }
+        this.batchManager.addEvent(batchKey, event, config, (events) => {
+            // Invoke function with all batched events
+            this.invokeFunctionWithBatch(fn, events).catch((error) => {
+                this.logger.error(`Function ${fn.id} (batched) failed:`, error);
+            });
+        });
+    }
+    /**
+     * Invoke function with a batch of events
+     */
+    async invokeFunctionWithBatch(fn, events) {
+        const runId = generateRunId();
+        // Build context with all events
+        let ctx = {
+            event: events[0], // First event is the primary
+            events: events,
+            step: this.createStepTools(runId, fn),
+            runId,
+            attempt: 1,
+            logger: this.logger,
+        };
+        // Track the run
+        const run = {
+            runId,
+            functionId: fn.id,
+            status: 'running',
+            event: events[0],
+            startedAt: Date.now(),
+        };
+        this.activeRuns.set(runId, run);
+        try {
+            const result = await fn.handler(ctx);
+            run.status = 'completed';
+            run.completedAt = Date.now();
+            return result;
+        }
+        catch (error) {
+            run.status = 'failed';
+            run.error = ensureError(error).message;
+            run.completedAt = Date.now();
+            throw error;
+        }
+        finally {
+            // Clear step results for this run (memory leak fix)
+            Array.from(this.stepResults.keys()).forEach((key) => {
+                if (key.startsWith(`${runId}:`)) {
+                    this.stepResults.delete(key);
+                }
+            });
+            // Cleanup after a delay
+            setTimeout(() => this.activeRuns.delete(runId), 60000);
+        }
+    }
+    /**
+     * Process cancellation events
+     */
+    async processCancellationEvent(event) {
+        const subscriptions = this.cancelSubscriptions.get(event.name);
+        if (!subscriptions)
+            return;
+        subscriptions.forEach(async ({ functionId, config }) => {
+            // Find matching active runs
+            Array.from(this.activeRuns.entries()).forEach(async ([runId, run]) => {
+                if (run.functionId !== functionId || run.status !== 'running')
+                    return;
+                // Check match condition
+                let shouldCancel = false;
+                if (config.match) {
+                    // Match on field path
+                    const triggerValue = getValueByPath(event, config.match);
+                    const runValue = getValueByPath(run.event, config.match);
+                    shouldCancel = triggerValue === runValue;
+                }
+                else if (config.if) {
+                    // Evaluate expression
+                    shouldCancel = evaluateExpression(config.if, { event, async: run.event });
+                }
+                else {
+                    // No condition, always cancel
+                    shouldCancel = true;
+                }
+                if (shouldCancel) {
+                    await this.cancel(runId, 'Cancelled by event: ' + event.name);
+                }
+            });
+        });
+    }
+    /**
+     * Get active runs for a function
+     */
+    async getRuns(options) {
+        const runs = [];
+        this.activeRuns.forEach((run) => {
+            if (!options.functionId || run.functionId === options.functionId) {
+                runs.push(run);
+            }
+        });
+        return runs;
+    }
+    /**
+     * Get state for a specific run
+     */
+    async getRunState(runId) {
+        return this.activeRuns.get(runId) || null;
+    }
+    /**
+     * Cancel a running function
+     */
+    async cancel(runId, reason) {
+        const run = this.activeRuns.get(runId);
+        if (!run)
+            return;
+        run.status = 'cancelled';
+        run.completedAt = Date.now();
+        // Reject any waiting promises
+        const cancellation = this.runCancellations.get(runId);
+        if (cancellation) {
+            cancellation.reject(new CancellationError(runId, reason));
+            this.runCancellations.delete(runId);
+        }
+        // Clear step results for this run
+        Array.from(this.stepResults.keys()).forEach((key) => {
+            if (key.startsWith(`${runId}:`)) {
+                this.stepResults.delete(key);
+            }
+        });
+        // Remove from active runs
+        this.activeRuns.delete(runId);
+    }
+    /**
+     * Create step tools for a function execution
+     */
+    createStepTools(runId, fn) {
+        const self = this;
+        return {
+            async run(stepId, stepFn) {
+                // Check for cached result (memoization/replay)
+                const cacheKey = `${runId}:${stepId}`;
+                if (self.stepResults.has(cacheKey)) {
+                    return self.stepResults.get(cacheKey);
+                }
+                // Check if cancelled
+                const run = self.activeRuns.get(runId);
+                if (run?.status === 'cancelled') {
+                    throw new CancellationError(runId);
+                }
+                // Apply throttling if configured
+                if (fn.config.throttle) {
+                    const throttleConfig = fn.config.throttle;
+                    const keyPath = throttleConfig.key;
+                    let throttleKey = fn.id;
+                    if (keyPath) {
+                        const run = self.activeRuns.get(runId);
+                        if (run) {
+                            const keyValue = getValueByPath({ event: run.event }, keyPath);
+                            throttleKey = `${fn.id}:${String(keyValue)}`;
+                        }
+                    }
+                    await self.throttleManager.acquire(throttleKey, throttleConfig.count, parseDuration(throttleConfig.period));
+                }
+                try {
+                    const result = await stepFn();
+                    self.stepResults.set(cacheKey, result);
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof NonRetriableError) {
+                        throw error;
+                    }
+                    const err = ensureError(error);
+                    throw new StepError(`Step "${stepId}" failed: ${err.message}`, stepId, { cause: err });
+                }
+            },
+            async sleep(stepId, duration) {
+                const cacheKey = `${runId}:${stepId}`;
+                if (self.stepResults.has(cacheKey)) {
+                    return;
+                }
+                // Check if cancelled
+                const run = self.activeRuns.get(runId);
+                if (run?.status === 'cancelled') {
+                    throw new CancellationError(runId);
+                }
+                const ms = parseDuration(duration);
+                // Create cancellable sleep with proper cleanup
+                await new Promise((resolve, reject) => {
+                    // Cleanup function to clear timeout and remove cancellation handler
+                    const cleanup = () => {
+                        clearTimeout(timeoutId);
+                        self.runCancellations.delete(runId);
+                    };
+                    const timeoutId = setTimeout(() => {
+                        cleanup();
+                        resolve();
+                    }, ms);
+                    // Register for cancellation
+                    self.runCancellations.set(runId, {
+                        reject: (error) => {
+                            cleanup();
+                            reject(error);
+                        },
+                    });
+                });
+                self.stepResults.set(cacheKey, true);
+            },
+            async waitForEvent(stepId, options) {
+                const cacheKey = `${runId}:${stepId}`;
+                if (self.stepResults.has(cacheKey)) {
+                    return self.stepResults.get(cacheKey);
+                }
+                if (!self.waitManager) {
+                    throw new Error('waitForEvent requires DO state to be provided');
+                }
+                try {
+                    const result = await self.waitManager.waitForEvent(options.event, {
+                        timeout: options.timeout,
+                        correlationId: runId,
+                    });
+                    self.stepResults.set(cacheKey, result);
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof WaitTimeoutError) {
+                        self.stepResults.set(cacheKey, null);
+                        return null;
+                    }
+                    throw error;
+                }
+            },
+            async sendEvent(stepId, event) {
+                const cacheKey = `${runId}:${stepId}`;
+                if (self.stepResults.has(cacheKey)) {
+                    return self.stepResults.get(cacheKey);
+                }
+                const result = await self.send(event);
+                self.stepResults.set(cacheKey, result);
+                return result;
+            },
+            async invoke(stepId, options) {
+                const cacheKey = `${runId}:${stepId}`;
+                if (self.stepResults.has(cacheKey)) {
+                    return self.stepResults.get(cacheKey);
+                }
+                const event = {
+                    name: options.function.eventName || `invoke/${options.function.id}`,
+                    data: options.data,
+                    ts: Date.now(),
+                    id: generateEventId(),
+                };
+                // Handle timeout
+                if (options.timeout) {
+                    const timeoutMs = parseDuration(options.timeout);
+                    const result = await Promise.race([
+                        self.invokeFunction(options.function, event),
+                        new Promise((_, reject) => {
+                            setTimeout(() => {
+                                reject(new InvokeTimeoutError(options.function.id, timeoutMs));
+                            }, timeoutMs);
+                        }),
+                    ]);
+                    self.stepResults.set(cacheKey, result);
+                    return result;
+                }
+                const result = await self.invokeFunction(options.function, event);
+                self.stepResults.set(cacheKey, result);
+                return result;
+            },
+            async parallel(stepId, steps) {
+                const cacheKey = `${runId}:${stepId}`;
+                if (self.stepResults.has(cacheKey)) {
+                    return self.stepResults.get(cacheKey);
+                }
+                const results = await Promise.all(steps.map((step) => step()));
+                self.stepResults.set(cacheKey, results);
+                return results;
+            },
+            ai: {
+                async infer(stepId, options) {
+                    const cacheKey = `${runId}:${stepId}`;
+                    if (self.stepResults.has(cacheKey)) {
+                        return self.stepResults.get(cacheKey);
+                    }
+                    // Stub - would integrate with AI providers
+                    throw new Error('AI inference not yet implemented in compat layer');
+                },
+                async wrap(stepId, _model, _options) {
+                    const cacheKey = `${runId}:${stepId}`;
+                    if (self.stepResults.has(cacheKey)) {
+                        return self.stepResults.get(cacheKey);
+                    }
+                    // Stub - would integrate with AI providers
+                    throw new Error('AI wrap not yet implemented in compat layer');
+                },
+            },
+        };
+    }
+    /**
+     * Invoke a function with an event (internal)
+     */
+    async invokeFunction(fn, event) {
+        const runId = generateRunId();
+        // Track the run
+        const run = {
+            runId,
+            functionId: fn.id,
+            status: 'running',
+            event: event,
+            startedAt: Date.now(),
+        };
+        this.activeRuns.set(runId, run);
+        // Apply concurrency limits
+        if (fn.config.concurrency) {
+            const concurrencyConfig = typeof fn.config.concurrency === 'number'
+                ? { limit: fn.config.concurrency }
+                : fn.config.concurrency;
+            let concurrencyKey = fn.id;
+            if (concurrencyConfig.key) {
+                const keyValue = getValueByPath({ event }, concurrencyConfig.key);
+                concurrencyKey = `${fn.id}:${String(keyValue)}`;
+            }
+            else if (concurrencyConfig.scope === 'env') {
+                concurrencyKey = `env:${this.id}`;
+            }
+            else if (concurrencyConfig.scope === 'account') {
+                concurrencyKey = 'account';
+            }
+            await this.concurrencyManager.acquire(concurrencyKey, concurrencyConfig.limit);
+            try {
+                return await this.executeFunction(fn, event, runId, run);
+            }
+            finally {
+                this.concurrencyManager.release(concurrencyKey);
+            }
+        }
+        return this.executeFunction(fn, event, runId, run);
+    }
+    /**
+     * Execute function (shared logic for invoke)
+     */
+    async executeFunction(fn, event, runId, run) {
+        // Apply middleware
+        let middlewareLifecycles = [];
+        for (const mw of this.middleware) {
+            if (mw.onFunctionRun) {
+                const lifecycle = await mw.onFunctionRun({
+                    event,
+                    runId,
+                    fn: fn,
+                });
+                middlewareLifecycles.push(lifecycle);
+            }
+        }
+        // Build context
+        let ctx = {
+            event,
+            events: [event],
+            step: this.createStepTools(runId, fn),
+            runId,
+            attempt: 1,
+            logger: this.logger,
+        };
+        // Transform input via middleware
+        for (const lifecycle of middlewareLifecycles) {
+            if (lifecycle.transformInput) {
+                ctx = (await lifecycle.transformInput(ctx));
+            }
+        }
+        // Before execution hooks
+        for (const lifecycle of middlewareLifecycles) {
+            await lifecycle.beforeExecution?.();
+        }
+        try {
+            // Execute the function
+            let result = await fn.handler(ctx);
+            // Transform output via middleware
+            for (const lifecycle of middlewareLifecycles) {
+                if (lifecycle.transformOutput) {
+                    result = (await lifecycle.transformOutput(result));
+                }
+            }
+            // After execution hooks
+            for (const lifecycle of middlewareLifecycles) {
+                await lifecycle.afterExecution?.();
+            }
+            run.status = 'completed';
+            run.completedAt = Date.now();
+            return result;
+        }
+        catch (error) {
+            const err = ensureError(error);
+            // Error hooks
+            for (const lifecycle of middlewareLifecycles) {
+                await lifecycle.onError?.(err);
+            }
+            run.status = 'failed';
+            run.error = err.message;
+            run.completedAt = Date.now();
+            throw error;
+        }
+        finally {
+            // Cleanup run cancellation handler
+            this.runCancellations.delete(runId);
+            // Clear step results for this run (memory leak fix)
+            // Step results are only needed during execution for memoization/replay
+            // Once execution completes (success or failure), they can be cleaned up
+            Array.from(this.stepResults.keys()).forEach((key) => {
+                if (key.startsWith(`${runId}:`)) {
+                    this.stepResults.delete(key);
+                }
+            });
+            // Cleanup after a delay
+            setTimeout(() => this.activeRuns.delete(runId), 60000);
+        }
+    }
+    /**
+     * Get all registered functions
+     */
+    getFunctions() {
+        return Array.from(this.functions.values());
+    }
+    /**
+     * Get a function by ID
+     */
+    getFunction(id) {
+        return this.functions.get(id);
+    }
+    /**
+     * Get failed runs for observability
+     */
+    getFailedRuns() {
+        return new Map(this.failedRuns);
+    }
+    /**
+     * Get count of currently running background tasks
+     */
+    getRunningTaskCount() {
+        return this.runningTasks.size;
+    }
+    /**
+     * Wait for all running background tasks to complete
+     * Useful for graceful shutdown or testing
+     */
+    async waitForAllTasks() {
+        const tasks = Array.from(this.runningTasks.values());
+        await Promise.allSettled(tasks);
+    }
+}
+/**
+ * Create a serve handler for HTTP frameworks
+ */
+export function serve(inngest, functions, config) {
+    // Register all functions
+    for (const fn of functions) {
+        inngest.createFunction(fn.config, fn.trigger, fn.handler);
+    }
+    // Return a fetch handler
+    return async (request) => {
+        const url = new URL(request.url);
+        const basePath = config?.path ?? '/api/inngest';
+        // Health check
+        if (request.method === 'GET' && url.pathname === basePath) {
+            return new Response(JSON.stringify({
+                appId: inngest.id,
+                functions: functions.map((f) => ({
+                    id: f.id,
+                    name: f.name,
+                    trigger: f.trigger,
+                })),
+            }), { headers: { 'Content-Type': 'application/json' } });
+        }
+        // Event ingestion
+        if (request.method === 'POST' && url.pathname === basePath) {
+            try {
+                const body = await request.json();
+                const events = Array.isArray(body) ? body : [body];
+                const result = await inngest.send(events);
+                return new Response(JSON.stringify(result), {
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            catch (error) {
+                return new Response(JSON.stringify({ error: ensureError(error).message }), {
+                    status: 400,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+        }
+        return new Response('Not Found', { status: 404 });
+    };
+}
+// ============================================================================
+// EXPORTS
+// ============================================================================
+export default Inngest;
+//# sourceMappingURL=index.js.map