ai-workflows 2.1.1 → 2.3.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAGH,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAG9F,OAAO,EAAE,EAAE,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAGxF,OAAO,EACL,KAAK,EACL,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,MAAM,EACN,YAAY,EACZ,cAAc,GACf,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAG7C,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAG3E,YAAY,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,WAAW,EACX,OAAO,EACP,UAAU,EACV,eAAe,EACf,eAAe,EACf,UAAU,EACV,YAAY,GACb,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -61,6 +61,13 @@
  */
 // Main Workflow API
 export { Workflow, createTestContext, parseEvent } from './workflow.js';
+// WorkflowRuntime - single owner of the `$` runtime contract
+// (composes cascade-context, database-context, on/send/every internally).
+// New callers should reach for createWorkflowRuntime() to understand exactly
+// what `$` contains end-to-end. The Workflow() function wraps a runtime with
+// schedule/timer lifecycle; for tests, runtime.dispatch() is the canonical
+// surface.
+export { createWorkflowRuntime, } from './runtime.js';
 // Standalone event handling (for global registration)
 export { on, registerEventHandler, getEventHandlers, clearEventHandlers } from './on.js';
 // Standalone scheduling (for global registration)
@@ -69,4 +76,22 @@ export { every, registerScheduleHandler, getScheduleHandlers, clearScheduleHandl
 export { send, getEventBus } from './send.js';
 // Context
 export { createWorkflowContext, createIsolatedContext } from './context.js';
+// Cascade Context - Correlation IDs and step metadata
+export { createCascadeContext, recordStep, withCascadeContext, } from './cascade-context.js';
+// Dependency Graph
+export { DependencyGraph, CircularDependencyError, MissingDependencyError, } from './dependency-graph.js';
+// Topological Sort - Execution ordering algorithms
+export { topologicalSort, topologicalSortKahn, topologicalSortDFS, getExecutionLevels, CycleDetectedError, MissingNodeError, } from './graph/topological-sort.js';
+// Barrier/Join Semantics - Parallel step coordination
+export { Barrier, BarrierTimeoutError, createBarrier, waitForAll, waitForAny, withConcurrencyLimit, } from './barrier.js';
+// Cascade Executor - code -> generative -> agentic -> human pattern
+export { CascadeExecutor, CascadeTimeoutError, TierSkippedError, AllTiersFailedError, TIER_ORDER, DEFAULT_TIER_TIMEOUTS, } from './cascade-executor.js';
+// DurableStep - Cloudflare Workflows step wrapper
+export { DurableStep, StepContext as DurableStepContext, 
+// Cascade types
+DurableCascadeStep, AllTiersFailed, CascadeTimeout, DEFAULT_CASCADE_TIMEOUTS, CASCADE_TIER_ORDER, } from './worker/durable-step.js';
+// WorkflowBuilder DSL - Fluent API for building durable workflows
+export { workflow, WorkflowBuilder, } from './workflow-builder.js';
+// WorkflowStateAdapter - Persistent state storage
+export { WorkflowStateAdapter, } from './worker/state-adapter.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,oBAAoB;AACpB,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAyB,MAAM,eAAe,CAAA;AAE9F,sDAAsD;AACtD,OAAO,EAAE,EAAE,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAExF,kDAAkD;AAClD,OAAO,EACL,KAAK,EACL,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,MAAM,EACN,YAAY,EACZ,cAAc,GACf,MAAM,YAAY,CAAA;AAEnB,iBAAiB;AACjB,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE7C,UAAU;AACV,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,oBAAoB;AACpB,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAyB,MAAM,eAAe,CAAA;AAE9F,6DAA6D;AAC7D,0EAA0E;AAC1E,6EAA6E;AAC7E,6EAA6E;AAC7E,2EAA2E;AAC3E,WAAW;AACX,OAAO,EACL,qBAAqB,GAGtB,MAAM,cAAc,CAAA;AAErB,sDAAsD;AACtD,OAAO,EAAE,EAAE,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAExF,kDAAkD;AAClD,OAAO,EACL,KAAK,EACL,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,MAAM,EACN,YAAY,EACZ,cAAc,GACf,MAAM,YAAY,CAAA;AAEnB,iBAAiB;AACjB,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE7C,UAAU;AACV,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAE3E,sDAAsD;AACtD,OAAO,EACL,oBAAoB,EACpB,UAAU,EACV,kBAAkB,GASnB,MAAM,sBAAsB,CAAA;AAE7B,mBAAmB;AACnB,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,sBAAsB,GAKvB,MAAM,uBAAuB,CAAA;AAE9B,mDAAmD;AACnD,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,GAKjB,MAAM,6BAA6B,CAAA;AAEpC,sDAAsD;AACtD,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,aAAa,EACb,UAAU,EACV,UAAU,EACV,oBAAoB,GAQrB,MAAM,cAAc,CAAA;AAErB,oEAAoE;AACpE,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,UAAU,EACV,qBAAqB,GAUtB,MAAM,uBAAuB,CAAA;AAE9B,kDAAkD;AAClD,OAAO,EACL,WAAW,EACX,WAAW,IAAI,kBAAkB;AAMjC,gBAAgB;AAChB,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,wBAAwB,EACxB,kBAAkB,GAanB,MAAM,0BAA0B,CAAA;AAEjC,kEAAkE;AAClE,OAAO,EACL,QAAQ,EACR,eAAe,GAahB,MAAM,uBAAuB,CAAA;AAE9B,kDAAkD;AAClD,OAAO,EACL,oBAAoB,GAMrB,MAAM,2BAA2B,CAAA"}

package/dist/logger.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Configurable Logger Interface
+ *
+ * Provides a pluggable logging abstraction for ai-workflows.
+ * By default uses console.log/warn/error, but can be replaced
+ * with any logging implementation.
+ *
+ * @example
+ * ```ts
+ * import { setLogger, getLogger } from 'ai-workflows'
+ *
+ * // Use default console logger
+ * const logger = getLogger()
+ * logger.log('[workflow] Starting', { workflowId: '123' })
+ *
+ * // Set a custom logger
+ * setLogger({
+ *   log: (msg, data) => winston.info(msg, data),
+ *   warn: (msg, data) => winston.warn(msg, data),
+ *   error: (msg, error) => winston.error(msg, { error }),
+ * })
+ *
+ * // Disable logging
+ * setLogger({
+ *   log: () => {},
+ *   warn: () => {},
+ *   error: () => {},
+ * })
+ * ```
+ */
+/**
+ * Logger interface for ai-workflows
+ *
+ * Implementations must provide log, warn, and error methods.
+ * Data parameter is optional and can be any value for context.
+ */
+export interface Logger {
+    /**
+     * Log informational messages
+     * @param msg - The log message
+     * @param data - Optional data for context
+     */
+    log(msg: string, data?: unknown): void;
+    /**
+     * Log warning messages
+     * @param msg - The warning message
+     * @param data - Optional data for context
+     */
+    warn(msg: string, data?: unknown): void;
+    /**
+     * Log error messages
+     * @param msg - The error message
+     * @param error - Optional error object or data
+     */
+    error(msg: string, error?: unknown): void;
+}
+/**
+ * Default console logger implementation
+ *
+ * Uses console.log, console.warn, and console.error.
+ */
+export declare const consoleLogger: Logger;
+/**
+ * No-op logger that discards all messages
+ *
+ * Useful for silencing logs in tests or production.
+ */
+export declare const noopLogger: Logger;
+/**
+ * Get the current logger instance
+ *
+ * @returns The current Logger implementation
+ */
+export declare function getLogger(): Logger;
+/**
+ * Set the logger implementation
+ *
+ * @param logger - The Logger implementation to use
+ *
+ * @example
+ * ```ts
+ * // Use a custom logger
+ * setLogger({
+ *   log: (msg, data) => myLogger.info(msg, data),
+ *   warn: (msg, data) => myLogger.warn(msg, data),
+ *   error: (msg, error) => myLogger.error(msg, { error }),
+ * })
+ *
+ * // Disable logging
+ * setLogger(noopLogger)
+ *
+ * // Reset to console
+ * setLogger(consoleLogger)
+ * ```
+ */
+export declare function setLogger(logger: Logger): void;
+/**
+ * Reset the logger to the default console logger
+ */
+export declare function resetLogger(): void;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IAEtC;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IAEvC;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;CAC1C;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,MAwB3B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,MAIxB,CAAA;AAQD;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAElC"}

package/dist/logger.js

@@ -0,0 +1,115 @@
+/**
+ * Configurable Logger Interface
+ *
+ * Provides a pluggable logging abstraction for ai-workflows.
+ * By default uses console.log/warn/error, but can be replaced
+ * with any logging implementation.
+ *
+ * @example
+ * ```ts
+ * import { setLogger, getLogger } from 'ai-workflows'
+ *
+ * // Use default console logger
+ * const logger = getLogger()
+ * logger.log('[workflow] Starting', { workflowId: '123' })
+ *
+ * // Set a custom logger
+ * setLogger({
+ *   log: (msg, data) => winston.info(msg, data),
+ *   warn: (msg, data) => winston.warn(msg, data),
+ *   error: (msg, error) => winston.error(msg, { error }),
+ * })
+ *
+ * // Disable logging
+ * setLogger({
+ *   log: () => {},
+ *   warn: () => {},
+ *   error: () => {},
+ * })
+ * ```
+ */
+/**
+ * Default console logger implementation
+ *
+ * Uses console.log, console.warn, and console.error.
+ */
+export const consoleLogger = {
+    log(msg, data) {
+        if (data !== undefined) {
+            console.log(msg, data);
+        }
+        else {
+            console.log(msg);
+        }
+    },
+    warn(msg, data) {
+        if (data !== undefined) {
+            console.warn(msg, data);
+        }
+        else {
+            console.warn(msg);
+        }
+    },
+    error(msg, error) {
+        if (error !== undefined) {
+            console.error(msg, error);
+        }
+        else {
+            console.error(msg);
+        }
+    },
+};
+/**
+ * No-op logger that discards all messages
+ *
+ * Useful for silencing logs in tests or production.
+ */
+export const noopLogger = {
+    log() { },
+    warn() { },
+    error() { },
+};
+/**
+ * Current logger instance
+ * Defaults to consoleLogger
+ */
+let currentLogger = consoleLogger;
+/**
+ * Get the current logger instance
+ *
+ * @returns The current Logger implementation
+ */
+export function getLogger() {
+    return currentLogger;
+}
+/**
+ * Set the logger implementation
+ *
+ * @param logger - The Logger implementation to use
+ *
+ * @example
+ * ```ts
+ * // Use a custom logger
+ * setLogger({
+ *   log: (msg, data) => myLogger.info(msg, data),
+ *   warn: (msg, data) => myLogger.warn(msg, data),
+ *   error: (msg, error) => myLogger.error(msg, { error }),
+ * })
+ *
+ * // Disable logging
+ * setLogger(noopLogger)
+ *
+ * // Reset to console
+ * setLogger(consoleLogger)
+ * ```
+ */
+export function setLogger(logger) {
+    currentLogger = logger;
+}
+/**
+ * Reset the logger to the default console logger
+ */
+export function resetLogger() {
+    currentLogger = consoleLogger;
+}
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AA+BH;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAW;IACnC,GAAG,CAAC,GAAW,EAAE,IAAc;QAC7B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;QACxB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAClB,CAAC;IACH,CAAC;IAED,IAAI,CAAC,GAAW,EAAE,IAAc;QAC9B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;QACzB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QACnB,CAAC;IACH,CAAC;IAED,KAAK,CAAC,GAAW,EAAE,KAAe;QAChC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;QAC3B,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACpB,CAAC;IACH,CAAC;CACF,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAW;IAChC,GAAG,KAAU,CAAC;IACd,IAAI,KAAU,CAAC;IACf,KAAK,KAAU,CAAC;CACjB,CAAA;AAED;;;GAGG;AACH,IAAI,aAAa,GAAW,aAAa,CAAA;AAEzC;;;;GAIG;AACH,MAAM,UAAU,SAAS;IACvB,OAAO,aAAa,CAAA;AACtB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,SAAS,CAAC,MAAc;IACtC,aAAa,GAAG,MAAM,CAAA;AACxB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW;IACzB,aAAa,GAAG,aAAa,CAAA;AAC/B,CAAC"}

package/dist/on.d.ts

@@ -5,8 +5,12 @@
  *   on.Customer.created(customer => { ... })
  *   on.Order.completed(order => { ... })
  *   on.Payment.failed(payment => { ... })
+ *
+ * With dependencies:
+ *   on.Step2.complete(handler, { dependsOn: 'Step1.complete' })
+ *   on.Step3.complete(handler, { dependsOn: ['Step1.complete', 'Step2.complete'] })
  */
-import type { EventHandler, EventRegistration } from './types.js';
+import type { EventHandler, EventRegistration, DependencyConfig, OnProxy } from './types.js';
 /**
  * Get all registered event handlers
  */
@@ -18,15 +22,37 @@ export declare function clearEventHandlers(): void;
 /**
  * Register an event handler directly
  */
-export declare function registerEventHandler(noun: string, event: string, handler: EventHandler): void;
+export declare function registerEventHandler(noun: string, event: string, handler: EventHandler, dependencies?: DependencyConfig): void;
+/**
+ * Handler registration callback type
+ * Used by createTypedOnProxy to customize handler registration
+ */
+export type OnProxyRegistrationCallback = (noun: string, event: string, handler: EventHandler, dependencies?: DependencyConfig) => void;
 /**
- * Event proxy type for on.Noun.event pattern
+ * Create a typed OnProxy with proper TypeScript generics
+ *
+ * This factory function creates a two-level proxy that allows:
+ *   proxy.Customer.created(handler)
+ *   proxy.Order.shipped(handler)
+ *
+ * The first property access captures the noun (Customer, Order)
+ * The second property access captures the event (created, shipped)
+ * The function call invokes the registration callback
+ *
+ * @param registerCallback - Function called when a handler is registered
+ * @returns A properly typed OnProxy
+ *
+ * @example
+ * ```ts
+ * // Create proxy with custom registration
+ * const myOn = createTypedOnProxy((noun, event, handler, deps) => {
+ *   myRegistry.push({ noun, event, handler, deps })
+ * })
+ *
+ * myOn.Customer.created(handler) // Properly typed!
+ * ```
  */
-type EventProxy = {
-    [noun: string]: {
-        [event: string]: (handler: EventHandler) => void;
-    };
-};
+export declare function createTypedOnProxy(registerCallback: OnProxyRegistrationCallback): OnProxy;
 /**
  * The `on` object for registering event handlers
  *
@@ -44,6 +70,5 @@ type EventProxy = {
  * })
  * ```
  */
-export declare const on: EventProxy;
-export {};
+export declare const on: OnProxy;
 //# sourceMappingURL=on.d.ts.map

package/dist/on.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"on.d.ts","sourceRoot":"","sources":["../src/on.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAOjE;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,iBAAiB,EAAE,CAEtD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,YAAY,GACpB,IAAI,CAON;AAED;;GAEG;AACH,KAAK,UAAU,GAAG;IAChB,CAAC,IAAI,EAAE,MAAM,GAAG;QACd,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAA;KACjD,CAAA;CACF,CAAA;AA6BD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,EAAE,YAAkB,CAAA"}
+{"version":3,"file":"on.d.ts","sourceRoot":"","sources":["../src/on.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,OAAO,EAIR,MAAM,YAAY,CAAA;AAOnB;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,iBAAiB,EAAE,CAEtD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,YAAY,EACrB,YAAY,CAAC,EAAE,gBAAgB,GAC9B,IAAI,CAQN;AAED;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG,CACxC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,YAAY,EACrB,YAAY,CAAC,EAAE,gBAAgB,KAC5B,IAAI,CAAA;AAET;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,2BAA2B,GAAG,OAAO,CA8BzF;AAYD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,EAAE,SAAkB,CAAA"}

package/dist/on.js

@@ -5,6 +5,10 @@
  *   on.Customer.created(customer => { ... })
  *   on.Order.completed(order => { ... })
  *   on.Payment.failed(payment => { ... })
+ *
+ * With dependencies:
+ *   on.Step2.complete(handler, { dependsOn: 'Step1.complete' })
+ *   on.Step3.complete(handler, { dependsOn: ['Step1.complete', 'Step2.complete'] })
  */
 /**
  * Registry of event handlers
@@ -25,39 +29,69 @@ export function clearEventHandlers() {
 /**
  * Register an event handler directly
  */
-export function registerEventHandler(noun, event, handler) {
+export function registerEventHandler(noun, event, handler, dependencies) {
     eventRegistry.push({
         noun,
         event,
         handler,
         source: handler.toString(),
+        ...(dependencies !== undefined && { dependencies }),
     });
 }
 /**
- * Create the `on` proxy
+ * Create a typed OnProxy with proper TypeScript generics
  *
- * This creates a proxy that allows:
- *   on.Customer.created(handler)
- *   on.Order.shipped(handler)
+ * This factory function creates a two-level proxy that allows:
+ *   proxy.Customer.created(handler)
+ *   proxy.Order.shipped(handler)
  *
  * The first property access captures the noun (Customer, Order)
  * The second property access captures the event (created, shipped)
- * The function call registers the handler
+ * The function call invokes the registration callback
+ *
+ * @param registerCallback - Function called when a handler is registered
+ * @returns A properly typed OnProxy
+ *
+ * @example
+ * ```ts
+ * // Create proxy with custom registration
+ * const myOn = createTypedOnProxy((noun, event, handler, deps) => {
+ *   myRegistry.push({ noun, event, handler, deps })
+ * })
+ *
+ * myOn.Customer.created(handler) // Properly typed!
+ * ```
  */
-function createOnProxy() {
-    return new Proxy({}, {
-        get(_target, noun) {
-            // Return a proxy for the event level
-            return new Proxy({}, {
-                get(_eventTarget, event) {
-                    // Return a function that registers the handler
-                    return (handler) => {
-                        registerEventHandler(noun, event, handler);
-                    };
-                }
-            });
-        }
+export function createTypedOnProxy(registerCallback) {
+    // Create typed handler for the noun level (event accessors)
+    const createNounHandler = (noun) => ({
+        get(_target, event, _receiver) {
+            // Return a function that registers the handler with optional dependencies
+            return (handler, dependencies) => {
+                registerCallback(noun, event, handler, dependencies);
+            };
+        },
     });
+    // Create typed handler for the top-level proxy (noun accessors)
+    const onHandler = {
+        get(_target, noun, _receiver) {
+            // Return a proxy for the event level with typed handler
+            const eventTarget = {};
+            return new Proxy(eventTarget, createNounHandler(noun));
+        },
+    };
+    // Create and return the typed OnProxy
+    const target = {};
+    return new Proxy(target, onHandler);
+}
+/**
+ * Create the `on` proxy using the global event registry
+ *
+ * This is the default implementation that uses registerEventHandler
+ * for backward compatibility with the standalone `on` export.
+ */
+function createOnProxy() {
+    return createTypedOnProxy(registerEventHandler);
 }
 /**
  * The `on` object for registering event handlers

package/dist/on.js.map

@@ -1 +1 @@
-{"version":3,"file":"on.js","sourceRoot":"","sources":["../src/on.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;GAEG;AACH,MAAM,aAAa,GAAwB,EAAE,CAAA;AAE7C;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,CAAC,GAAG,aAAa,CAAC,CAAA;AAC3B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAChC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAA;AAC1B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAY,EACZ,KAAa,EACb,OAAqB;IAErB,aAAa,CAAC,IAAI,CAAC;QACjB,IAAI;QACJ,KAAK;QACL,OAAO;QACP,MAAM,EAAE,OAAO,CAAC,QAAQ,EAAE;KAC3B,CAAC,CAAA;AACJ,CAAC;AAWD;;;;;;;;;;GAUG;AACH,SAAS,aAAa;IACpB,OAAO,IAAI,KAAK,CAAC,EAAgB,EAAE;QACjC,GAAG,CAAC,OAAO,EAAE,IAAY;YACvB,qCAAqC;YACrC,OAAO,IAAI,KAAK,CAAC,EAAE,EAAE;gBACnB,GAAG,CAAC,YAAY,EAAE,KAAa;oBAC7B,+CAA+C;oBAC/C,OAAO,CAAC,OAAqB,EAAE,EAAE;wBAC/B,oBAAoB,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAA;oBAC5C,CAAC,CAAA;gBACH,CAAC;aACF,CAAC,CAAA;QACJ,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,aAAa,EAAE,CAAA"}
+{"version":3,"file":"on.js","sourceRoot":"","sources":["../src/on.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAYH;;GAEG;AACH,MAAM,aAAa,GAAwB,EAAE,CAAA;AAE7C;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,CAAC,GAAG,aAAa,CAAC,CAAA;AAC3B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAChC,aAAa,CAAC,MAAM,GAAG,CAAC,CAAA;AAC1B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAY,EACZ,KAAa,EACb,OAAqB,EACrB,YAA+B;IAE/B,aAAa,CAAC,IAAI,CAAC;QACjB,IAAI;QACJ,KAAK;QACL,OAAO;QACP,MAAM,EAAE,OAAO,CAAC,QAAQ,EAAE;QAC1B,GAAG,CAAC,YAAY,KAAK,SAAS,IAAI,EAAE,YAAY,EAAE,CAAC;KACpD,CAAC,CAAA;AACJ,CAAC;AAaD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,kBAAkB,CAAC,gBAA6C;IAC9E,4DAA4D;IAC5D,MAAM,iBAAiB,GAAG,CAAC,IAAY,EAAyB,EAAE,CAAC,CAAC;QAClE,GAAG,CACD,OAAyF,EACzF,KAAa,EACb,SAAkB;YAElB,0EAA0E;YAC1E,OAAO,CAAC,OAAqB,EAAE,YAA+B,EAAE,EAAE;gBAChE,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,CAAC,CAAA;YACtD,CAAC,CAAA;QACH,CAAC;KACF,CAAC,CAAA;IAEF,gEAAgE;IAChE,MAAM,SAAS,GAAmB;QAChC,GAAG,CAAC,OAAuC,EAAE,IAAY,EAAE,SAAkB;YAC3E,wDAAwD;YACxD,MAAM,WAAW,GAGb,EAAE,CAAA;YACN,OAAO,IAAI,KAAK,CAAC,WAAW,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAmB,CAAA;QAC1E,CAAC;KACF,CAAA;IAED,sCAAsC;IACtC,MAAM,MAAM,GAAmC,EAAE,CAAA;IACjD,OAAO,IAAI,KAAK,CAAC,MAAM,EAAE,SAAS,CAAY,CAAA;AAChD,CAAC;AAED;;;;;GAKG;AACH,SAAS,aAAa;IACpB,OAAO,kBAAkB,CAAC,oBAAoB,CAAC,CAAA;AACjD,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,aAAa,EAAE,CAAA"}

package/dist/runtime.d.ts

@@ -0,0 +1,169 @@
+/**
+ * WorkflowRuntime - Owns the `$` runtime contract
+ *
+ * Purpose: Single module that owns end-to-end construction of the `$` context
+ * a workflow handler receives. Before this module existed the answer to
+ * "what does the handler see when it runs?" was stitched together from three
+ * separate modules:
+ *
+ *   - cascade-context.ts (5W+H tracing)
+ *   - database-context.ts (DB injection)
+ *   - on.ts / send.ts / every.ts (event dispatch)
+ *
+ * Callers reading `$.on.Order.placed(...)` had no single place to discover
+ * what `$` contains. Tests had to assemble three contexts independently to
+ * exercise a handler.
+ *
+ * `WorkflowRuntime` collapses these into one port:
+ *
+ *   - {@link createWorkflowRuntime} builds the runtime, owning the event/
+ *     schedule registries, the optional `DatabaseContext` injection, and the
+ *     optional cascade context.
+ *   - The runtime exposes `$` (a {@link WorkflowContext}) and `dispatch()` —
+ *     the latter is the test surface for exercising a handler against an
+ *     event without spinning up a full {@link Workflow}.
+ *
+ * The cascade-context, database-context, and on/send/every modules continue
+ * to exist as **internal seams** — private adapters the runtime composes.
+ * `DatabaseContext` stays as an injected port so callers can wire either
+ * `ai-database`'s adapter or an in-memory adapter; this keeps `ai-workflows`
+ * Layer 0.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { createWorkflowRuntime } from 'ai-workflows'
+ *
+ * const runtime = createWorkflowRuntime()
+ * runtime.register('Customer', 'created', async (customer, $) => {
+ *   $.log('New customer:', customer)
+ * })
+ * await runtime.dispatch('Customer.created', { id: '123' })
+ * ```
+ *
+ * @example With injected DatabaseContext
+ * ```ts
+ * import { createWorkflowRuntime, createMemoryDatabaseContext } from 'ai-workflows'
+ *
+ * const runtime = createWorkflowRuntime({ db: createMemoryDatabaseContext() })
+ * ```
+ *
+ * @example Direct handler dispatch (test surface)
+ * ```ts
+ * const runtime = createWorkflowRuntime()
+ * const handler = vi.fn()
+ * runtime.register('Order', 'placed', handler)
+ * await runtime.dispatch('Order.placed', { id: 'o-1' })
+ * expect(handler).toHaveBeenCalled()
+ * ```
+ *
+ * @packageDocumentation
+ */
+import type { DatabaseContext, EventHandler, EventRegistration, ParsedEvent, ScheduleHandler, ScheduleInterval, ScheduleRegistration, WorkflowContext, WorkflowState, DependencyConfig } from './types.js';
+import { type CascadeContext } from './cascade-context.js';
+/**
+ * Parse an event string in `Noun.event` form. Returns `null` for invalid
+ * input. Lives on the runtime because dispatch is the only thing that needs
+ * to crack event names; `workflow.ts` re-exports it for back-compat.
+ */
+export declare function parseEvent(event: string): ParsedEvent | null;
+/**
+ * Options for constructing a {@link WorkflowRuntime}.
+ *
+ * All options are optional — a runtime constructed with no arguments runs
+ * fully in-memory with no persistence and no parent trace.
+ */
+export interface WorkflowRuntimeOptions {
+    /**
+     * Initial state context (key/value bag exposed as `$.state`).
+     * Cloned defensively at construction so the caller's object is not mutated.
+     */
+    context?: Record<string, unknown>;
+    /**
+     * Optional persistence port. When provided, `$.send` records events and
+     * `$.do` records actions through this adapter. When omitted, events and
+     * actions are still delivered in-memory but not persisted.
+     */
+    db?: DatabaseContext;
+    /**
+     * Optional cascade context for distributed tracing / 5W+H step recording.
+     * If omitted a fresh root cascade context is created.
+     */
+    cascade?: CascadeContext;
+    /**
+     * Optional name for the cascade context (used when cascade is auto-created).
+     */
+    name?: string;
+}
+/**
+ * Public surface of the workflow runtime.
+ *
+ * The runtime owns construction of `$` and provides a single dispatch port
+ * for delivering events. Internal modules (cascade-context, database-context,
+ * on/send/every) are composed here, not exposed.
+ */
+export interface WorkflowRuntime {
+    /**
+     * The `$` context handed to event and schedule handlers. This is the
+     * single source of truth for "what does a handler see when it runs."
+     */
+    readonly $: WorkflowContext;
+    /**
+     * The cascade context owned by this runtime. Exposed for distributed
+     * tracing integration; not part of the handler-facing surface.
+     */
+    readonly cascade: CascadeContext;
+    /**
+     * Register an event handler under a noun/event pair.
+     *
+     * Equivalent to `$.on.<Noun>.<event>(handler)`; provided as a direct method
+     * for tests and callers that hold the runtime reference rather than `$`.
+     */
+    register(noun: string, event: string, handler: EventHandler, dependencies?: DependencyConfig): void;
+    /**
+     * Register a schedule handler under an interval.
+     * Schedule timers are not started by the runtime — the {@link Workflow}
+     * instance handles that. The runtime only tracks registrations.
+     */
+    registerSchedule(interval: ScheduleInterval, handler: ScheduleHandler): void;
+    /**
+     * Dispatch an event to all matching registered handlers.
+     *
+     * This is the canonical test surface — exercise a handler by registering
+     * it on the runtime and calling `dispatch`. Awaits all handlers; rethrows
+     * the first error if any handler throws.
+     */
+    dispatch(event: string, data: unknown): Promise<void>;
+    /**
+     * Dispatch an event and return the result of the first matching handler.
+     * Used by `$.do` and `$.try` semantics — `do` is the durable variant that
+     * also persists through the database adapter when one is configured.
+     */
+    execute<TResult = unknown>(event: string, data: unknown, durable: boolean): Promise<TResult>;
+    /**
+     * All event handlers registered on this runtime.
+     * Returns the live array (mutated as new handlers register) so callers
+     * such as the {@link Workflow} lifecycle wrapper can read it as a definition.
+     */
+    getEventRegistry(): EventRegistration[];
+    /**
+     * All schedule handlers registered on this runtime. See {@link getEventRegistry}
+     * for sharing semantics.
+     */
+    getScheduleRegistry(): ScheduleRegistration[];
+    /** Mutable workflow state (context bag + history). */
+    readonly state: WorkflowState;
+}
+/**
+ * Construct a {@link WorkflowRuntime}.
+ *
+ * The runtime is the single owner of the `$` contract — it composes:
+ *
+ *   1. Event/schedule registries (the dispatch half of on/send/every).
+ *   2. The optional injected `DatabaseContext` for durable record-keeping.
+ *   3. A cascade context for 5W+H tracing.
+ *
+ * The returned `runtime.$` is what handlers receive; `runtime.dispatch` is
+ * the canonical test surface.
+ */
+export declare function createWorkflowRuntime(options?: WorkflowRuntimeOptions): WorkflowRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,EAEf,aAAa,EACb,gBAAgB,EAGjB,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAGhF;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAU5D;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAEjC;;;;OAIG;IACH,EAAE,CAAC,EAAE,eAAe,CAAA;IAEpB;;;OAGG;IACH,OAAO,CAAC,EAAE,cAAc,CAAA;IAExB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,CAAC,EAAE,eAAe,CAAA;IAE3B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAEhC;;;;;OAKG;IACH,QAAQ,CACN,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,YAAY,EACrB,YAAY,CAAC,EAAE,gBAAgB,GAC9B,IAAI,CAAA;IAEP;;;;OAIG;IACH,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAAA;IAE5E;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAErD;;;;OAIG;IACH,OAAO,CAAC,OAAO,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAE5F;;;;OAIG;IACH,gBAAgB,IAAI,iBAAiB,EAAE,CAAA;IAEvC;;;OAGG;IACH,mBAAmB,IAAI,oBAAoB,EAAE,CAAA;IAE7C,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAA;CAC9B;AASD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,sBAA2B,GAAG,eAAe,CAqN3F"}