@unlaxer/tramli 1.9.0 → 1.10.0

package/dist/cjs/index.d.ts

@@ -11,6 +11,8 @@ export { MermaidGenerator } from './mermaid-generator.js';
 export { SkeletonGenerator } from './skeleton-generator.js';
 export type { TargetLanguage } from './skeleton-generator.js';
 export { DataFlowGraph } from './data-flow-graph.js';
+export { Pipeline, PipelineBuilder, PipelineDataFlow, PipelineException } from './pipeline.js';
+export type { PipelineStep } from './pipeline.js';
 export type { NodeInfo } from './data-flow-graph.js';
 export { flowKey } from './flow-key.js';
 export type { FlowKey } from './flow-key.js';

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flowKey = exports.DataFlowGraph = exports.SkeletonGenerator = exports.MermaidGenerator = exports.InMemoryFlowStore = exports.FlowError = exports.SubFlowBuilder = exports.BranchBuilder = exports.FromBuilder = exports.Builder = exports.FlowDefinition = exports.FlowInstance = exports.FlowContext = exports.FlowEngine = exports.Tramli = void 0;
+exports.flowKey = exports.PipelineException = exports.PipelineDataFlow = exports.PipelineBuilder = exports.Pipeline = exports.DataFlowGraph = exports.SkeletonGenerator = exports.MermaidGenerator = exports.InMemoryFlowStore = exports.FlowError = exports.SubFlowBuilder = exports.BranchBuilder = exports.FromBuilder = exports.Builder = exports.FlowDefinition = exports.FlowInstance = exports.FlowContext = exports.FlowEngine = exports.Tramli = void 0;
 var tramli_js_1 = require("./tramli");
 Object.defineProperty(exports, "Tramli", { enumerable: true, get: function () { return tramli_js_1.Tramli; } });
 var flow_engine_js_1 = require("./flow-engine");
@@ -25,5 +25,10 @@ var skeleton_generator_js_1 = require("./skeleton-generator");
 Object.defineProperty(exports, "SkeletonGenerator", { enumerable: true, get: function () { return skeleton_generator_js_1.SkeletonGenerator; } });
 var data_flow_graph_js_1 = require("./data-flow-graph");
 Object.defineProperty(exports, "DataFlowGraph", { enumerable: true, get: function () { return data_flow_graph_js_1.DataFlowGraph; } });
+var pipeline_js_1 = require("./pipeline");
+Object.defineProperty(exports, "Pipeline", { enumerable: true, get: function () { return pipeline_js_1.Pipeline; } });
+Object.defineProperty(exports, "PipelineBuilder", { enumerable: true, get: function () { return pipeline_js_1.PipelineBuilder; } });
+Object.defineProperty(exports, "PipelineDataFlow", { enumerable: true, get: function () { return pipeline_js_1.PipelineDataFlow; } });
+Object.defineProperty(exports, "PipelineException", { enumerable: true, get: function () { return pipeline_js_1.PipelineException; } });
 var flow_key_js_1 = require("./flow-key");
 Object.defineProperty(exports, "flowKey", { enumerable: true, get: function () { return flow_key_js_1.flowKey; } });

package/dist/cjs/pipeline.d.ts

@@ -0,0 +1,55 @@
+import { FlowContext } from './flow-context.js';
+import { FlowError } from './flow-error.js';
+import type { FlowKey } from './flow-key.js';
+import type { TransitionLogEntry, StateLogEntry, ErrorLogEntry } from './flow-engine.js';
+export interface PipelineStep {
+    name: string;
+    requires: FlowKey<unknown>[];
+    produces: FlowKey<unknown>[];
+    process(ctx: FlowContext): Promise<void> | void;
+}
+export declare class PipelineException extends FlowError {
+    readonly failedStep: string;
+    readonly completedSteps: string[];
+    readonly context: FlowContext;
+    readonly cause: Error;
+    constructor(failedStep: string, completedSteps: string[], context: FlowContext, cause: Error);
+}
+export declare class PipelineDataFlow {
+    private readonly steps;
+    private readonly initiallyAvailable;
+    constructor(steps: PipelineStep[], initiallyAvailable: Set<string>);
+    deadData(): Set<string>;
+    stepOrder(): string[];
+    availableAfter(stepName: string): Set<string>;
+    toMermaid(): string;
+}
+export declare class Pipeline {
+    readonly name: string;
+    private readonly steps;
+    private readonly _initiallyAvailable;
+    private readonly _dataFlow;
+    private strictMode;
+    private transitionLogger?;
+    private stateLogger?;
+    private errorLogger?;
+    private constructor();
+    dataFlow(): PipelineDataFlow;
+    setStrictMode(strict: boolean): void;
+    setTransitionLogger(l: ((e: TransitionLogEntry) => void) | null): void;
+    setStateLogger(l: ((e: StateLogEntry) => void) | null): void;
+    setErrorLogger(l: ((e: ErrorLogEntry) => void) | null): void;
+    removeAllLoggers(): void;
+    execute(initialData: Map<string, unknown>): Promise<FlowContext>;
+    asStep(): PipelineStep;
+    static builder(name: string): PipelineBuilder;
+}
+export declare class PipelineBuilder {
+    private readonly name;
+    private readonly steps;
+    private readonly _initiallyAvailable;
+    constructor(name: string);
+    initiallyAvailable(...keys: FlowKey<unknown>[]): this;
+    step(s: PipelineStep): this;
+    build(): Pipeline;
+}

package/dist/cjs/pipeline.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineBuilder = exports.Pipeline = exports.PipelineDataFlow = exports.PipelineException = void 0;
+const flow_context_js_1 = require("./flow-context");
+const flow_error_js_1 = require("./flow-error");
+class PipelineException extends flow_error_js_1.FlowError {
+    failedStep;
+    completedSteps;
+    context;
+    cause;
+    constructor(failedStep, completedSteps, context, cause) {
+        super('PIPELINE_STEP_FAILED', `Pipeline step '${failedStep}' failed: ${cause.message}`);
+        this.failedStep = failedStep;
+        this.completedSteps = completedSteps;
+        this.context = context;
+        this.cause = cause;
+    }
+}
+exports.PipelineException = PipelineException;
+class PipelineDataFlow {
+    steps;
+    initiallyAvailable;
+    constructor(steps, initiallyAvailable) {
+        this.steps = steps;
+        this.initiallyAvailable = initiallyAvailable;
+    }
+    deadData() {
+        const allProduced = new Set(this.initiallyAvailable);
+        const allConsumed = new Set();
+        for (const s of this.steps) {
+            for (const r of s.requires)
+                allConsumed.add(r);
+            for (const p of s.produces)
+                allProduced.add(p);
+        }
+        const dead = new Set();
+        for (const p of allProduced) {
+            if (!allConsumed.has(p))
+                dead.add(p);
+        }
+        return dead;
+    }
+    stepOrder() { return this.steps.map(s => s.name); }
+    availableAfter(stepName) {
+        const available = new Set(this.initiallyAvailable);
+        for (const s of this.steps) {
+            for (const p of s.produces)
+                available.add(p);
+            if (s.name === stepName)
+                return available;
+        }
+        return available;
+    }
+    toMermaid() {
+        const lines = ['flowchart LR'];
+        for (const s of this.steps) {
+            for (const r of s.requires)
+                lines.push(`    ${r} -->|requires| ${s.name}`);
+            for (const p of s.produces)
+                lines.push(`    ${s.name} -->|produces| ${p}`);
+        }
+        return lines.join('\n') + '\n';
+    }
+}
+exports.PipelineDataFlow = PipelineDataFlow;
+class Pipeline {
+    name;
+    steps;
+    _initiallyAvailable;
+    _dataFlow;
+    strictMode = false;
+    transitionLogger;
+    stateLogger;
+    errorLogger;
+    constructor(name, steps, initiallyAvailable) {
+        this.name = name;
+        this.steps = [...steps];
+        this._initiallyAvailable = new Set(initiallyAvailable);
+        this._dataFlow = new PipelineDataFlow(steps, initiallyAvailable);
+    }
+    dataFlow() { return this._dataFlow; }
+    setStrictMode(strict) { this.strictMode = strict; }
+    setTransitionLogger(l) { this.transitionLogger = l ?? undefined; }
+    setStateLogger(l) { this.stateLogger = l ?? undefined; }
+    setErrorLogger(l) { this.errorLogger = l ?? undefined; }
+    removeAllLoggers() { this.transitionLogger = undefined; this.stateLogger = undefined; this.errorLogger = undefined; }
+    async execute(initialData) {
+        const flowId = crypto.randomUUID();
+        const ctx = new flow_context_js_1.FlowContext(flowId);
+        for (const [k, v] of initialData)
+            ctx.put(k, v);
+        const completed = [];
+        let prev = 'initial';
+        for (const step of this.steps) {
+            this.transitionLogger?.({ flowId, from: prev, to: step.name, trigger: step.name });
+            const keysBefore = this.stateLogger ? new Set(ctx.snapshot().keys()) : null;
+            try {
+                await step.process(ctx);
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                this.errorLogger?.({ flowId, from: prev, to: step.name, trigger: step.name, cause: err });
+                throw new PipelineException(step.name, [...completed], ctx, err);
+            }
+            if (this.strictMode) {
+                for (const prod of step.produces) {
+                    if (!ctx.has(prod)) {
+                        const err = new flow_error_js_1.FlowError('PRODUCES_VIOLATION', `Step '${step.name}' declares produces ${prod} but did not put it`);
+                        throw new PipelineException(step.name, [...completed], ctx, err);
+                    }
+                }
+            }
+            if (this.stateLogger && keysBefore) {
+                for (const [k] of ctx.snapshot()) {
+                    if (!keysBefore.has(k)) {
+                        this.stateLogger({ flowId, state: step.name, key: k, value: ctx.snapshot().get(k) });
+                    }
+                }
+            }
+            completed.push(step.name);
+            prev = step.name;
+        }
+        return ctx;
+    }
+    asStep() {
+        const self = this;
+        return {
+            name: self.name,
+            requires: [...self._initiallyAvailable],
+            produces: self.steps.flatMap(s => s.produces),
+            async process(ctx) {
+                for (const s of self.steps)
+                    await s.process(ctx);
+            },
+        };
+    }
+    static builder(name) { return new PipelineBuilder(name); }
+}
+exports.Pipeline = Pipeline;
+class PipelineBuilder {
+    name;
+    steps = [];
+    _initiallyAvailable = new Set();
+    constructor(name) {
+        this.name = name;
+    }
+    initiallyAvailable(...keys) {
+        for (const k of keys)
+            this._initiallyAvailable.add(k);
+        return this;
+    }
+    step(s) { this.steps.push(s); return this; }
+    build() {
+        const errors = [];
+        const available = new Set(this._initiallyAvailable);
+        for (const s of this.steps) {
+            for (const req of s.requires) {
+                if (!available.has(req))
+                    errors.push(`Step '${s.name}' requires ${req} but it may not be available`);
+            }
+            for (const p of s.produces)
+                available.add(p);
+        }
+        if (errors.length > 0) {
+            throw new flow_error_js_1.FlowError('INVALID_PIPELINE', `Pipeline '${this.name}' has ${errors.length} error(s):\n  - ${errors.join('\n  - ')}`);
+        }
+        return Pipeline.builder(this.name);
+        // Use private constructor via reflection-like pattern
+    }
+}
+exports.PipelineBuilder = PipelineBuilder;
+// Fix: expose Pipeline constructor to builder
+Object.defineProperty(PipelineBuilder.prototype, 'build', {
+    value: function () {
+        const errors = [];
+        const available = new Set(this._initiallyAvailable);
+        for (const s of this.steps) {
+            for (const req of s.requires) {
+                if (!available.has(req))
+                    errors.push(`Step '${s.name}' requires ${req} but it may not be available`);
+            }
+            for (const p of s.produces)
+                available.add(p);
+        }
+        if (errors.length > 0) {
+            throw new flow_error_js_1.FlowError('INVALID_PIPELINE', `Pipeline '${this.name}' has ${errors.length} error(s):\n  - ${errors.join('\n  - ')}`);
+        }
+        const pipeline = Object.create(Pipeline.prototype);
+        Object.assign(pipeline, {
+            name: this.name,
+            steps: [...this.steps],
+            _initiallyAvailable: new Set(this._initiallyAvailable),
+            _dataFlow: new PipelineDataFlow([...this.steps], new Set(this._initiallyAvailable)),
+            strictMode: false,
+        });
+        return pipeline;
+    },
+});

package/dist/cjs/tramli.d.ts

@@ -2,9 +2,11 @@ import type { StateConfig } from './types.js';
 import { Builder } from './flow-definition.js';
 import { FlowEngine } from './flow-engine.js';
 import type { InMemoryFlowStore } from './in-memory-flow-store.js';
+import { PipelineBuilder } from './pipeline.js';
 export declare class Tramli {
     static define<S extends string>(name: string, stateConfig: Record<S, StateConfig>): Builder<S>;
     static engine(store: InMemoryFlowStore, options?: {
         strictMode?: boolean;
     }): FlowEngine;
+    static pipeline(name: string): PipelineBuilder;
 }

package/dist/cjs/tramli.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tramli = void 0;
 const flow_definition_js_1 = require("./flow-definition");
 const flow_engine_js_1 = require("./flow-engine");
+const pipeline_js_1 = require("./pipeline");
 class Tramli {
     static define(name, stateConfig) {
         return new flow_definition_js_1.Builder(name, stateConfig);
@@ -10,5 +11,8 @@ class Tramli {
     static engine(store, options) {
         return new flow_engine_js_1.FlowEngine(store, options);
     }
+    static pipeline(name) {
+        return new pipeline_js_1.PipelineBuilder(name);
+    }
 }
 exports.Tramli = Tramli;

package/dist/esm/index.d.ts

@@ -11,6 +11,8 @@ export { MermaidGenerator } from './mermaid-generator.js';
 export { SkeletonGenerator } from './skeleton-generator.js';
 export type { TargetLanguage } from './skeleton-generator.js';
 export { DataFlowGraph } from './data-flow-graph.js';
+export { Pipeline, PipelineBuilder, PipelineDataFlow, PipelineException } from './pipeline.js';
+export type { PipelineStep } from './pipeline.js';
 export type { NodeInfo } from './data-flow-graph.js';
 export { flowKey } from './flow-key.js';
 export type { FlowKey } from './flow-key.js';

package/dist/esm/index.js

@@ -8,4 +8,5 @@ export { InMemoryFlowStore } from './in-memory-flow-store.js';
 export { MermaidGenerator } from './mermaid-generator.js';
 export { SkeletonGenerator } from './skeleton-generator.js';
 export { DataFlowGraph } from './data-flow-graph.js';
+export { Pipeline, PipelineBuilder, PipelineDataFlow, PipelineException } from './pipeline.js';
 export { flowKey } from './flow-key.js';

package/dist/esm/pipeline.d.ts

@@ -0,0 +1,55 @@
+import { FlowContext } from './flow-context.js';
+import { FlowError } from './flow-error.js';
+import type { FlowKey } from './flow-key.js';
+import type { TransitionLogEntry, StateLogEntry, ErrorLogEntry } from './flow-engine.js';
+export interface PipelineStep {
+    name: string;
+    requires: FlowKey<unknown>[];
+    produces: FlowKey<unknown>[];
+    process(ctx: FlowContext): Promise<void> | void;
+}
+export declare class PipelineException extends FlowError {
+    readonly failedStep: string;
+    readonly completedSteps: string[];
+    readonly context: FlowContext;
+    readonly cause: Error;
+    constructor(failedStep: string, completedSteps: string[], context: FlowContext, cause: Error);
+}
+export declare class PipelineDataFlow {
+    private readonly steps;
+    private readonly initiallyAvailable;
+    constructor(steps: PipelineStep[], initiallyAvailable: Set<string>);
+    deadData(): Set<string>;
+    stepOrder(): string[];
+    availableAfter(stepName: string): Set<string>;
+    toMermaid(): string;
+}
+export declare class Pipeline {
+    readonly name: string;
+    private readonly steps;
+    private readonly _initiallyAvailable;
+    private readonly _dataFlow;
+    private strictMode;
+    private transitionLogger?;
+    private stateLogger?;
+    private errorLogger?;
+    private constructor();
+    dataFlow(): PipelineDataFlow;
+    setStrictMode(strict: boolean): void;
+    setTransitionLogger(l: ((e: TransitionLogEntry) => void) | null): void;
+    setStateLogger(l: ((e: StateLogEntry) => void) | null): void;
+    setErrorLogger(l: ((e: ErrorLogEntry) => void) | null): void;
+    removeAllLoggers(): void;
+    execute(initialData: Map<string, unknown>): Promise<FlowContext>;
+    asStep(): PipelineStep;
+    static builder(name: string): PipelineBuilder;
+}
+export declare class PipelineBuilder {
+    private readonly name;
+    private readonly steps;
+    private readonly _initiallyAvailable;
+    constructor(name: string);
+    initiallyAvailable(...keys: FlowKey<unknown>[]): this;
+    step(s: PipelineStep): this;
+    build(): Pipeline;
+}

package/dist/esm/pipeline.js

@@ -0,0 +1,191 @@
+import { FlowContext } from './flow-context.js';
+import { FlowError } from './flow-error.js';
+export class PipelineException extends FlowError {
+    failedStep;
+    completedSteps;
+    context;
+    cause;
+    constructor(failedStep, completedSteps, context, cause) {
+        super('PIPELINE_STEP_FAILED', `Pipeline step '${failedStep}' failed: ${cause.message}`);
+        this.failedStep = failedStep;
+        this.completedSteps = completedSteps;
+        this.context = context;
+        this.cause = cause;
+    }
+}
+export class PipelineDataFlow {
+    steps;
+    initiallyAvailable;
+    constructor(steps, initiallyAvailable) {
+        this.steps = steps;
+        this.initiallyAvailable = initiallyAvailable;
+    }
+    deadData() {
+        const allProduced = new Set(this.initiallyAvailable);
+        const allConsumed = new Set();
+        for (const s of this.steps) {
+            for (const r of s.requires)
+                allConsumed.add(r);
+            for (const p of s.produces)
+                allProduced.add(p);
+        }
+        const dead = new Set();
+        for (const p of allProduced) {
+            if (!allConsumed.has(p))
+                dead.add(p);
+        }
+        return dead;
+    }
+    stepOrder() { return this.steps.map(s => s.name); }
+    availableAfter(stepName) {
+        const available = new Set(this.initiallyAvailable);
+        for (const s of this.steps) {
+            for (const p of s.produces)
+                available.add(p);
+            if (s.name === stepName)
+                return available;
+        }
+        return available;
+    }
+    toMermaid() {
+        const lines = ['flowchart LR'];
+        for (const s of this.steps) {
+            for (const r of s.requires)
+                lines.push(`    ${r} -->|requires| ${s.name}`);
+            for (const p of s.produces)
+                lines.push(`    ${s.name} -->|produces| ${p}`);
+        }
+        return lines.join('\n') + '\n';
+    }
+}
+export class Pipeline {
+    name;
+    steps;
+    _initiallyAvailable;
+    _dataFlow;
+    strictMode = false;
+    transitionLogger;
+    stateLogger;
+    errorLogger;
+    constructor(name, steps, initiallyAvailable) {
+        this.name = name;
+        this.steps = [...steps];
+        this._initiallyAvailable = new Set(initiallyAvailable);
+        this._dataFlow = new PipelineDataFlow(steps, initiallyAvailable);
+    }
+    dataFlow() { return this._dataFlow; }
+    setStrictMode(strict) { this.strictMode = strict; }
+    setTransitionLogger(l) { this.transitionLogger = l ?? undefined; }
+    setStateLogger(l) { this.stateLogger = l ?? undefined; }
+    setErrorLogger(l) { this.errorLogger = l ?? undefined; }
+    removeAllLoggers() { this.transitionLogger = undefined; this.stateLogger = undefined; this.errorLogger = undefined; }
+    async execute(initialData) {
+        const flowId = crypto.randomUUID();
+        const ctx = new FlowContext(flowId);
+        for (const [k, v] of initialData)
+            ctx.put(k, v);
+        const completed = [];
+        let prev = 'initial';
+        for (const step of this.steps) {
+            this.transitionLogger?.({ flowId, from: prev, to: step.name, trigger: step.name });
+            const keysBefore = this.stateLogger ? new Set(ctx.snapshot().keys()) : null;
+            try {
+                await step.process(ctx);
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                this.errorLogger?.({ flowId, from: prev, to: step.name, trigger: step.name, cause: err });
+                throw new PipelineException(step.name, [...completed], ctx, err);
+            }
+            if (this.strictMode) {
+                for (const prod of step.produces) {
+                    if (!ctx.has(prod)) {
+                        const err = new FlowError('PRODUCES_VIOLATION', `Step '${step.name}' declares produces ${prod} but did not put it`);
+                        throw new PipelineException(step.name, [...completed], ctx, err);
+                    }
+                }
+            }
+            if (this.stateLogger && keysBefore) {
+                for (const [k] of ctx.snapshot()) {
+                    if (!keysBefore.has(k)) {
+                        this.stateLogger({ flowId, state: step.name, key: k, value: ctx.snapshot().get(k) });
+                    }
+                }
+            }
+            completed.push(step.name);
+            prev = step.name;
+        }
+        return ctx;
+    }
+    asStep() {
+        const self = this;
+        return {
+            name: self.name,
+            requires: [...self._initiallyAvailable],
+            produces: self.steps.flatMap(s => s.produces),
+            async process(ctx) {
+                for (const s of self.steps)
+                    await s.process(ctx);
+            },
+        };
+    }
+    static builder(name) { return new PipelineBuilder(name); }
+}
+export class PipelineBuilder {
+    name;
+    steps = [];
+    _initiallyAvailable = new Set();
+    constructor(name) {
+        this.name = name;
+    }
+    initiallyAvailable(...keys) {
+        for (const k of keys)
+            this._initiallyAvailable.add(k);
+        return this;
+    }
+    step(s) { this.steps.push(s); return this; }
+    build() {
+        const errors = [];
+        const available = new Set(this._initiallyAvailable);
+        for (const s of this.steps) {
+            for (const req of s.requires) {
+                if (!available.has(req))
+                    errors.push(`Step '${s.name}' requires ${req} but it may not be available`);
+            }
+            for (const p of s.produces)
+                available.add(p);
+        }
+        if (errors.length > 0) {
+            throw new FlowError('INVALID_PIPELINE', `Pipeline '${this.name}' has ${errors.length} error(s):\n  - ${errors.join('\n  - ')}`);
+        }
+        return Pipeline.builder(this.name);
+        // Use private constructor via reflection-like pattern
+    }
+}
+// Fix: expose Pipeline constructor to builder
+Object.defineProperty(PipelineBuilder.prototype, 'build', {
+    value: function () {
+        const errors = [];
+        const available = new Set(this._initiallyAvailable);
+        for (const s of this.steps) {
+            for (const req of s.requires) {
+                if (!available.has(req))
+                    errors.push(`Step '${s.name}' requires ${req} but it may not be available`);
+            }
+            for (const p of s.produces)
+                available.add(p);
+        }
+        if (errors.length > 0) {
+            throw new FlowError('INVALID_PIPELINE', `Pipeline '${this.name}' has ${errors.length} error(s):\n  - ${errors.join('\n  - ')}`);
+        }
+        const pipeline = Object.create(Pipeline.prototype);
+        Object.assign(pipeline, {
+            name: this.name,
+            steps: [...this.steps],
+            _initiallyAvailable: new Set(this._initiallyAvailable),
+            _dataFlow: new PipelineDataFlow([...this.steps], new Set(this._initiallyAvailable)),
+            strictMode: false,
+        });
+        return pipeline;
+    },
+});

package/dist/esm/tramli.d.ts

@@ -2,9 +2,11 @@ import type { StateConfig } from './types.js';
 import { Builder } from './flow-definition.js';
 import { FlowEngine } from './flow-engine.js';
 import type { InMemoryFlowStore } from './in-memory-flow-store.js';
+import { PipelineBuilder } from './pipeline.js';
 export declare class Tramli {
     static define<S extends string>(name: string, stateConfig: Record<S, StateConfig>): Builder<S>;
     static engine(store: InMemoryFlowStore, options?: {
         strictMode?: boolean;
     }): FlowEngine;
+    static pipeline(name: string): PipelineBuilder;
 }

package/dist/esm/tramli.js

@@ -1,5 +1,6 @@
 import { Builder } from './flow-definition.js';
 import { FlowEngine } from './flow-engine.js';
+import { PipelineBuilder } from './pipeline.js';
 export class Tramli {
     static define(name, stateConfig) {
         return new Builder(name, stateConfig);
@@ -7,4 +8,7 @@ export class Tramli {
     static engine(store, options) {
         return new FlowEngine(store, options);
     }
+    static pipeline(name) {
+        return new PipelineBuilder(name);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unlaxer/tramli",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Constrained flow engine — state machines that prevent invalid transitions at build time",
   "type": "module",
   "exports": {