@bpmnkit/core 0.1.2 → 0.2.0

package/dist/bpmn/optimize/tasks.js

@@ -53,21 +53,45 @@ function computeSimilarity(a, b) {
         score += 0.15;
     return score;
 }
-/** Cluster service tasks into connected components above the similarity threshold. */
+/**
+ * Cluster service tasks into connected components above the similarity
+ * threshold. Similarity requires an identical job type, so tasks are bucketed
+ * by type first and the pairwise comparison only runs within a bucket.
+ */
 function cluster(tasks, threshold) {
+    const byType = new Map();
+    const clusters = [];
+    for (const task of tasks) {
+        const type = readZeebeTaskType(task.extensionElements);
+        // Without a job type nothing is similar to this task; it stands alone.
+        if (type === null) {
+            clusters.push([task]);
+            continue;
+        }
+        const bucket = byType.get(type);
+        if (bucket)
+            bucket.push(task);
+        else
+            byType.set(type, [task]);
+    }
+    for (const bucket of byType.values())
+        clusterBucket(bucket, threshold, clusters);
+    // Report clusters in declaration order of their first member.
+    const order = new Map(tasks.map((task, index) => [task, index]));
+    clusters.sort((a, b) => (order.get(a[0]) ?? 0) - (order.get(b[0]) ?? 0));
+    return clusters;
+}
+function clusterBucket(tasks, threshold, clusters) {
     const n = tasks.length;
     const visited = new Array(n).fill(false);
-    const clusters = [];
     for (let i = 0; i < n; i++) {
         if (visited[i])
             continue;
         const group = [];
         const queue = [i];
         visited[i] = true;
-        while (queue.length > 0) {
-            const curr = queue.shift();
-            if (curr === undefined)
-                break;
+        for (let head = 0; head < queue.length; head++) {
+            const curr = queue[head];
             const task = tasks[curr];
             if (task === undefined)
                 break;
@@ -87,7 +111,6 @@ function cluster(tasks, threshold) {
         }
         clusters.push(group);
     }
-    return clusters;
 }
 // ---------------------------------------------------------------------------
 // Build the extracted BpmnDefinitions

package/dist/bpmn/optimize/utils.js

@@ -70,10 +70,8 @@ export function buildFlowIndex(p) {
 export function reachableFrom(startIds, bySource) {
     const visited = new Set(startIds);
     const queue = [...startIds];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (current === undefined)
-            break;
+    for (let head = 0; head < queue.length; head++) {
+        const current = queue[head];
         const outflows = bySource.get(current) ?? [];
         for (const flow of outflows) {
             if (!visited.has(flow.targetRef)) {

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

@@ -238,6 +238,58 @@ function readResultVariable(ext) {
     return null;
 }
 // ---------------------------------------------------------------------------
+// Scope propagation
+// ---------------------------------------------------------------------------
+/**
+ * For every node in the flow graph, the variables produced by that node or by
+ * any node with a path to it. A worklist fixed point over the graph handles
+ * cycles and costs O((V + E) · vars), instead of one full graph walk per flow.
+ */
+function reachingProduces(flows, produces) {
+    const successors = new Map();
+    const scope = new Map();
+    for (const flow of flows) {
+        const out = successors.get(flow.sourceRef);
+        if (out)
+            out.push(flow.targetRef);
+        else
+            successors.set(flow.sourceRef, [flow.targetRef]);
+        if (!scope.has(flow.sourceRef)) {
+            scope.set(flow.sourceRef, new Set(produces.get(flow.sourceRef) ?? []));
+        }
+        if (!scope.has(flow.targetRef)) {
+            scope.set(flow.targetRef, new Set(produces.get(flow.targetRef) ?? []));
+        }
+    }
+    const queue = [...scope.keys()];
+    const queued = new Set(queue);
+    for (let head = 0; head < queue.length; head++) {
+        const id = queue[head];
+        queued.delete(id);
+        const own = scope.get(id);
+        const next = successors.get(id);
+        if (!own || own.size === 0 || !next)
+            continue;
+        for (const target of next) {
+            const targetScope = scope.get(target);
+            if (!targetScope)
+                continue;
+            let grew = false;
+            for (const v of own) {
+                if (!targetScope.has(v)) {
+                    targetScope.add(v);
+                    grew = true;
+                }
+            }
+            if (grew && !queued.has(target)) {
+                queued.add(target);
+                queue.push(target);
+            }
+        }
+    }
+    return scope;
+}
+// ---------------------------------------------------------------------------
 // Main analysis
 // ---------------------------------------------------------------------------
 export function analyzeVariableFlow(p) {
@@ -377,42 +429,10 @@ export function analyzeVariableFlow(p) {
         });
     }
     // ── Per-edge scope findings (variables available at each sequence flow) ──
-    // Build reverse adjacency: targetId → set of source IDs
-    const reverseAdj = new Map();
+    const scopeAt = reachingProduces(p.sequenceFlows, elementProduces);
     for (const flow of p.sequenceFlows) {
-        const set = reverseAdj.get(flow.targetRef) ?? new Set();
-        set.add(flow.sourceRef);
-        reverseAdj.set(flow.targetRef, set);
-    }
-    // Collect all transitive predecessors of an element (inclusive of start)
-    function allPredecessors(elementId) {
-        const visited = new Set();
-        const queue = [elementId];
-        while (queue.length > 0) {
-            const current = queue.shift();
-            if (current === undefined)
-                break;
-            const preds = reverseAdj.get(current);
-            if (preds === undefined)
-                continue;
-            for (const pred of preds) {
-                if (!visited.has(pred)) {
-                    visited.add(pred);
-                    queue.push(pred);
-                }
-            }
-        }
-        return visited;
-    }
-    for (const flow of p.sequenceFlows) {
-        const predIds = allPredecessors(flow.sourceRef);
-        predIds.add(flow.sourceRef);
-        const inScope = new Set();
-        for (const predId of predIds) {
-            for (const v of elementProduces.get(predId) ?? [])
-                inScope.add(v);
-        }
-        if (inScope.size === 0)
+        const inScope = scopeAt.get(flow.sourceRef);
+        if (inScope === undefined || inScope.size === 0)
             continue;
         const scopeVars = [...inScope].sort();
         findings.push({
@@ -455,42 +475,13 @@ export function analyzeVariableFlow(p) {
                 }
             }
         }
-        // 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
+        const innerScopeAt = reachingProduces(sp.sequenceFlows, innerProduces);
         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);
-            }
+            for (const v of innerScopeAt.get(flow.sourceRef) ?? [])
+                inScope.add(v);
             const scopeVars = [...inScope].sort();
             findings.push({
                 id: `data-flow/edge-scope:${flow.id}`,

package/dist/bpmn/semantic-hash.d.ts

@@ -0,0 +1,93 @@
+import type { BpmnDefinitions } from "./bpmn-model.js";
+/**
+ * A presentation-free, canonical view of a BPMN model, and a hash over it.
+ *
+ * Two documents that mean the same thing hash the same, however they are laid
+ * out, ordered or formatted. That turns a claim into an assertion: re-running
+ * auto-layout, or re-serialising a file, cannot change the hash — if it does,
+ * something touched the model, not the diagram.
+ *
+ * What is excluded, and why:
+ *
+ * - **Diagram interchange** (`diagrams`) entirely — shapes, edges, waypoints and
+ *   their `bioc`/`color` extensions are where a layout lives.
+ * - **`zeebe:modelerTemplateIcon`** — a base64 icon that would otherwise
+ *   dominate every diff it appears in.
+ * - **`exporter` / `exporterVersion`** — which tool wrote the file, not what the
+ *   file says. The same model exported by two tools hashes the same.
+ *
+ * `modeler:executionPlatform` and its version are deliberately **kept**: they
+ * name the engine the model targets, so changing them is a real change. This
+ * differs from some other implementations; flip it here if that is not wanted.
+ *
+ * Ordering carries no meaning in BPMN — `flowElements` may appear in any order —
+ * so collections are sorted canonically and object keys are sorted by name.
+ */
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * Namespace prefixes that carry presentation rather than meaning.
+ *
+ * Named once so the two things that need the notion cannot disagree about what
+ * counts as presentation: this module, and the descriptor coverage check, which
+ * treats these packages as handled structurally by the diagram model rather than
+ * as gaps.
+ *
+ * They are excluded here in two different ways, which is why the list is not
+ * itself the attribute filter. `bpmndi` / `dc` / `di` describe the diagram, and
+ * the diagram is dropped wholesale via the `diagrams` key. `bioc` and `color`
+ * are extension *attributes* that ride on diagram elements, so they are dropped
+ * by name wherever they appear.
+ */
+export declare const PRESENTATION_PREFIXES: ReadonlySet<string>;
+/** A canonical view of a model, plus a per-element index for diffing. */
+export interface SemanticProjection {
+    /** Canonical JSON of the whole model, presentation excluded. */
+    readonly value: JsonValue;
+    /**
+     * One entry per element that carries an `id`, projected shallowly —
+     * descendants with their own id appear as that id, so a change is attributed
+     * to the element that actually changed rather than to all its ancestors.
+     */
+    readonly elements: ReadonlyMap<string, JsonValue>;
+}
+/**
+ * Projects a model onto its canonical, presentation-free form.
+ *
+ * @param definitions - The model to project.
+ */
+export declare function projectSemantics(definitions: BpmnDefinitions): SemanticProjection;
+/**
+ * Returns the SHA-256 of a model's canonical projection.
+ *
+ * Stable across formatting, element order, attribute order and any change to
+ * the diagram. Use it to tell "the model changed" from "the picture moved".
+ *
+ * @param definitions - The model to hash.
+ */
+export declare function semanticHash(definitions: BpmnDefinitions): string;
+/** What changed between two models, keyed by element id. */
+export interface SemanticDiff {
+    /** Ids present only in the later model. */
+    added: string[];
+    /** Ids present only in the earlier model. */
+    removed: string[];
+    /** Ids whose own projection differs, with both sides. */
+    changed: Array<{
+        id: string;
+        before: JsonValue;
+        after: JsonValue;
+    }>;
+}
+/**
+ * Compares two models element by element.
+ *
+ * @param before - The earlier model.
+ * @param after - The later model.
+ * @returns Ids added, removed, and changed — the report a write boundary or a
+ *   review loop shows a user before touching anything.
+ */
+export declare function diffSemantics(before: BpmnDefinitions, after: BpmnDefinitions): SemanticDiff;
+//# sourceMappingURL=semantic-hash.d.ts.map

package/dist/bpmn/semantic-hash.js

@@ -0,0 +1,155 @@
+import { sha256Hex } from "./sha256.js";
+/** Attribute names dropped wherever they appear. */
+const EXCLUDED_ATTRIBUTES = new Set(["zeebe:modelerTemplateIcon"]);
+/**
+ * Namespace prefixes that carry presentation rather than meaning.
+ *
+ * Named once so the two things that need the notion cannot disagree about what
+ * counts as presentation: this module, and the descriptor coverage check, which
+ * treats these packages as handled structurally by the diagram model rather than
+ * as gaps.
+ *
+ * They are excluded here in two different ways, which is why the list is not
+ * itself the attribute filter. `bpmndi` / `dc` / `di` describe the diagram, and
+ * the diagram is dropped wholesale via the `diagrams` key. `bioc` and `color`
+ * are extension *attributes* that ride on diagram elements, so they are dropped
+ * by name wherever they appear.
+ */
+export const PRESENTATION_PREFIXES = new Set([
+    "bpmndi",
+    "dc",
+    "di",
+    "bioc",
+    "color",
+]);
+/** The subset of the above excluded per-attribute rather than per-subtree. */
+const EXCLUDED_ATTRIBUTE_PREFIXES = ["bioc:", "color:"];
+/** Top-level `BpmnDefinitions` keys that describe the exporter or the diagram. */
+const EXCLUDED_DEFINITIONS_KEYS = new Set(["diagrams", "exporter", "exporterVersion"]);
+function isExcludedAttribute(name) {
+    return (EXCLUDED_ATTRIBUTES.has(name) ||
+        EXCLUDED_ATTRIBUTE_PREFIXES.some((prefix) => name.startsWith(prefix)));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Canonicalises a value: drops empties, sorts object keys, and sorts array
+ * entries by their own canonical form so ordering cannot affect the result.
+ */
+function canonicalise(value, excludedKeys) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const entries = value
+            .map((entry) => canonicalise(entry))
+            .filter((entry) => entry !== undefined)
+            .map((entry) => [JSON.stringify(entry), entry])
+            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+            .map(([, entry]) => entry);
+        return entries.length > 0 ? entries : undefined;
+    }
+    if (!isRecord(value))
+        return undefined;
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+        if (excludedKeys?.has(key))
+            continue;
+        if (isExcludedAttribute(key))
+            continue;
+        const projected = canonicalise(value[key]);
+        if (projected !== undefined)
+            result[key] = projected;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+/**
+ * Replaces every descendant that carries its own `id` with that id, so an
+ * element's projection describes the element and not its whole subtree.
+ */
+function shallow(value) {
+    if (Array.isArray(value))
+        return value.map(shallow);
+    if (typeof value !== "object" || value === null)
+        return value;
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === "id") {
+            result[key] = entry;
+            continue;
+        }
+        if (Array.isArray(entry)) {
+            result[key] = entry.map((item) => isRecord(item) && typeof item.id === "string" ? item.id : shallow(item));
+            continue;
+        }
+        result[key] =
+            isRecord(entry) && typeof entry.id === "string" ? entry.id : shallow(entry);
+    }
+    return result;
+}
+function collectElements(value, into) {
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            collectElements(entry, into);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    if (typeof value.id === "string") {
+        into.set(value.id, shallow(value));
+    }
+    for (const entry of Object.values(value)) {
+        collectElements(entry, into);
+    }
+}
+/**
+ * Projects a model onto its canonical, presentation-free form.
+ *
+ * @param definitions - The model to project.
+ */
+export function projectSemantics(definitions) {
+    const value = canonicalise(definitions, EXCLUDED_DEFINITIONS_KEYS) ?? {};
+    const elements = new Map();
+    collectElements(value, elements);
+    return { value, elements };
+}
+/**
+ * Returns the SHA-256 of a model's canonical projection.
+ *
+ * Stable across formatting, element order, attribute order and any change to
+ * the diagram. Use it to tell "the model changed" from "the picture moved".
+ *
+ * @param definitions - The model to hash.
+ */
+export function semanticHash(definitions) {
+    return sha256Hex(JSON.stringify(projectSemantics(definitions).value));
+}
+/**
+ * Compares two models element by element.
+ *
+ * @param before - The earlier model.
+ * @param after - The later model.
+ * @returns Ids added, removed, and changed — the report a write boundary or a
+ *   review loop shows a user before touching anything.
+ */
+export function diffSemantics(before, after) {
+    const left = projectSemantics(before).elements;
+    const right = projectSemantics(after).elements;
+    const added = [...right.keys()].filter((id) => !left.has(id)).sort();
+    const removed = [...left.keys()].filter((id) => !right.has(id)).sort();
+    const changed = [...right.keys()]
+        .filter((id) => left.has(id))
+        .sort()
+        .flatMap((id) => {
+        const earlier = left.get(id);
+        const later = right.get(id);
+        return JSON.stringify(earlier) === JSON.stringify(later)
+            ? []
+            : [{ id, before: earlier, after: later }];
+    });
+    return { added, removed, changed };
+}
+//# sourceMappingURL=semantic-hash.js.map

package/dist/bpmn/sha256.d.ts

@@ -0,0 +1,17 @@
+/**
+ * SHA-256, synchronous and dependency-free.
+ *
+ * `node:crypto` would break browser builds and `crypto.subtle` is async and
+ * unavailable outside secure contexts, either of which would force every caller
+ * of {@link semanticHash} — and the write boundary above it — to become async
+ * for no benefit. The algorithm is small enough to carry.
+ *
+ * @see https://csrc.nist.gov/publications/detail/fips/180/4/final
+ */
+/**
+ * Returns the lowercase hex SHA-256 digest of a string, encoded as UTF-8.
+ *
+ * @param input - Text to digest.
+ */
+export declare function sha256Hex(input: string): string;
+//# sourceMappingURL=sha256.d.ts.map

package/dist/bpmn/sha256.js

@@ -0,0 +1,95 @@
+/**
+ * SHA-256, synchronous and dependency-free.
+ *
+ * `node:crypto` would break browser builds and `crypto.subtle` is async and
+ * unavailable outside secure contexts, either of which would force every caller
+ * of {@link semanticHash} — and the write boundary above it — to become async
+ * for no benefit. The algorithm is small enough to carry.
+ *
+ * @see https://csrc.nist.gov/publications/detail/fips/180/4/final
+ */
+/** First 32 bits of the fractional parts of the cube roots of the first 64 primes. */
+// biome-ignore format: the round constants read better as a block
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+function rotr(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+/**
+ * Returns the lowercase hex SHA-256 digest of a string, encoded as UTF-8.
+ *
+ * @param input - Text to digest.
+ */
+export function sha256Hex(input) {
+    const bytes = new TextEncoder().encode(input);
+    const bitLength = bytes.length * 8;
+    // Pad to a multiple of 64 bytes: 0x80, zeroes, then the length as 64 bits.
+    const padded = new Uint8Array((((bytes.length + 9 + 63) / 64) | 0) * 64);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(bitLength / 0x1_0000_0000));
+    view.setUint32(padded.length - 4, bitLength >>> 0);
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = view.getUint32(offset + i * 4);
+        }
+        for (let i = 16; i < 64; i++) {
+            const a = w[i - 15];
+            const b = w[i - 2];
+            const s0 = rotr(a, 7) ^ rotr(a, 18) ^ (a >>> 3);
+            const s1 = rotr(b, 17) ^ rotr(b, 19) ^ (b >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let a = h[0];
+        let b = h[1];
+        let c = h[2];
+        let d = h[3];
+        let e = h[4];
+        let f = h[5];
+        let g = h[6];
+        let hh = h[7];
+        for (let i = 0; i < 64; i++) {
+            const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const temp1 = (hh + s1 + ch + K[i] + w[i]) >>> 0;
+            const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (s0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + temp1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    let digest = "";
+    for (const word of h) {
+        digest += word.toString(16).padStart(8, "0");
+    }
+    return digest;
+}
+//# sourceMappingURL=sha256.js.map

package/dist/bpmn/zeebe-extensions.d.ts

@@ -98,4 +98,60 @@ export interface ZeebeExtensions {
 }
 /** Convert Zeebe extensions to XmlElement array for the BPMN model. */
 export declare function zeebeExtensionsToXmlElements(extensions: ZeebeExtensions): XmlElement[];
+/**
+ * Reports where a Zeebe extension may go, from the descriptor rather than from
+ * our own idea of the rules.
+ *
+ * `zeebe.json` records a `meta.allowedIn` list per extension type;
+ * `scripts/generate-zeebe-placement.ts` resolves those entries — many of which
+ * name abstract BPMN types or Zeebe aliases — into the concrete element names in
+ * `ZEEBE_PLACEMENT`. Writing `zeebe:calledDecision` onto a service task produces
+ * a file Camunda rejects at deploy time; catching it at the write is the point.
+ *
+ * **An extension the table does not mention is allowed.** The descriptor
+ * declares no owner for `zeebe:subscription` or `zeebe:properties`, so we do not
+ * know where they may go and must not invent a rule — this check rejects only
+ * what the descriptor positively forbids. Vendor extensions outside the `zeebe:`
+ * namespace are not this function's business and are likewise allowed.
+ *
+ * @param ownerElement - The owner's BPMN element name, e.g. `bpmn:serviceTask`.
+ * @param extension - The extension element name, e.g. `zeebe:taskDefinition`.
+ */
+export declare function isZeebePlacementAllowed(ownerElement: string, extension: string): boolean;
+/** Thrown when a Zeebe extension is written somewhere the descriptor forbids. */
+export declare class ZeebePlacementError extends Error {
+    readonly ownerElement: string;
+    readonly extension: string;
+    readonly allowedOn: readonly string[];
+    constructor(ownerElement: string, extension: string, allowedOn: readonly string[]);
+}
+/**
+ * Throws {@link ZeebePlacementError} if the placement is one the descriptor
+ * forbids. See {@link isZeebePlacementAllowed} for what "forbids" covers.
+ */
+export declare function assertZeebePlacement(ownerElement: string, extension: string): void;
+/**
+ * The BPMN element name a flow element is written as.
+ *
+ * The model's `type` is the element's local name in every case but one:
+ * `eventSubProcess` is our name for a `bpmn:subProcess` carrying
+ * `triggeredByEvent`, and BPMN has no element of that name.
+ */
+export declare function bpmnElementName(flowElement: {
+    type: string;
+}): string;
+/**
+ * Finds a Zeebe extension element on a flow element, creating it if absent, and
+ * refuses a placement the descriptor forbids.
+ *
+ * Use this rather than pushing onto `extensionElements` directly: the push
+ * cannot fail, so an extension on the wrong element becomes a deploy-time error
+ * in someone else's terminal instead of a throw here.
+ *
+ * @throws ZeebePlacementError
+ */
+export declare function ensureZeebeExtension(owner: {
+    type: string;
+    extensionElements: XmlElement[];
+}, extension: string): XmlElement;
 //# sourceMappingURL=zeebe-extensions.d.ts.map