@bpmnkit/core 0.0.16 → 0.0.20

package/README.md

@@ -6,6 +6,8 @@
   [![npm](https://img.shields.io/npm/v/@bpmnkit/core?style=flat-square&color=6244d7)](https://www.npmjs.com/package/@bpmnkit/core)
   [![license](https://img.shields.io/npm/l/@bpmnkit/core?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/core/CHANGELOG.md)
 </div>

package/dist/bpmn/bpmn-builder.js

@@ -133,7 +133,7 @@ function buildMultiInstance(options) {
             children: [],
         });
     }
-    return { extensionElements: extChildren };
+    return { isSequential: options.isSequential || undefined, extensionElements: extChildren };
 }
 function buildAdHocLoopCharacteristics(lc) {
     const attrs = {

package/dist/bpmn/bpmn-model.d.ts

@@ -88,6 +88,8 @@ export interface BpmnCompensateEventDefinition {
 export type BpmnEventDefinition = BpmnTimerEventDefinition | BpmnErrorEventDefinition | BpmnEscalationEventDefinition | BpmnMessageEventDefinition | BpmnSignalEventDefinition | BpmnConditionalEventDefinition | BpmnLinkEventDefinition | BpmnCancelEventDefinition | BpmnTerminateEventDefinition | BpmnCompensateEventDefinition;
 /** Multi-instance loop configuration attached to a task or sub-process. */
 export interface BpmnMultiInstanceLoopCharacteristics {
+    /** When true, iterations run one at a time (sequential). When false or absent, runs in parallel. */
+    isSequential?: boolean;
     extensionElements: XmlElement[];
 }
 /** A FEEL condition expression on a sequence flow outgoing from a gateway. */

package/dist/bpmn/bpmn-parser.js

@@ -230,7 +230,8 @@ function parseLoopCharacteristics(element) {
     const loopEl = findChild(element, "multiInstanceLoopCharacteristics");
     if (!loopEl)
         return undefined;
-    return { extensionElements: parseExtensionElements(loopEl) };
+    const isSequential = loopEl.attributes.isSequential === "true" ? true : undefined;
+    return { isSequential, extensionElements: parseExtensionElements(loopEl) };
 }
 // ---------------------------------------------------------------------------
 // Flow elements

package/dist/bpmn/bpmn-serializer.js

@@ -137,8 +137,11 @@ function serializeExtensionElements(extensions, bp) {
 function serializeLoopCharacteristics(lc, bp) {
     if (!lc)
         return [];
+    const attrs = {};
+    if (lc.isSequential)
+        attrs.isSequential = "true";
     return [
-        el(`${bp}:multiInstanceLoopCharacteristics`, {}, [
+        el(`${bp}:multiInstanceLoopCharacteristics`, attrs, [
             ...serializeExtensionElements(lc.extensionElements, bp),
         ]),
     ];

package/dist/bpmn/input-validation.d.ts

@@ -0,0 +1,85 @@
+import type { BpmnDefinitions } from "./bpmn-model.js";
+/** Supported variable types for input validation. */
+export type ValidationVariableType = "string" | "number" | "boolean" | "context" | "list" | "any";
+/** A single input variable definition used to build a validation DMN. */
+export interface InputVariableDef {
+    /** Variable name (must be a valid FEEL identifier). */
+    name: string;
+    /** Expected type. */
+    type: ValidationVariableType;
+    /** When true, generates a required check row. */
+    required: boolean;
+    /** Minimum numeric value (number type only). */
+    min?: number;
+    /** Maximum numeric value (number type only). */
+    max?: number;
+    /** Minimum string length (string type only). */
+    minLength?: number;
+    /** Maximum string length (string type only). */
+    maxLength?: number;
+    /** Regex pattern the value must match (string type only). */
+    pattern?: string;
+}
+/** Location of a validation structure wired after a start event. */
+export interface ValidationStructure {
+    businessRuleTaskId: string;
+    decisionId: string;
+}
+/**
+ * Returns the deterministic DMN decision ID for the validation decision linked
+ * to a given start event.
+ */
+export declare function validationDecisionId(startEventId: string): string;
+/**
+ * Builds a validation DMN XML string from a list of variable definitions.
+ *
+ * Uses the Collect hit policy so every violated rule contributes an error
+ * string to the `validationErrors` list. An empty list means valid input.
+ */
+export declare function buildValidationDmn(startEventId: string, variables: InputVariableDef[]): string;
+/**
+ * Detects whether a validation structure (Business Rule Task →  XOR gateway →
+ * Error End Event) is already wired immediately after the given start event.
+ *
+ * Returns `{ businessRuleTaskId, decisionId }` on success, or `null` if no
+ * validation structure is found.
+ */
+export declare function findValidationStructure(defs: BpmnDefinitions, startEventId: string): ValidationStructure | null;
+/**
+ * Inserts the standard validation structure after a start event:
+ *
+ * ```
+ * [Start Event] → [Business Rule Task] → [XOR Gateway]
+ *                                             ├── = count(validationErrors) = 0 → [original next]
+ *                                             └── (default) → [Error End Event: VALIDATION_FAILED]
+ * ```
+ *
+ * If the start event has an existing outgoing flow, that flow is redirected to
+ * originate from the XOR gateway (valid path) with the condition
+ * `= count(validationErrors) = 0`. The start event now connects to the Business
+ * Rule Task instead.
+ *
+ * If the start event has no outgoing flow the validation elements are inserted
+ * with only the error path connected; the caller can wire the valid path later.
+ *
+ * @returns Updated `BpmnDefinitions` — the original is not mutated.
+ */
+export declare function insertValidationStructure(defs: BpmnDefinitions, startEventId: string, decisionId: string): BpmnDefinitions;
+/**
+ * Removes the validation structure wired after the given start event, if any.
+ *
+ * Restores the start event's outgoing connection to the element that the XOR
+ * gateway's valid path was pointing to. The generated error definition is also
+ * removed from `defs.errors`.
+ *
+ * @returns Updated `BpmnDefinitions` — the original is not mutated.
+ */
+export declare function removeValidationStructure(defs: BpmnDefinitions, startEventId: string): BpmnDefinitions;
+/**
+ * Parses a validation DMN XML and returns the input column expression names.
+ * Used by the Process Runner to display expected variable hints.
+ *
+ * Returns an empty array on any parse error.
+ */
+export declare function getValidationInputNames(dmnXml: string): string[];
+//# sourceMappingURL=input-validation.d.ts.map

package/dist/bpmn/input-validation.js

@@ -0,0 +1,497 @@
+import { DecisionTableBuilder } from "../dmn/dmn-builder.js";
+import { parseDmn } from "../dmn/dmn-parser.js";
+import { generateId } from "../types/id-generator.js";
+import { getZeebeExtensions } from "./utils.js";
+import { zeebeExtensionsToXmlElements } from "./zeebe-extensions.js";
+// ── Decision ID ───────────────────────────────────────────────────────────────
+/**
+ * Returns the deterministic DMN decision ID for the validation decision linked
+ * to a given start event.
+ */
+export function validationDecisionId(startEventId) {
+    return `${startEventId}_inputValidation`;
+}
+// ── DMN factory ───────────────────────────────────────────────────────────────
+/**
+ * Builds a validation DMN XML string from a list of variable definitions.
+ *
+ * Uses the Collect hit policy so every violated rule contributes an error
+ * string to the `validationErrors` list. An empty list means valid input.
+ */
+export function buildValidationDmn(startEventId, variables) {
+    const decisionId = validationDecisionId(startEventId);
+    const builder = new DecisionTableBuilder(decisionId).name("Input Validation").hitPolicy("COLLECT");
+    for (const v of variables) {
+        builder.input({
+            label: v.name,
+            expression: v.name,
+        });
+    }
+    builder.output({ label: "Error", name: "error", typeRef: "string" });
+    for (let i = 0; i < variables.length; i++) {
+        const v = variables[i];
+        if (!v)
+            continue;
+        /** Build a rule that fires (on violation) for variable at index i. */
+        const addRow = (entry, message) => {
+            const inputs = variables.map((_, j) => (j === i ? entry : ""));
+            builder.rule({ inputs, outputs: [`"${message}"`] });
+        };
+        if (v.required) {
+            addRow("null", `${v.name} is required`);
+        }
+        if (v.type === "string") {
+            addRow("not(instance of string)", `${v.name} must be a string`);
+        }
+        else if (v.type === "number") {
+            addRow("not(instance of number)", `${v.name} must be a number`);
+        }
+        else if (v.type === "boolean") {
+            addRow("not(instance of boolean)", `${v.name} must be a boolean`);
+        }
+        else if (v.type === "context") {
+            addRow("not(instance of context)", `${v.name} must be a context`);
+        }
+        else if (v.type === "list") {
+            addRow("not(instance of list)", `${v.name} must be a list`);
+        }
+        // "any" accepts all types — no type-check rule generated
+        if (v.type === "string") {
+            if (v.minLength !== undefined) {
+                addRow(`string length(?) < ${v.minLength}`, `${v.name} must be at least ${v.minLength} characters`);
+            }
+            if (v.maxLength !== undefined) {
+                addRow(`string length(?) > ${v.maxLength}`, `${v.name} must be at most ${v.maxLength} characters`);
+            }
+            if (v.pattern) {
+                addRow(`not(matches(?, "${v.pattern}"))`, `${v.name} has invalid format`);
+            }
+        }
+        else if (v.type === "number") {
+            if (v.min !== undefined) {
+                addRow(`< ${v.min}`, `${v.name} must be >= ${v.min}`);
+            }
+            if (v.max !== undefined) {
+                addRow(`> ${v.max}`, `${v.name} must be <= ${v.max}`);
+            }
+        }
+    }
+    return builder.toXml();
+}
+// ── BPMN structure detection ──────────────────────────────────────────────────
+/** Returns the process that contains the given element id, or undefined. */
+function findProcessFor(defs, elementId) {
+    return defs.processes.find((p) => p.flowElements.some((e) => e.id === elementId));
+}
+/**
+ * Detects whether a validation structure (Business Rule Task →  XOR gateway →
+ * Error End Event) is already wired immediately after the given start event.
+ *
+ * Returns `{ businessRuleTaskId, decisionId }` on success, or `null` if no
+ * validation structure is found.
+ */
+export function findValidationStructure(defs, startEventId) {
+    const process = findProcessFor(defs, startEventId);
+    if (!process)
+        return null;
+    for (const flow of process.sequenceFlows) {
+        if (flow.sourceRef !== startEventId)
+            continue;
+        const target = process.flowElements.find((e) => e.id === flow.targetRef);
+        if (!target || target.type !== "businessRuleTask")
+            continue;
+        const ext = getZeebeExtensions(target.extensionElements);
+        if (ext.calledDecision?.resultVariable !== "validationErrors")
+            continue;
+        return { businessRuleTaskId: target.id, decisionId: ext.calledDecision.decisionId };
+    }
+    return null;
+}
+// ── BPMN structure insertion ──────────────────────────────────────────────────
+/** Standard element dimensions used when placing new validation elements. */
+const SIZES = {
+    event: { w: 36, h: 36 },
+    task: { w: 100, h: 80 },
+    gateway: { w: 50, h: 50 },
+};
+const H_GAP = 80;
+const V_GAP = 80;
+/**
+ * Inserts the standard validation structure after a start event:
+ *
+ * ```
+ * [Start Event] → [Business Rule Task] → [XOR Gateway]
+ *                                             ├── = count(validationErrors) = 0 → [original next]
+ *                                             └── (default) → [Error End Event: VALIDATION_FAILED]
+ * ```
+ *
+ * If the start event has an existing outgoing flow, that flow is redirected to
+ * originate from the XOR gateway (valid path) with the condition
+ * `= count(validationErrors) = 0`. The start event now connects to the Business
+ * Rule Task instead.
+ *
+ * If the start event has no outgoing flow the validation elements are inserted
+ * with only the error path connected; the caller can wire the valid path later.
+ *
+ * @returns Updated `BpmnDefinitions` — the original is not mutated.
+ */
+export function insertValidationStructure(defs, startEventId, decisionId) {
+    const processIdx = defs.processes.findIndex((p) => p.flowElements.some((e) => e.id === startEventId));
+    const process = defs.processes[processIdx];
+    if (processIdx < 0 || !process)
+        return defs;
+    // ── Generate IDs ─────────────────────────────────────────────────────────
+    const brtId = generateId("Activity");
+    const gwId = generateId("Gateway");
+    const errEndId = generateId("Event");
+    const errorId = generateId("Error");
+    const flowStartToBrt = generateId("Flow");
+    const flowBrtToGw = generateId("Flow");
+    const flowGwToError = generateId("Flow");
+    // ── Find existing outgoing flow from start event ──────────────────────────
+    const originalOutgoingFlowId = process.sequenceFlows.find((f) => f.sourceRef === startEventId)?.id;
+    // ── Build new flow elements ───────────────────────────────────────────────
+    const brt = {
+        type: "businessRuleTask",
+        id: brtId,
+        name: "Validate Input",
+        incoming: [flowStartToBrt],
+        outgoing: [flowBrtToGw],
+        extensionElements: zeebeExtensionsToXmlElements({
+            calledDecision: { decisionId, resultVariable: "validationErrors" },
+        }),
+        unknownAttributes: {},
+    };
+    const gwOutgoing = [flowGwToError];
+    if (originalOutgoingFlowId)
+        gwOutgoing.unshift(originalOutgoingFlowId);
+    const gateway = {
+        type: "exclusiveGateway",
+        id: gwId,
+        name: "Input valid?",
+        default: flowGwToError,
+        incoming: [flowBrtToGw],
+        outgoing: gwOutgoing,
+        extensionElements: [],
+        unknownAttributes: {},
+    };
+    const errEnd = {
+        type: "endEvent",
+        id: errEndId,
+        name: "Invalid Input",
+        incoming: [flowGwToError],
+        outgoing: [],
+        eventDefinitions: [{ type: "error", errorRef: errorId }],
+        extensionElements: [],
+        unknownAttributes: {},
+    };
+    const errorDef = {
+        id: errorId,
+        name: "VALIDATION_FAILED",
+        errorCode: "VALIDATION_FAILED",
+    };
+    // ── New sequence flows ────────────────────────────────────────────────────
+    const newFlows = [
+        {
+            id: flowStartToBrt,
+            sourceRef: startEventId,
+            targetRef: brtId,
+            extensionElements: [],
+            unknownAttributes: {},
+        },
+        {
+            id: flowBrtToGw,
+            sourceRef: brtId,
+            targetRef: gwId,
+            extensionElements: [],
+            unknownAttributes: {},
+        },
+        {
+            id: flowGwToError,
+            sourceRef: gwId,
+            targetRef: errEndId,
+            extensionElements: [],
+            unknownAttributes: {},
+        },
+    ];
+    // ── Update start event outgoing list ──────────────────────────────────────
+    const updatedElements = process.flowElements.map((el) => {
+        if (el.id !== startEventId)
+            return el;
+        const without = el.outgoing.filter((o) => o !== originalOutgoingFlowId);
+        return { ...el, outgoing: [...without, flowStartToBrt] };
+    });
+    // ── Redirect original outgoing flow ───────────────────────────────────────
+    const updatedFlows = process.sequenceFlows.map((f) => {
+        if (f.id !== originalOutgoingFlowId)
+            return f;
+        return {
+            ...f,
+            sourceRef: gwId,
+            conditionExpression: {
+                text: "= count(validationErrors) = 0",
+                attributes: {},
+            },
+        };
+    });
+    const newProcess = {
+        ...process,
+        flowElements: [...updatedElements, brt, gateway, errEnd],
+        sequenceFlows: [...updatedFlows, ...newFlows],
+    };
+    // ── DI: compute positions ─────────────────────────────────────────────────
+    let updatedDefs = {
+        ...defs,
+        errors: [...defs.errors, errorDef],
+        processes: defs.processes.map((p, i) => (i === processIdx ? newProcess : p)),
+    };
+    updatedDefs = _insertValidationDi(updatedDefs, startEventId, {
+        brtId,
+        gwId,
+        errEndId,
+        flowStartToBrt,
+        flowBrtToGw,
+        flowGwToError,
+        originalOutgoingFlowId,
+    });
+    return updatedDefs;
+}
+/** Adds DI shapes and edges for the newly inserted validation elements. */
+function _insertValidationDi(defs, startEventId, ids) {
+    if (!defs.diagrams[0])
+        return defs;
+    const plane = defs.diagrams[0].plane;
+    const startShape = plane.shapes.find((s) => s.bpmnElement === startEventId);
+    // Default position if no DI exists for the start event
+    const sx = startShape?.bounds.x ?? 152;
+    const sy = startShape?.bounds.y ?? 202;
+    const sw = SIZES.event.w;
+    const sh = SIZES.event.h;
+    // Vertical center of start event
+    const centerY = sy + sh / 2;
+    // Positions (top-left corner of each element)
+    const brtX = sx + sw + H_GAP;
+    const brtY = centerY - SIZES.task.h / 2;
+    const gwX = brtX + SIZES.task.w + H_GAP;
+    const gwY = centerY - SIZES.gateway.h / 2;
+    const errX = gwX + SIZES.gateway.w / 2 - SIZES.event.w / 2;
+    const errY = gwY + SIZES.gateway.h + V_GAP;
+    // Centers for waypoint computation
+    const startCx = sx + sw / 2;
+    const startCy = centerY;
+    const brtCx = brtX + SIZES.task.w / 2;
+    const brtCy = centerY;
+    const gwCx = gwX + SIZES.gateway.w / 2;
+    const gwCy = centerY;
+    const errCx = errX + SIZES.event.w / 2;
+    const errCy = errY + SIZES.event.h / 2;
+    const newShapes = [
+        {
+            id: generateId("Shape"),
+            bpmnElement: ids.brtId,
+            bounds: { x: brtX, y: brtY, width: SIZES.task.w, height: SIZES.task.h },
+            unknownAttributes: {},
+        },
+        {
+            id: generateId("Shape"),
+            bpmnElement: ids.gwId,
+            isMarkerVisible: true,
+            bounds: { x: gwX, y: gwY, width: SIZES.gateway.w, height: SIZES.gateway.h },
+            unknownAttributes: {},
+        },
+        {
+            id: generateId("Shape"),
+            bpmnElement: ids.errEndId,
+            bounds: { x: errX, y: errY, width: SIZES.event.w, height: SIZES.event.h },
+            unknownAttributes: {},
+        },
+    ];
+    const newEdges = [
+        {
+            id: generateId("Edge"),
+            bpmnElement: ids.flowStartToBrt,
+            waypoints: [
+                { x: startCx + sw / 2, y: startCy },
+                { x: brtX, y: brtCy },
+            ],
+            unknownAttributes: {},
+        },
+        {
+            id: generateId("Edge"),
+            bpmnElement: ids.flowBrtToGw,
+            waypoints: [
+                { x: brtX + SIZES.task.w, y: brtCy },
+                { x: gwX, y: gwCy },
+            ],
+            unknownAttributes: {},
+        },
+        {
+            id: generateId("Edge"),
+            bpmnElement: ids.flowGwToError,
+            waypoints: [
+                { x: gwCx, y: gwY + SIZES.gateway.h },
+                { x: errCx, y: errY },
+            ],
+            unknownAttributes: {},
+        },
+    ];
+    // Update the redirected outgoing flow edge to start from the gateway
+    const updatedEdges = plane.edges.map((e) => {
+        if (e.bpmnElement !== ids.originalOutgoingFlowId)
+            return e;
+        const firstWp = e.waypoints[0];
+        const rest = e.waypoints.slice(1);
+        return {
+            ...e,
+            waypoints: [
+                // Replace first waypoint with gateway right-edge
+                { x: gwX + SIZES.gateway.w, y: gwCy },
+                ...(firstWp ? rest : []),
+            ],
+        };
+    });
+    const updatedPlane = {
+        ...plane,
+        shapes: [...plane.shapes, ...newShapes],
+        edges: [...updatedEdges, ...newEdges],
+    };
+    return {
+        ...defs,
+        diagrams: [
+            {
+                ...defs.diagrams[0],
+                plane: updatedPlane,
+            },
+            ...defs.diagrams.slice(1),
+        ],
+    };
+}
+// ── BPMN structure removal ────────────────────────────────────────────────────
+/**
+ * Removes the validation structure wired after the given start event, if any.
+ *
+ * Restores the start event's outgoing connection to the element that the XOR
+ * gateway's valid path was pointing to. The generated error definition is also
+ * removed from `defs.errors`.
+ *
+ * @returns Updated `BpmnDefinitions` — the original is not mutated.
+ */
+export function removeValidationStructure(defs, startEventId) {
+    const processIdx = defs.processes.findIndex((p) => p.flowElements.some((e) => e.id === startEventId));
+    const process = defs.processes[processIdx];
+    if (processIdx < 0 || !process)
+        return defs;
+    // Locate the BRT immediately after the start event
+    const startToBrtFlow = process.sequenceFlows.find((f) => f.sourceRef === startEventId);
+    if (!startToBrtFlow)
+        return defs;
+    const brt = process.flowElements.find((e) => e.id === startToBrtFlow.targetRef && e.type === "businessRuleTask");
+    if (!brt)
+        return defs;
+    const ext = getZeebeExtensions(brt.extensionElements);
+    if (ext.calledDecision?.resultVariable !== "validationErrors")
+        return defs;
+    // BRT → gateway
+    const brtToGwFlow = process.sequenceFlows.find((f) => f.sourceRef === brt.id);
+    const gateway = brtToGwFlow
+        ? process.flowElements.find((e) => e.id === brtToGwFlow.targetRef && e.type === "exclusiveGateway")
+        : undefined;
+    if (!gateway || gateway.type !== "exclusiveGateway")
+        return defs;
+    // Gateway → error end event (default/no-condition flow)
+    const gwFlows = process.sequenceFlows.filter((f) => f.sourceRef === gateway.id);
+    const errorFlow = gwFlows.find((f) => !f.conditionExpression);
+    const validFlow = gwFlows.find((f) => f.conditionExpression);
+    const errEnd = errorFlow
+        ? process.flowElements.find((e) => e.id === errorFlow.targetRef && e.type === "endEvent")
+        : undefined;
+    // Collect IDs to remove
+    const removeElementIds = new Set([brt.id, gateway.id, ...(errEnd ? [errEnd.id] : [])]);
+    const removeFlowIds = new Set([
+        startToBrtFlow.id,
+        ...(brtToGwFlow ? [brtToGwFlow.id] : []),
+        ...(errorFlow ? [errorFlow.id] : []),
+    ]);
+    // Find error ref to remove from defs.errors
+    const errEndEl = errEnd?.type === "endEvent" ? errEnd : undefined;
+    const errorRefId = errEndEl?.eventDefinitions[0]?.type === "error"
+        ? errEndEl.eventDefinitions[0].errorRef
+        : undefined;
+    // Reconnect: restore the valid-path flow to come from the start event
+    const updatedFlows = process.sequenceFlows
+        .filter((f) => !removeFlowIds.has(f.id))
+        .map((f) => {
+        if (f.id !== validFlow?.id)
+            return f;
+        return { ...f, sourceRef: startEventId, conditionExpression: undefined };
+    });
+    // Restore start event outgoing list
+    const updatedElements = process.flowElements
+        .filter((e) => !removeElementIds.has(e.id))
+        .map((el) => {
+        if (el.id !== startEventId)
+            return el;
+        const without = el.outgoing.filter((o) => o !== startToBrtFlow.id);
+        const restored = validFlow ? [validFlow.id, ...without] : without;
+        return { ...el, outgoing: restored };
+    });
+    const newProcess = {
+        ...process,
+        flowElements: updatedElements,
+        sequenceFlows: updatedFlows,
+    };
+    // Remove DI shapes and edges for removed elements
+    let updatedDefs = {
+        ...defs,
+        errors: errorRefId ? defs.errors.filter((e) => e.id !== errorRefId) : defs.errors,
+        processes: defs.processes.map((p, i) => (i === processIdx ? newProcess : p)),
+    };
+    updatedDefs = _removeValidationDi(updatedDefs, removeElementIds, removeFlowIds, validFlow?.id);
+    return updatedDefs;
+}
+function _removeValidationDi(defs, removeElementIds, removeFlowIds, restoredFlowId) {
+    if (!defs.diagrams[0])
+        return defs;
+    const plane = defs.diagrams[0].plane;
+    const updatedShapes = plane.shapes.filter((s) => !removeElementIds.has(s.bpmnElement));
+    const updatedEdges = plane.edges
+        .filter((e) => !removeFlowIds.has(e.bpmnElement))
+        .map((e) => {
+        // The restored flow's edge now starts from the start event again.
+        // We don't know the start event's exact right-edge position here, but
+        // leaving the waypoints as-is is acceptable — auto-layout can fix them.
+        if (e.bpmnElement !== restoredFlowId)
+            return e;
+        return e; // leave waypoints unchanged; user can re-layout
+    });
+    return {
+        ...defs,
+        diagrams: [
+            {
+                ...defs.diagrams[0],
+                plane: { ...plane, shapes: updatedShapes, edges: updatedEdges },
+            },
+            ...defs.diagrams.slice(1),
+        ],
+    };
+}
+// ── DMN variable name extraction ──────────────────────────────────────────────
+/**
+ * Parses a validation DMN XML and returns the input column expression names.
+ * Used by the Process Runner to display expected variable hints.
+ *
+ * Returns an empty array on any parse error.
+ */
+export function getValidationInputNames(dmnXml) {
+    try {
+        const defs = parseDmn(dmnXml);
+        const decision = defs.decisions[0];
+        if (!decision?.decisionTable)
+            return [];
+        return decision.decisionTable.inputs.map((i) => i.inputExpression.text ?? "").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=input-validation.js.map

package/dist/bpmn/optimize/variable-flow.js

@@ -426,6 +426,84 @@ export function analyzeVariableFlow(p) {
             produces: scopeVars,
         });
     }
+    // ── Multi-instance sub-process inner scopes ──────────────────────────────────
+    // For each multi-instance sub-process, emit edge-scope findings for inner
+    // sequence flows seeded with the iteration variable (inputElement).
+    for (const el of p.flowElements) {
+        if (el.type !== "subProcess")
+            continue;
+        const sp = el;
+        if (!sp.loopCharacteristics)
+            continue;
+        // Extract inputElement from zeebe:loopCharacteristics extension element
+        const loopExt = sp.loopCharacteristics.extensionElements.find((e) => e.name === "zeebe:loopCharacteristics");
+        const inputElement = loopExt?.attributes.inputElement?.trim();
+        if (!inputElement)
+            continue;
+        // Collect variables produced by inner elements (from IO mapping outputs)
+        const innerProduces = new Map();
+        for (const inner of sp.flowElements) {
+            const io = readZeebeIoMapping(inner.extensionElements);
+            if (io) {
+                for (const out of io.outputs) {
+                    if (out.target.trim() === "")
+                        continue;
+                    const list = innerProduces.get(inner.id) ?? [];
+                    if (!list.includes(out.target.trim()))
+                        list.push(out.target.trim());
+                    innerProduces.set(inner.id, list);
+                }
+            }
+        }
+        // Build inner reverse adjacency for BFS
+        const innerReverseAdj = new Map();
+        for (const flow of sp.sequenceFlows) {
+            const set = innerReverseAdj.get(flow.targetRef) ?? new Set();
+            set.add(flow.sourceRef);
+            innerReverseAdj.set(flow.targetRef, set);
+        }
+        function innerAllPredecessors(elementId) {
+            const visited = new Set();
+            const queue = [elementId];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (current === undefined)
+                    break;
+                const preds = innerReverseAdj.get(current);
+                if (preds === undefined)
+                    continue;
+                for (const pred of preds) {
+                    if (!visited.has(pred)) {
+                        visited.add(pred);
+                        queue.push(pred);
+                    }
+                }
+            }
+            return visited;
+        }
+        // Emit edge-scope findings for inner sequence flows
+        for (const flow of sp.sequenceFlows) {
+            const predIds = innerAllPredecessors(flow.sourceRef);
+            predIds.add(flow.sourceRef);
+            // Scope always includes the iteration variable, plus anything inner elements produce
+            const inScope = new Set([inputElement]);
+            for (const predId of predIds) {
+                for (const v of innerProduces.get(predId) ?? [])
+                    inScope.add(v);
+            }
+            const scopeVars = [...inScope].sort();
+            findings.push({
+                id: `data-flow/edge-scope:${flow.id}`,
+                category: "data-flow",
+                severity: "info",
+                message: `Variables in scope at flow "${flow.id}": ${scopeVars.join(", ")}.`,
+                suggestion: "",
+                processId,
+                elementIds: [flow.id],
+                produces: scopeVars,
+            });
+        }
+    }
     return findings;
 }
 //# sourceMappingURL=variable-flow.js.map

package/dist/index.d.ts

@@ -36,6 +36,8 @@ export { ELEMENT_SIZES, GRID_CELL_HEIGHT } from "./layout/index.js";
 export { compactify, expand } from "./bpmn/compact.js";
 export { applyOperations } from "./bpmn/operations.js";
 export type { BpmnOperation } from "./bpmn/operations.js";
+export { buildValidationDmn, findValidationStructure, getValidationInputNames, insertValidationStructure, removeValidationStructure, validationDecisionId, } from "./bpmn/input-validation.js";
+export type { InputVariableDef, ValidationStructure, ValidationVariableType, } from "./bpmn/input-validation.js";
 export { exportSvg } from "./bpmn/svg.js";
 export type { SvgExportOptions } from "./bpmn/svg.js";
 export type { CompactDiagram, CompactElement, CompactFlow, CompactProcess, } from "./bpmn/compact.js";

package/dist/index.js

@@ -18,5 +18,6 @@ export { benchmarkLayout, compareLayouts, formatBenchmarkResult, generateAutoLay
 export { ELEMENT_SIZES, GRID_CELL_HEIGHT } from "./layout/index.js";
 export { compactify, expand } from "./bpmn/compact.js";
 export { applyOperations } from "./bpmn/operations.js";
+export { buildValidationDmn, findValidationStructure, getValidationInputNames, insertValidationStructure, removeValidationStructure, validationDecisionId, } from "./bpmn/input-validation.js";
 export { exportSvg } from "./bpmn/svg.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/core",
-  "version": "0.0.16",
+  "version": "0.0.20",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -17,7 +17,7 @@
     "dist/**/*.d.ts"
   ],
   "dependencies": {
-    "@bpmnkit/feel": "0.0.13"
+    "@bpmnkit/feel": "0.0.16"
   },
   "description": "TypeScript-first BPMN 2.0 SDK — parse, build, layout, and optimize diagrams",
   "keywords": [