@bpmnkit/core 0.1.1 → 0.2.0

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

package/dist/plan/merge.js

@@ -0,0 +1,80 @@
+/**
+ * Applies a `ProcessPlan` delta onto an already-compiled `BpmnDefinitions`
+ * process — an id-based structural merge, not a byte-stable patch: elements
+ * whose id already exists are replaced, new elements are appended, and
+ * auto-layout re-runs over the whole diagram (so untouched elements keep
+ * their meaning but not necessarily their exact DI coordinates).
+ */
+import { applyAutoLayout } from "../bpmn/auto-layout.js";
+import { Bpmn } from "../bpmn/index.js";
+import { optimize } from "../bpmn/optimize/index.js";
+import { compilePlan } from "./compile.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 function mergePlan(existing, delta, opts = {}) {
+    const deltaResult = compilePlan(delta, { ...opts, skipAutoFix: true });
+    if (!deltaResult.defs)
+        return deltaResult;
+    const targetProcess = existing.processes.find((p) => p.id === delta.process.id) ?? existing.processes[0];
+    const deltaProcess = deltaResult.defs.processes[0];
+    if (!targetProcess || !deltaProcess) {
+        return { problems: [{ path: "process", message: "Could not resolve a process to merge into" }] };
+    }
+    const problems = [];
+    for (const el of deltaProcess.flowElements) {
+        const existingIndex = targetProcess.flowElements.findIndex((e) => e.id === el.id);
+        if (existingIndex >= 0)
+            targetProcess.flowElements[existingIndex] = el;
+        else
+            targetProcess.flowElements.push(el);
+    }
+    // Sequence-flow ids aren't stable across compiles, so merging by flow id
+    // would leave stale flows around any element the delta re-wires. Instead:
+    // drop every existing flow touching an element the delta redefines, then
+    // add the delta's flows fresh. Flows between two untouched elements are
+    // left alone.
+    const deltaElementIds = new Set(deltaProcess.flowElements.map((e) => e.id));
+    targetProcess.sequenceFlows = targetProcess.sequenceFlows.filter((f) => !deltaElementIds.has(f.sourceRef) && !deltaElementIds.has(f.targetRef));
+    targetProcess.sequenceFlows.push(...deltaProcess.sequenceFlows);
+    // Pull in any new root error/message/signal/escalation definitions the delta introduced.
+    for (const err of deltaResult.defs.errors) {
+        if (!existing.errors.some((e) => e.id === err.id))
+            existing.errors.push(err);
+    }
+    for (const msg of deltaResult.defs.messages) {
+        if (!existing.messages.some((m) => m.id === msg.id))
+            existing.messages.push(msg);
+    }
+    for (const sig of deltaResult.defs.signals) {
+        if (!existing.signals.some((s) => s.id === sig.id))
+            existing.signals.push(sig);
+    }
+    for (const esc of deltaResult.defs.escalations) {
+        if (!existing.escalations.some((e) => e.id === esc.id))
+            existing.escalations.push(esc);
+    }
+    let laidOut = applyAutoLayout(existing);
+    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,
+            });
+        }
+    }
+    return { defs: laidOut, xml: Bpmn.export(laidOut), problems };
+}
+//# sourceMappingURL=merge.js.map

package/dist/plan/slug.d.ts

@@ -0,0 +1,5 @@
+/** Derives a stable, readable element id from a step name, deduping against ids already used in this plan. */
+export declare function slugify(text: string): string;
+/** Returns a unique id: `base`, or `base_2`, `base_3`, … if `base` is already taken. */
+export declare function uniqueId(base: string, taken: Set<string>): string;
+//# sourceMappingURL=slug.d.ts.map

package/dist/plan/slug.js

