@bpmn-ld/bpmn-ld 0.0.0-stage → 0.2.0

package/dist/analyze/rules/compensation-association.js

@@ -0,0 +1,13 @@
+export const compensationAssociationRule = {
+    id: "compensation-activity-without-association",
+    severity: "warning",
+    check: (scope) => scope.nodes
+        .filter((node) => node.forCompensation)
+        .filter((node) => !scope.associations.some((association) => association.target === node.id && scope.nodes.some((source) => source.id === association.source && source.compensationBoundary)))
+        .map((node) => ({
+        rule: "compensation-activity-without-association",
+        severity: "warning",
+        node: node.id,
+        message: "compensation activity is not the target of an association from a compensation boundary event, so no compensation event triggers it",
+    })),
+};

package/dist/analyze/rules/dead-end.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const deadEndRule: Rule;

package/dist/analyze/rules/dead-end.js

@@ -0,0 +1,13 @@
+import { hasType } from "../scope-graph.js";
+export const deadEndRule = {
+    id: "node-dead-end",
+    severity: "warning",
+    check: (scope) => {
+        if (scope.adHoc)
+            return [];
+        const sources = new Set(scope.flows.map((flow) => flow.source));
+        return scope.nodes
+            .filter((node) => !node.exempt && !hasType(node, "EndEvent") && !sources.has(node.id))
+            .map((node) => ({ rule: "node-dead-end", severity: "warning", node: node.id, message: "flow node has no outgoing sequence flow and is not an end event" }));
+    },
+};

package/dist/analyze/rules/end-event.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const endEventRule: Rule;

package/dist/analyze/rules/end-event.js

@@ -0,0 +1,8 @@
+import { hasType, isPlaceholder } from "../scope-graph.js";
+export const endEventRule = {
+    id: "end-event-missing",
+    severity: "warning",
+    check: (scope) => isPlaceholder(scope) || scope.adHoc || scope.nodes.some((node) => hasType(node, "EndEvent"))
+        ? []
+        : [{ rule: "end-event-missing", severity: "warning", node: scope.id, message: `${scope.kind === "process" ? "process" : "sub-process"} has no end event` }],
+};

package/dist/analyze/rules/error-catch.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const errorCatchRule: Rule;

package/dist/analyze/rules/error-catch.js

@@ -0,0 +1,14 @@
+export const errorCatchRule = {
+    id: "error-throw-without-catch",
+    severity: "warning",
+    check: (scope) => scope.catchesAnyError
+        ? []
+        : scope.nodes
+            .filter((node) => node.errorThrows.some((error) => !scope.caughtErrors.includes(error)))
+            .map((node) => ({
+            rule: "error-throw-without-catch",
+            severity: "warning",
+            node: node.id,
+            message: "error end event references an error that no boundary event or event sub-process start event in the document catches",
+        })),
+};

package/dist/analyze/rules/escalation-catch.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const escalationCatchRule: Rule;

package/dist/analyze/rules/escalation-catch.js

@@ -0,0 +1,14 @@
+export const escalationCatchRule = {
+    id: "escalation-throw-without-catch",
+    severity: "warning",
+    check: (scope) => scope.catchesAnyEscalation
+        ? []
+        : scope.nodes
+            .filter((node) => node.escalationThrows.some((escalation) => !scope.caughtEscalations.includes(escalation)))
+            .map((node) => ({
+            rule: "escalation-throw-without-catch",
+            severity: "warning",
+            node: node.id,
+            message: "escalation throw event references an escalation that no boundary event or event sub-process start event in the document catches",
+        })),
+};

package/dist/analyze/rules/gateway-cardinality.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "./rule.ts";
+export declare const gatewayDivergingRule: Rule;
+export declare const gatewayConvergingRule: Rule;

package/dist/analyze/rules/gateway-cardinality.js

@@ -0,0 +1,17 @@
+import { bpmn } from "../scope-graph.js";
+export const gatewayDivergingRule = {
+    id: "gateway-diverging-too-few-outgoing",
+    severity: "error",
+    check: (scope) => scope.nodes
+        .filter((node) => node.direction === bpmn("Diverging"))
+        .filter((node) => scope.flows.filter((flow) => flow.source === node.id).length < 2)
+        .map((node) => ({ rule: "gateway-diverging-too-few-outgoing", severity: "error", node: node.id, message: "diverging gateway has fewer than two outgoing flows" })),
+};
+export const gatewayConvergingRule = {
+    id: "gateway-converging-too-few-incoming",
+    severity: "error",
+    check: (scope) => scope.nodes
+        .filter((node) => node.direction === bpmn("Converging"))
+        .filter((node) => scope.flows.filter((flow) => flow.target === node.id).length < 2)
+        .map((node) => ({ rule: "gateway-converging-too-few-incoming", severity: "error", node: node.id, message: "converging gateway has fewer than two incoming flows" })),
+};

package/dist/analyze/rules/index.d.ts

@@ -0,0 +1,4 @@
+import { type Severity } from "../findings.ts";
+import type { Rule } from "./rule.ts";
+export declare const rules: Rule[];
+export declare const findingSeverities: () => Record<string, Severity>;

package/dist/analyze/rules/index.js

@@ -0,0 +1,21 @@
+import { STRUCTURAL_RULE } from "../findings.js";
+import { adHocCompletionConditionRule } from "./ad-hoc-completion-condition.js";
+import { cannotReachEndRule } from "./cannot-reach-end.js";
+import { compensationAssociationRule } from "./compensation-association.js";
+import { deadEndRule } from "./dead-end.js";
+import { endEventRule } from "./end-event.js";
+import { errorCatchRule } from "./error-catch.js";
+import { escalationCatchRule } from "./escalation-catch.js";
+import { gatewayConvergingRule, gatewayDivergingRule } from "./gateway-cardinality.js";
+import { instantiatingGatewayRule } from "./instantiating-gateway.js";
+import { nonInterruptingStartRule } from "./non-interrupting-start.js";
+import { reachabilityRule } from "./reachability.js";
+import { signalCatchRule } from "./signal-catch.js";
+import { startEventRule } from "./start-event.js";
+import { taskMessageFlowRule } from "./task-message-flow.js";
+import { splitJoinFindingIds, splitJoinPairingRule } from "./split-join-pairing.js";
+export const rules = [startEventRule, endEventRule, gatewayDivergingRule, gatewayConvergingRule, reachabilityRule, deadEndRule, cannotReachEndRule, splitJoinPairingRule, nonInterruptingStartRule, instantiatingGatewayRule, adHocCompletionConditionRule, compensationAssociationRule, taskMessageFlowRule, signalCatchRule, errorCatchRule, escalationCatchRule];
+export const findingSeverities = () => ({
+    [STRUCTURAL_RULE]: "error",
+    ...Object.fromEntries(rules.flatMap((rule) => (rule === splitJoinPairingRule ? splitJoinFindingIds : [rule.id]).map((id) => [id, rule.severity]))),
+});

package/dist/analyze/rules/instantiating-gateway.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const instantiatingGatewayRule: Rule;

package/dist/analyze/rules/instantiating-gateway.js

@@ -0,0 +1,14 @@
+import { hasType } from "../scope-graph.js";
+export const instantiatingGatewayRule = {
+    id: "instantiating-gateway-with-incoming-flow",
+    severity: "error",
+    check: (scope) => scope.nodes
+        .filter((node) => node.instantiating && hasType(node, "EventBasedGateway"))
+        .filter((node) => scope.flows.some((flow) => flow.target === node.id))
+        .map((node) => ({
+        rule: "instantiating-gateway-with-incoming-flow",
+        severity: "error",
+        node: node.id,
+        message: "instantiating event-based gateway has an incoming sequence flow, but it starts the process and must have none",
+    })),
+};

package/dist/analyze/rules/non-interrupting-start.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const nonInterruptingStartRule: Rule;

package/dist/analyze/rules/non-interrupting-start.js

@@ -0,0 +1,14 @@
+export const nonInterruptingStartRule = {
+    id: "non-interrupting-start-outside-event-sub-process",
+    severity: "warning",
+    check: (scope) => scope.eventSubProcess
+        ? []
+        : scope.nodes
+            .filter((node) => node.nonInterrupting)
+            .map((node) => ({
+            rule: "non-interrupting-start-outside-event-sub-process",
+            severity: "warning",
+            node: node.id,
+            message: "start event is non-interrupting but is not in an event sub-process, so isInterrupting has no effect",
+        })),
+};

