@hazeljs/flow 0.2.0-beta.75

package/dist/engine/FlowEngine.d.ts

@@ -0,0 +1,46 @@
+import type { FlowDefinition, FlowRunStatus } from '../types/FlowTypes.js';
+import type { FlowRunRow } from '../persistence/storage.js';
+import type { FlowStorage } from '../persistence/storage.js';
+export interface FlowEngineOptions {
+    /** Storage (default: in-memory). Use createPrismaStorage(prisma) from @hazeljs/flow/prisma for DB. */
+    storage?: FlowStorage;
+    services?: Record<string, unknown>;
+}
+export interface StartRunArgs {
+    flowId: string;
+    version: string;
+    tenantId?: string;
+    input: unknown;
+    initialState?: Record<string, unknown>;
+}
+export interface StartRunResult {
+    runId: string;
+    status: FlowRunStatus;
+}
+export declare class FlowEngine {
+    private readonly storage;
+    private readonly services;
+    private readonly defRegistry;
+    constructor(options?: FlowEngineOptions);
+    registerDefinition(def: FlowDefinition): Promise<void>;
+    private getDefinition;
+    startRun(args: StartRunArgs): Promise<StartRunResult>;
+    tick(runId: string): Promise<FlowRunRow>;
+    private tickCore;
+    resumeRun(runId: string, payload?: unknown): Promise<FlowRunRow>;
+    getRun(runId: string): Promise<FlowRunRow | null>;
+    getRunningRunIds(): Promise<string[]>;
+    listFlows(): Promise<Array<{
+        flowId: string;
+        version: string;
+        definitionJson: unknown;
+    }>>;
+    getTimeline(runId: string): Promise<Array<{
+        at: Date;
+        type: string;
+        nodeId: string | null;
+        attempt: number | null;
+        payloadJson: unknown;
+    }>>;
+}
+//# sourceMappingURL=FlowEngine.d.ts.map

package/dist/engine/FlowEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowEngine.d.ts","sourceRoot":"","sources":["../../src/engine/FlowEngine.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAe,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACxF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAM7D,MAAM,WAAW,iBAAiB;IAChC,sGAAsG;IACtG,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,CAAC;CACvB;AAOD,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;IACnD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqC;gBAErD,OAAO,GAAE,iBAAsB;IAKrC,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5D,OAAO,CAAC,aAAa;IAIf,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;IAyBrD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;YAIhC,QAAQ;IAyHhB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IAiChE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAIjD,gBAAgB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAKrC,SAAS,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAIzF,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CACvC,KAAK,CAAC;QACJ,EAAE,EAAE,IAAI,CAAC;QACT,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,WAAW,EAAE,OAAO,CAAC;KACtB,CAAC,CACH;CAGF"}

