@bpmnkit/engine 0.1.7

package/dist/timers.js

@@ -0,0 +1,85 @@
+/**
+ * Schedule a timer from a BPMN timer event definition.
+ * Supports ISO 8601 durations (PT2M), dates (2025-06-01T00:00:00Z),
+ * and cycles (R3/PT5S — fires N times or indefinitely when R/...).
+ * Returns a cancel function.
+ */
+export function scheduleTimer(def, callback) {
+    if (def.timeDuration !== undefined) {
+        return scheduleAfterDuration(def.timeDuration, callback);
+    }
+    if (def.timeDate !== undefined) {
+        return scheduleAtDate(def.timeDate, callback);
+    }
+    if (def.timeCycle !== undefined) {
+        return scheduleCycle(def.timeCycle, callback);
+    }
+    // No timer definition — fire immediately
+    const id = setTimeout(callback, 0);
+    return () => clearTimeout(id);
+}
+function scheduleAfterDuration(duration, cb) {
+    const ms = parseDurationMs(duration);
+    const id = setTimeout(cb, ms);
+    return () => clearTimeout(id);
+}
+function scheduleAtDate(dateStr, cb) {
+    const target = new Date(dateStr).getTime();
+    const ms = Math.max(0, target - Date.now());
+    const id = setTimeout(cb, ms);
+    return () => clearTimeout(id);
+}
+function scheduleCycle(cycle, cb) {
+    // Format: R<n>/<duration> or R/<duration> (infinite) or just <duration>
+    const cycleMatch = /^R(\d*)\/(.+)$/.exec(cycle);
+    if (cycleMatch === null) {
+        return scheduleAfterDuration(cycle, cb);
+    }
+    const countStr = cycleMatch[1];
+    const durationStr = cycleMatch[2] ?? "";
+    const maxFires = countStr === "" || countStr === undefined ? Number.POSITIVE_INFINITY : Number(countStr);
+    const ms = parseDurationMs(durationStr);
+    let fired = 0;
+    let cancelled = false;
+    let timerId;
+    const fire = () => {
+        if (cancelled)
+            return;
+        cb();
+        fired++;
+        if (fired < maxFires) {
+            timerId = setTimeout(fire, ms);
+        }
+    };
+    timerId = setTimeout(fire, ms);
+    return () => {
+        cancelled = true;
+        if (timerId !== undefined)
+            clearTimeout(timerId);
+    };
+}
+/**
+ * Parse an ISO 8601 duration string into milliseconds.
+ * Handles: PT#S, PT#M, PT#H, P#D, P#W, and combinations.
+ */
+export function parseDurationMs(duration) {
+    const re = /^P(?:(\d+(?:\.\d+)?)Y)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+    const m = re.exec(duration.trim());
+    if (m === null)
+        return 0;
+    const years = Number(m[1] ?? 0);
+    const months = Number(m[2] ?? 0);
+    const weeks = Number(m[3] ?? 0);
+    const days = Number(m[4] ?? 0);
+    const hours = Number(m[5] ?? 0);
+    const minutes = Number(m[6] ?? 0);
+    const seconds = Number(m[7] ?? 0);
+    return (years * 365.25 * 24 * 3600 * 1000 +
+        months * 30.44 * 24 * 3600 * 1000 +
+        weeks * 7 * 24 * 3600 * 1000 +
+        days * 24 * 3600 * 1000 +
+        hours * 3600 * 1000 +
+        minutes * 60 * 1000 +
+        seconds * 1000);
+}
+//# sourceMappingURL=timers.js.map

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+export type ProcessEvent = {
+    type: "element:entering";
+    elementId: string;
+    elementName?: string;
+    elementType: string;
+} | {
+    type: "element:entered";
+    elementId: string;
+    elementName?: string;
+    elementType: string;
+} | {
+    type: "element:leaving";
+    elementId: string;
+    elementName?: string;
+    elementType: string;
+} | {
+    type: "element:left";
+    elementId: string;
+    elementName?: string;
+    elementType: string;
+} | {
+    type: "variable:set";
+    name: string;
+    value: unknown;
+    scopeId: string;
+} | {
+    type: "job:created";
+    job: Job;
+} | {
+    type: "feel:evaluated";
+    elementId: string;
+    property: string;
+    expression: string;
+    result: unknown;
+    variables: Record<string, unknown>;
+} | {
+    type: "element:failed";
+    elementId: string;
+    error: string;
+} | {
+    type: "process:completed";
+    variables: Record<string, unknown>;
+} | {
+    type: "process:failed";
+    error: string;
+};
+export interface Job {
+    readonly id: string;
+    readonly type: string;
+    readonly headers: Record<string, string>;
+    readonly variables: Record<string, unknown>;
+    complete(variables?: Record<string, unknown>): void;
+    fail(error: string): void;
+    throwError(code: string, message: string): void;
+}
+export type JobHandler = (job: Job) => void | Promise<void>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,3 @@
+// ── Events ────────────────────────────────────────────────────────────────────
+export {};
+//# sourceMappingURL=types.js.map

