@bpmnkit/core 0.1.1 → 0.1.2

package/dist/plan/compile.js

@@ -0,0 +1,380 @@
+import { parseExpression } from "@bpmnkit/feel";
+import { buildAiAgentSubProcess } from "../bpmn/agentic.js";
+import { applyAutoLayout } from "../bpmn/auto-layout.js";
+import { Bpmn } from "../bpmn/index.js";
+import { optimize } from "../bpmn/optimize/index.js";
+import { slugify, uniqueId } from "./slug.js";
+// ---------------------------------------------------------------------------
+// ID assignment — every step gets a stable id before any builder call is made,
+// so gateway branches can `connectTo()` the right target up front.
+// ---------------------------------------------------------------------------
+function assignIds(steps, taken, idOf) {
+    for (const step of steps) {
+        const base = step.id ?? slugify(step.name ?? step.kind);
+        idOf.set(step, uniqueId(base, taken));
+        if (step.errorBoundary)
+            assignIds(step.errorBoundary.steps, taken, idOf);
+        if (step.timerBoundary)
+            assignIds(step.timerBoundary.steps, taken, idOf);
+        if (step.kind === "gateway") {
+            for (const branch of step.branches)
+                assignIds(branch.steps, taken, idOf);
+        }
+        if (step.kind === "subProcess")
+            assignIds(step.steps, taken, idOf);
+    }
+}
+// ---------------------------------------------------------------------------
+// FEEL validation
+// ---------------------------------------------------------------------------
+function checkFeel(path, value, problems) {
+    if (!value || !value.startsWith("="))
+        return;
+    const { errors } = parseExpression(value.slice(1));
+    for (const err of errors) {
+        problems.push({ path, message: `Invalid FEEL expression: ${err.message}` });
+    }
+}
+// ---------------------------------------------------------------------------
+// Connector / agent tool resolution
+// ---------------------------------------------------------------------------
+function resolveConnectorOrProblem(ref, path, resolve, problems) {
+    if (!resolve) {
+        problems.push({
+            path,
+            message: `Step references connector template "${ref.template}" but no connector resolver was provided to compilePlan()`,
+        });
+        return undefined;
+    }
+    const result = resolve(ref.template, ref.values ?? {});
+    for (const p of result.problems) {
+        problems.push({ path: p.key ? `${path}.values.${p.key}` : path, message: p.message });
+    }
+    return result;
+}
+function toolServiceTaskOptions(tool, path, resolve, problems) {
+    if (tool.connector) {
+        const result = resolveConnectorOrProblem(tool.connector, path, resolve, problems);
+        if (result?.serviceTask)
+            return result.serviceTask;
+        return { name: tool.id, taskType: "" };
+    }
+    return { name: tool.id, taskType: tool.jobType ?? "" };
+}
+// ---------------------------------------------------------------------------
+// Step emission
+// ---------------------------------------------------------------------------
+function emitStep(b, step, id, path, nextId, idOf, resolve, problems) {
+    switch (step.kind) {
+        case "start":
+            // Handled by the caller — start steps are only valid as plan.steps[0].
+            return;
+        case "connector": {
+            const result = resolveConnectorOrProblem(step.connector, `${path}.connector`, resolve, problems);
+            b.serviceTask(id, {
+                ...(result?.serviceTask ?? { name: step.name ?? id, taskType: "" }),
+                documentation: step.documentation,
+                ...(step.retries ? { retries: step.retries } : {}),
+            });
+            return;
+        }
+        case "serviceTask": {
+            const inputs = Object.entries(step.inputs ?? {}).map(([target, source]) => ({
+                source,
+                target,
+            }));
+            const outputs = Object.entries(step.outputs ?? {}).map(([target, source]) => ({
+                source,
+                target,
+            }));
+            for (const [k, v] of Object.entries(step.inputs ?? {}))
+                checkFeel(`${path}.inputs.${k}`, v, problems);
+            for (const [k, v] of Object.entries(step.outputs ?? {}))
+                checkFeel(`${path}.outputs.${k}`, v, problems);
+            b.serviceTask(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                taskType: step.jobType,
+                retries: step.retries,
+                taskHeaders: step.taskHeaders,
+                ioMapping: inputs.length || outputs.length ? { inputs, outputs } : undefined,
+            });
+            return;
+        }
+        case "userTask":
+            b.userTask(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                zeebeUserTask: true,
+                formId: step.formId,
+                assignee: step.assignee,
+                candidateGroups: step.candidateGroups,
+                candidateUsers: step.candidateUsers,
+                dueDate: step.dueDate,
+                followUpDate: step.followUpDate,
+                priority: step.priority,
+            });
+            return;
+        case "businessRuleTask":
+            b.businessRuleTask(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                decisionId: step.decisionId,
+                resultVariable: step.resultVariable,
+            });
+            return;
+        case "scriptTask":
+            checkFeel(`${path}.expression`, step.expression, problems);
+            b.scriptTask(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                expression: step.expression,
+                resultVariable: step.resultVariable,
+            });
+            return;
+        case "sendTask":
+            b.sendTask(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                messageName: step.messageName,
+            });
+            return;
+        case "receiveTask":
+            b.receiveTask(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                messageName: step.messageName,
+                correlationKey: step.correlationKey,
+            });
+            return;
+        case "callActivity":
+            b.callActivity(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                processId: step.processId,
+                propagateAllChildVariables: step.propagateAllChildVariables,
+            });
+            return;
+        case "aiAgent": {
+            checkFeel(`${path}.systemPrompt`, step.systemPrompt, problems);
+            checkFeel(`${path}.userPrompt`, step.userPrompt, problems);
+            checkFeel(`${path}.completionCondition`, step.completionCondition, problems);
+            if (step.tools.length === 0) {
+                problems.push({ path: `${path}.tools`, message: "aiAgent step has no tools" });
+            }
+            const agent = buildAiAgentSubProcess({
+                id,
+                name: step.name,
+                model: {
+                    provider: step.provider,
+                    inputs: { [`provider.${step.provider}.model.model`]: step.model, ...step.providerInputs },
+                },
+                systemPrompt: step.systemPrompt,
+                userPrompt: step.userPrompt,
+                memoryStorageType: step.memoryStorageType,
+                maxModelCalls: step.maxModelCalls,
+                outputVariable: step.outputVariable,
+                retries: step.retries,
+                completionCondition: step.completionCondition,
+                cancelRemainingInstances: step.cancelRemainingInstances,
+                tools: step.tools.map((tool) => ({
+                    id: tool.id,
+                    description: tool.description,
+                    serviceTask: toolServiceTaskOptions(tool, `${path}.tools[${tool.id}]`, resolve, problems),
+                    params: (tool.params ?? []).map((p) => ({
+                        name: p.name,
+                        description: p.description,
+                        type: p.type,
+                        required: p.required,
+                        schema: p.schema,
+                        target: p.target ?? p.name,
+                    })),
+                    resultSource: tool.resultExpression,
+                })),
+            });
+            b.adHocSubProcess(id, agent.content, agent.options);
+            return;
+        }
+        case "gateway": {
+            const gwOptions = { name: step.name, documentation: step.documentation };
+            switch (step.gatewayType) {
+                case "exclusive":
+                    b.exclusiveGateway(id, gwOptions);
+                    break;
+                case "parallel":
+                    b.parallelGateway(id, gwOptions);
+                    break;
+                case "inclusive":
+                    b.inclusiveGateway(id, gwOptions);
+                    break;
+                case "eventBased":
+                    b.eventBasedGateway(id, gwOptions);
+                    break;
+            }
+            for (let bi = 0; bi < step.branches.length; bi++) {
+                const branch = step.branches[bi];
+                checkFeel(`${path}.branches[${bi}].condition`, branch.condition, problems);
+                b.branch(branch.name ?? `branch_${bi + 1}`, (bb) => {
+                    if (branch.default)
+                        bb.defaultFlow();
+                    else if (branch.condition)
+                        bb.condition(branch.condition);
+                    emitSteps(bb, branch.steps, idOf, resolve, problems, `${path}.branches[${bi}].steps`);
+                    if (nextId)
+                        bb.connectTo(nextId);
+                });
+            }
+            return;
+        }
+        case "subProcess":
+            b.subProcess(id, (sb) => emitSteps(sb, step.steps, idOf, resolve, problems, `${path}.steps`), {
+                name: step.name,
+                documentation: step.documentation,
+                multiInstance: step.multiInstance
+                    ? {
+                        isSequential: step.multiInstance.isSequential,
+                        collection: step.multiInstance.collection,
+                        elementVariable: step.multiInstance.elementVariable,
+                        completionCondition: step.multiInstance.completionCondition,
+                    }
+                    : undefined,
+            });
+            return;
+        case "wait":
+            checkFeel(`${path}.message.correlationKey`, step.message?.correlationKey, problems);
+            b.intermediateCatchEvent(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                timerDuration: step.timer?.duration,
+                timerDate: step.timer?.date,
+                timerCycle: step.timer?.cycle,
+                messageName: step.message?.name,
+                correlationKey: step.message?.correlationKey,
+            });
+            return;
+        case "end":
+            b.endEvent(id, {
+                name: step.name ?? id,
+                documentation: step.documentation,
+                errorCode: step.errorCode,
+            });
+            return;
+        case "raw":
+            problems.push({
+                path,
+                message: `"raw" steps are not yet compiled — element type "${step.elementType}" was skipped`,
+            });
+            return;
+    }
+}
+function emitBoundaries(b, step, id, path, idOf, resolve, problems) {
+    if (step.errorBoundary) {
+        b.withBoundary(`${id}_error`, {
+            errorCode: step.errorBoundary.errorCode,
+            cancelActivity: step.errorBoundary.interrupting ?? true,
+        }, (hb) => emitSteps(hb, step.errorBoundary.steps, idOf, resolve, problems, `${path}.errorBoundary.steps`));
+    }
+    if (step.timerBoundary) {
+        b.withBoundary(`${id}_timer`, {
+            timerDuration: step.timerBoundary.duration,
+            timerDate: step.timerBoundary.date,
+            timerCycle: step.timerBoundary.cycle,
+            cancelActivity: step.timerBoundary.interrupting ?? true,
+        }, (hb) => emitSteps(hb, step.timerBoundary.steps, idOf, resolve, problems, `${path}.timerBoundary.steps`));
+    }
+}
+function emitSteps(b, steps, idOf, resolve, problems, path, indexOffset = 0) {
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const id = idOf.get(step);
+        if (!id)
+            continue;
+        const stepPath = `${path}[${i + indexOffset}]`;
+        const nextStep = steps[i + 1];
+        const nextId = nextStep ? idOf.get(nextStep) : undefined;
+        emitStep(b, step, id, stepPath, nextId, idOf, resolve, problems);
+        emitBoundaries(b, step, id, stepPath, idOf, resolve, problems);
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Compiles a `ProcessPlan` into laid-out, validated BPMN XML. Deterministic:
+ * the same plan always produces the same XML. Problems are collected, not
+ * thrown — check `result.problems` before using `result.xml`.
+ */
+export function compilePlan(plan, opts = {}) {
+    const problems = [];
+    if (plan.version !== 1) {
+        problems.push({ path: "version", message: `Unsupported plan version ${String(plan.version)}` });
+        return { problems };
+    }
+    if (!plan.process?.id) {
+        problems.push({ path: "process.id", message: "process.id is required" });
+        return { problems };
+    }
+    if (!plan.steps || plan.steps.length === 0) {
+        problems.push({ path: "steps", message: "Plan has no steps" });
+        return { problems };
+    }
+    const [firstStep, ...restSteps] = plan.steps;
+    if (!firstStep || firstStep.kind !== "start") {
+        problems.push({ path: "steps[0]", message: 'The first step must have kind "start"' });
+        return { problems };
+    }
+    const taken = new Set();
+    const idOf = new Map();
+    assignIds(plan.steps, taken, idOf);
+    const builder = Bpmn.createProcess(plan.process.id);
+    if (plan.process.name)
+        builder.name(plan.process.name);
+    if (plan.process.versionTag)
+        builder.versionTag(plan.process.versionTag);
+    let startResult;
+    if (firstStep.connector) {
+        startResult = resolveConnectorOrProblem(firstStep.connector, "steps[0].connector", opts.resolveConnector, problems);
+    }
+    const startId = idOf.get(firstStep);
+    builder.startEvent(startId, {
+        name: firstStep.name ?? "Start",
+        documentation: firstStep.documentation,
+        timerDuration: firstStep.timer?.duration,
+        timerDate: firstStep.timer?.date,
+        timerCycle: firstStep.timer?.cycle,
+        messageName: firstStep.message?.name,
+        zeebeProperties: startResult?.startEvent?.zeebeProperties,
+    });
+    emitSteps(builder, restSteps, idOf, opts.resolveConnector, problems, "steps", 1);
+    let defs;
+    try {
+        defs = builder.build();
+    }
+    catch (err) {
+        problems.push({
+            path: "steps",
+            message: `Build failed: ${err instanceof Error ? err.message : String(err)}`,
+        });
+        return { problems };
+    }
+    let laidOut = applyAutoLayout(defs);
+    if (!opts.skipAutoFix) {
+        const report = optimize(laidOut);
+        for (const finding of report.findings) {
+            finding.applyFix?.(laidOut);
+        }
+        laidOut = applyAutoLayout(laidOut);
+    }
+    const finalReport = optimize(laidOut);
+    for (const finding of finalReport.findings) {
+        if (finding.severity === "error") {
+            problems.push({
+                path: finding.elementIds.length > 0 ? `element:${finding.elementIds.join(",")}` : "process",
+                message: finding.message,
+            });
+        }
+    }
+    const xml = Bpmn.export(laidOut);
+    return { defs: laidOut, xml, problems };
+}
+//# sourceMappingURL=compile.js.map

package/dist/plan/extract.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Lifts an existing `BpmnDefinitions` process back into `ProcessPlan` form,
+ * so `/bpmnkit:extend`-style skills can express a delta instead of
+ * regenerating a whole process.
+ *
+ * Scope (documented, not silently exceeded): linear chains of tasks/events,
+ * plus a single level of exclusive/parallel/inclusive gateway branches that
+ * reconverge to a common next element. Sub-processes, ad-hoc sub-processes
+ * (including AI Agent sub-processes), nested gateways, pools/lanes, and data
+ * objects are not lifted — they are reported in `unsupported` rather than
+ * silently dropped or guessed at. Use `mergePlan()` to add new steps to a
+ * process without needing to fully extract it first.
+ */
+import type { BpmnDefinitions } from "../bpmn/bpmn-model.js";
+import type { ProcessPlan } from "./types.js";
+export interface UnsupportedElement {
+    id: string;
+    type: string;
+    reason: string;
+}
+export interface ExtractResult {
+    plan: ProcessPlan;
+    unsupported: UnsupportedElement[];
+}
+/**
+ * Extracts a single BPMN process into `ProcessPlan` form. Handles linear
+ * chains and a single level of gateway branching that reconverges; anything
+ * else is listed in `unsupported`, not fabricated.
+ */
+export declare function extractPlan(defs: BpmnDefinitions, processId?: string): ExtractResult;
+//# sourceMappingURL=extract.d.ts.map

package/dist/plan/extract.js

@@ -0,0 +1,248 @@
+import { readZeebeIoMapping, readZeebeTaskHeaders, readZeebeTaskType, } from "../bpmn/optimize/utils.js";
+function ioMappingToRecords(ext) {
+    const io = readZeebeIoMapping(ext);
+    if (!io)
+        return {};
+    const inputs = {};
+    for (const i of io.inputs)
+        inputs[i.target] = i.source;
+    const outputs = {};
+    for (const o of io.outputs)
+        outputs[o.target] = o.source;
+    return {
+        inputs: Object.keys(inputs).length > 0 ? inputs : undefined,
+        outputs: Object.keys(outputs).length > 0 ? outputs : undefined,
+    };
+}
+function taskHeadersOf(ext) {
+    const h = readZeebeTaskHeaders(ext);
+    if (!h || h.headers.length === 0)
+        return undefined;
+    const out = {};
+    for (const entry of h.headers)
+        out[entry.key] = entry.value;
+    return out;
+}
+function findExt(el, name) {
+    return el.extensionElements.find((e) => e.name === name);
+}
+function extractStep(el, unsupported, rootErrors) {
+    const base = { id: el.id, name: el.name, documentation: el.documentation };
+    switch (el.type) {
+        case "startEvent":
+            return { ...base, kind: "start" };
+        case "endEvent": {
+            const errorDef = el.eventDefinitions.find((d) => d.type === "error");
+            const errorCode = errorDef
+                ? rootErrors.find((e) => e.id === errorDef.errorRef)?.errorCode
+                : undefined;
+            const terminate = el.eventDefinitions.some((d) => d.type === "terminate");
+            return { ...base, kind: "end", errorCode, terminate: terminate || undefined };
+        }
+        case "serviceTask": {
+            const jobType = readZeebeTaskType(el.extensionElements);
+            if (!jobType) {
+                unsupported.push({
+                    id: el.id,
+                    type: el.type,
+                    reason: "service task has no zeebe:taskDefinition type",
+                });
+                return undefined;
+            }
+            return {
+                ...base,
+                kind: "serviceTask",
+                jobType,
+                taskHeaders: taskHeadersOf(el.extensionElements),
+                ...ioMappingToRecords(el.extensionElements),
+            };
+        }
+        case "userTask": {
+            const assignment = findExt(el, "zeebe:assignmentDefinition");
+            const schedule = findExt(el, "zeebe:taskSchedule");
+            const priority = findExt(el, "zeebe:priorityDefinition");
+            const form = findExt(el, "zeebe:formDefinition");
+            return {
+                ...base,
+                kind: "userTask",
+                formId: form?.attributes.formId,
+                assignee: assignment?.attributes.assignee,
+                candidateGroups: assignment?.attributes.candidateGroups,
+                candidateUsers: assignment?.attributes.candidateUsers,
+                dueDate: schedule?.attributes.dueDate,
+                followUpDate: schedule?.attributes.followUpDate,
+                priority: priority?.attributes.priority ? Number(priority.attributes.priority) : undefined,
+            };
+        }
+        case "businessRuleTask": {
+            const decision = findExt(el, "zeebe:calledDecision");
+            if (!decision) {
+                unsupported.push({
+                    id: el.id,
+                    type: el.type,
+                    reason: "business rule task has no zeebe:calledDecision",
+                });
+                return undefined;
+            }
+            return {
+                ...base,
+                kind: "businessRuleTask",
+                decisionId: decision.attributes.decisionId ?? "",
+                resultVariable: decision.attributes.resultVariable,
+            };
+        }
+        case "callActivity": {
+            const called = findExt(el, "zeebe:calledElement");
+            return {
+                ...base,
+                kind: "callActivity",
+                processId: called?.attributes.processId ?? "",
+                propagateAllChildVariables: called?.attributes.propagateAllChildVariables === "true",
+            };
+        }
+        default:
+            unsupported.push({
+                id: el.id,
+                type: el.type,
+                reason: `element type "${el.type}" is not liftable yet`,
+            });
+            return undefined;
+    }
+}
+/**
+ * Extracts a single BPMN process into `ProcessPlan` form. Handles linear
+ * chains and a single level of gateway branching that reconverges; anything
+ * else is listed in `unsupported`, not fabricated.
+ */
+export function extractPlan(defs, processId) {
+    const process = processId
+        ? defs.processes.find((p) => p.id === processId)
+        : defs.processes[0];
+    if (!process) {
+        return {
+            plan: { version: 1, process: { id: processId ?? "unknown" }, steps: [] },
+            unsupported: [{ id: processId ?? "unknown", type: "process", reason: "process not found" }],
+        };
+    }
+    const unsupported = [];
+    const bySource = new Map();
+    for (const flow of process.sequenceFlows) {
+        const list = bySource.get(flow.sourceRef) ?? [];
+        list.push(flow);
+        bySource.set(flow.sourceRef, list);
+    }
+    const byId = new Map(process.flowElements.map((e) => [e.id, e]));
+    const start = process.flowElements.find((e) => e.type === "startEvent");
+    if (!start) {
+        return {
+            plan: { version: 1, process: { id: process.id, name: process.name }, steps: [] },
+            unsupported: [{ id: process.id, type: "process", reason: "no start event" }],
+        };
+    }
+    const steps = [];
+    const visited = new Set();
+    function walkFrom(elementId) {
+        let currentId = elementId;
+        while (currentId && !visited.has(currentId)) {
+            visited.add(currentId);
+            const el = byId.get(currentId);
+            if (!el)
+                return;
+            const outgoing = bySource.get(currentId) ?? [];
+            const isGatewayType = el.type === "exclusiveGateway" ||
+                el.type === "parallelGateway" ||
+                el.type === "inclusiveGateway";
+            // A gateway with at most one outgoing flow makes no decision — it's a
+            // join the compiler auto-inserted (or an equivalent pass-through), not
+            // something the plan format needs to represent as a step.
+            if (isGatewayType && outgoing.length <= 1) {
+                currentId = outgoing[0]?.targetRef;
+                continue;
+            }
+            if (isGatewayType) {
+                const gatewayType = el.type === "exclusiveGateway"
+                    ? "exclusive"
+                    : el.type === "parallelGateway"
+                        ? "parallel"
+                        : "inclusive";
+                const branches = [];
+                for (const flow of outgoing) {
+                    const branchSteps = [];
+                    const branchVisited = new Set();
+                    let branchCursor = flow.targetRef;
+                    while (branchCursor && !visited.has(branchCursor) && !branchVisited.has(branchCursor)) {
+                        const branchEl = byId.get(branchCursor);
+                        if (!branchEl)
+                            break;
+                        const branchOutgoing = bySource.get(branchCursor) ?? [];
+                        const branchElIsGateway = branchEl.type === "exclusiveGateway" ||
+                            branchEl.type === "parallelGateway" ||
+                            branchEl.type === "inclusiveGateway";
+                        // A gateway with ≤1 outgoing flow here is the join this split
+                        // reconverges to — stop the branch walk without consuming it, so
+                        // the outer walk's convergence scan can pick it up.
+                        if (branchElIsGateway && branchOutgoing.length <= 1)
+                            break;
+                        if (branchOutgoing.length > 1) {
+                            unsupported.push({
+                                id: branchCursor,
+                                type: branchEl.type,
+                                reason: "nested gateway inside a branch is not liftable yet",
+                            });
+                            branchVisited.add(branchCursor);
+                            break;
+                        }
+                        branchVisited.add(branchCursor);
+                        const step = extractStep(branchEl, unsupported, defs.errors);
+                        if (step)
+                            branchSteps.push(step);
+                        branchCursor = branchOutgoing[0]?.targetRef;
+                    }
+                    for (const id of branchVisited)
+                        visited.add(id);
+                    branches.push({
+                        condition: flow.conditionExpression?.text,
+                        default: el.type === "exclusiveGateway" || el.type === "inclusiveGateway"
+                            ? flow.id === el.default
+                            : undefined,
+                        steps: branchSteps,
+                    });
+                }
+                steps.push({ id: el.id, name: el.name, kind: "gateway", gatewayType, branches });
+                // All branches reconverge (or dead-end) — continue from the common next element, if any.
+                const convergent = [...visited]
+                    .flatMap((id) => bySource.get(id) ?? [])
+                    .find((f) => !visited.has(f.targetRef));
+                currentId = convergent?.targetRef;
+                continue;
+            }
+            if (outgoing.length > 1) {
+                unsupported.push({
+                    id: el.id,
+                    type: el.type,
+                    reason: "multiple outgoing flows on a non-gateway element",
+                });
+                return;
+            }
+            const step = extractStep(el, unsupported, defs.errors);
+            if (step)
+                steps.push(step);
+            currentId = outgoing[0]?.targetRef;
+        }
+    }
+    walkFrom(start.id);
+    for (const el of process.flowElements) {
+        if (!visited.has(el.id) && el.type !== "boundaryEvent") {
+            unsupported.push({
+                id: el.id,
+                type: el.type,
+                reason: "not reachable from the linear/branching walk",
+            });
+        }
+    }
+    return {
+        plan: { version: 1, process: { id: process.id, name: process.name }, steps },
+        unsupported,
+    };
+}
+//# sourceMappingURL=extract.js.map

package/dist/plan/index.d.ts

@@ -0,0 +1,6 @@
+export { compilePlan, type CompilePlanOptions, type ConnectorApplyResult, type ConnectorResolver, type PlanProblem, type SynthResult, } from "./compile.js";
+export { extractPlan, type ExtractResult, type UnsupportedElement } from "./extract.js";
+export { mergePlan } from "./merge.js";
+export type { PlanAgentTool, PlanAiAgentStep, PlanBranch, PlanBusinessRuleTaskStep, PlanCallActivityStep, PlanConnectorRef, PlanConnectorStep, PlanEndStep, PlanErrorBoundary, PlanGatewayStep, PlanInputVariable, PlanRawStep, PlanReceiveTaskStep, PlanScenario, PlanScriptTaskStep, PlanSendTaskStep, PlanServiceTaskStep, PlanStartStep, PlanStep, PlanSubProcessStep, PlanTimerBoundary, PlanUserTaskStep, PlanWaitStep, ProcessPlan, } from "./types.js";
+export { slugify, uniqueId } from "./slug.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/plan/index.js

@@ -0,0 +1,5 @@
+export { compilePlan, } from "./compile.js";
+export { extractPlan } from "./extract.js";
+export { mergePlan } from "./merge.js";
+export { slugify, uniqueId } from "./slug.js";
+//# sourceMappingURL=index.js.map

package/dist/plan/merge.d.ts

@@ -0,0 +1,13 @@
+import type { BpmnDefinitions } from "../bpmn/bpmn-model.js";
+import type { CompilePlanOptions, SynthResult } from "./compile.js";
+import type { ProcessPlan } from "./types.js";
+/**
+ * Compiles `delta` standalone, then merges its elements/flows into
+ * `existing`'s matching process by id (matching ids are replaced, new ids
+ * are appended). `delta.steps[0]` must still be a `start` step — the merge
+ * only uses `delta`'s flow elements and sequence flows, and drops the
+ * delta's own start/end events when a same-id start/end already exists in
+ * `existing`.
+ */
+export declare function mergePlan(existing: BpmnDefinitions, delta: ProcessPlan, opts?: CompilePlanOptions): SynthResult;
+//# sourceMappingURL=merge.d.ts.map