package/dist/analyze/rules/reachability.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const reachabilityRule: Rule;

package/dist/analyze/rules/reachability.js

@@ -0,0 +1,25 @@
+import { hasType } from "../scope-graph.js";
+export const reachabilityRule = {
+    id: "node-unreachable",
+    severity: "warning",
+    check: (scope) => {
+        if (scope.adHoc || !scope.nodes.some((node) => hasType(node, "StartEvent")))
+            return [];
+        const reached = new Set(scope.nodes.filter((node) => node.exempt || hasType(node, "StartEvent")).map((node) => node.id));
+        const queue = [...reached];
+        const visit = (id) => {
+            if (!reached.has(id)) {
+                reached.add(id);
+                queue.push(id);
+            }
+        };
+        while (queue.length > 0) {
+            const current = queue.shift();
+            scope.flows.filter((flow) => flow.source === current && flow.target !== null).forEach((flow) => visit(flow.target));
+            scope.nodes.filter((node) => node.attachedTo === current).forEach((node) => visit(node.id));
+        }
+        return scope.nodes
+            .filter((node) => !reached.has(node.id))
+            .map((node) => ({ rule: "node-unreachable", severity: "warning", node: node.id, message: "flow node is not reachable from a start event" }));
+    },
+};

package/dist/analyze/rules/rule.d.ts

@@ -0,0 +1,7 @@
+import type { Finding, Severity } from "../findings.ts";
+import type { Scope } from "../scope-graph.ts";
+export interface Rule {
+    id: string;
+    severity: Severity;
+    check: (scope: Scope) => Finding[];
+}

package/dist/analyze/rules/rule.js

@@ -0,0 +1 @@
+export {};

package/dist/analyze/rules/signal-catch.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const signalCatchRule: Rule;

package/dist/analyze/rules/signal-catch.js

@@ -0,0 +1,12 @@
+export const signalCatchRule = {
+    id: "signal-throw-without-catch",
+    severity: "warning",
+    check: (scope) => scope.nodes
+        .filter((node) => node.signalThrows.some((signal) => !scope.caughtSignals.includes(signal)))
+        .map((node) => ({
+        rule: "signal-throw-without-catch",
+        severity: "warning",
+        node: node.id,
+        message: "signal throw event references a signal that no start, intermediate catch or boundary event in the document catches",
+    })),
+};

package/dist/analyze/rules/split-join-pairing.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "./rule.ts";
+export declare const splitJoinFindingIds: string[];
+export declare const splitJoinPairingRule: Rule;

package/dist/analyze/rules/split-join-pairing.js

@@ -0,0 +1,50 @@
+import { bpmn, hasType } from "../scope-graph.js";
+const MISMATCHES = [
+    { split: "ExclusiveGateway", join: "ParallelGateway", rule: "split-join-exclusive-to-parallel", message: "exclusive split is merged by a parallel join, which may deadlock" },
+    { split: "ParallelGateway", join: "ExclusiveGateway", rule: "split-join-parallel-to-exclusive", message: "parallel split is merged by an exclusive join, which may activate the flow more than once" },
+];
+export const splitJoinFindingIds = MISMATCHES.map((mismatch) => mismatch.rule);
+const successors = (scope) => {
+    const next = new Map();
+    for (const flow of scope.flows) {
+        if (flow.source !== null && flow.target !== null)
+            next.set(flow.source, [...(next.get(flow.source) ?? []), flow.target]);
+    }
+    return next;
+};
+const reachableFrom = (start, split, next) => {
+    const seen = new Set();
+    const queue = [start];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (id === split || seen.has(id))
+            continue;
+        seen.add(id);
+        queue.push(...(next.get(id) ?? []));
+    }
+    return seen;
+};
+const nearestJoins = (scope, splitId, next) => {
+    const branches = (next.get(splitId) ?? []).map((start) => reachableFrom(start, splitId, next));
+    const merged = scope.nodes.filter((node) => node.direction === bpmn("Converging") && branches.filter((branch) => branch.has(node.id)).length >= 2);
+    const mergedIds = new Set(merged.map((node) => node.id));
+    const downstream = (id) => reachableFrom(id, splitId, next);
+    return merged.filter((node) => ![...mergedIds].some((other) => other !== node.id && downstream(other).has(node.id) && !downstream(node.id).has(other)));
+};
+export const splitJoinPairingRule = {
+    id: "split-join-pairing-mismatch",
+    severity: "warning",
+    check: (scope) => {
+        const next = successors(scope);
+        const found = new Map();
+        for (const split of scope.nodes.filter((node) => node.direction === bpmn("Diverging"))) {
+            for (const join of nearestJoins(scope, split.id, next)) {
+                for (const mismatch of MISMATCHES) {
+                    if (hasType(split, mismatch.split) && hasType(join, mismatch.join))
+                        found.set(`${mismatch.rule}|${join.id}`, { rule: mismatch.rule, message: mismatch.message, node: join.id });
+                }
+            }
+        }
+        return [...found.values()].map((entry) => ({ ...entry, severity: "warning" }));
+    },
+};