package/dist/variables.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hierarchical variable scope store.
+ * Scopes form a parent chain; reads walk up, writes update the nearest
+ * scope that already owns the variable (or fall through to local).
+ */
+export declare class VariableStore {
+    private readonly scopes;
+    private readonly parents;
+    createScope(id: string, parentId?: string): void;
+    removeScope(id: string): void;
+    /** Walk up the chain and return the value, or undefined if not found. */
+    get(scopeId: string, name: string): unknown;
+    /**
+     * Set a variable. Walks up the chain and updates it in the nearest scope
+     * that already holds the variable. If not found anywhere, sets it locally.
+     */
+    set(scopeId: string, name: string, value: unknown): void;
+    /** Set a variable in this scope only, regardless of parent state. */
+    setLocal(scopeId: string, name: string, value: unknown): void;
+    /** Return all variables merged from root → this scope (child wins). */
+    getAll(scopeId: string): Record<string, unknown>;
+    private hasOwn;
+    private ancestorHas;
+}
+//# sourceMappingURL=variables.d.ts.map

package/dist/variables.js

@@ -0,0 +1,76 @@
+/**
+ * Hierarchical variable scope store.
+ * Scopes form a parent chain; reads walk up, writes update the nearest
+ * scope that already owns the variable (or fall through to local).
+ */
+export class VariableStore {
+    scopes = new Map();
+    parents = new Map();
+    createScope(id, parentId) {
+        this.scopes.set(id, new Map());
+        if (parentId !== undefined) {
+            this.parents.set(id, parentId);
+        }
+    }
+    removeScope(id) {
+        this.scopes.delete(id);
+        this.parents.delete(id);
+    }
+    /** Walk up the chain and return the value, or undefined if not found. */
+    get(scopeId, name) {
+        const scope = this.scopes.get(scopeId);
+        if (scope === undefined)
+            return undefined;
+        if (scope.has(name))
+            return scope.get(name);
+        const parentId = this.parents.get(scopeId);
+        if (parentId !== undefined)
+            return this.get(parentId, name);
+        return undefined;
+    }
+    /**
+     * Set a variable. Walks up the chain and updates it in the nearest scope
+     * that already holds the variable. If not found anywhere, sets it locally.
+     */
+    set(scopeId, name, value) {
+        if (this.hasOwn(scopeId, name)) {
+            this.scopes.get(scopeId)?.set(name, value);
+            return;
+        }
+        const parentId = this.parents.get(scopeId);
+        if (parentId !== undefined && this.ancestorHas(parentId, name)) {
+            this.set(parentId, name, value);
+            return;
+        }
+        this.scopes.get(scopeId)?.set(name, value);
+    }
+    /** Set a variable in this scope only, regardless of parent state. */
+    setLocal(scopeId, name, value) {
+        this.scopes.get(scopeId)?.set(name, value);
+    }
+    /** Return all variables merged from root → this scope (child wins). */
+    getAll(scopeId) {
+        const parentId = this.parents.get(scopeId);
+        const parentVars = parentId !== undefined ? this.getAll(parentId) : {};
+        const scope = this.scopes.get(scopeId);
+        if (scope === undefined)
+            return parentVars;
+        const result = { ...parentVars };
+        for (const [k, v] of scope) {
+            result[k] = v;
+        }
+        return result;
+    }
+    hasOwn(scopeId, name) {
+        return this.scopes.get(scopeId)?.has(name) ?? false;
+    }
+    ancestorHas(scopeId, name) {
+        if (this.hasOwn(scopeId, name))
+            return true;
+        const parentId = this.parents.get(scopeId);
+        if (parentId !== undefined)
+            return this.ancestorHas(parentId, name);
+        return false;
+    }
+}
+//# sourceMappingURL=variables.js.map

package/dist/zeebe.d.ts

@@ -0,0 +1,35 @@
+import type { XmlElement } from "@bpmnkit/core";
+/** Parsed Zeebe extension data for a BPMN element. */
+export interface ParsedZeebeExt {
+    taskDefinition?: {
+        type: string;
+        retries: number;
+    };
+    ioMapping?: {
+        inputs: Array<{
+            source: string;
+            target: string;
+        }>;
+        outputs: Array<{
+            source: string;
+            target: string;
+        }>;
+    };
+    taskHeaders?: Record<string, string>;
+    calledDecision?: {
+        decisionId: string;
+        resultVariable: string;
+    };
+    formDefinition?: {
+        formId: string;
+    };
+    scriptTask?: {
+        expression: string;
+        resultVariable: string;
+    };
+    /** JSON string from `camundaModeler:exampleOutputJson` zeebe:property — used in play mode. */
+    exampleOutputJson?: string;
+}
+/** Parse extensionElements XmlElement array into a typed Zeebe extension object. */
+export declare function parseZeebeExt(extensionElements: XmlElement[]): ParsedZeebeExt;
+//# sourceMappingURL=zeebe.d.ts.map

package/dist/zeebe.js

@@ -0,0 +1,75 @@
+/** Parse extensionElements XmlElement array into a typed Zeebe extension object. */
+export function parseZeebeExt(extensionElements) {
+    const result = {};
+    for (const el of extensionElements) {
+        switch (el.name) {
+            case "zeebe:taskDefinition": {
+                const type = el.attributes.type ?? "";
+                const retries = Number(el.attributes.retries ?? "3");
+                result.taskDefinition = { type, retries };
+                break;
+            }
+            case "zeebe:ioMapping": {
+                const inputs = [];
+                const outputs = [];
+                for (const child of el.children) {
+                    if (child.name === "zeebe:input") {
+                        inputs.push({
+                            source: child.attributes.source ?? "",
+                            target: child.attributes.target ?? "",
+                        });
+                    }
+                    else if (child.name === "zeebe:output") {
+                        outputs.push({
+                            source: child.attributes.source ?? "",
+                            target: child.attributes.target ?? "",
+                        });
+                    }
+                }
+                result.ioMapping = { inputs, outputs };
+                break;
+            }
+            case "zeebe:taskHeaders": {
+                const headers = {};
+                for (const child of el.children) {
+                    if (child.name === "zeebe:header") {
+                        const key = child.attributes.key;
+                        const value = child.attributes.value;
+                        if (key !== undefined)
+                            headers[key] = value ?? "";
+                    }
+                }
+                result.taskHeaders = headers;
+                break;
+            }
+            case "zeebe:calledDecision": {
+                const decisionId = el.attributes.decisionId ?? "";
+                const resultVariable = el.attributes.resultVariable ?? "";
+                result.calledDecision = { decisionId, resultVariable };
+                break;
+            }
+            case "zeebe:formDefinition": {
+                const formId = el.attributes.formId ?? "";
+                result.formDefinition = { formId };
+                break;
+            }
+            case "zeebe:script": {
+                const expression = el.attributes.expression ?? "";
+                const resultVariable = el.attributes.resultVariable ?? "";
+                result.scriptTask = { expression, resultVariable };
+                break;
+            }
+            case "zeebe:properties": {
+                for (const child of el.children) {
+                    if (child.name === "zeebe:property" &&
+                        child.attributes.name === "camundaModeler:exampleOutputJson") {
+                        result.exampleOutputJson = child.attributes.value;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=zeebe.js.map

package/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "@bpmnkit/engine",
+	"version": "0.1.7",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": ["dist/**/*.js", "dist/**/*.d.ts"],
+	"scripts": {
+		"build": "tsc",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run",
+		"check": "biome check ."
+	},
+	"dependencies": {
+		"@bpmnkit/core": "workspace:*",
+		"@bpmnkit/feel": "workspace:*"
+	},
+	"description": "Lightweight BPMN 2.0 process execution engine for browsers and Node.js — zero dependencies",
+	"keywords": ["bpmn", "engine", "simulation", "workflow", "typescript", "dmn"],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/bpmnkit/monorepo"
+	}
+}