package/dist/engine/FlowEngine.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowEngine = void 0;
+/**
+ * FlowEngine - framework-agnostic execution graph engine
+ * Default storage is in-memory (no DB). For DB persistence, pass storage from createPrismaStorage(prisma) via @hazeljs/flow/prisma.
+ */
+const crypto_1 = require("crypto");
+const memory_js_1 = require("../persistence/memory.js");
+const Executor_js_1 = require("./Executor.js");
+const Transition_js_1 = require("./Transition.js");
+const Errors_js_1 = require("../types/Errors.js");
+const RUNNING = 'RUNNING';
+const WAITING = 'WAITING';
+const COMPLETED = 'COMPLETED';
+const FAILED = 'FAILED';
+class FlowEngine {
+    constructor(options = {}) {
+        this.defRegistry = new Map();
+        this.storage = options.storage ?? (0, memory_js_1.createMemoryStorage)();
+        this.services = options.services ?? {};
+    }
+    async registerDefinition(def) {
+        this.defRegistry.set(`${def.flowId}@${def.version}`, def);
+        await this.storage.definitionRepo.save(def);
+    }
+    getDefinition(flowId, version) {
+        return this.defRegistry.get(`${flowId}@${version}`) ?? null;
+    }
+    async startRun(args) {
+        const def = this.getDefinition(args.flowId, args.version);
+        if (!def) {
+            throw new Errors_js_1.FlowNotFoundError(args.flowId, args.version);
+        }
+        const runId = (0, crypto_1.randomUUID)();
+        await this.storage.runRepo.create({
+            runId,
+            flowId: args.flowId,
+            flowVersion: args.version,
+            tenantId: args.tenantId,
+            input: args.input,
+            initialState: args.initialState,
+        });
+        await this.storage.eventRepo.append(runId, 'RUN_STARTED', {});
+        await this.storage.runRepo.update(runId, {
+            currentNodeId: def.entry,
+        });
+        return { runId, status: RUNNING };
+    }
+    async tick(runId) {
+        return this.storage.withLock(runId, () => this.tickCore(runId));
+    }
+    async tickCore(runId) {
+        const run = await this.storage.runRepo.get(runId);
+        if (!run)
+            throw new Errors_js_1.RunNotFoundError(runId);
+        if (run.status !== RUNNING && run.status !== WAITING) {
+            return run;
+        }
+        const def = this.getDefinition(run.flowId, run.flowVersion);
+        if (!def)
+            throw new Errors_js_1.FlowNotFoundError(run.flowId, run.flowVersion);
+        const currentNodeId = run.currentNodeId ?? def.entry;
+        const node = def.nodes[currentNodeId];
+        if (!node) {
+            await this.storage.runRepo.update(runId, { status: FAILED });
+            await this.storage.eventRepo.append(runId, 'RUN_ABORTED', {
+                error: { code: 'NODE_NOT_FOUND', message: `Node ${currentNodeId} not found` },
+            });
+            return (await this.storage.runRepo.get(runId));
+        }
+        const ctx = {
+            runId,
+            flowId: run.flowId,
+            flowVersion: run.flowVersion,
+            tenantId: run.tenantId ?? undefined,
+            input: run.inputJson,
+            state: run.stateJson,
+            outputs: run.outputsJson,
+            meta: { attempts: {}, startedAt: run.createdAt.toISOString() },
+            services: this.services,
+        };
+        const { result, cached } = await (0, Executor_js_1.executeNode)(node, ctx, this.storage.eventRepo, this.storage.idempotencyRepo);
+        if (result.status === 'error') {
+            await this.storage.runRepo.update(runId, {
+                status: FAILED,
+                currentNodeId: null,
+            });
+            await this.storage.eventRepo.append(runId, 'RUN_ABORTED', {
+                error: result.error,
+            });
+            return (await this.storage.runRepo.get(runId));
+        }
+        if (result.status === 'wait') {
+            let newState = ctx.state;
+            if (result.patch) {
+                const { applyPatch } = await Promise.resolve().then(() => __importStar(require('./Executor.js')));
+                newState = applyPatch(ctx.state, result.patch);
+            }
+            const newOutputs = { ...ctx.outputs, [currentNodeId]: result.output };
+            await this.storage.runRepo.update(runId, {
+                status: WAITING,
+                stateJson: newState,
+                outputsJson: newOutputs,
+                currentNodeId,
+            });
+            await this.storage.eventRepo.append(runId, 'RUN_WAITING', {
+                nodeId: currentNodeId,
+                reason: result.reason,
+                until: result.until,
+            });
+            return (await this.storage.runRepo.get(runId));
+        }
+        // result.status === 'ok'
+        let newState = ctx.state;
+        if (result.patch && !cached) {
+            const { applyPatch } = await Promise.resolve().then(() => __importStar(require('./Executor.js')));
+            newState = applyPatch(ctx.state, result.patch);
+        }
+        else if (result.patch && cached) {
+            newState = { ...ctx.state, ...result.patch };
+        }
+        const newOutputs = { ...ctx.outputs, [currentNodeId]: result.output };
+        let nextNodeId;
+        try {
+            nextNodeId = (0, Transition_js_1.selectNextNode)(currentNodeId, def.edges, {
+                ...ctx,
+                state: newState,
+                outputs: newOutputs,
+            });
+        }
+        catch (err) {
+            const code = err instanceof Error && 'code' in err ? err.code : 'UNKNOWN';
+            const message = err instanceof Error ? err.message : String(err);
+            await this.storage.runRepo.update(runId, {
+                status: FAILED,
+                currentNodeId: null,
+            });
+            await this.storage.eventRepo.append(runId, 'RUN_ABORTED', {
+                error: { code, message },
+            });
+            return (await this.storage.runRepo.get(runId));
+        }
+        if (nextNodeId === null) {
+            await this.storage.runRepo.update(runId, {
+                status: COMPLETED,
+                stateJson: newState,
+                outputsJson: newOutputs,
+                currentNodeId: null,
+            });
+            await this.storage.eventRepo.append(runId, 'RUN_COMPLETED', {});
+            return (await this.storage.runRepo.get(runId));
+        }
+        await this.storage.runRepo.update(runId, {
+            stateJson: newState,
+            outputsJson: newOutputs,
+            currentNodeId: nextNodeId,
+        });
+        return (await this.storage.runRepo.get(runId));
+    }
+    async resumeRun(runId, payload) {
+        return this.storage.withLock(runId, async () => {
+            const run = await this.storage.runRepo.get(runId);
+            if (!run)
+                throw new Errors_js_1.RunNotFoundError(runId);
+            if (run.status !== WAITING) {
+                return run;
+            }
+            const def = this.getDefinition(run.flowId, run.flowVersion);
+            if (!def)
+                throw new Errors_js_1.FlowNotFoundError(run.flowId, run.flowVersion);
+            const currentNodeId = run.currentNodeId;
+            const node = def.nodes[currentNodeId];
+            if (!node) {
+                await this.storage.runRepo.update(runId, { status: FAILED });
+                return (await this.storage.runRepo.get(runId));
+            }
+            // Merge payload into state (e.g. for wait/resume flows)
+            let newState = run.stateJson;
+            if (payload != null && typeof payload === 'object') {
+                newState = { ...newState, _resumePayload: payload };
+            }
+            await this.storage.runRepo.update(runId, {
+                status: RUNNING,
+                stateJson: newState,
+            });
+            return this.tickCore(runId);
+        });
+    }
+    async getRun(runId) {
+        return this.storage.runRepo.get(runId);
+    }
+    async getRunningRunIds() {
+        const runs = await this.storage.runRepo.findRunning();
+        return runs.map((r) => r.runId);
+    }
+    async listFlows() {
+        return this.storage.definitionRepo.list();
+    }
+    async getTimeline(runId) {
+        return this.storage.eventRepo.getTimeline(runId);
+    }
+}
+exports.FlowEngine = FlowEngine;

package/dist/engine/Idempotency.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Idempotency check and store helpers
+ */
+import type { IIdempotencyRepo } from '../persistence/storage.js';
+export declare function checkIdempotency(repo: IIdempotencyRepo, key: string): Promise<{
+    output?: unknown;
+    patch?: Record<string, unknown>;
+} | null>;
+export declare function storeIdempotency(repo: IIdempotencyRepo, key: string, runId: string, nodeId: string, output?: unknown, patch?: Record<string, unknown>): Promise<void>;
+//# sourceMappingURL=Idempotency.d.ts.map

package/dist/engine/Idempotency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Idempotency.d.ts","sourceRoot":"","sources":["../../src/engine/Idempotency.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC,CAOvE;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,OAAO,EAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/dist/engine/Idempotency.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIdempotency = checkIdempotency;
+exports.storeIdempotency = storeIdempotency;
+async function checkIdempotency(repo, key) {
+    const record = await repo.get(key);
+    if (!record)
+        return null;
+    return {
+        output: record.outputJson,
+        patch: record.patchJson,
+    };
+}
+async function storeIdempotency(repo, key, runId, nodeId, output, patch) {
+    await repo.set(key, runId, nodeId, output, patch);
+}

package/dist/engine/Locks.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Postgres advisory locks for flow run concurrency safety.
+ * Uses a stable hash of runId -> bigint for pg_advisory_lock.
+ *
+ * Hash algorithm: djb2-like string hash, then take mod to fit in int8 range.
+ * PostgreSQL advisory lock keys are int8 (signed 64-bit).
+ */
+import type { PrismaClient } from '../persistence/prisma.js';
+export declare function runIdToLockKey(runId: string): bigint;
+export declare function withAdvisoryLock<T>(prisma: PrismaClient, runId: string, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=Locks.d.ts.map

package/dist/engine/Locks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Locks.d.ts","sourceRoot":"","sources":["../../src/engine/Locks.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQpD;AAED,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAaZ"}

package/dist/engine/Locks.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Postgres advisory locks for flow run concurrency safety.
+ * Uses a stable hash of runId -> bigint for pg_advisory_lock.
+ *
+ * Hash algorithm: djb2-like string hash, then take mod to fit in int8 range.
+ * PostgreSQL advisory lock keys are int8 (signed 64-bit).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runIdToLockKey = runIdToLockKey;
+exports.withAdvisoryLock = withAdvisoryLock;
+function runIdToLockKey(runId) {
+    let hash = 5381;
+    for (let i = 0; i < runId.length; i++) {
+        hash = ((hash << 5) + hash) ^ runId.charCodeAt(i);
+    }
+    // Ensure positive and within safe int8 range (use MAX_SAFE_INTEGER to avoid precision loss)
+    const h = Math.abs(hash);
+    return BigInt(h % Number.MAX_SAFE_INTEGER);
+}
+async function withAdvisoryLock(prisma, runId, fn) {
+    const key = runIdToLockKey(runId);
+    try {
+        const result = await prisma.$queryRaw `SELECT pg_try_advisory_lock(${key}) as acquired`;
+        const acquired = result[0]?.acquired;
+        if (!acquired) {
+            const { LockBusyError } = await Promise.resolve().then(() => __importStar(require('../types/Errors.js')));
+            throw new LockBusyError(runId);
+        }
+        return await fn();
+    }
+    finally {
+        await prisma.$executeRaw `SELECT pg_advisory_unlock(${key})`;
+    }
+}

package/dist/engine/Retry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Retry logic with fixed or exponential backoff
+ */
+import type { RetryPolicy } from '../types/FlowTypes.js';
+export declare function delay(ms: number): Promise<void>;
+export declare function getRetryDelayMs(attempt: number, policy: RetryPolicy): number;
+//# sourceMappingURL=Retry.d.ts.map

package/dist/engine/Retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Retry.d.ts","sourceRoot":"","sources":["../../src/engine/Retry.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,MAAM,CAY5E"}

package/dist/engine/Retry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+exports.getRetryDelayMs = getRetryDelayMs;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getRetryDelayMs(attempt, policy) {
+    if (attempt >= policy.maxAttempts)
+        return -1;
+    let ms;
+    if (policy.backoff === 'exponential') {
+        ms = policy.baseDelayMs * Math.pow(2, attempt);
+    }
+    else {
+        ms = policy.baseDelayMs;
+    }
+    if (policy.maxDelayMs != null && ms > policy.maxDelayMs) {
+        ms = policy.maxDelayMs;
+    }
+    return ms;
+}

package/dist/engine/Timeout.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Per-node timeout via Promise.race
+ */
+export declare class TimeoutError extends Error {
+    readonly nodeId: string;
+    readonly timeoutMs: number;
+    constructor(message: string, nodeId: string, timeoutMs: number);
+}
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, nodeId: string): Promise<T>;
+//# sourceMappingURL=Timeout.d.ts.map