@@ -0,0 +1,22 @@
+/** Derives a stable, readable element id from a step name, deduping against ids already used in this plan. */
+export function slugify(text) {
+    const slug = text
+        .trim()
+        .replace(/[^a-zA-Z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return slug.length > 0 ? slug : "element";
+}
+/** Returns a unique id: `base`, or `base_2`, `base_3`, … if `base` is already taken. */
+export function uniqueId(base, taken) {
+    if (!taken.has(base)) {
+        taken.add(base);
+        return base;
+    }
+    let n = 2;
+    while (taken.has(`${base}_${n}`))
+        n++;
+    const id = `${base}_${n}`;
+    taken.add(id);
+    return id;
+}
+//# sourceMappingURL=slug.js.map

package/dist/plan/types.d.ts

@@ -0,0 +1,225 @@
+/**
+ * ProcessPlan — the typed intermediate representation Claude (or any LLM)
+ * authors instead of BPMN XML. `compilePlan()` turns a plan into valid,
+ * laid-out, executable BPMN via the `@bpmnkit/core` builder; the model never
+ * touches XML, DI, element IDs, or connector property keys directly.
+ *
+ * Every string field documented as FEEL follows this SDK's existing
+ * convention throughout: a leading "=" makes it a FEEL expression, its
+ * absence makes it a literal string. This matches how `zeebe:input`/`output`
+ * `source` values already work in `@bpmnkit/core`.
+ */
+/** A connector reference — resolved against `@bpmnkit/connectors` (or an equivalent resolver) at compile time. */
+export interface PlanConnectorRef {
+    /** Bundled template id, e.g. "io.camunda.connectors.Slack.v1". */
+    template: string;
+    /** Values keyed by the template's input keys — see `ConnectorSummary.requiredInputs`/`optionalInputs`. */
+    values?: Record<string, string>;
+}
+/** An error boundary attached to a step that can throw a BPMN error. */
+export interface PlanErrorBoundary {
+    /**
+     * BPMN error code this boundary catches. Required: the underlying builder
+     * only emits an `errorEventDefinition` when a code is given, so an
+     * omitted `errorCode` produces an untyped (non-functional) boundary event.
+     */
+    errorCode: string;
+    /** Steps to run when the error is caught. */
+    steps: PlanStep[];
+    /** False = non-interrupting boundary event (default true). */
+    interrupting?: boolean;
+}
+/** A timer boundary attached to a step. */
+export interface PlanTimerBoundary {
+    duration?: string;
+    date?: string;
+    cycle?: string;
+    steps: PlanStep[];
+    interrupting?: boolean;
+}
+interface PlanStepBase {
+    /** Stable element id. Auto-derived from `name` (slugified, deduped) if omitted. */
+    id?: string;
+    name?: string;
+    /** Shown as documentation on the element; becomes the AI Agent tool description for tools inside an `aiAgent` step. */
+    documentation?: string;
+    errorBoundary?: PlanErrorBoundary;
+    timerBoundary?: PlanTimerBoundary;
+}
+export interface PlanStartStep extends PlanStepBase {
+    kind: "start";
+    timer?: {
+        duration?: string;
+        date?: string;
+        cycle?: string;
+    };
+    message?: {
+        name: string;
+    };
+    /** Inbound connector template (e.g. a webhook start event). */
+    connector?: PlanConnectorRef;
+}
+export interface PlanConnectorStep extends PlanStepBase {
+    kind: "connector";
+    connector: PlanConnectorRef;
+    retries?: string;
+}
+export interface PlanServiceTaskStep extends PlanStepBase {
+    kind: "serviceTask";
+    jobType: string;
+    inputs?: Record<string, string>;
+    outputs?: Record<string, string>;
+    taskHeaders?: Record<string, string>;
+    retries?: string;
+}
+export interface PlanUserTaskStep extends PlanStepBase {
+    kind: "userTask";
+    formId?: string;
+    assignee?: string;
+    candidateGroups?: string;
+    candidateUsers?: string;
+    dueDate?: string;
+    followUpDate?: string;
+    priority?: number;
+}
+export interface PlanBusinessRuleTaskStep extends PlanStepBase {
+    kind: "businessRuleTask";
+    decisionId: string;
+    resultVariable?: string;
+}
+export interface PlanScriptTaskStep extends PlanStepBase {
+    kind: "scriptTask";
+    expression: string;
+    resultVariable: string;
+}
+export interface PlanSendTaskStep extends PlanStepBase {
+    kind: "sendTask";
+    messageName: string;
+}
+export interface PlanReceiveTaskStep extends PlanStepBase {
+    kind: "receiveTask";
+    messageName: string;
+    correlationKey?: string;
+}
+export interface PlanCallActivityStep extends PlanStepBase {
+    kind: "callActivity";
+    processId: string;
+    propagateAllChildVariables?: boolean;
+}
+/** One tool available to an `aiAgent` step. */
+export interface PlanAgentTool {
+    id: string;
+    description: string;
+    /** A connector-backed tool. */
+    connector?: PlanConnectorRef;
+    /** A plain job-worker tool (mutually exclusive with `connector`). */
+    jobType?: string;
+    params?: Array<{
+        name: string;
+        description: string;
+        type?: "string" | "number" | "boolean" | "integer" | "array" | "object";
+        required?: boolean;
+        schema?: Record<string, unknown>;
+        /** Input-mapping target on the tool activity (default: same as `name`). */
+        target?: string;
+    }>;
+    resultExpression?: string;
+}
+export interface PlanAiAgentStep extends PlanStepBase {
+    kind: "aiAgent";
+    provider: string;
+    model: string;
+    /** Extra dotted zeebe:input bindings — auth, endpoint, region, etc. Keys match the bundled template's input keys. */
+    providerInputs?: Record<string, string>;
+    systemPrompt: string;
+    userPrompt: string;
+    memoryStorageType?: string;
+    maxModelCalls?: number;
+    outputVariable?: string;
+    tools: PlanAgentTool[];
+    completionCondition?: string;
+    cancelRemainingInstances?: boolean;
+    retries?: string;
+}
+export interface PlanBranch {
+    name?: string;
+    /** FEEL condition (required unless `default` is set). */
+    condition?: string;
+    default?: boolean;
+    steps: PlanStep[];
+}
+export interface PlanGatewayStep extends PlanStepBase {
+    kind: "gateway";
+    gatewayType: "exclusive" | "parallel" | "inclusive" | "eventBased";
+    branches: PlanBranch[];
+}
+export interface PlanSubProcessStep extends PlanStepBase {
+    kind: "subProcess";
+    steps: PlanStep[];
+    multiInstance?: {
+        isSequential?: boolean;
+        collection: string;
+        elementVariable?: string;
+        completionCondition?: string;
+    };
+}
+export interface PlanWaitStep extends PlanStepBase {
+    kind: "wait";
+    timer?: {
+        duration?: string;
+        date?: string;
+        cycle?: string;
+    };
+    message?: {
+        name: string;
+        correlationKey: string;
+    };
+}
+export interface PlanEndStep extends PlanStepBase {
+    kind: "end";
+    errorCode?: string;
+    terminate?: boolean;
+}
+/** Escape hatch for anything the plan format can't express yet — a raw builder-options object, applied as-is. */
+export interface PlanRawStep extends PlanStepBase {
+    kind: "raw";
+    elementType: string;
+    options?: Record<string, unknown>;
+}
+export type PlanStep = PlanStartStep | PlanConnectorStep | PlanServiceTaskStep | PlanUserTaskStep | PlanBusinessRuleTaskStep | PlanScriptTaskStep | PlanSendTaskStep | PlanReceiveTaskStep | PlanCallActivityStep | PlanAiAgentStep | PlanGatewayStep | PlanSubProcessStep | PlanWaitStep | PlanEndStep | PlanRawStep;
+export interface PlanInputVariable {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+}
+export interface PlanScenario {
+    name: string;
+    inputs?: Record<string, unknown>;
+    /** jobType → { outputs } or { error: { code, message? } } */
+    mocks?: Record<string, {
+        outputs?: Record<string, unknown>;
+    } | {
+        error: {
+            code: string;
+            message?: string;
+        };
+    }>;
+    expect?: {
+        path?: string[];
+        variables?: Record<string, unknown>;
+    };
+}
+export interface ProcessPlan {
+    version: 1;
+    process: {
+        id: string;
+        name?: string;
+        versionTag?: string;
+    };
+    inputs?: PlanInputVariable[];
+    steps: PlanStep[];
+    tests?: PlanScenario[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/plan/types.js

@@ -0,0 +1,13 @@
+/**
+ * ProcessPlan — the typed intermediate representation Claude (or any LLM)
+ * authors instead of BPMN XML. `compilePlan()` turns a plan into valid,
+ * laid-out, executable BPMN via the `@bpmnkit/core` builder; the model never
+ * touches XML, DI, element IDs, or connector property keys directly.
+ *
+ * Every string field documented as FEEL follows this SDK's existing
+ * convention throughout: a leading "=" makes it a FEEL expression, its
+ * absence makes it a literal string. This matches how `zeebe:input`/`output`
+ * `source` values already work in `@bpmnkit/core`.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types/id-generator.js

@@ -1,12 +1,20 @@
 const ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 const ID_SIZE = 8;
+// Random bytes are drawn in batches: one getRandomValues call per id is
+// dominated by the crypto call overhead, not by the bytes it returns.
+const POOL_SIZE = 1024;
+const pool = new Uint8Array(POOL_SIZE);
+let poolOffset = POOL_SIZE;
 function nanoId() {
-    const bytes = new Uint8Array(ID_SIZE);
-    crypto.getRandomValues(bytes);
+    if (poolOffset + ID_SIZE > POOL_SIZE) {
+        crypto.getRandomValues(pool);
+        poolOffset = 0;
+    }
     let id = "";
     for (let i = 0; i < ID_SIZE; i++) {
-        id += ALPHABET[bytes[i] % ALPHABET.length];
+        id += ALPHABET[pool[poolOffset + i] % ALPHABET.length];
     }
+    poolOffset += ID_SIZE;
     return id;
 }
 // Counter used only in deterministic test mode (activated by resetIdCounter())

package/dist/xml/index.d.ts

@@ -1,2 +1,4 @@
-export { parseXml, serializeXml } from "./xml-parser.js";
+export { parseXml, scanXml, serializeXml } from "./xml-parser.js";
+export { Visit } from "./xml-parser.js";
+export type { XmlSink } from "./xml-parser.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/xml/index.js

@@ -1,2 +1,3 @@
-export { parseXml, serializeXml } from "./xml-parser.js";
+export { parseXml, scanXml, serializeXml } from "./xml-parser.js";
+export { Visit } from "./xml-parser.js";
 //# sourceMappingURL=index.js.map