@hazeljs/flow 0.2.0-beta.75

package/dist/persistence/memory.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * In-memory storage for flow engine (default, no DB required).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryStorage = createMemoryStorage;
+const serialize_js_1 = require("./serialize.js");
+const RUNNING = 'RUNNING';
+function now() {
+    return new Date();
+}
+class MemoryFlowDefinitionRepo {
+    constructor() {
+        this.store = new Map();
+    }
+    key(flowId, version) {
+        return `${flowId}@${version}`;
+    }
+    async save(def) {
+        this.store.set(this.key(def.flowId, def.version), { ...def });
+    }
+    async get(flowId, version) {
+        return this.store.get(this.key(flowId, version)) ?? null;
+    }
+    async list() {
+        const entries = Array.from(this.store.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+        return entries.map(([k, def]) => {
+            const [flowId, version] = k.split('@');
+            return {
+                flowId,
+                version,
+                definitionJson: (0, serialize_js_1.toSerializable)(def),
+            };
+        });
+    }
+}
+class MemoryFlowRunRepo {
+    constructor() {
+        this.runs = new Map();
+    }
+    async create(input) {
+        const now_ = now();
+        const row = {
+            runId: input.runId,
+            flowId: input.flowId,
+            flowVersion: input.flowVersion,
+            tenantId: input.tenantId ?? null,
+            status: RUNNING,
+            currentNodeId: null,
+            inputJson: input.input,
+            stateJson: input.initialState ?? {},
+            outputsJson: {},
+            createdAt: now_,
+            updatedAt: now_,
+        };
+        this.runs.set(input.runId, row);
+        return row;
+    }
+    async get(runId) {
+        return this.runs.get(runId) ?? null;
+    }
+    async update(runId, data) {
+        const existing = this.runs.get(runId);
+        if (!existing)
+            throw new Error(`Run not found: ${runId}`);
+        const updated = {
+            ...existing,
+            ...data,
+            updatedAt: now(),
+        };
+        this.runs.set(runId, updated);
+        return updated;
+    }
+    async findRunning() {
+        return Array.from(this.runs.values()).filter((r) => r.status === 'RUNNING');
+    }
+}
+class MemoryFlowEventRepo {
+    constructor() {
+        this.events = [];
+        this.id = 0;
+    }
+    async append(runId, type, payload = {}) {
+        this.events.push({
+            id: `evt-${++this.id}`,
+            runId,
+            at: now(),
+            type,
+            nodeId: payload.nodeId ?? null,
+            attempt: payload.attempt ?? null,
+            payloadJson: payload,
+        });
+    }
+    async getTimeline(runId) {
+        return this.events
+            .filter((e) => e.runId === runId)
+            .sort((a, b) => a.at.getTime() - b.at.getTime())
+            .map((e) => ({
+            at: e.at,
+            type: e.type,
+            nodeId: e.nodeId,
+            attempt: e.attempt,
+            payloadJson: e.payloadJson,
+        }));
+    }
+}
+class MemoryIdempotencyRepo {
+    constructor() {
+        this.store = new Map();
+    }
+    async get(key) {
+        return this.store.get(key) ?? null;
+    }
+    async set(key, runId, nodeId, outputJson, patchJson) {
+        this.store.set(key, {
+            key,
+            runId,
+            nodeId,
+            outputJson: outputJson ?? null,
+            patchJson: patchJson ?? null,
+        });
+    }
+}
+const memoryLockQueues = new Map();
+/** In-memory mutex per runId */
+function memoryWithLock(runId, fn) {
+    const prev = memoryLockQueues.get(runId) ?? Promise.resolve();
+    let resolveNext;
+    const _next = new Promise((r) => {
+        resolveNext = r;
+    });
+    const chain = prev.then(() => (async () => {
+        try {
+            return await fn();
+        }
+        finally {
+            resolveNext();
+        }
+    })());
+    memoryLockQueues.set(runId, chain);
+    return chain;
+}
+/**
+ * Create in-memory storage (default, no database).
+ */
+function createMemoryStorage() {
+    return {
+        definitionRepo: new MemoryFlowDefinitionRepo(),
+        runRepo: new MemoryFlowRunRepo(),
+        eventRepo: new MemoryFlowEventRepo(),
+        idempotencyRepo: new MemoryIdempotencyRepo(),
+        withLock: memoryWithLock,
+    };
+}

package/dist/persistence/prisma.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-export flow Prisma client (generated to src/generated/prisma)
+ */
+export { PrismaClient, FlowRunStatus } from '../generated/prisma';
+//# sourceMappingURL=prisma.d.ts.map

package/dist/persistence/prisma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../src/persistence/prisma.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/persistence/prisma.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowRunStatus = exports.PrismaClient = void 0;
+/**
+ * Re-export flow Prisma client (generated to src/generated/prisma)
+ */
+var prisma_1 = require("../generated/prisma");
+Object.defineProperty(exports, "PrismaClient", { enumerable: true, get: function () { return prisma_1.PrismaClient; } });
+Object.defineProperty(exports, "FlowRunStatus", { enumerable: true, get: function () { return prisma_1.FlowRunStatus; } });

package/dist/persistence/prismaClient.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Prisma client factory and singleton for @hazeljs/flow
+ * Uses its own schema - independent of Hazel core
+ */
+import { PrismaClient } from './prisma.js';
+/**
+ * Create a Prisma client for the flow schema.
+ * Use this when you need a fresh client or want to pass a custom database URL.
+ */
+export declare function createFlowPrismaClient(databaseUrl?: string): PrismaClient;
+/**
+ * Get the singleton Prisma client for flow.
+ * Uses DATABASE_URL from environment.
+ * Call createFlowPrismaClient(url) first if you need to set a custom URL.
+ */
+export declare function getFlowPrismaClient(databaseUrl?: string): PrismaClient;
+/**
+ * Reset the singleton (useful for testing)
+ */
+export declare function resetFlowPrismaClient(): void;
+//# sourceMappingURL=prismaClient.d.ts.map

package/dist/persistence/prismaClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prismaClient.d.ts","sourceRoot":"","sources":["../../src/persistence/prismaClient.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAYzE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAMtE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAK5C"}

package/dist/persistence/prismaClient.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Prisma client factory and singleton for @hazeljs/flow
+ * Uses its own schema - independent of Hazel core
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFlowPrismaClient = createFlowPrismaClient;
+exports.getFlowPrismaClient = getFlowPrismaClient;
+exports.resetFlowPrismaClient = resetFlowPrismaClient;
+const prisma_js_1 = require("./prisma.js");
+let flowPrismaInstance = null;
+/**
+ * Create a Prisma client for the flow schema.
+ * Use this when you need a fresh client or want to pass a custom database URL.
+ */
+function createFlowPrismaClient(databaseUrl) {
+    const url = databaseUrl ?? process.env.DATABASE_URL;
+    if (!url) {
+        throw new Error('DATABASE_URL is required. Set it in environment or pass to createFlowPrismaClient().');
+    }
+    return new prisma_js_1.PrismaClient({
+        datasources: {
+            db: { url },
+        },
+    });
+}
+/**
+ * Get the singleton Prisma client for flow.
+ * Uses DATABASE_URL from environment.
+ * Call createFlowPrismaClient(url) first if you need to set a custom URL.
+ */
+function getFlowPrismaClient(databaseUrl) {
+    if (flowPrismaInstance) {
+        return flowPrismaInstance;
+    }
+    flowPrismaInstance = createFlowPrismaClient(databaseUrl);
+    return flowPrismaInstance;
+}
+/**
+ * Reset the singleton (useful for testing)
+ */
+function resetFlowPrismaClient() {
+    if (flowPrismaInstance) {
+        flowPrismaInstance.$disconnect();
+        flowPrismaInstance = null;
+    }
+}

package/dist/persistence/prismaStorage.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Prisma-backed storage. Use when you want to persist flows in a database.
+ * Import from '@hazeljs/flow/prisma' so Prisma is optional for the default package.
+ */
+import type { PrismaClient } from './prisma.js';
+import type { FlowStorage } from './storage.js';
+/**
+ * Create storage backed by Prisma (Postgres). Requires @prisma/client and the flow schema.
+ */
+export declare function createPrismaStorage(prisma: PrismaClient): FlowStorage;
+//# sourceMappingURL=prismaStorage.d.ts.map

package/dist/persistence/prismaStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prismaStorage.d.ts","sourceRoot":"","sources":["../../src/persistence/prismaStorage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAOhD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW,CAQrE"}

package/dist/persistence/prismaStorage.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Prisma-backed storage. Use when you want to persist flows in a database.
+ * Import from '@hazeljs/flow/prisma' so Prisma is optional for the default package.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrismaStorage = createPrismaStorage;
+const FlowDefinitionRepo_js_1 = require("./FlowDefinitionRepo.js");
+const FlowRunRepo_js_1 = require("./FlowRunRepo.js");
+const FlowEventRepo_js_1 = require("./FlowEventRepo.js");
+const IdempotencyRepo_js_1 = require("./IdempotencyRepo.js");
+const Locks_js_1 = require("../engine/Locks.js");
+/**
+ * Create storage backed by Prisma (Postgres). Requires @prisma/client and the flow schema.
+ */
+function createPrismaStorage(prisma) {
+    return {
+        definitionRepo: new FlowDefinitionRepo_js_1.FlowDefinitionRepo(prisma),
+        runRepo: new FlowRunRepo_js_1.FlowRunRepo(prisma),
+        eventRepo: new FlowEventRepo_js_1.FlowEventRepo(prisma),
+        idempotencyRepo: new IdempotencyRepo_js_1.IdempotencyRepo(prisma),
+        withLock: (runId, fn) => (0, Locks_js_1.withAdvisoryLock)(prisma, runId, fn),
+    };
+}

package/dist/persistence/serialize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Serialize flow definition for DB storage (strips functions)
+ */
+import type { FlowDefinition } from '../types/FlowTypes.js';
+export declare function toSerializable(def: FlowDefinition): Record<string, unknown>;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/persistence/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/persistence/serialize.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwB3E"}

package/dist/persistence/serialize.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSerializable = toSerializable;
+function toSerializable(def) {
+    const nodes = {};
+    for (const [id, node] of Object.entries(def.nodes)) {
+        nodes[id] = {
+            id: node.id,
+            name: node.name,
+            retry: node.retry,
+            timeoutMs: node.timeoutMs,
+            // handler, idempotencyKey are not serializable - omitted
+        };
+    }
+    const edges = def.edges.map((e) => ({
+        from: e.from,
+        to: e.to,
+        priority: e.priority,
+        // when is a function - omitted
+    }));
+    return {
+        flowId: def.flowId,
+        version: def.version,
+        entry: def.entry,
+        nodes,
+        edges,
+    };
+}

package/dist/persistence/storage.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Storage interfaces for flow engine.
+ * Default implementation is in-memory; Prisma can be injected via createPrismaStorage (see @hazeljs/flow/prisma).
+ */
+import type { FlowDefinition } from '../types/FlowTypes.js';
+import type { FlowRunStatus } from '../types/FlowTypes.js';
+import type { FlowEventType, FlowRunEventPayload } from '../types/Events.js';
+export type { FlowRunStatus };
+export interface FlowRunRow {
+    runId: string;
+    flowId: string;
+    flowVersion: string;
+    tenantId: string | null;
+    status: FlowRunStatus;
+    currentNodeId: string | null;
+    inputJson: unknown;
+    stateJson: unknown;
+    outputsJson: unknown;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface CreateRunInput {
+    runId: string;
+    flowId: string;
+    flowVersion: string;
+    tenantId?: string | null;
+    input: unknown;
+    initialState?: Record<string, unknown>;
+}
+export interface IFlowDefinitionRepo {
+    save(def: FlowDefinition): Promise<void>;
+    get(flowId: string, version: string): Promise<FlowDefinition | null>;
+    list(): Promise<Array<{
+        flowId: string;
+        version: string;
+        definitionJson: unknown;
+    }>>;
+}
+export interface IFlowRunRepo {
+    create(input: CreateRunInput): Promise<FlowRunRow>;
+    get(runId: string): Promise<FlowRunRow | null>;
+    update(runId: string, data: Partial<FlowRunRow>): Promise<FlowRunRow>;
+    findRunning(): Promise<FlowRunRow[]>;
+}
+export interface IFlowEventRepo {
+    append(runId: string, type: FlowEventType, payload?: FlowRunEventPayload): Promise<void>;
+    getTimeline(runId: string): Promise<Array<{
+        at: Date;
+        type: string;
+        nodeId: string | null;
+        attempt: number | null;
+        payloadJson: unknown;
+    }>>;
+}
+export interface IdempotencyRecord {
+    key: string;
+    runId: string;
+    nodeId: string;
+    outputJson: unknown;
+    patchJson: unknown;
+}
+export interface IIdempotencyRepo {
+    get(key: string): Promise<IdempotencyRecord | null>;
+    set(key: string, runId: string, nodeId: string, outputJson?: unknown, patchJson?: unknown): Promise<void>;
+}
+/** Run-scoped lock: only one tick/resume per runId at a time */
+export type WithLockFn = <T>(runId: string, fn: () => Promise<T>) => Promise<T>;
+export interface FlowStorage {
+    definitionRepo: IFlowDefinitionRepo;
+    runRepo: IFlowRunRepo;
+    eventRepo: IFlowEventRepo;
+    idempotencyRepo: IIdempotencyRepo;
+    withLock: WithLockFn;
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/persistence/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/persistence/storage.ts"],"names":[],"mappings":"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"}

package/dist/persistence/storage.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Storage interfaces for flow engine.
+ * Default implementation is in-memory; Prisma can be injected via createPrismaStorage (see @hazeljs/flow/prisma).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/prisma.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Prisma-backed storage for @hazeljs/flow.
+ * Import from '@hazeljs/flow/prisma' when you want DB persistence.
+ * Requires @prisma/client to be installed and the flow schema applied (migrations).
+ */
+export { createPrismaStorage } from './persistence/prismaStorage.js';
+export { createFlowPrismaClient, getFlowPrismaClient, resetFlowPrismaClient, } from './persistence/prismaClient.js';
+export { FlowDefinitionRepo } from './persistence/FlowDefinitionRepo.js';
+export { FlowRunRepo } from './persistence/FlowRunRepo.js';
+export type { FlowRunRow } from './persistence/FlowRunRepo.js';
+export { FlowEventRepo } from './persistence/FlowEventRepo.js';
+export { IdempotencyRepo } from './persistence/IdempotencyRepo.js';
+export { runIdToLockKey, withAdvisoryLock } from './engine/Locks.js';
+//# sourceMappingURL=prisma.d.ts.map

package/dist/prisma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../src/prisma.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,YAAY,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/prisma.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Prisma-backed storage for @hazeljs/flow.
+ * Import from '@hazeljs/flow/prisma' when you want DB persistence.
+ * Requires @prisma/client to be installed and the flow schema applied (migrations).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAdvisoryLock = exports.runIdToLockKey = exports.IdempotencyRepo = exports.FlowEventRepo = exports.FlowRunRepo = exports.FlowDefinitionRepo = exports.resetFlowPrismaClient = exports.getFlowPrismaClient = exports.createFlowPrismaClient = exports.createPrismaStorage = void 0;
+var prismaStorage_js_1 = require("./persistence/prismaStorage.js");
+Object.defineProperty(exports, "createPrismaStorage", { enumerable: true, get: function () { return prismaStorage_js_1.createPrismaStorage; } });
+var prismaClient_js_1 = require("./persistence/prismaClient.js");
+Object.defineProperty(exports, "createFlowPrismaClient", { enumerable: true, get: function () { return prismaClient_js_1.createFlowPrismaClient; } });
+Object.defineProperty(exports, "getFlowPrismaClient", { enumerable: true, get: function () { return prismaClient_js_1.getFlowPrismaClient; } });
+Object.defineProperty(exports, "resetFlowPrismaClient", { enumerable: true, get: function () { return prismaClient_js_1.resetFlowPrismaClient; } });
+var FlowDefinitionRepo_js_1 = require("./persistence/FlowDefinitionRepo.js");
+Object.defineProperty(exports, "FlowDefinitionRepo", { enumerable: true, get: function () { return FlowDefinitionRepo_js_1.FlowDefinitionRepo; } });
+var FlowRunRepo_js_1 = require("./persistence/FlowRunRepo.js");
+Object.defineProperty(exports, "FlowRunRepo", { enumerable: true, get: function () { return FlowRunRepo_js_1.FlowRunRepo; } });
+var FlowEventRepo_js_1 = require("./persistence/FlowEventRepo.js");
+Object.defineProperty(exports, "FlowEventRepo", { enumerable: true, get: function () { return FlowEventRepo_js_1.FlowEventRepo; } });
+var IdempotencyRepo_js_1 = require("./persistence/IdempotencyRepo.js");
+Object.defineProperty(exports, "IdempotencyRepo", { enumerable: true, get: function () { return IdempotencyRepo_js_1.IdempotencyRepo; } });
+var Locks_js_1 = require("./engine/Locks.js");
+Object.defineProperty(exports, "runIdToLockKey", { enumerable: true, get: function () { return Locks_js_1.runIdToLockKey; } });
+Object.defineProperty(exports, "withAdvisoryLock", { enumerable: true, get: function () { return Locks_js_1.withAdvisoryLock; } });

package/dist/types/Errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Flow engine error types
+ */
+export declare class FlowError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(message: string, code: string, retryable?: boolean);
+}
+export declare class LockBusyError extends FlowError {
+    constructor(runId: string);
+}
+export declare class AmbiguousEdgeError extends FlowError {
+    constructor(nodeId: string);
+}
+export declare class FlowNotFoundError extends FlowError {
+    constructor(flowId: string, version: string);
+}
+export declare class RunNotFoundError extends FlowError {
+    constructor(runId: string);
+}
+//# sourceMappingURL=Errors.d.ts.map

package/dist/types/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../src/types/Errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,SAAU,SAAQ,KAAK;aAGhB,IAAI,EAAE,MAAM;aACZ,SAAS;gBAFzB,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,SAAS,UAAQ;CAMpC;AAED,qBAAa,aAAc,SAAQ,SAAS;gBAC9B,KAAK,EAAE,MAAM;CAI1B;AAED,qBAAa,kBAAmB,SAAQ,SAAS;gBACnC,MAAM,EAAE,MAAM;CAI3B;AAED,qBAAa,iBAAkB,SAAQ,SAAS;gBAClC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI5C;AAED,qBAAa,gBAAiB,SAAQ,SAAS;gBACjC,KAAK,EAAE,MAAM;CAI1B"}

package/dist/types/Errors.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Flow engine error types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunNotFoundError = exports.FlowNotFoundError = exports.AmbiguousEdgeError = exports.LockBusyError = exports.FlowError = void 0;
+class FlowError extends Error {
+    constructor(message, code, retryable = false) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = 'FlowError';
+        Object.setPrototypeOf(this, FlowError.prototype);
+    }
+}
+exports.FlowError = FlowError;
+class LockBusyError extends FlowError {
+    constructor(runId) {
+        super(`Lock busy for run ${runId}`, 'LOCK_BUSY', true);
+        this.name = 'LockBusyError';
+    }
+}
+exports.LockBusyError = LockBusyError;
+class AmbiguousEdgeError extends FlowError {
+    constructor(nodeId) {
+        super(`Ambiguous edge from node ${nodeId}`, 'AMBIGUOUS_EDGE', false);
+        this.name = 'AmbiguousEdgeError';
+    }
+}
+exports.AmbiguousEdgeError = AmbiguousEdgeError;
+class FlowNotFoundError extends FlowError {
+    constructor(flowId, version) {
+        super(`Flow not found: ${flowId}@${version}`, 'FLOW_NOT_FOUND', false);
+        this.name = 'FlowNotFoundError';
+    }
+}
+exports.FlowNotFoundError = FlowNotFoundError;
+class RunNotFoundError extends FlowError {
+    constructor(runId) {
+        super(`Run not found: ${runId}`, 'RUN_NOT_FOUND', false);
+        this.name = 'RunNotFoundError';
+    }
+}
+exports.RunNotFoundError = RunNotFoundError;

package/dist/types/Events.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Flow run event types for audit timeline
+ */
+export type FlowEventType = 'RUN_STARTED' | 'NODE_STARTED' | 'NODE_FINISHED' | 'NODE_FAILED' | 'RUN_WAITING' | 'RUN_COMPLETED' | 'RUN_ABORTED';
+export interface FlowRunEventPayload {
+    nodeId?: string;
+    attempt?: number;
+    cached?: boolean;
+    error?: {
+        code: string;
+        message: string;
+    };
+    reason?: string;
+    until?: string;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=Events.d.ts.map

package/dist/types/Events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Events.d.ts","sourceRoot":"","sources":["../../src/types/Events.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,aAAa,GACrB,aAAa,GACb,cAAc,GACd,eAAe,GACf,aAAa,GACb,aAAa,GACb,eAAe,GACf,aAAa,CAAC;AAElB,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB"}

package/dist/types/Events.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Flow run event types for audit timeline
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/FlowTypes.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Core flow definition types
+ */
+export type NodeId = string;
+/** Run status (used by storage; DB enum matches these values) */
+export type FlowRunStatus = 'RUNNING' | 'WAITING' | 'COMPLETED' | 'FAILED';
+export interface FlowContext {
+    runId: string;
+    flowId: string;
+    flowVersion: string;
+    tenantId?: string;
+    input: unknown;
+    state: Record<string, unknown>;
+    outputs: Record<string, unknown>;
+    meta: {
+        attempts: Record<string, number>;
+        startedAt: string;
+    };
+    services?: Record<string, unknown>;
+}
+export interface RetryPolicy {
+    maxAttempts: number;
+    backoff: 'fixed' | 'exponential';
+    baseDelayMs: number;
+    maxDelayMs?: number;
+}
+export interface NodeDefinition {
+    id: NodeId;
+    name?: string;
+    handler: (ctx: FlowContext) => Promise<NodeResult>;
+    retry?: RetryPolicy;
+    timeoutMs?: number;
+    idempotencyKey?: (ctx: FlowContext) => string;
+}
+export interface EdgeDefinition {
+    from: NodeId;
+    to: NodeId;
+    when?: (ctx: FlowContext) => boolean;
+    priority?: number;
+}
+export interface FlowDefinition {
+    flowId: string;
+    version: string;
+    entry: NodeId;
+    nodes: Record<NodeId, NodeDefinition>;
+    edges: EdgeDefinition[];
+}
+export type NodeResult = {
+    status: 'ok';
+    patch?: Record<string, unknown>;
+    output?: unknown;
+} | {
+    status: 'error';
+    error: {
+        code: string;
+        message: string;
+        retryable?: boolean;
+    };
+} | {
+    status: 'wait';
+    reason?: string;
+    until?: string;
+    patch?: Record<string, unknown>;
+    output?: unknown;
+};
+//# sourceMappingURL=FlowTypes.d.ts.map

package/dist/types/FlowTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowTypes.d.ts","sourceRoot":"","sources":["../../src/types/FlowTypes.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAE5B,iEAAiE;AACjE,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE3E,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjC,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,GAAG,aAAa,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACnD,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,MAAM,CAAC;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACtC,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB;AAED,MAAM,MAAM,UAAU,GAClB;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GACnE;IACE,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC/D,GACD;IACE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC"}

package/dist/types/FlowTypes.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Core flow definition types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });