@bpmnkit/engine 0.1.14 → 0.1.19

package/README.md

@@ -6,6 +6,8 @@
   [![npm](https://img.shields.io/npm/v/@bpmnkit/engine?style=flat-square&color=6244d7)](https://www.npmjs.com/package/@bpmnkit/engine)
   [![license](https://img.shields.io/npm/l/@bpmnkit/engine?style=flat-square)](https://github.com/bpmnkit/monorepo/blob/main/LICENSE)
   [![typescript](https://img.shields.io/badge/TypeScript-strict-6244d7?style=flat-square&logo=typescript&logoColor=white)](https://github.com/bpmnkit/monorepo)
+  [![ai-assisted](https://img.shields.io/badge/AI--assisted-claude-8b5cf6?style=flat-square)](https://github.com/bpmnkit/monorepo)
+  [![experimental](https://img.shields.io/badge/status-experimental-f59e0b?style=flat-square)](https://github.com/bpmnkit/monorepo)
 
   [Website](https://bpmnkit.com) · [Documentation](https://docs.bpmnkit.com) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/packages/engine/CHANGELOG.md)
 </div>

package/dist/engine.d.ts

@@ -1,5 +1,6 @@
 import type { BpmnDefinitions, DmnDefinitions, FormDefinition } from "@bpmnkit/core";
 import { ProcessInstance } from "./instance.js";
+import type { SecretResolver } from "./secrets.js";
 import type { JobHandler } from "./types.js";
 /** Options for {@link Engine.start}. */
 export interface StartOptions {
@@ -9,11 +10,18 @@ export interface StartOptions {
      */
     beforeComplete?: (elementId: string) => Promise<void>;
 }
+/** Options for the {@link Engine} constructor. */
+export interface EngineOptions {
+    /** Resolver for `{{secrets.NAME}}` placeholders in connector configurations. */
+    secretResolver?: SecretResolver;
+}
 export declare class Engine {
     private readonly processes;
     private readonly decisions;
     private readonly forms;
     private readonly workers;
+    private readonly secretResolver;
+    constructor(options?: EngineOptions);
     /**
      * Deploy BPMN processes, DMN decisions, and form definitions.
      * Calling deploy multiple times merges into the registry.

package/dist/engine.js

@@ -4,6 +4,10 @@ export class Engine {
     decisions = new Map();
     forms = new Map();
     workers = new Map();
+    secretResolver;
+    constructor(options) {
+        this.secretResolver = options?.secretResolver;
+    }
     /**
      * Deploy BPMN processes, DMN decisions, and form definitions.
      * Calling deploy multiple times merges into the registry.
@@ -40,7 +44,7 @@ export class Engine {
         if (process === undefined) {
             throw new Error(`Process "${processId}" is not deployed`);
         }
-        const instance = new ProcessInstance(process, this.decisions, this.forms, this.workers, variables ?? {});
+        const instance = new ProcessInstance(process, this.decisions, this.forms, this.workers, variables ?? {}, this.secretResolver);
         if (options?.beforeComplete !== undefined) {
             instance.beforeComplete = options.beforeComplete;
         }

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { Engine } from "./engine.js";
-export type { StartOptions } from "./engine.js";
+export type { StartOptions, EngineOptions } from "./engine.js";
+export { EnvSecretResolver, resolveSecretString } from "./secrets.js";
+export type { SecretResolver } from "./secrets.js";
 export { ProcessInstance } from "./instance.js";
 export type { ProcessEvent, Job, JobHandler } from "./types.js";
 export { VariableStore } from "./variables.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 export { Engine } from "./engine.js";
+export { EnvSecretResolver, resolveSecretString } from "./secrets.js";
 export { ProcessInstance } from "./instance.js";
 export { VariableStore } from "./variables.js";
 export { evaluateDecision } from "./dmn.js";

package/dist/instance.d.ts

@@ -1,4 +1,5 @@
 import type { BpmnProcess, DmnDecision, FormDefinition } from "@bpmnkit/core";
+import type { SecretResolver } from "./secrets.js";
 import type { JobHandler, ProcessEvent } from "./types.js";
 type InstanceState = "active" | "completed" | "terminated" | "failed";
 export declare class ProcessInstance {
@@ -25,13 +26,14 @@ export declare class ProcessInstance {
     private readonly decisions;
     private readonly forms;
     private readonly jobWorkers;
+    private readonly secretResolver;
     /**
      * Optional hook called just before an element completes (token moves on).
      * Returning a Promise lets the caller pause execution — useful for
      * step-by-step simulation. Set via {@link Engine.start} options.
      */
     beforeComplete?: (elementId: string) => Promise<void>;
-    constructor(process: BpmnProcess, decisions: Map<string, DmnDecision>, forms: Map<string, FormDefinition>, jobWorkers: Map<string, JobHandler>, initialVars: Record<string, unknown>);
+    constructor(process: BpmnProcess, decisions: Map<string, DmnDecision>, forms: Map<string, FormDefinition>, jobWorkers: Map<string, JobHandler>, initialVars: Record<string, unknown>, secretResolver?: SecretResolver);
     get state(): InstanceState;
     get error(): string | undefined;
     get activeElements(): string[];

package/dist/instance.js

@@ -1,6 +1,7 @@
 import { generateId } from "@bpmnkit/core";
 import { evaluate, parseExpression } from "@bpmnkit/feel";
 import { evaluateDecision } from "./dmn.js";
+import { resolveSecretString } from "./secrets.js";
 import { scheduleTimer } from "./timers.js";
 import { VariableStore } from "./variables.js";
 import { parseZeebeExt } from "./zeebe.js";
@@ -29,18 +30,20 @@ export class ProcessInstance {
     decisions;
     forms;
     jobWorkers;
+    secretResolver;
     /**
      * Optional hook called just before an element completes (token moves on).
      * Returning a Promise lets the caller pause execution — useful for
      * step-by-step simulation. Set via {@link Engine.start} options.
      */
     beforeComplete;
-    constructor(process, decisions, forms, jobWorkers, initialVars) {
+    constructor(process, decisions, forms, jobWorkers, initialVars, secretResolver) {
         this.id = generateId("pi");
         this.processId = process.id;
         this.decisions = decisions;
         this.forms = forms;
         this.jobWorkers = jobWorkers;
+        this.secretResolver = secretResolver;
         this.variables = new VariableStore();
         this.rootScopeId = `scope_${this.id}`;
         this.variables.createScope(this.rootScopeId);
@@ -186,10 +189,27 @@ export class ProcessInstance {
         const ext = parseZeebeExt(el.extensionElements);
         if (ext.ioMapping) {
             for (const inp of ext.ioMapping.inputs) {
-                const val = this.evalFeel(inp.source, scopeId, {
-                    elementId: el.id,
-                    property: `input:${inp.target}`,
-                });
+                let val;
+                if (this.secretResolver !== undefined && inp.source.includes("{{secrets.")) {
+                    const resolved = await resolveSecretString(inp.source, this.secretResolver);
+                    // If source starts with "=", it's a FEEL expression — evaluate after secret substitution.
+                    // Otherwise it's a literal string — use the resolved value directly.
+                    if (inp.source.trimStart().startsWith("=")) {
+                        val = this.evalFeel(resolved, scopeId, {
+                            elementId: el.id,
+                            property: `input:${inp.target}`,
+                        });
+                    }
+                    else {
+                        val = resolved;
+                    }
+                }
+                else {
+                    val = this.evalFeel(inp.source, scopeId, {
+                        elementId: el.id,
+                        property: `input:${inp.target}`,
+                    });
+                }
                 this.variables.setLocal(scopeId, inp.target, val);
                 this.emit({ type: "variable:set", name: inp.target, value: val, scopeId });
             }
@@ -314,7 +334,17 @@ export class ProcessInstance {
             return;
         }
         const jobId = generateId("job");
-        const headers = ext.taskHeaders ?? {};
+        const rawHeaders = ext.taskHeaders ?? {};
+        let headers;
+        if (this.secretResolver !== undefined) {
+            headers = {};
+            for (const [k, v] of Object.entries(rawHeaders)) {
+                headers[k] = await resolveSecretString(v, this.secretResolver);
+            }
+        }
+        else {
+            headers = rawHeaders;
+        }
         const vars = this.variables.getAll(ctx.scopeId);
         let jobError;
         await new Promise((resolve) => {
@@ -376,8 +406,14 @@ export class ProcessInstance {
         if (cd === undefined)
             return;
         const decision = this.decisions.get(cd.decisionId);
-        if (decision === undefined)
+        if (decision === undefined) {
+            this.emit({
+                type: "element:failed",
+                elementId: _el.id,
+                error: `DMN decision '${cd.decisionId}' not found. Deploy the DMN before running the process.`,
+            });
             return;
+        }
         const result = evaluateDecision(decision, this.variables.getAll(scopeId));
         this.variables.set(scopeId, cd.resultVariable, result);
         this.emit({ type: "variable:set", name: cd.resultVariable, value: result, scopeId });

package/dist/scenario.d.ts

@@ -36,6 +36,13 @@ export interface ScenarioResult {
     visitedElements: string[];
     /** Final variable state. */
     finalVariables: Record<string, unknown>;
+    /** FEEL expressions evaluated during the run, in order. */
+    feelEvals: Array<{
+        elementId: string;
+        property: string;
+        expression: string;
+        result: unknown;
+    }>;
     /** Errors collected during the run. */
     errors: Array<{
         elementId?: string;

package/dist/scenario.js

@@ -21,6 +21,7 @@ export function runScenario(engine, defs, scenario, timeoutMs = DEFAULT_TIMEOUT_
                 passed: false,
                 visitedElements: [],
                 finalVariables: {},
+                feelEvals: [],
                 errors: [{ message: "No process found in definitions." }],
                 failures: [{ field: "processId", expected: "a deployed process", actual: undefined }],
                 durationMs: Date.now() - startMs,
@@ -42,6 +43,7 @@ export function runScenario(engine, defs, scenario, timeoutMs = DEFAULT_TIMEOUT_
         }
         const visitedElements = [];
         const variableState = new Map();
+        const feelEvals = [];
         const errors = [];
         let settled = false;
         let timeoutHandle;
@@ -95,6 +97,7 @@ export function runScenario(engine, defs, scenario, timeoutMs = DEFAULT_TIMEOUT_
                 passed: failures.length === 0,
                 visitedElements,
                 finalVariables,
+                feelEvals,
                 errors,
                 failures,
                 durationMs: Date.now() - startMs,
@@ -121,6 +124,7 @@ export function runScenario(engine, defs, scenario, timeoutMs = DEFAULT_TIMEOUT_
                 passed: false,
                 visitedElements: [],
                 finalVariables: {},
+                feelEvals: [],
                 errors: [{ message: msg }],
                 failures: [{ field: "start", expected: "process to start", actual: msg }],
                 durationMs: Date.now() - startMs,
@@ -134,6 +138,14 @@ export function runScenario(engine, defs, scenario, timeoutMs = DEFAULT_TIMEOUT_
             else if (evt.type === "variable:set") {
                 variableState.set(evt.name, evt.value);
             }
+            else if (evt.type === "feel:evaluated") {
+                feelEvals.push({
+                    elementId: evt.elementId,
+                    property: evt.property,
+                    expression: evt.expression,
+                    result: evt.result,
+                });
+            }
             else if (evt.type === "element:failed") {
                 errors.push({ elementId: evt.elementId, message: evt.error });
             }

package/dist/secrets.d.ts

@@ -0,0 +1,18 @@
+/** Interface for resolving secret values by name. */
+export interface SecretResolver {
+    resolve(name: string): Promise<string | undefined>;
+}
+/**
+ * Replace all `{{secrets.NAME}}` placeholders in `value` using the given resolver.
+ * Returns the original string unchanged if no placeholders are present.
+ * Throws if any referenced secret is not configured.
+ */
+export declare function resolveSecretString(value: string, resolver: SecretResolver): Promise<string>;
+/**
+ * Secret resolver that reads from `process.env`.
+ * Works in Node.js; always returns `undefined` in browser contexts.
+ */
+export declare class EnvSecretResolver implements SecretResolver {
+    resolve(name: string): Promise<string | undefined>;
+}
+//# sourceMappingURL=secrets.d.ts.map

package/dist/secrets.js

@@ -0,0 +1,35 @@
+const SECRET_RE = /\{\{secrets\.([^}]+)\}\}/g;
+/**
+ * Replace all `{{secrets.NAME}}` placeholders in `value` using the given resolver.
+ * Returns the original string unchanged if no placeholders are present.
+ * Throws if any referenced secret is not configured.
+ */
+export async function resolveSecretString(value, resolver) {
+    if (!value.includes("{{secrets."))
+        return value;
+    // Collect all unique names first to allow parallel resolution
+    const names = new Set();
+    for (const m of value.matchAll(SECRET_RE)) {
+        if (m[1])
+            names.add(m[1]);
+    }
+    const resolved = new Map();
+    await Promise.all([...names].map(async (name) => {
+        const val = await resolver.resolve(name);
+        if (val === undefined) {
+            throw new Error(`Secret "{{secrets.${name}}}" is not configured`);
+        }
+        resolved.set(name, val);
+    }));
+    return value.replace(SECRET_RE, (_match, name) => resolved.get(name) ?? "");
+}
+/**
+ * Secret resolver that reads from `process.env`.
+ * Works in Node.js; always returns `undefined` in browser contexts.
+ */
+export class EnvSecretResolver {
+    async resolve(name) {
+        return typeof process !== "undefined" ? process.env[name] : undefined;
+    }
+}
+//# sourceMappingURL=secrets.js.map

package/dist/wasm-runner.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Scenario runner backed by the WasmEngine (reebe-wasm).
+ *
+ * Works in both browser and Node.js:
+ *   - Browser: WASM is loaded via the default export (fetch-based).
+ *   - Node.js:  WASM bytes are read from disk via initSync to avoid
+ *               Node's lack of fetch() support for file:// URLs.
+ *
+ * Creates a fresh WasmEngine per scenario for clean isolation, deploys the
+ * current BPMN XML (and all referenced DMN/BPMN resources recursively), drives
+ * jobs to completion using mock outputs from the scenario definition, then
+ * asserts expectations.
+ */
+export interface ScenarioLike {
+    id: string;
+    name: string;
+    processId?: string;
+    inputs?: Record<string, unknown>;
+    mocks?: Record<string, {
+        outputs?: Record<string, unknown>;
+        error?: string;
+    }>;
+    expect?: {
+        path?: string[];
+        variables?: Record<string, unknown>;
+    };
+}
+export interface ScenarioResultLike {
+    scenarioId: string;
+    scenarioName: string;
+    passed: boolean;
+    visitedElements: string[];
+    finalVariables: Record<string, unknown>;
+    feelEvals: Array<{
+        elementId: string;
+        property: string;
+        expression: string;
+        result: unknown;
+    }>;
+    errors: Array<{
+        elementId?: string;
+        message: string;
+    }>;
+    failures: Array<{
+        field: string;
+        expected: unknown;
+        actual: unknown;
+    }>;
+    durationMs: number;
+}
+export declare function runScenarioWasm(xml: string, scenario: ScenarioLike, getDecisionDmn?: (decisionId: string) => string | null, getProcessBpmn?: (processId: string) => string | null): Promise<ScenarioResultLike>;
+//# sourceMappingURL=wasm-runner.d.ts.map

package/dist/wasm-runner.js

@@ -0,0 +1,461 @@
+/**
+ * Scenario runner backed by the WasmEngine (reebe-wasm).
+ *
+ * Works in both browser and Node.js:
+ *   - Browser: WASM is loaded via the default export (fetch-based).
+ *   - Node.js:  WASM bytes are read from disk via initSync to avoid
+ *               Node's lack of fetch() support for file:// URLs.
+ *
+ * Creates a fresh WasmEngine per scenario for clean isolation, deploys the
+ * current BPMN XML (and all referenced DMN/BPMN resources recursively), drives
+ * jobs to completion using mock outputs from the scenario definition, then
+ * asserts expectations.
+ */
+// ── WASM initialisation ───────────────────────────────────────────────────────
+let wasmReady = false;
+async function ensureWasmInit() {
+    if (wasmReady)
+        return;
+    const mod = await import("@bpmnkit/reebe-wasm");
+    // Node.js: fetch() does not support file:// URLs generated by wasm-bindgen,
+    // so we read the .wasm bytes from disk and use initSync.
+    if (typeof process !== "undefined" && typeof process.versions?.node === "string") {
+        const { readFileSync } = await import("node:fs");
+        const { createRequire } = await import("node:module");
+        const { dirname, resolve } = await import("node:path");
+        const req = createRequire(import.meta.url);
+        const jsPath = req.resolve("@bpmnkit/reebe-wasm");
+        const wasmPath = resolve(dirname(jsPath), "reebe_wasm_bg.wasm");
+        mod.initSync({ module: readFileSync(wasmPath) });
+    }
+    else {
+        await mod.default();
+    }
+    wasmReady = true;
+}
+// ── Recursive dependency deployment ──────────────────────────────────────────
+function deployDependencies(xml, engine, getDecisionDmn, getProcessBpmn, deployed) {
+    const missingDecisions = [];
+    // DMN decisions referenced via decisionId="..."
+    if (getDecisionDmn) {
+        for (const [, id] of xml.matchAll(/decisionId="([^"]+)"/g)) {
+            if (!id || deployed.has(`dmn:${id}`))
+                continue;
+            deployed.add(`dmn:${id}`);
+            const dmnXml = getDecisionDmn(id);
+            if (dmnXml) {
+                try {
+                    engine.deploy(dmnXml);
+                }
+                catch {
+                    missingDecisions.push(id);
+                }
+            }
+            else {
+                missingDecisions.push(id);
+            }
+        }
+    }
+    // Sub-processes / call activities referenced via calledElement="..."
+    if (getProcessBpmn) {
+        for (const [, id] of xml.matchAll(/calledElement="([^"]+)"/g)) {
+            if (!id || deployed.has(`bpmn:${id}`))
+                continue;
+            deployed.add(`bpmn:${id}`);
+            const bpmnXml = getProcessBpmn(id);
+            if (bpmnXml) {
+                const nested = deployDependencies(bpmnXml, engine, getDecisionDmn, getProcessBpmn, deployed);
+                missingDecisions.push(...nested);
+                engine.deploy(bpmnXml);
+            }
+        }
+    }
+    return missingDecisions;
+}
+// ── BPMN helpers ─────────────────────────────────────────────────────────────
+/**
+ * Extract condition expressions keyed by sequence flow ID from BPMN XML.
+ * Used to reconstruct FEEL evaluations from SEQUENCE_FLOW_TAKEN event log records.
+ */
+function extractFlowConditions(bpmnXml) {
+    const result = new Map();
+    // Strategy: find each conditionExpression element, then look backward to the
+    // nearest enclosing <sequenceFlow id="..."> opening tag.  Using a greedy
+    // prefix ([\s\S]*) forces the match to the LAST occurrence before the
+    // conditionExpression, which is always the immediately enclosing flow.
+    // This avoids the self-closing `/>` confusion that plagues forward-matching regexes.
+    const condPattern = /<(?:[a-zA-Z]+:)?conditionExpression[^>]*>([\s\S]*?)<\/(?:[a-zA-Z]+:)?conditionExpression>/g;
+    for (const condMatch of bpmnXml.matchAll(condPattern)) {
+        const rawExpr = condMatch[1]?.trim() ?? "";
+        const condition = rawExpr.startsWith("<![CDATA[") && rawExpr.endsWith("]]>") ? rawExpr.slice(9, -3) : rawExpr;
+        // Slice everything before this conditionExpression and find the last sequenceFlow id
+        const before = bpmnXml.slice(0, condMatch.index);
+        const flowMatch = before.match(/[\s\S]*<(?:[a-zA-Z]+:)?sequenceFlow\b[^>]*\bid="([^"]+)"/);
+        if (flowMatch?.[1]) {
+            result.set(flowMatch[1], condition);
+        }
+    }
+    return result;
+}
+/**
+ * Ensure BRT result variables are propagated to the parent process scope.
+ *
+ * When a BPMN `businessRuleTask` has both `zeebe:calledDecision resultVariable="X"`
+ * and a `zeebe:ioMapping` element, the WASM engine only propagates explicitly mapped
+ * output variables.  Without an output entry for X, the result stays in the element
+ * scope (scope_key = element instance key) and is cleaned up when the BRT completes —
+ * never reaching the process instance scope where the runner's snapshot reads variables.
+ *
+ * This function rewrites the XML so that each such BRT has an explicit
+ * `<zeebe:output source="=X" target="X"/>` entry, mirroring real Zeebe behaviour
+ * where resultVariable is always stored at the parent scope.
+ */
+function ensureBrtResultVariableOutputs(xml) {
+    const brtPattern = /(<(?:[a-zA-Z]+:)?businessRuleTask\b[^>]*>)([\s\S]*?)(<\/(?:[a-zA-Z]+:)?businessRuleTask>)/g;
+    return xml.replace(brtPattern, (_match, open, body, close) => {
+        const rvMatch = /resultVariable="([^"]+)"/.exec(body);
+        if (!rvMatch?.[1])
+            return open + body + close; // no calledDecision resultVariable
+        const resultVar = rvMatch[1];
+        // Already has an output entry for this variable? Nothing to do
+        if (new RegExp(`<(?:[a-zA-Z]+:)?output\\b[^>]*target="${resultVar}"`).test(body))
+            return open + body + close;
+        const outputEntry = `<zeebe:output source="=${resultVar}" target="${resultVar}"/>`;
+        const hasIoMapping = /<(?:[a-zA-Z]+:)?ioMapping\b/.test(body);
+        let patched;
+        if (!hasIoMapping) {
+            // No ioMapping at all — inject one before the closing extensionElements tag
+            patched = body.replace(/(<\/(?:[a-zA-Z]+:)?extensionElements>)/, `<zeebe:ioMapping>${outputEntry}</zeebe:ioMapping>$1`);
+        }
+        else if (/<(?:[a-zA-Z]+:)?ioMapping\s*\/>/.test(body)) {
+            // Self-closing <zeebe:ioMapping/> — expand and inject
+            patched = body.replace(/<(?:[a-zA-Z]+:)?ioMapping\s*\/>/, `<zeebe:ioMapping>${outputEntry}</zeebe:ioMapping>`);
+        }
+        else {
+            // Open/close <zeebe:ioMapping>…</zeebe:ioMapping> — inject before closing tag
+            patched = body.replace(/(<\/(?:[a-zA-Z]+:)?ioMapping>)/, `${outputEntry}$1`);
+        }
+        return open + patched + close;
+    });
+}
+function extractBrtInfos(bpmnXml) {
+    const infos = [];
+    const pattern = /<(?:[a-zA-Z]+:)?businessRuleTask\b([^>]*)>([\s\S]*?)<\/(?:[a-zA-Z]+:)?businessRuleTask>/g;
+    for (const m of bpmnXml.matchAll(pattern)) {
+        const attrs = m[1] ?? "";
+        const body = m[2] ?? "";
+        const idMatch = /\bid="([^"]+)"/.exec(attrs);
+        const decisionIdMatch = /decisionId="([^"]+)"/.exec(body);
+        const resultVarMatch = /resultVariable="([^"]+)"/.exec(body);
+        if (idMatch?.[1] && decisionIdMatch?.[1] && resultVarMatch?.[1]) {
+            infos.push({
+                elementId: idMatch[1],
+                decisionId: decisionIdMatch[1],
+                resultVar: resultVarMatch[1],
+            });
+        }
+    }
+    return infos;
+}
+function parseDmnDecisionTable(dmnXml, decisionId) {
+    const decisionMatch = new RegExp(`<(?:[a-zA-Z]+:)?decision\\b[^>]*\\bid="${decisionId}"[^>]*>[\\s\\S]*?<\\/(?:[a-zA-Z]+:)?decision>`).exec(dmnXml);
+    if (!decisionMatch)
+        return null;
+    const decisionBody = decisionMatch[0];
+    const tableMatch = /<(?:[a-zA-Z]+:)?decisionTable\b([^>]*)>([\s\S]*?)<\/(?:[a-zA-Z]+:)?decisionTable>/.exec(decisionBody);
+    if (!tableMatch)
+        return null;
+    const hitPolicy = /hitPolicy="([^"]*)"/.exec(tableMatch[1] ?? "")?.[1] ?? "UNIQUE";
+    const tableBody = tableMatch[2] ?? "";
+    const extractText = (xml) => /<(?:[a-zA-Z]+:)?text\b[^>]*>([\s\S]*?)<\/(?:[a-zA-Z]+:)?text>/.exec(xml)?.[1]?.trim() ?? "";
+    const inputs = [];
+    for (const m of tableBody.matchAll(/<(?:[a-zA-Z]+:)?input\b[^>]*>([\s\S]*?)<\/(?:[a-zA-Z]+:)?input>/g)) {
+        const exprBody = /<(?:[a-zA-Z]+:)?inputExpression\b[^>]*>([\s\S]*?)<\/(?:[a-zA-Z]+:)?inputExpression>/.exec(m[1] ?? "")?.[1] ?? "";
+        inputs.push(extractText(exprBody));
+    }
+    const outputs = [];
+    for (const m of tableBody.matchAll(/<(?:[a-zA-Z]+:)?output\b([^/>]*?)(?:\/>|>[\s\S]*?<\/(?:[a-zA-Z]+:)?output>)/g)) {
+        outputs.push(/\bname="([^"]*)"/.exec(m[1] ?? "")?.[1] ?? "");
+    }
+    const rules = [];
+    for (const ruleMatch of tableBody.matchAll(/<(?:[a-zA-Z]+:)?rule\b[^>]*>([\s\S]*?)<\/(?:[a-zA-Z]+:)?rule>/g)) {
+        const ruleBody = ruleMatch[1] ?? "";
+        const inputEntries = [];
+        for (const ie of ruleBody.matchAll(/<(?:[a-zA-Z]+:)?inputEntry\b[^>]*>([\s\S]*?)<\/(?:[a-zA-Z]+:)?inputEntry>/g))
+            inputEntries.push(extractText(ie[1] ?? ""));
+        const outputEntries = [];
+        for (const oe of ruleBody.matchAll(/<(?:[a-zA-Z]+:)?outputEntry\b[^>]*>([\s\S]*?)<\/(?:[a-zA-Z]+:)?outputEntry>/g))
+            outputEntries.push(extractText(oe[1] ?? ""));
+        rules.push({ inputEntries, outputEntries });
+    }
+    return { hitPolicy, inputs, outputs, rules };
+}
+function evalDmnDecisionTable(table, vars) {
+    const feel = feelModule;
+    if (!feel)
+        return null;
+    const ctx = { vars: vars };
+    const collectResults = [];
+    for (const rule of table.rules) {
+        let matches = true;
+        for (let i = 0; i < table.inputs.length; i++) {
+            const inputExpr = table.inputs[i] ?? "";
+            const testExpr = rule.inputEntries[i] ?? "";
+            if (!testExpr)
+                continue; // empty = any
+            const inputParsed = feel.parseExpression(inputExpr);
+            if (!inputParsed.ast) {
+                matches = false;
+                break;
+            }
+            const inputVal = feel.evaluate(inputParsed.ast, ctx);
+            const testParsed = feel.parseUnaryTests(testExpr);
+            if (!testParsed.ast) {
+                matches = false;
+                break;
+            }
+            if (!feel.evaluateUnaryTests(testParsed.ast, inputVal, ctx)) {
+                matches = false;
+                break;
+            }
+        }
+        if (!matches)
+            continue;
+        if (table.outputs.length === 1) {
+            const expr = rule.outputEntries[0] ?? "";
+            if (expr) {
+                const parsed = feel.parseExpression(expr);
+                if (parsed.ast)
+                    collectResults.push(feel.evaluate(parsed.ast, ctx));
+            }
+        }
+        else {
+            const row = {};
+            for (let i = 0; i < table.outputs.length; i++) {
+                const name = table.outputs[i];
+                const expr = rule.outputEntries[i] ?? "";
+                if (name && expr) {
+                    const parsed = feel.parseExpression(expr);
+                    if (parsed.ast)
+                        row[name] = feel.evaluate(parsed.ast, ctx);
+                }
+            }
+            collectResults.push(row);
+        }
+    }
+    // Apply hit policy
+    if (table.hitPolicy === "FIRST")
+        return collectResults[0] ?? null;
+    if (table.hitPolicy === "UNIQUE" || table.hitPolicy === "ANY")
+        return collectResults[0] ?? null;
+    return collectResults; // COLLECT, RULE ORDER, etc.
+}
+// Lazily cached feel module reference (avoids repeated dynamic imports)
+let feelModule = null;
+async function ensureFeelModule() {
+    if (feelModule)
+        return;
+    feelModule = await import("@bpmnkit/feel");
+}
+/**
+ * For visited BRTs that have a resultVariable, evaluate the DMN decision table
+ * directly using the FEEL engine and return {resultVar: value} pairs.
+ *
+ * The WASM browser engine cleans up BRT local-scope variables on element
+ * completion and does not propagate the resultVariable to the process scope
+ * snapshot.  Evaluating the DMN with the FEEL engine directly sidesteps this
+ * limitation.
+ */
+async function evaluateBrtResultVariables(bpmnXml, visitedElementIds, vars, getDecisionDmn) {
+    if (!getDecisionDmn)
+        return {};
+    const allBrts = extractBrtInfos(bpmnXml);
+    const visitedBrts = allBrts.filter((b) => visitedElementIds.includes(b.elementId));
+    if (visitedBrts.length === 0)
+        return {};
+    await ensureFeelModule();
+    const result = {};
+    for (const { decisionId, resultVar } of visitedBrts) {
+        const dmnXml = getDecisionDmn(decisionId);
+        if (!dmnXml)
+            continue;
+        const table = parseDmnDecisionTable(dmnXml, decisionId);
+        if (!table)
+            continue;
+        result[resultVar] = evalDmnDecisionTable(table, vars);
+    }
+    return result;
+}
+// ── Runner ────────────────────────────────────────────────────────────────────
+const MAX_ROUNDS = 200;
+const TIMEOUT_MS = 10_000;
+export async function runScenarioWasm(xml, scenario, getDecisionDmn, getProcessBpmn) {
+    const startMs = Date.now();
+    await ensureWasmInit();
+    const mod = await import("@bpmnkit/reebe-wasm");
+    const engine = new mod.WasmEngine();
+    try {
+        const deployed = new Set();
+        const missingDecisions = deployDependencies(xml, engine, getDecisionDmn, getProcessBpmn, deployed);
+        // Deploy main BPMN (with BRT result variable output mappings patched in)
+        const deployResult = engine.deploy(ensureBrtResultVariableOutputs(xml));
+        const processId = scenario.processId ?? deployResult.deployments[0]?.bpmnProcessId;
+        if (!processId) {
+            return fail(scenario, startMs, "No process found in deployed BPMN.");
+        }
+        // Start instance
+        engine.create_process_instance(processId, JSON.stringify(scenario.inputs ?? {}));
+        // Drive jobs to completion
+        for (let round = 0; round < MAX_ROUNDS; round++) {
+            if (Date.now() - startMs > TIMEOUT_MS)
+                break;
+            const snap = engine.snapshot();
+            const pi = snap.processInstances.find((p) => p.bpmn_process_id === processId);
+            if (!pi || pi.state !== "ACTIVE")
+                break;
+            const activatable = snap.jobs.filter((j) => j.state === "ACTIVATABLE" && j.process_instance_key === pi.key);
+            if (activatable.length === 0)
+                break;
+            for (const job of activatable) {
+                try {
+                    engine.activate_job(job.key, "test-worker", 30_000);
+                    const mock = scenario.mocks?.[job.job_type];
+                    if (mock?.error !== undefined) {
+                        engine.fail_job(job.key, 0, mock.error);
+                    }
+                    else {
+                        engine.complete_job(job.key, JSON.stringify(mock?.outputs ?? {}));
+                    }
+                }
+                catch {
+                    // Job may have already been handled — skip
+                }
+            }
+        }
+        // Collect final state
+        const snap = engine.snapshot();
+        const pi = snap.processInstances.find((p) => p.bpmn_process_id === processId);
+        if (!pi)
+            return fail(scenario, startMs, "Process instance not found after run.");
+        const timedOut = pi.state === "ACTIVE" && Date.now() - startMs >= TIMEOUT_MS;
+        const visitedElements = snap.elementInstances
+            .filter((e) => e.process_instance_key === pi.key)
+            .map((e) => e.element_id);
+        // Collect variables: merge snapshot state (deduplicated, final values) with
+        // VARIABLE.CREATED events from the event log (catches DMN-produced variables
+        // that may not survive snapshot filtering due to scope key differences).
+        const piKeyStr = String(pi.key);
+        const finalVariables = {};
+        for (const rec of snap.eventLog) {
+            if (rec.record_type === "EVENT" &&
+                rec.value_type === "VARIABLE" &&
+                rec.intent === "CREATED" &&
+                String(rec.payload.processInstanceKey) === piKeyStr) {
+                const name = rec.payload.name;
+                if (name !== undefined)
+                    finalVariables[name] = rec.payload.value;
+            }
+        }
+        // Snapshot variables override (they represent the final upserted state)
+        for (const v of snap.variables.filter((v) => v.process_instance_key === pi.key)) {
+            finalVariables[v.name] = v.value;
+        }
+        // BRT resultVariable post-hoc evaluation: the WASM browser engine cleans up
+        // BRT local-scope variables on element completion so they never reach the
+        // process-scope snapshot.  Evaluate each visited BRT's DMN directly with
+        // the FEEL engine and inject the result (snapshot value wins if present).
+        const brtResultVars = await evaluateBrtResultVariables(xml, visitedElements, finalVariables, getDecisionDmn);
+        for (const [k, v] of Object.entries(brtResultVars)) {
+            if (!(k in finalVariables))
+                finalVariables[k] = v;
+        }
+        // Reconstruct FEEL evaluations from SEQUENCE_FLOW_TAKEN events.
+        // The WASM engine evaluates conditions but doesn't emit dedicated FEEL records;
+        // we pair each taken flow with its conditionExpression from the BPMN XML.
+        const flowConditions = extractFlowConditions(xml);
+        const feelEvals = [];
+        for (const rec of snap.eventLog) {
+            if (rec.record_type === "EVENT" &&
+                rec.value_type === "PROCESS_INSTANCE" &&
+                rec.intent === "SEQUENCE_FLOW_TAKEN" &&
+                String(rec.payload.processInstanceKey) === piKeyStr) {
+                const flowId = rec.payload.elementId;
+                const sourceId = rec.payload.sourceElementId;
+                if (!flowId)
+                    continue;
+                const expression = flowConditions.get(flowId);
+                if (expression !== undefined) {
+                    feelEvals.push({
+                        elementId: sourceId ?? flowId,
+                        property: "condition",
+                        expression,
+                        result: true,
+                    });
+                }
+            }
+        }
+        const errors = snap.incidents
+            .filter((i) => i.process_instance_key === pi.key)
+            .map((i) => ({ elementId: i.element_id, message: i.error_message ?? i.error_type }));
+        for (const id of missingDecisions) {
+            errors.push({ message: `DMN decision '${id}' not found. Create the DMN in the Models view.` });
+        }
+        if (timedOut) {
+            errors.push({ message: `Scenario timed out after ${TIMEOUT_MS}ms` });
+        }
+        // Evaluate assertions
+        const failures = [];
+        if (scenario.expect?.path !== undefined) {
+            let cursor = 0;
+            for (const expectedId of scenario.expect.path) {
+                const idx = visitedElements.indexOf(expectedId, cursor);
+                if (idx === -1) {
+                    failures.push({
+                        field: "path",
+                        expected: expectedId,
+                        actual: `not found in [${visitedElements.join(", ")}]`,
+                    });
+                }
+                else {
+                    cursor = idx + 1;
+                }
+            }
+        }
+        if (scenario.expect?.variables !== undefined) {
+            for (const [key, expectedValue] of Object.entries(scenario.expect.variables)) {
+                const actualValue = finalVariables[key];
+                if (JSON.stringify(actualValue) !== JSON.stringify(expectedValue)) {
+                    failures.push({ field: `variables.${key}`, expected: expectedValue, actual: actualValue });
+                }
+            }
+        }
+        return {
+            scenarioId: scenario.id,
+            scenarioName: scenario.name,
+            passed: errors.length === 0 && failures.length === 0,
+            visitedElements,
+            finalVariables,
+            feelEvals,
+            errors,
+            failures,
+            durationMs: Date.now() - startMs,
+        };
+    }
+    finally {
+        engine.free();
+    }
+}
+function fail(scenario, startMs, message) {
+    return {
+        scenarioId: scenario.id,
+        scenarioName: scenario.name,
+        passed: false,
+        visitedElements: [],
+        finalVariables: {},
+        feelEvals: [],
+        errors: [{ message }],
+        failures: [{ field: "start", expected: "process to deploy and start", actual: message }],
+        durationMs: Date.now() - startMs,
+    };
+}
+//# sourceMappingURL=wasm-runner.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/engine",
-  "version": "0.1.14",
+  "version": "0.1.19",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -8,6 +8,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./wasm-runner": {
+      "types": "./dist/wasm-runner.d.ts",
+      "import": "./dist/wasm-runner.js"
     }
   },
   "files": [
@@ -17,8 +21,9 @@
     "dist/**/*.d.ts"
   ],
   "dependencies": {
-    "@bpmnkit/core": "0.0.15",
-    "@bpmnkit/feel": "0.0.13"
+    "@bpmnkit/feel": "0.0.16",
+    "@bpmnkit/reebe-wasm": "npm:reebe-wasm@0.1.0",
+    "@bpmnkit/core": "0.0.20"
   },
   "description": "Lightweight BPMN 2.0 process execution engine for browsers and Node.js — zero dependencies",
   "keywords": [