@miragon/design-iq-validator 5.0.0-rc.0

package/dist/content-BoFksK67.js

@@ -0,0 +1,994 @@
+import { readFileSync, statSync } from "node:fs";
+import { join, posix, relative } from "node:path";
+import { readdir } from "node:fs/promises";
+import { parse } from "yaml";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+//#region ../notations/index.ts
+const NOTATIONS = [
+	{
+		id: "bpmn",
+		label: "BPMN 2.0",
+		noun: {
+			singular: "process",
+			plural: "processes"
+		},
+		extensions: [".bpmn"],
+		mediaKind: "xml",
+		docShape: "text",
+		monacoLanguage: "xml",
+		graphHints: {
+			flowEdgeKinds: ["sequenceFlow"],
+			entryNodeTypes: ["startEvent"]
+		}
+	},
+	{
+		id: "dmn",
+		label: "DMN",
+		noun: {
+			singular: "decision",
+			plural: "decisions"
+		},
+		extensions: [".dmn"],
+		mediaKind: "xml",
+		docShape: "text",
+		monacoLanguage: "xml",
+		graphHints: {
+			flowEdgeKinds: ["informationRequirement"],
+			entryNodeTypes: []
+		}
+	},
+	{
+		id: "wardley",
+		label: "Wardley Map",
+		noun: {
+			singular: "wardley map",
+			plural: "wardley maps"
+		},
+		extensions: [".owm", ".wmap"],
+		mediaKind: "dsl",
+		docShape: "text",
+		monacoLanguage: "plaintext",
+		graphHints: {
+			flowEdgeKinds: ["dependency"],
+			entryNodeTypes: []
+		}
+	},
+	{
+		id: "team-topology",
+		label: "Team Topology",
+		noun: {
+			singular: "team topology",
+			plural: "team topologies"
+		},
+		extensions: [".tt", ".ttm.json"],
+		mediaKind: "json",
+		docShape: "text",
+		monacoLanguage: "json"
+	},
+	{
+		id: "event-storming",
+		label: "Event Storming",
+		noun: {
+			singular: "event storming board",
+			plural: "event storming boards"
+		},
+		extensions: [".storm"],
+		mediaKind: "dsl",
+		docShape: "text",
+		monacoLanguage: "plaintext",
+		graphHints: {
+			flowEdgeKinds: ["arrow"],
+			entryNodeTypes: []
+		}
+	},
+	{
+		id: "context-map",
+		label: "Context Map",
+		noun: {
+			singular: "context map",
+			plural: "context maps"
+		},
+		extensions: [".cm.json"],
+		mediaKind: "json",
+		docShape: "text",
+		monacoLanguage: "json",
+		graphHints: {
+			flowEdgeKinds: [
+				"partnership",
+				"shared-kernel",
+				"customer-supplier",
+				"upstream-downstream",
+				"separate-ways"
+			],
+			entryNodeTypes: []
+		}
+	},
+	{
+		id: "value-chain",
+		label: "Value Chain",
+		noun: {
+			singular: "value chain",
+			plural: "value chains"
+		},
+		extensions: [".vc.json"],
+		mediaKind: "json",
+		docShape: "text",
+		monacoLanguage: "json"
+	},
+	{
+		id: "markdown",
+		label: "Markdown",
+		noun: {
+			singular: "document",
+			plural: "documents"
+		},
+		extensions: [".md"],
+		mediaKind: "markdown",
+		docShape: "text",
+		monacoLanguage: "markdown"
+	}
+];
+function byId(id) {
+	return NOTATIONS.find((n) => n.id === id);
+}
+/** longest-suffix winner across every registered extension, so ".vc.json"
+*  beats a hypothetical ".json" — shared by byExtension and modelStem */
+function longestMatch(path) {
+	let best;
+	for (const n of NOTATIONS) for (const ext of n.extensions) if (path.endsWith(ext) && ext.length > (best?.ext.length ?? 0)) best = {
+		notation: n,
+		ext
+	};
+	return best;
+}
+function byExtension(path) {
+	return longestMatch(path)?.notation;
+}
+/**
+* The file stem that IS a model's id (the content contract: a process is its
+* .bpmn file, a decision its .dmn file). Strips the FULL registered extension,
+* so compound suffixes resolve correctly ("a.vc.json" → "a", never "a.vc");
+* unknown extensions fall back to stripping the final dot-suffix.
+*/
+function modelStem(path) {
+	const base = path.split("/").pop() ?? path;
+	const ext = longestMatch(base)?.ext;
+	return ext ? base.slice(0, -ext.length) : base.replace(/\.[^.]+$/, "");
+}
+[...NOTATIONS.flatMap((n) => n.extensions)];
+//#endregion
+//#region ../notations/bpmn-kinds.ts
+const BPMN_ELEMENT_KIND = /* @__PURE__ */ new Map([
+	["task", "activity"],
+	["userTask", "activity"],
+	["serviceTask", "activity"],
+	["scriptTask", "activity"],
+	["businessRuleTask", "activity"],
+	["manualTask", "activity"],
+	["sendTask", "activity"],
+	["receiveTask", "activity"],
+	["callActivity", "activity"],
+	["subProcess", "activity"],
+	["adHocSubProcess", "activity"],
+	["transaction", "activity"],
+	["startEvent", "event"],
+	["endEvent", "event"],
+	["intermediateThrowEvent", "event"],
+	["intermediateCatchEvent", "event"],
+	["boundaryEvent", "event"],
+	["exclusiveGateway", "gateway"],
+	["parallelGateway", "gateway"],
+	["inclusiveGateway", "gateway"],
+	["eventBasedGateway", "gateway"],
+	["complexGateway", "gateway"]
+]);
+/** the kind of a flow-node tag; undefined = not a flow node (artifact, lane, …) */
+const kindOf = (tag) => BPMN_ELEMENT_KIND.get(tag);
+/** every flow-node tag — everything else (textAnnotation, dataObject, …) is a
+*  legal artifact but NOT a flow node; treating it as one produces false
+*  "unreachable"/"dead end" errors on perfectly valid models */
+const BPMN_FLOW_NODE_TAGS = new Set(BPMN_ELEMENT_KIND.keys());
+/** container tags whose children form their own flow graph */
+const BPMN_SUB_CONTAINER_TAGS = /* @__PURE__ */ new Set([
+	"subProcess",
+	"adHocSubProcess",
+	"transaction"
+]);
+/** non-flow-node artifacts that still need a BPMNDI shape/edge to render.
+*  Exactly these five: plain `dataObject` is deliberately ABSENT — bpmn-js
+*  draws the dataObjectReference, not the dataObject; requiring DI for the
+*  latter would false-error every model with one. */
+const BPMN_DI_ARTIFACT_TAGS = /* @__PURE__ */ new Set([
+	"textAnnotation",
+	"association",
+	"dataObjectReference",
+	"dataStoreReference",
+	"group"
+]);
+//#endregion
+//#region ../notations/extract.ts
+/**
+* extract(raw) => ModelGraph — the analysis seam of the notation registry.
+*
+* Every notation knows how to turn its raw file content into ONE generic
+* graph shape. Analyses (MCP tools, future dashboards) are written against
+* ModelGraph and automatically cover every notation that implements extract —
+* instead of one parser per tool per notation.
+*
+* Node-safe: fast-xml-parser + JSON + regex only, no DOM, no editor libraries.
+*/
+const xml = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	removeNSPrefix: true
+});
+/** the ONE fast-xml-parser configuration (the validator used to carry a
+*  byte-identical copy — that is how the two BPMN walks drifted) */
+const parseXml = (raw) => xml.parse(raw);
+const asArray = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+/**
+* The decision a businessRuleTask delegates to. BPMN 2.0 has no standard
+* attribute for it, so every engine invented its own — all of them are read
+* here (namespace prefixes are already stripped by the parser):
+*
+*   decisionRef="x"                              Camunda 7
+*   <extensionElements><calledDecision decisionId="x"/>   Camunda 8 / Zeebe
+*   calledDecision="x" / calledElement="x"       hand-written models
+*
+* The platform contract is the same as for callActivity: the value names the
+* DECISION FILE STEM, so the link resolves against the repo's .dmn files.
+*
+* Exported as THE spelling list: the validator's link-integrity check must
+* read exactly what the platform follows, or a spelling becomes a link that
+* get_process reports and no check ever verifies (that drift shipped once).
+*/
+function decisionRefOf(task) {
+	const called = task.extensionElements?.calledDecision;
+	const fromExtension = asArray(called)[0]?.["@_decisionId"];
+	const ref = task["@_decisionRef"] ?? fromExtension ?? task["@_calledDecision"] ?? task["@_calledElement"] ?? void 0;
+	const text = ref === void 0 || ref === null ? "" : String(ref).trim();
+	return text === "" ? void 0 : text;
+}
+/** parse-tree in (parseXml(raw).definitions), the shared model out */
+function readBpmn(defs) {
+	const model = {
+		containers: [],
+		nodes: [],
+		flows: [],
+		diRequired: /* @__PURE__ */ new Set(),
+		lanes: [],
+		collaborations: []
+	};
+	const walk = (el, label, id, isSubProcess) => {
+		const container = {
+			label,
+			id,
+			isSubProcess,
+			triggeredByEvent: String(el["@_triggeredByEvent"]) === "true",
+			nodes: /* @__PURE__ */ new Map(),
+			flows: []
+		};
+		model.containers.push(container);
+		for (const [tag, value] of Object.entries(el)) {
+			if (tag.startsWith("@_")) continue;
+			if (tag === "sequenceFlow") {
+				for (const f of asArray(value)) {
+					const flow = {
+						id: f["@_id"] ?? "",
+						from: f["@_sourceRef"] ?? "",
+						to: f["@_targetRef"] ?? "",
+						name: f["@_name"]
+					};
+					container.flows.push(flow);
+					model.flows.push(flow);
+					if (f["@_id"]) model.diRequired.add(f["@_id"]);
+				}
+				continue;
+			}
+			if (BPMN_FLOW_NODE_TAGS.has(tag)) {
+				for (const node of asArray(value)) {
+					const rec = node;
+					const nodeId = rec["@_id"];
+					if (!nodeId) continue;
+					const decisionRef = tag === "businessRuleTask" ? decisionRefOf(node) : void 0;
+					const entry = {
+						id: nodeId,
+						tag,
+						name: rec["@_name"],
+						...rec["@_attachedToRef"] !== void 0 ? { attachedTo: rec["@_attachedToRef"] } : {},
+						...rec["@_calledElement"] !== void 0 ? { calledElement: rec["@_calledElement"] } : {},
+						...decisionRef ? { decisionRef } : {},
+						container
+					};
+					model.nodes.push(entry);
+					container.nodes.set(nodeId, entry);
+					model.diRequired.add(nodeId);
+					if (BPMN_SUB_CONTAINER_TAGS.has(tag)) walk(node, `${tag} ${nodeId}`, nodeId, true);
+				}
+				continue;
+			}
+			if (BPMN_DI_ARTIFACT_TAGS.has(tag)) {
+				for (const node of asArray(value)) if (node["@_id"]) model.diRequired.add(node["@_id"]);
+			}
+		}
+	};
+	let processIndex = 0;
+	for (const proc of asArray(defs.process)) {
+		const rec = proc;
+		const pid = rec["@_id"];
+		walk(proc, `process ${pid ?? "(anonymous)"}`, pid, false);
+		for (const lane of asArray(rec.laneSet?.lane)) model.lanes.push({
+			id: lane["@_id"],
+			name: lane["@_name"],
+			nodeIds: asArray(lane.flowNodeRef).map(String),
+			processIndex
+		});
+		processIndex++;
+	}
+	for (const collab of asArray(defs.collaboration)) {
+		const rec = collab;
+		model.collaborations.push({
+			pools: asArray(rec.participant).map((pl) => ({
+				id: pl["@_id"],
+				name: pl["@_name"],
+				processRef: pl["@_processRef"]
+			})),
+			messageFlows: asArray(rec.messageFlow).map((mf) => ({
+				id: mf["@_id"],
+				from: mf["@_sourceRef"],
+				to: mf["@_targetRef"],
+				name: mf["@_name"]
+			}))
+		});
+	}
+	return model;
+}
+function extractBpmn(raw) {
+	const model = readBpmn(parseXml(raw).definitions ?? {});
+	const nodes = model.nodes.map((n) => ({
+		id: n.id,
+		type: n.tag,
+		name: n.name,
+		extra: {
+			...n.container.isSubProcess && n.container.id ? { parent: n.container.id } : {},
+			...n.calledElement ? { calledElement: n.calledElement } : {},
+			...n.attachedTo ? { attachedTo: n.attachedTo } : {},
+			...n.decisionRef ? { decisionRef: n.decisionRef } : {}
+		}
+	}));
+	const edges = model.flows.map((f) => ({
+		id: f.id,
+		from: f.from,
+		to: f.to,
+		kind: "sequenceFlow",
+		name: f.name
+	}));
+	for (const collab of model.collaborations) for (const mf of collab.messageFlows) edges.push({
+		id: mf.id ?? "",
+		from: mf.from ?? "",
+		to: mf.to ?? "",
+		kind: "messageFlow",
+		name: mf.name
+	});
+	return {
+		notation: "bpmn",
+		nodes,
+		edges,
+		meta: {
+			lanes: model.lanes.map((l) => ({
+				id: l.id,
+				name: l.name,
+				nodeIds: l.nodeIds
+			})),
+			pools: model.collaborations.flatMap((c) => c.pools.map((pl) => ({
+				id: pl.id ?? "",
+				name: pl.name ?? "",
+				processRef: pl.processRef ?? ""
+			})))
+		}
+	};
+}
+/**
+* A tag's text content as a STRING. fast-xml-parser coerces tag values
+* ("42" → 42, "true" → true), but every DMN entry is FEEL SOURCE TEXT — a
+* rule entry `1` must stay the literal "1", never the number. Empty and
+* self-closing tags collapse to "" (an empty entry means "any" in DMN).
+*/
+function textOf(value) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") return textOf(value["#text"]);
+	return String(value);
+}
+/**
+* The target of an informationRequirement — requiredInput/requiredDecision,
+* in that lookup order. THE spelling pair (it was byte-identical in the
+* validator, the decisionRefOf duplication class): `local` means same-file
+* ("#id"); a namespace-qualified href ("other.dmn#id") is NOT local — the
+* validator's dangling check skips it, and extractDmn currently passes it
+* through verbatim (known inconsistency vs analyze_decision, tracked in #86).
+*/
+function requirementHref(req) {
+	const href = req.requiredInput?.["@_href"] ?? req.requiredDecision?.["@_href"];
+	if (href === void 0) return void 0;
+	return {
+		href,
+		local: href.startsWith("#")
+	};
+}
+/**
+* DMN: decisions (with their full decision-table logic), input data and the
+* information requirements between them. The table detail rides in
+* node.extra — deriveDecision (derive.ts) turns it into the decision view,
+* and the simulator (@designiq/decisions) into its evaluation model, so this is
+* the ONE DMN parser on the server side.
+*/
+function extractDmn(raw) {
+	const defs = parseXml(raw).definitions ?? {};
+	const nodes = [];
+	const edges = [];
+	for (const input of asArray(defs.inputData)) nodes.push({
+		id: input["@_id"] ?? "",
+		type: "inputData",
+		name: input["@_name"] ?? "",
+		extra: {
+			variable: input.variable?.["@_name"] ?? input["@_name"] ?? "",
+			typeRef: input.variable?.["@_typeRef"] ?? "string"
+		}
+	});
+	for (const decision of asArray(defs.decision)) {
+		const table = decision.decisionTable;
+		const literal = decision.literalExpression;
+		nodes.push({
+			id: decision["@_id"],
+			type: "decision",
+			name: decision["@_name"],
+			extra: {
+				variable: decision.variable?.["@_name"] ?? decision["@_name"] ?? decision["@_id"],
+				typeRef: decision.variable?.["@_typeRef"] ?? "string",
+				...table ? {
+					kind: "decisionTable",
+					hitPolicy: table["@_hitPolicy"] ?? "UNIQUE",
+					...table["@_aggregation"] ? { aggregation: table["@_aggregation"] } : {},
+					inputs: asArray(table.input).map((i, n) => ({
+						id: i["@_id"] ?? `Input_${n + 1}`,
+						label: i["@_label"] ?? textOf(i.inputExpression?.text),
+						expression: textOf(i.inputExpression?.text),
+						typeRef: i.inputExpression?.["@_typeRef"] ?? "string",
+						inputValues: splitFeelList(textOf(i.inputValues?.text))
+					})),
+					outputs: asArray(table.output).map((o, n) => ({
+						id: o["@_id"] ?? `Output_${n + 1}`,
+						name: o["@_name"] ?? o["@_label"] ?? "",
+						label: o["@_label"] ?? o["@_name"] ?? "",
+						typeRef: o["@_typeRef"] ?? "string",
+						outputValues: splitFeelList(textOf(o.outputValues?.text))
+					})),
+					rules: asArray(table.rule).map((r, n) => ({
+						id: r["@_id"] ?? `Rule_${n + 1}`,
+						description: textOf(r.description) || void 0,
+						inputEntries: asArray(r.inputEntry).map((e) => textOf(e.text)),
+						outputEntries: asArray(r.outputEntry).map((e) => textOf(e.text))
+					}))
+				} : literal ? {
+					kind: "literalExpression",
+					expression: textOf(literal.text)
+				} : { kind: "none" }
+			}
+		});
+		for (const req of asArray(decision.informationRequirement)) {
+			const target = requirementHref(req);
+			if (target && target.href) edges.push({
+				id: req["@_id"] ?? `req-${edges.length}`,
+				from: target.href.replace(/^#/, ""),
+				to: decision["@_id"],
+				kind: "informationRequirement"
+			});
+		}
+	}
+	return {
+		notation: "dmn",
+		nodes,
+		edges,
+		meta: {
+			name: defs["@_name"] ?? null,
+			namespace: defs["@_namespace"] ?? null
+		}
+	};
+}
+/** `"a","b"` (a DMN inputValues/outputValues list) → the raw FEEL items */
+function splitFeelList(raw) {
+	const trimmed = raw.trim();
+	if (trimmed === "") return [];
+	return trimmed.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+/** OWM DSL: `component Name [y, x]`, `Name -> Other`, `evolve Name x` */
+function extractWardley(raw) {
+	const nodes = [];
+	const edges = [];
+	for (const m of raw.matchAll(/^component\s+([^[\n]+?)\s*\[\s*([\d.]+)\s*,\s*([\d.]+)\s*\]/gm)) {
+		const evolution = Number(m[3]);
+		nodes.push({
+			id: m[1] ?? "",
+			type: "component",
+			name: m[1],
+			extra: {
+				visibility: Number(m[2]),
+				evolution,
+				stage: evolution < .25 ? "genesis" : evolution < .5 ? "custom-built" : evolution < .75 ? "product" : "commodity"
+			}
+		});
+	}
+	const directive = /^(title|component|anchor|market|note|annotation|annotations|style|evolution|submap|url|pipeline)\b/;
+	let i = 0;
+	for (const m of raw.matchAll(/^([^\s>[\n][^>[\n]*?)\s*->\s*([^\n;]+)$/gm)) {
+		if (directive.test(m[0] ?? "")) continue;
+		edges.push({
+			id: `dep-${i++}`,
+			from: m[1]?.trim() ?? "",
+			to: m[2]?.trim() ?? "",
+			kind: "dependency"
+		});
+	}
+	return {
+		notation: "wardley",
+		nodes,
+		edges
+	};
+}
+function extractTeamTopology(raw) {
+	const data = JSON.parse(raw);
+	return {
+		notation: "team-topology",
+		nodes: (data.nodes ?? []).map((n) => ({
+			id: n.id,
+			type: n.type ?? "team",
+			name: n.label ?? n.name,
+			extra: n.description ? { description: n.description } : void 0
+		})),
+		edges: (data.edges ?? []).map((e, i) => ({
+			id: e.id ?? `edge-${i}`,
+			from: e.source ?? e.from,
+			to: e.target ?? e.to,
+			kind: e.interaction ?? e.type ?? "interaction"
+		}))
+	};
+}
+const STORM_ID_PREFIX = {
+	event: "event",
+	command: "cmd",
+	actor: "actor",
+	aggregate: "agg",
+	policy: "policy",
+	readmodel: "read",
+	external: "ext",
+	hotspot: "hot"
+};
+/** stickies that can carry a pinned actor/hotspot/note — `(on <Host>)` */
+const STORM_HOST_KINDS = /* @__PURE__ */ new Set([
+	"event",
+	"command",
+	"aggregate",
+	"policy",
+	"readmodel",
+	"external"
+]);
+const STORM_ATTACHABLE_KINDS = /* @__PURE__ */ new Set([
+	"actor",
+	"hotspot",
+	"note"
+]);
+const STORM_COORDS = /\[\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\]/;
+const STORM_POINTS = /\[\s*(\[[^[\]]*\](?:\s*,\s*\[[^[\]]*\])+)\s*\]/;
+const stormSlug = (label) => label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_/, "").replace(/_$/, "") || "x";
+/** the `(on <Host>)` / `(id <id>)` / `(color <c>)` suffixes of a sticky line;
+*  `rest` is the text with EVERY parenthesised suffix removed (size/align are
+*  note layout — irrelevant to the graph) */
+function stormSuffixes(text) {
+	let host;
+	let rest = text;
+	const on = /\(\s*on\s+/i.exec(text);
+	if (on) {
+		const start = on.index + on[0].length;
+		const close = text.lastIndexOf(")");
+		if (close >= start && text.slice(start, close).trim()) {
+			host = text.slice(start, close).trim();
+			rest = `${text.slice(0, on.index)} ${text.slice(close + 1)}`;
+		}
+	}
+	const id = /\(\s*id\s+([A-Za-z0-9_-]+)\s*\)/i.exec(rest)?.[1];
+	const color = /\(\s*color\s+(#[0-9a-fA-F]{3,8}|[a-zA-Z][\w-]*)\s*\)/i.exec(rest)?.[1];
+	return {
+		host,
+		id,
+		color,
+		rest: rest.replace(/\([^)]*\)/g, " ")
+	};
+}
+function extractEventStorming(raw) {
+	const nodes = [];
+	const edges = [];
+	let title = null;
+	let level = null;
+	const used = /* @__PURE__ */ new Set();
+	const nameToId = /* @__PURE__ */ new Map();
+	const claim = (id) => {
+		if (!id || used.has(id)) return void 0;
+		used.add(id);
+		return id;
+	};
+	const alloc = (prefix, label) => {
+		const base = `${prefix}_${stormSlug(label)}`;
+		let id = base;
+		for (let i = 2; used.has(id); i++) id = `${base}_${i}`;
+		used.add(id);
+		return id;
+	};
+	const decode = (name) => name.replace(/\\n/g, "\n");
+	const arrows = [];
+	const pins = [];
+	for (const source of raw.replace(/\/\*[\s\S]*?\*\//g, " ").split(/\r?\n/)) {
+		const line = source.replace(/(?<!:)\/\/.*$/, "").trim();
+		if (!line) continue;
+		const kw = (/^[A-Za-z][\w-]*/.exec(line)?.[0] ?? "").toLowerCase();
+		const after = line.slice(kw.length).trim();
+		const semi = line.indexOf(";");
+		const core = (semi >= 0 ? line.slice(0, semi) : line).trim();
+		const arrowAt = core.indexOf("->");
+		if (arrowAt > 0 && !STORM_COORDS.test(core)) {
+			const from = core.slice(0, arrowAt).trim();
+			const to = core.slice(arrowAt + 2).trim();
+			if (from && to && (kw !== "title" || nameToId.has(decode(from)))) {
+				const label = semi >= 0 ? line.slice(semi + 1).trim() : "";
+				arrows.push({
+					from,
+					to,
+					...label ? { label } : {}
+				});
+				continue;
+			}
+		}
+		if (kw === "title") title = after;
+		else if (kw === "level") {
+			const value = after.toLowerCase();
+			if ([
+				"big-picture",
+				"process",
+				"design"
+			].includes(value)) level = value;
+		} else if (Object.hasOwn(STORM_ID_PREFIX, kw) || kw === "note") {
+			const at = STORM_COORDS.exec(after);
+			if (!at && after.includes("[")) continue;
+			const x = at ? Number(at[1]) : 0;
+			const y = at ? Number(at[2]) : 0;
+			if (Number.isNaN(x) || Number.isNaN(y)) continue;
+			const name = decode(at ? after.slice(0, at.index).trim() : stormSuffixes(after).rest.trim());
+			const { host, id: explicit, color } = stormSuffixes(at ? after.slice(at.index + at[0].length) : after);
+			if (kw !== "note" && !name) continue;
+			const id = kw === "note" ? alloc("note", name || "note") : claim(explicit) ?? alloc(STORM_ID_PREFIX[kw], name);
+			const node = {
+				id,
+				type: kw,
+				name,
+				extra: {
+					x,
+					y,
+					...color ? { color } : {}
+				}
+			};
+			nodes.push(node);
+			if (kw !== "note" && !nameToId.has(name)) nameToId.set(name, id);
+			if (host && STORM_ATTACHABLE_KINDS.has(kw)) pins.push({
+				node,
+				host
+			});
+		} else if (kw === "line") {
+			const points = STORM_POINTS.exec(after)?.[1];
+			const tuples = points ? [...points.matchAll(/\[\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\]/g)] : [];
+			if (tuples.length < 2) continue;
+			nodes.push({
+				id: alloc("draw", "line"),
+				type: "drawing",
+				extra: {
+					x: Number(tuples[0][1]),
+					y: Number(tuples[0][2]),
+					points: tuples.length
+				}
+			});
+		}
+	}
+	const resolve = (token) => {
+		const id = token.startsWith("#") ? token.slice(1) : nameToId.get(decode(token));
+		return id === void 0 ? void 0 : nodes.find((n) => n.id === id);
+	};
+	for (const { node, host } of pins) {
+		const target = resolve(host);
+		if (target && STORM_HOST_KINDS.has(target.type)) node.extra = {
+			...node.extra,
+			attachedTo: target.id
+		};
+	}
+	let n = 0;
+	for (const arrow of arrows) {
+		const from = resolve(arrow.from);
+		const to = resolve(arrow.to);
+		if (!from || !to || !Object.hasOwn(STORM_ID_PREFIX, from.type) || !Object.hasOwn(STORM_ID_PREFIX, to.type)) continue;
+		let id = `arrow_${++n}`;
+		while (used.has(id)) id = `arrow_${++n}`;
+		edges.push({
+			id,
+			from: from.id,
+			to: to.id,
+			kind: "arrow",
+			name: arrow.label
+		});
+	}
+	return {
+		notation: "event-storming",
+		nodes,
+		edges,
+		meta: {
+			title,
+			level
+		}
+	};
+}
+const CM_SUBDOMAIN_TYPES = /* @__PURE__ */ new Set([
+	"core",
+	"supporting",
+	"generic"
+]);
+function extractContextMap(raw) {
+	const parsed = JSON.parse(raw);
+	const data = parsed !== null && typeof parsed === "object" ? parsed : {};
+	const contexts = Array.isArray(data.contexts) ? data.contexts : [];
+	const relationships = Array.isArray(data.relationships) ? data.relationships : [];
+	const text = (v) => typeof v === "string" && v !== "" ? v : void 0;
+	const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+	const roles = (v) => Array.isArray(v) ? v.filter((r) => typeof r === "string") : [];
+	const nodes = [];
+	for (const c of contexts) {
+		if (c === null || typeof c !== "object" || typeof c.id !== "string" || c.id === "") continue;
+		const subdomainType = text(c.subdomainType);
+		const team = text(c.team);
+		const description = text(c.description);
+		nodes.push({
+			id: c.id,
+			type: subdomainType && CM_SUBDOMAIN_TYPES.has(subdomainType) ? subdomainType : "context",
+			name: text(c.label),
+			extra: {
+				...team ? { team } : {},
+				...description ? { description } : {},
+				x: num(c.position?.x) ?? 0,
+				y: num(c.position?.y) ?? 0,
+				width: num(c.size?.width) ?? 0,
+				height: num(c.size?.height) ?? 0
+			}
+		});
+	}
+	const edges = [];
+	for (const [i, r] of relationships.entries()) {
+		if (r === null || typeof r !== "object") continue;
+		const upstreamRoles = roles(r.upstreamRoles);
+		const downstreamRoles = roles(r.downstreamRoles);
+		const implementationTechnology = text(r.implementationTechnology);
+		const description = text(r.description);
+		const extra = {
+			...upstreamRoles.length > 0 ? { upstreamRoles } : {},
+			...downstreamRoles.length > 0 ? { downstreamRoles } : {},
+			...implementationTechnology ? { implementationTechnology } : {},
+			...description ? { description } : {}
+		};
+		edges.push({
+			id: text(r.id) ?? `rel-${i}`,
+			from: text(r.from) ?? "",
+			to: text(r.to) ?? "",
+			kind: text(r.pattern) ?? "relationship",
+			name: text(r.label),
+			...Object.keys(extra).length > 0 ? { extra } : {}
+		});
+	}
+	return {
+		notation: "context-map",
+		nodes,
+		edges,
+		meta: { title: text(data.title) ?? null }
+	};
+}
+function extractValueChain(raw) {
+	const data = JSON.parse(raw);
+	return {
+		notation: "value-chain",
+		nodes: (data.elements ?? []).map((el) => ({
+			id: el.id,
+			type: el.elementType ?? "element",
+			name: el.label ?? el.name
+		})),
+		edges: (data.connections ?? []).map((c, i) => ({
+			id: c.id ?? `conn-${i}`,
+			from: c.source,
+			to: c.target,
+			kind: c.connectionType ?? "connection"
+		}))
+	};
+}
+const EXTRACTORS = {
+	bpmn: extractBpmn,
+	dmn: extractDmn,
+	wardley: extractWardley,
+	"team-topology": extractTeamTopology,
+	"event-storming": extractEventStorming,
+	"context-map": extractContextMap,
+	"value-chain": extractValueChain
+};
+/** notation id or file path in, ModelGraph out; undefined = no extractor registered */
+function extractModelGraph(notationOrPath, raw) {
+	const notation = byId(notationOrPath) ?? byExtension(notationOrPath);
+	const extractor = notation && EXTRACTORS[notation.id];
+	return extractor ? extractor(raw) : void 0;
+}
+//#endregion
+//#region ../notations/content.ts
+/**
+* The content-repo contract (designiq.yml) — the ONE definition of "what is a
+* content repo, and what are its models", shared by every consumer that reads
+* a checkout: the Live Host, the MCP server, and the validator.
+*
+*   # designiq.yml
+*   models: processes        # or the legacy alias:  processes: processes
+*
+* A repo is a content repo iff a root designiq.yml names the folder its model
+* files live in. A model IS a file with a registered notation extension under
+* that folder (@designiq/notations); its id is the file stem (modelStem). A
+* process is the .bpmn special case, a decision the .dmn one. Nothing else
+* about the layout is assumed.
+*
+* The contract file answers to two names (CONTENT_CONFIG_FILES, in precedence
+* order): the first one that EXISTS at the root is THE config, the other is
+* not even read. Selection is by existence only — a preferred file that is
+* mid-edit or broken makes the repo "not a content repo" instead of silently
+* handing the model folder to whatever the other file says. The second name
+* is the legacy one: read forever, written never — the CLIs nudge a rename
+* (legacyContentConfigFile).
+*
+* Node-only (fs + yaml) — imported via the "@designiq/notations/content" subpath,
+* NEVER from the browser-safe package index.
+*/
+/** the documented name of the contract file — the one messages and docs say,
+*  and the one a new repo gets (the starter template carries it) */
+const CONTENT_CONFIG_FILE = "designiq.yml";
+/**
+* Every name the contract file is accepted under, in precedence order. The
+* second one is the legacy name and stays readable permanently: customer
+* repos, the starter template and every released image <= 4.2.0 carry it.
+*/
+const CONTENT_CONFIG_FILES = ["designiq.yml", "bpmiq.yml"];
+/**
+* The NAME of the contract file at `root`: the first of CONTENT_CONFIG_FILES
+* that exists. By existence ONLY — whether it parses is loadContentConfig's
+* business. A present-but-broken first choice must NOT fall through to the
+* next name: the file is plausibly mid-edit in a live session, and a fallback
+* would silently flip the room-containment folder to a different one.
+*/
+function resolveContentConfigFile(root) {
+	return CONTENT_CONFIG_FILES.find((name) => isContractFile(root, name));
+}
+/** a regular FILE of that name — a folder that merely carries a contract name
+*  (anyone may create one in a repo whose models live at the root) must not
+*  shadow the real contract file under the other name */
+function isContractFile(root, name) {
+	try {
+		return statSync(join(root, name)).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* The LEGACY name `root`'s contract is read from — set only when that file is
+* the one actually in use (no designiq.yml beside it). A repo carrying both
+* names on purpose (to stay readable by images that predate designiq.yml) is
+* fine and gets no nudge; contentConfigConflict covers the two disagreeing.
+*/
+function legacyContentConfigFile(root) {
+	const used = resolveContentConfigFile(root);
+	return used === void 0 || used === "designiq.yml" ? void 0 : used;
+}
+/** how messages name the contract file: the documented name, then the legacy
+*  one an older repo still carries — its owner must recognise their file */
+const CONTENT_CONFIG_NAMES = `${CONTENT_CONFIG_FILE} (or legacy ${CONTENT_CONFIG_FILES[1]})`;
+/**
+* The folder ONE contract file names — `models:`, the legacy `processes:` key
+* stays a full alias (existing repos remain valid unchanged). `undefined` for
+* an unreadable/unparseable/ill-typed file.
+*/
+function readContentFolder(root, name) {
+	let parsed;
+	try {
+		parsed = parse(readFileSync(join(root, name), "utf8"));
+	} catch {
+		return;
+	}
+	const raw = parsed;
+	const folder = raw?.models ?? raw?.processes;
+	if (typeof folder !== "string" || folder.trim().length === 0) return void 0;
+	const normalized = posix.normalize(folder.trim()).replace(/\/+$/, "");
+	if (normalized === "" || normalized === ".") return ".";
+	if (normalized.startsWith("/") || normalized.split("/").includes("..")) return void 0;
+	return normalized;
+}
+/**
+* Read + validate the root contract file (resolveContentConfigFile picks which
+* name). `undefined` means "not a content repo" — an unreadable/unparseable/
+* ill-typed config must degrade to that, never crash a listing (the file is
+* plausibly mid-edit in a live session).
+*/
+function loadContentConfig(root) {
+	const name = resolveContentConfigFile(root);
+	const folder = name === void 0 ? void 0 : readContentFolder(root, name);
+	return folder === void 0 ? void 0 : {
+		models: folder,
+		processes: folder
+	};
+}
+/**
+* The one situation that needs a human: BOTH names exist and do not resolve
+* to the same folder (a file naming no usable folder differs from one that
+* does). `used` still wins — but a tool that predates it reads `ignored` and
+* sees other models. Agreeing files are silent on purpose: a repo that must
+* stay readable by older tools carries both for a long time. Two files that
+* BOTH name nothing agree as well — that repo is simply not a content repo.
+*/
+function contentConfigConflict(root) {
+	const [used, ignored] = CONTENT_CONFIG_FILES.filter((name) => isContractFile(root, name));
+	if (used === void 0 || ignored === void 0) return void 0;
+	const usedFolder = readContentFolder(root, used);
+	const ignoredFolder = readContentFolder(root, ignored);
+	return usedFolder === ignoredFolder ? void 0 : {
+		used,
+		ignored,
+		usedFolder,
+		ignoredFolder
+	};
+}
+/**
+* Every file with a registered notation extension under the configured folder
+* (recursive, sorted by path). The id is the file stem (modelStem) so it stays
+* a single URL segment; ids are unique PER NOTATION (order.bpmn and order.dmn
+* are legal separate namespaces) — a second same-notation file with the same
+* stem elsewhere in the tree is skipped + logged rather than shadowing the
+* first.
+*/
+async function discoverModels(root, cfg) {
+	const dir = join(root, cfg.models);
+	let entries;
+	try {
+		entries = await readdir(dir, {
+			withFileTypes: true,
+			recursive: true
+		});
+	} catch {
+		return [];
+	}
+	const paths = entries.filter((e) => e.isFile()).map((e) => join(cfg.models, relative(dir, join(e.parentPath, e.name)))).filter((p) => !p.split("/").some((s) => s.startsWith(".") || s === "node_modules")).sort();
+	const out = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const path of paths) {
+		const notation = byExtension(path);
+		if (!notation) continue;
+		const id = modelStem(path);
+		const key = `${notation.id}/${id}`;
+		const first = seen.get(key);
+		if (first) {
+			console.log(`content: duplicate ${notation.id} id '${id}' (${path}) — keeping ${first}`);
+			continue;
+		}
+		seen.set(key, path);
+		out.push({
+			id,
+			path,
+			notation: notation.id
+		});
+	}
+	return out;
+}
+//#endregion
+export { byId as _, discoverModels as a, resolveContentConfigFile as c, extractModelGraph as d, parseXml as f, byExtension as g, kindOf as h, contentConfigConflict as i, XMLValidator as l, requirementHref as m, CONTENT_CONFIG_FILES as n, legacyContentConfigFile as o, readBpmn as p, CONTENT_CONFIG_NAMES as r, loadContentConfig as s, CONTENT_CONFIG_FILE as t, asArray as u };