package/dist/engine/Timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Timeout.d.ts","sourceRoot":"","sources":["../../src/engine/Timeout.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,YAAa,SAAQ,KAAK;aAGnB,MAAM,EAAE,MAAM;aACd,SAAS,EAAE,MAAM;gBAFjC,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM;CAMpC;AAED,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,CAAC,CAOZ"}

package/dist/engine/Timeout.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Per-node timeout via Promise.race
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = void 0;
+exports.withTimeout = withTimeout;
+class TimeoutError extends Error {
+    constructor(message, nodeId, timeoutMs) {
+        super(message);
+        this.nodeId = nodeId;
+        this.timeoutMs = timeoutMs;
+        this.name = 'TimeoutError';
+        this.code = 'TIMEOUT';
+    }
+}
+exports.TimeoutError = TimeoutError;
+async function withTimeout(promise, timeoutMs, nodeId) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new TimeoutError(`Node ${nodeId} timed out after ${timeoutMs}ms`, nodeId, timeoutMs));
+        }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+}

package/dist/engine/Transition.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Edge transition logic - select next node from outgoing edges
+ */
+import type { FlowContext, EdgeDefinition } from '../types/FlowTypes.js';
+export declare function selectNextNode(fromNodeId: string, edges: EdgeDefinition[], ctx: FlowContext): string | null;
+//# sourceMappingURL=Transition.d.ts.map