package/dist/analyze/rules/start-event.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const startEventRule: Rule;

package/dist/analyze/rules/start-event.js

@@ -0,0 +1,8 @@
+import { hasType, isPlaceholder } from "../scope-graph.js";
+export const startEventRule = {
+    id: "start-event-missing",
+    severity: "error",
+    check: (scope) => isPlaceholder(scope) || scope.adHoc || scope.nodes.some((node) => node.instantiating) || scope.nodes.some((node) => hasType(node, "StartEvent"))
+        ? []
+        : [{ rule: "start-event-missing", severity: "error", node: scope.id, message: `${scope.kind === "process" ? "process" : "sub-process"} has no start event` }],
+};

package/dist/analyze/rules/task-message-flow.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "./rule.ts";
+export declare const taskMessageFlowRule: Rule;

package/dist/analyze/rules/task-message-flow.js

@@ -0,0 +1,19 @@
+import { hasType } from "../scope-graph.js";
+export const taskMessageFlowRule = {
+    id: "task-message-without-message-flow",
+    severity: "warning",
+    check: (scope) => scope.nodes
+        .filter((node) => node.messageRef !== null && (hasType(node, "SendTask") || hasType(node, "ReceiveTask")))
+        .filter((node) => {
+        const sends = hasType(node, "SendTask");
+        return !scope.messageFlows.some((messageFlow) => (sends ? messageFlow.source : messageFlow.target) === node.id && (messageFlow.messageRef === null || messageFlow.messageRef === node.messageRef));
+    })
+        .map((node) => ({
+        rule: "task-message-without-message-flow",
+        severity: "warning",
+        node: node.id,
+        message: hasType(node, "SendTask")
+            ? "send task references a message but no message flow that leaves it carries that message"
+            : "receive task references a message but no message flow that enters it carries that message",
+    })),
+};

package/dist/analyze/scope-graph.d.ts

@@ -0,0 +1,56 @@
+import type { Store } from "n3";
+import type { Node } from "../validate.ts";
+export interface FlowNode {
+    id: string;
+    types: string[];
+    attachedTo: string | null;
+    direction: string | null;
+    exempt: boolean;
+    forCompensation: boolean;
+    compensationBoundary: boolean;
+    nonInterrupting: boolean;
+    instantiating: boolean;
+    messageRef: string | null;
+    signalThrows: string[];
+    errorThrows: string[];
+    escalationThrows: string[];
+}
+export interface MessageFlow {
+    id: string;
+    source: string | null;
+    target: string | null;
+    messageRef: string | null;
+}
+export interface SequenceFlow {
+    id: string;
+    source: string | null;
+    target: string | null;
+}
+export interface Association {
+    id: string;
+    source: string | null;
+    target: string | null;
+}
+export type ScopeKind = "process" | "subProcess";
+export interface Scope {
+    id: string;
+    kind: ScopeKind;
+    parent: string | null;
+    eventSubProcess: boolean;
+    adHoc: boolean;
+    completionCondition: boolean;
+    participant: string | null;
+    nodes: FlowNode[];
+    flows: SequenceFlow[];
+    associations: Association[];
+    messageFlows: MessageFlow[];
+    caughtSignals: string[];
+    caughtErrors: string[];
+    catchesAnyError: boolean;
+    caughtEscalations: string[];
+    catchesAnyEscalation: boolean;
+}
+export declare const isPlaceholder: (scope: Scope) => boolean;
+export declare const bpmn: (name: string) => string;
+export declare const hasType: (node: FlowNode, name: string) => boolean;
+export declare const buildScopes: (expanded: Node[], store?: Store) => Scope[];

package/dist/analyze/scope-graph.js

@@ -0,0 +1,89 @@
+import { BPMN_NAMESPACE } from "../namespace.js";
+import { isSubClassOf, loadOntology } from "../ontology.js";
+export const isPlaceholder = (scope) => scope.kind === "subProcess" && scope.nodes.length === 0;
+export const bpmn = (name) => `${BPMN_NAMESPACE}${name}`;
+export const hasType = (node, name) => node.types.includes(bpmn(name));
+const valuesOf = (value) => value.flatMap((v) => ("@list" in v ? v["@list"] : [v]));
+const indexNode = (node, index) => {
+    const id = node["@id"];
+    const entry = id === undefined ? undefined : (index.get(id) ?? { types: new Set(), properties: new Map() });
+    if (id !== undefined && entry !== undefined)
+        index.set(id, entry);
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "@type")
+            value.forEach((t) => entry?.types.add(t));
+        else if (!key.startsWith("@")) {
+            const members = valuesOf(value);
+            entry?.properties.set(key, [...(entry.properties.get(key) ?? []), ...members]);
+            members.filter((m) => !("@value" in m)).forEach((m) => indexNode(m, index));
+        }
+    }
+};
+const hasEventDefinition = (entry, definition) => (entry.properties.get(bpmn("eventDefinitions")) ?? []).some((candidate) => (candidate["@type"] ?? []).includes(bpmn(definition)));
+const definitionsOf = (entry, definition) => (entry.properties.get(bpmn("eventDefinitions")) ?? []).filter((candidate) => (candidate["@type"] ?? []).includes(bpmn(definition)));
+const definitionRefs = (definition, property) => (definition[bpmn(property)] ?? []).flatMap((ref) => (typeof ref["@id"] === "string" ? [ref["@id"]] : []));
+const signalRefsOf = (entry) => definitionsOf(entry, "SignalEventDefinition").flatMap((definition) => definitionRefs(definition, "signalRef"));
+const errorRefsOf = (entry) => definitionsOf(entry, "ErrorEventDefinition").flatMap((definition) => definitionRefs(definition, "errorRef"));
+const escalationRefsOf = (entry) => definitionsOf(entry, "EscalationEventDefinition").flatMap((definition) => definitionRefs(definition, "escalationRef"));
+const EXEMPT_EVENT_DEFINITIONS = [bpmn("LinkEventDefinition"), bpmn("SignalEventDefinition")];
+const flagOf = (entry, property) => (entry.properties.get(bpmn(property)) ?? []).some((m) => m["@value"] === true);
+const refsOf = (entry, property) => (entry?.properties.get(bpmn(property)) ?? []).flatMap((m) => (typeof m["@id"] === "string" ? [m["@id"]] : []));
+export const buildScopes = (expanded, store = loadOntology()) => {
+    const index = new Map();
+    expanded.forEach((node) => indexNode(node, index));
+    const isA = (entry, name) => [...entry.types].some((t) => isSubClassOf(store, t, bpmn(name)));
+    const isExempt = (member) => flagOf(member, "isForCompensation") ||
+        flagOf(member, "triggeredByEvent") ||
+        (isA(member, "BoundaryEvent") && hasEventDefinition(member, "CompensateEventDefinition")) ||
+        (isA(member, "CatchEvent") &&
+            !isA(member, "BoundaryEvent") &&
+            (member.properties.get(bpmn("eventDefinitions")) ?? []).some((definition) => (definition["@type"] ?? []).some((t) => EXEMPT_EVENT_DEFINITIONS.includes(t))));
+    const participants = new Map();
+    for (const [id, entry] of index) {
+        if (isA(entry, "Participant"))
+            refsOf(entry, "processRef").forEach((processId) => participants.set(processId, id));
+    }
+    const messageFlows = [];
+    for (const [id, entry] of index) {
+        if (isA(entry, "MessageFlow")) {
+            messageFlows.push({ id, source: refsOf(entry, "sourceRef")[0] ?? null, target: refsOf(entry, "targetRef")[0] ?? null, messageRef: refsOf(entry, "messageRef")[0] ?? null });
+        }
+    }
+    const caughtSignals = [...new Set([...index.values()].filter((entry) => isA(entry, "CatchEvent")).flatMap(signalRefsOf))];
+    const catchEvents = [...index.values()].filter((entry) => isA(entry, "BoundaryEvent") || isA(entry, "StartEvent"));
+    const caughtErrors = [...new Set(catchEvents.flatMap(errorRefsOf))];
+    const catchesAnyError = catchEvents.some((entry) => definitionsOf(entry, "ErrorEventDefinition").some((definition) => definitionRefs(definition, "errorRef").length === 0));
+    const caughtEscalations = [...new Set(catchEvents.flatMap(escalationRefsOf))];
+    const catchesAnyEscalation = catchEvents.some((entry) => definitionsOf(entry, "EscalationEventDefinition").some((definition) => definitionRefs(definition, "escalationRef").length === 0));
+    const scopes = [];
+    const addScope = (id, entry, kind, parent) => {
+        const scope = { id, kind, parent, eventSubProcess: flagOf(entry, "triggeredByEvent"), adHoc: isA(entry, "AdHocSubProcess"), completionCondition: (entry.properties.get(bpmn("completionCondition")) ?? []).length > 0, participant: participants.get(id) ?? null, nodes: [], flows: [], associations: [], messageFlows, caughtSignals, caughtErrors, catchesAnyError, caughtEscalations, catchesAnyEscalation };
+        scopes.push(scope);
+        const subProcesses = [];
+        for (const artifactId of refsOf(entry, "artifacts")) {
+            const artifact = index.get(artifactId);
+            if (artifact !== undefined && isA(artifact, "Association")) {
+                scope.associations.push({ id: artifactId, source: refsOf(artifact, "sourceRef")[0] ?? null, target: refsOf(artifact, "targetRef")[0] ?? null });
+            }
+        }
+        for (const memberId of refsOf(entry, "flowElements")) {
+            const member = index.get(memberId);
+            if (member === undefined)
+                continue;
+            if (isA(member, "SequenceFlow")) {
+                scope.flows.push({ id: memberId, source: refsOf(member, "sourceRef")[0] ?? null, target: refsOf(member, "targetRef")[0] ?? null });
+            }
+            else if (isA(member, "FlowNode")) {
+                scope.nodes.push({ id: memberId, types: [...member.types], attachedTo: refsOf(member, "attachedToRef")[0] ?? null, direction: refsOf(member, "gatewayDirection")[0] ?? null, exempt: isExempt(member), forCompensation: flagOf(member, "isForCompensation"), compensationBoundary: isA(member, "BoundaryEvent") && hasEventDefinition(member, "CompensateEventDefinition"), nonInterrupting: isA(member, "StartEvent") && (member.properties.get(bpmn("isInterrupting")) ?? []).some((m) => m["@value"] === false), instantiating: flagOf(member, "instantiate"), messageRef: refsOf(member, "messageRef")[0] ?? null, signalThrows: isA(member, "ThrowEvent") ? signalRefsOf(member) : [], errorThrows: isA(member, "EndEvent") ? errorRefsOf(member) : [], escalationThrows: isA(member, "ThrowEvent") ? escalationRefsOf(member) : [] });
+                if (isA(member, "SubProcess"))
+                    subProcesses.push([memberId, member]);
+            }
+        }
+        subProcesses.forEach(([subId, sub]) => addScope(subId, sub, "subProcess", id));
+    };
+    for (const [id, entry] of index) {
+        if (isA(entry, "Process"))
+            addScope(id, entry, "process", null);
+    }
+    return scopes;
+};