package/dist/engine/Transition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transition.d.ts","sourceRoot":"","sources":["../../src/engine/Transition.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGzE,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,cAAc,EAAE,EACvB,GAAG,EAAE,WAAW,GACf,MAAM,GAAG,IAAI,CAef"}

package/dist/engine/Transition.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectNextNode = selectNextNode;
+const Errors_js_1 = require("../types/Errors.js");
+function selectNextNode(fromNodeId, edges, ctx) {
+    const outgoing = edges.filter((e) => e.from === fromNodeId);
+    if (outgoing.length === 0)
+        return null;
+    const matching = outgoing.filter((e) => !e.when || e.when(ctx));
+    if (matching.length === 0)
+        return null;
+    const sorted = [...matching].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    const topPriority = sorted[0].priority ?? 0;
+    const atTop = sorted.filter((e) => (e.priority ?? 0) === topPriority);
+    if (atTop.length > 1) {
+        throw new Errors_js_1.AmbiguousEdgeError(fromNodeId);
+    }
+    return sorted[0].to;
+}

package/dist/engine/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple deep merge for state patching (MVP)
+ */
+export declare function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/engine/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/engine/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmBzB"}

package/dist/engine/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = deepMerge;
+/**
+ * Simple deep merge for state patching (MVP)
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const srcVal = source[key];
+        const tgtVal = result[key];
+        if (srcVal != null &&
+            typeof srcVal === 'object' &&
+            !Array.isArray(srcVal) &&
+            tgtVal != null &&
+            typeof tgtVal === 'object' &&
+            !Array.isArray(tgtVal)) {
+            result[key] = deepMerge(tgtVal, srcVal);
+        }
+        else {
+            result[key] = srcVal;
+        }
+    }
+    return result;
+}

package/dist/examples/branching.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=branching.d.ts.map

package/dist/examples/branching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branching.d.ts","sourceRoot":"","sources":["../../src/examples/branching.ts"],"names":[],"mappings":""}

package/dist/examples/branching.js

@@ -0,0 +1,72 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Branching flow example - conditional edges (decorator-based)
+ * Run: npm run example:branching  |  or from source: npx tsx src/examples/branching.ts
+ */
+const index_js_1 = require("../index.js");
+let BranchingFlow = class BranchingFlow {
+    async check(ctx) {
+        const score = ctx.input.score;
+        return { status: 'ok', output: { score }, patch: { score } };
+    }
+    async approve() {
+        return { status: 'ok', output: { decision: 'approved' } };
+    }
+    async reject() {
+        return { status: 'ok', output: { decision: 'rejected' } };
+    }
+};
+__decorate([
+    (0, index_js_1.Entry)(),
+    (0, index_js_1.Node)('check'),
+    (0, index_js_1.Edge)('approve', (ctx) => ctx.state.score >= 70, 1),
+    (0, index_js_1.Edge)('reject', (ctx) => ctx.state.score < 70, 1),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], BranchingFlow.prototype, "check", null);
+__decorate([
+    (0, index_js_1.Node)('approve'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], BranchingFlow.prototype, "approve", null);
+__decorate([
+    (0, index_js_1.Node)('reject'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], BranchingFlow.prototype, "reject", null);
+BranchingFlow = __decorate([
+    (0, index_js_1.Flow)('branching-flow', '1.0.0')
+], BranchingFlow);
+async function main() {
+    const engine = new index_js_1.FlowEngine();
+    const def = (0, index_js_1.buildFlowDefinition)(BranchingFlow);
+    await engine.registerDefinition(def);
+    const { runId } = await engine.startRun({
+        flowId: 'branching-flow',
+        version: '1.0.0',
+        input: { score: 85 },
+    });
+    let run = await engine.getRun(runId);
+    while (run?.status === 'RUNNING') {
+        run = await engine.tick(runId);
+    }
+    // eslint-disable-next-line no-console
+    console.log('Run result:', run?.outputsJson);
+}
+main().catch((err) => {
+    // eslint-disable-next-line no-console
+    console.error(err);
+});

package/dist/examples/simple.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=simple.d.ts.map

package/dist/examples/simple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.d.ts","sourceRoot":"","sources":["../../src/examples/simple.ts"],"names":[],"mappings":""}