package/dist/analyze-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/analyze-cli.js

@@ -0,0 +1,5 @@
+import { runAnalyze } from "./analyze-run.js";
+const { exitCode, stdout, stderr } = await runAnalyze(process.argv.slice(2));
+process.stdout.write(stdout);
+process.stderr.write(stderr);
+process.exitCode = exitCode;

package/dist/analyze-run.d.ts

@@ -0,0 +1,12 @@
+import type { Finding } from "./analyze/findings.ts";
+export declare const EXIT_OK = 0;
+export declare const EXIT_FINDINGS = 1;
+export declare const EXIT_INPUT = 2;
+export declare const exitCodeFor: (findings: Finding[]) => number;
+export interface CliResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export declare const USAGE = "Usage: analyze <file.jsonld> [options]\n\nAnalyzes a BPMN-LD document and reports process-level findings.\n\nOptions:\n      --format <text|json>  Output format (default: text)\n  -h, --help                Show this help\n\nExit codes:\n  0  No findings, or warnings only\n  1  At least one error finding\n  2  Usage error or unusable input (missing file, invalid JSON)\n";
+export declare const runAnalyze: (argv: string[]) => Promise<CliResult>;

package/dist/analyze-run.js

@@ -0,0 +1,85 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { analyze } from "./analyze/analyze.js";
+import { formatJson, formatText } from "./analyze/report.js";
+export const EXIT_OK = 0;
+export const EXIT_FINDINGS = 1;
+export const EXIT_INPUT = 2;
+export const exitCodeFor = (findings) => (findings.some((f) => f.severity === "error") ? EXIT_FINDINGS : EXIT_OK);
+export const USAGE = `Usage: analyze <file.jsonld> [options]
+
+Analyzes a BPMN-LD document and reports process-level findings.
+
+Options:
+      --format <text|json>  Output format (default: text)
+  -h, --help                Show this help
+
+Exit codes:
+  0  No findings, or warnings only
+  1  At least one error finding
+  2  Usage error or unusable input (missing file, invalid JSON)
+`;
+class UsageError extends Error {
+}
+const parseArgs = (argv) => {
+    const options = { input: "", format: "text" };
+    let input;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "-h" || arg === "--help")
+            return "help";
+        else if (arg === "--format") {
+            const value = argv[++i];
+            if (value !== "text" && value !== "json")
+                throw new UsageError("--format requires text or json");
+            options.format = value;
+        }
+        else if (arg.startsWith("-"))
+            throw new UsageError(`unknown option ${arg}`);
+        else if (input !== undefined)
+            throw new UsageError(`unexpected extra argument ${arg}`);
+        else
+            input = arg;
+    }
+    if (input === undefined)
+        throw new UsageError("missing input file");
+    options.input = input;
+    return options;
+};
+const failure = (message, usage = false) => ({
+    exitCode: EXIT_INPUT,
+    stdout: "",
+    stderr: `error: ${message}\n${usage ? `\n${USAGE}` : ""}`,
+});
+export const runAnalyze = async (argv) => {
+    let options;
+    try {
+        options = parseArgs(argv);
+    }
+    catch (error) {
+        if (error instanceof UsageError)
+            return failure(error.message, true);
+        throw error;
+    }
+    if (options === "help")
+        return { exitCode: EXIT_OK, stdout: USAGE, stderr: "" };
+    let text;
+    try {
+        text = readFileSync(options.input, "utf8");
+    }
+    catch (error) {
+        const reason = error.code === "ENOENT" ? "no such file" : error.message;
+        return failure(`cannot read ${options.input}: ${reason}`);
+    }
+    let document;
+    try {
+        document = JSON.parse(text);
+    }
+    catch (error) {
+        return failure(`${options.input} is not valid JSON: ${error.message}`);
+    }
+    const findings = await analyze(document, pathToFileURL(resolve(options.input)).href);
+    const stdout = options.format === "json" ? formatJson(findings) : formatText(findings);
+    return { exitCode: exitCodeFor(findings), stdout, stderr: "" };
+};

package/dist/bpmn-ld-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};