@miragon/design-iq-validator 5.4.0 → 5.6.0

package/README.md

@@ -3,12 +3,47 @@
 Deterministic validator for designIQ content repositories: `designiq.yml` discovery, BPMN
 structural checks (flow soundness, complete BPMNDI coverage), DMN structure and DMNDI coverage,
 the generic cross-model reference rule (every required reference — `callActivity` calls,
-`businessRuleTask` decides — must resolve in the repo), and a per-mediaKind parse baseline for
-every other registered notation (a broken `.tt`/`.vc.json` is an ERROR; DSL notations are
-lenient by design; a Mermaid diagram that does not start with a diagram type such as
-`flowchart` or `sequenceDiagram` is a WARN, `mermaid/diagram-type`). Every finding carries a stable `ruleId` (e.g. `bpmn/flow`, `dmn/di`,
-`refs/dangling`). It treats the target repo as pure data — it never executes content-repo code.
-Exit code 0 = no errors (warnings allowed), 1 = errors.
+`businessRuleTask` decides — must resolve in the repo), the schema check of the Miragon JSON
+notations, and a per-mediaKind parse baseline for every other registered notation (a file that
+is no JSON or XML is an ERROR; DSL notations are lenient by design; a `mermaid` fence in a
+Markdown document that does not start with a diagram type such as `flowchart` or
+`sequenceDiagram` is a WARN, `mermaid/diagram-type`, naming the document's line). Every finding
+carries a stable `ruleId` (e.g. `bpmn/flow`, `dmn/di`, `refs/dangling`). It treats the target
+repo as pure data — it never executes content-repo code. Exit code 0 = no errors (warnings
+allowed), 1 = errors.
+
+## Team Topologies, Context Maps and Value Chains
+
+A `.tt`/`.ttm.json`, `.cm.json` or `.vc.json` file is parsed with the schema model its canvas
+opens it with (`@miragon/team-topologies-schema-model`, `@miragon/context-maps-schema-model`,
+`@miragon/value-chain-schema-model`). Whatever the schema model refuses, the canvas cannot open,
+so each refusal is an ERROR (`team-topology/schema`, `context-map/schema`,
+`value-chain/schema`) that names the offending value by its JSON path, e.g.
+`nodes.1.id: duplicate id "a"`. Refused among others:
+
+- a duplicate id, and the ids the diagram keeps for itself: `tt-root`, `cm-root`, `vc-root`,
+  every id starting with `__implicitroot`, and `assoc_<annotation id>` in a Team Topology;
+- in all three notations, an id that names a built-in JavaScript object property such as
+  `constructor`, `toString` or `__proto__`: the canvas keeps its elements in a plain object and
+  cannot import it. The Team Topology and Context Map schema models still take these ids, so the
+  validator refuses them itself, under the same rule;
+- in a Context Map: a JSON list instead of an object, a `version` newer than 1, coordinates or
+  sizes beyond 1,000,000;
+- in a Value Chain: keys other than `x`, `y`, `width`, `height` in `bounds` and other than `x`,
+  `y` in a waypoint, coordinates beyond ±1e9, and a `__proto__` key anywhere.
+
+A Context Map's strategic-DDD rules (`validateDocument`, e.g. `protect-or-conform`,
+`endpoints-on-map`) are WARNs, `context-map/semantics`, with the rule named at the end of the
+message: the canvas opens such a map and marks the finding. A repeated id is the exception: the
+canvas refuses it, so it is an ERROR (`context-map/schema`) at the path of the repeat, e.g.
+`contexts.2.id: Duplicate id "a". (unique-ids)`.
+
+Paths count in the document as the schema model reads it. A Team Topology drops a legacy
+interaction without `position` or `size` before the check, so the index of a later interaction
+counts without it. Some rules only run once the document's shape is valid: the id rules of a Team
+Topology and a Value Chain, and in a Context Map the repeated ids and the strategic-DDD rules.
+Fixing the reported errors can therefore bring up further ones, so check again until the file is
+clean.
 
 ## Usage
 

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as runCli } from "./validate-Dy2lNoBR.js";
+import { o as runCli } from "./validate-BqkEd0ma.js";
 //#region src/cli.ts
 /**
 * CLI entry for the platform validator. A dedicated entry file (instead of an

package/dist/{content-DJ1x-ykR.js → content-Bu1bNrez.js}

@@ -126,18 +126,6 @@ const NOTATIONS = [
 		mediaKind: "markdown",
 		docShape: "text",
 		monacoLanguage: "markdown"
-	},
-	{
-		id: "mermaid",
-		label: "Mermaid",
-		noun: {
-			singular: "diagram",
-			plural: "diagrams"
-		},
-		extensions: [".mmd", ".mermaid"],
-		mediaKind: "dsl",
-		docShape: "text",
-		monacoLanguage: "plaintext"
 	}
 ];
 function byId(id) {
@@ -549,20 +537,23 @@ function extractWardley(raw) {
 }
 function extractTeamTopology(raw) {
 	const data = JSON.parse(raw);
+	const list = (v) => Array.isArray(v) ? v : [];
+	const teams = list(data.nodes).map((n) => ({
+		id: n.id,
+		type: n.type ?? "team",
+		name: n.label ?? n.name,
+		extra: n.description ? { description: n.description } : void 0
+	}));
+	const interactions = list(data.interactions).filter((i) => i !== null && typeof i === "object" && "position" in i && "size" in i).map((i) => ({
+		id: i.id,
+		type: "interaction",
+		name: i.label,
+		extra: { mode: i.mode }
+	}));
 	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"
-		}))
+		nodes: [...teams, ...interactions],
+		edges: []
 	};
 }
 const STORM_ID_PREFIX = {
@@ -813,7 +804,7 @@ function extractValueChain(raw) {
 		nodes: (data.elements ?? []).map((el) => ({
 			id: el.id,
 			type: el.elementType ?? "element",
-			name: el.label ?? el.name
+			name: el.name
 		})),
 		edges: (data.connections ?? []).map((c, i) => ({
 			id: c.id ?? `conn-${i}`,

package/dist/{content-Dld6ZUbs.js → content-CE4SulnP.js}

@@ -1 +1 @@
-export { t as CONTENT_CONFIG_FILE, i as contentConfigConflict, a as discoverModels, o as legacyContentConfigFile, s as loadContentConfig } from "./content-DJ1x-ykR.js";
+export { t as CONTENT_CONFIG_FILE, i as contentConfigConflict, a as discoverModels, o as legacyContentConfigFile, s as loadContentConfig } from "./content-Bu1bNrez.js";

package/dist/{validate-Dy2lNoBR.js → validate-BqkEd0ma.js}

@@ -1,6 +1,9 @@
-import { _ as byId, c as resolveContentConfigFile, d as extractModelGraph, f as parseXml, g as byExtension, h as kindOf, l as XMLValidator, m as requirementHref, p as readBpmn, r as CONTENT_CONFIG_NAMES, u as asArray } from "./content-DJ1x-ykR.js";
+import { _ as byId, c as resolveContentConfigFile, d as extractModelGraph, f as parseXml, g as byExtension, h as kindOf, l as XMLValidator, m as requirementHref, p as readBpmn, r as CONTENT_CONFIG_NAMES, u as asArray } from "./content-Bu1bNrez.js";
 import { readFileSync } from "node:fs";
 import { relative, resolve } from "node:path";
+import { parseDocumentText, validateDocument } from "@miragon/context-maps-schema-model";
+import { parseDocument } from "@miragon/team-topologies-schema-model";
+import { documentIssues } from "@miragon/value-chain-schema-model";
 //#region ../notations/refs.ts
 const REF_EMITTERS = { bpmn: (graph) => {
 	const refs = [];
@@ -84,6 +87,343 @@ const notContentRepoError = (root) => {
 	return found === void 0 ? `[ERROR] ${root}: no ${CONTENT_CONFIG_NAMES} at the root — not a content repo (or wrong --root)` : `[ERROR] ${root}: ${found} at the root names no models folder — not a content repo (or wrong --root)`;
 };
 //#endregion
+//#region ../notations/markdown.ts
+const NONE = { kind: "none" };
+const PARAGRAPH = { kind: "paragraph" };
+const CODE = { kind: "code" };
+const FENCE_OPEN = /^(`{3,}|~{3,})(.*)$/;
+const THEMATIC_BREAK = /^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+const ATX_HEADING = /^#{1,6}(?:[ \t]|$)/;
+const SETEXT_UNDERLINE = /^(?:=+|-+)[ \t]*$/;
+const BULLET = /^[-+*](?=[ \t]|$)/;
+const ORDERED = /^(\d{1,9})[.)](?=[ \t]|$)/;
+const BLANK = /^[ \t]*$/;
+/** a link reference definition on one line: [label]: destination "title" (a
+*  "[^" label is a footnote, which render.ts keeps as paragraph text; a bare
+*  destination ends at a space or a control character, as in markdown-it) */
+const LINK_DEFINITION = /^\[(?!\^)((?:[^[\]\\]|\\.)*)\]:[ \t]*(<(?:[^<>\\]|\\.)*>|[^ <\x00-\x1f\x7f][^ \x00-\x1f\x7f]*)(?:[ \t]+(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\((?:[^()\\]|\\.)*\)))?[ \t]*$/;
+/** the destinations markdown-it's validateLink refuses: no definition then */
+const BAD_LINK = /^(?:vbscript|javascript|file|data):/i;
+const GOOD_DATA_LINK = /^data:image\/(?:gif|png|jpeg|webp);/i;
+/** markdown-it's maxNesting: content nested this deep (a Container's `level`)
+*  it does not parse, and drops the rest of the innermost quote around it,
+*  or of the document */
+const MAX_NESTING = 100;
+/** start, end and whether it may interrupt a paragraph; an end of /^$/ is the next blank line */
+const HTML_BLOCKS = [
+	[
+		/^<(?:script|pre|style|textarea)(?=\s|>|$)/i,
+		/<\/(?:script|pre|style|textarea)>/i,
+		true
+	],
+	[
+		/^<!--/,
+		/-->/,
+		true
+	],
+	[
+		/^<\?/,
+		/\?>/,
+		true
+	],
+	[
+		/^<![A-Za-z]/,
+		/>/,
+		true
+	],
+	[
+		/^<!\[CDATA\[/,
+		/\]\]>/,
+		true
+	],
+	[
+		new RegExp(`^</?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?=\\s|/?>|$)`, "i"),
+		/^$/,
+		true
+	],
+	[
+		new RegExp(`^(?:<[A-Za-z][A-Za-z0-9\\-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^"'=<>\`\\x00-\\x20]+|'[^']*'|"[^"]*"))?)*\\s*\\/?>|<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>)\\s*$`),
+		/^$/,
+		false
+	]
+];
+/** the leading blanks of a rest */
+function leading(rest) {
+	let col = rest.col;
+	let i = 0;
+	for (; i < rest.text.length; i++) {
+		const ch = rest.text[i];
+		if (ch === " ") col++;
+		else if (ch === "	") col += 4 - col % 4;
+		else break;
+	}
+	return {
+		indent: col - rest.col,
+		blank: i === rest.text.length
+	};
+}
+/** the columns of leading blanks */
+const indentOf = (rest) => leading(rest).indent;
+/** drop up to `n` columns of leading blanks; a tab cut in two leaves its other columns as spaces */
+function dropIndent(rest, n) {
+	const target = rest.col + n;
+	let col = rest.col;
+	let i = 0;
+	while (i < rest.text.length && col < target) {
+		const ch = rest.text[i];
+		if (ch === " ") col++;
+		else if (ch === "	") {
+			const next = col + 4 - col % 4;
+			if (next > target) return {
+				text: " ".repeat(next - target) + rest.text.slice(i + 1),
+				col: target
+			};
+			col = next;
+		} else break;
+		i++;
+	}
+	return {
+		text: rest.text.slice(i),
+		col
+	};
+}
+/** the line after its indent, when that is at most three columns (more is indented code) */
+function blockStart(rest) {
+	const indent = indentOf(rest);
+	return indent < 4 ? dropIndent(rest, indent) : void 0;
+}
+/** a quote's ">" and the one column of blank after it: a space, or the first
+*  column of a tab (which stays, a column narrower, as in markdown-it) */
+function afterQuoteMarker(at) {
+	const rest = {
+		text: at.text.slice(1),
+		col: at.col + 1
+	};
+	if (rest.text.startsWith(" ") || rest.text.startsWith("	") && rest.col % 4 === 3) return {
+		text: rest.text.slice(1),
+		col: rest.col + 1
+	};
+	return rest.text.startsWith("	") ? {
+		text: rest.text,
+		col: rest.col + 1
+	} : rest;
+}
+/** the rest of the line when it continues the container, undefined when the
+*  container ends. `lead` is the rest's leading blanks, kept up to date across
+*  the columns a list item drops, so a line is not measured once per container */
+function continues(container, rest, lead) {
+	if (container.kind === "quote") {
+		const at = dropIndent(rest, lead.indent);
+		return at.text.startsWith(">") ? afterQuoteMarker(at) : void 0;
+	}
+	const fresh = container.fresh;
+	container.fresh = false;
+	if (lead.blank ? fresh : lead.indent < container.indent) return void 0;
+	lead.indent = Math.max(0, lead.indent - container.indent);
+	return dropIndent(rest, container.indent);
+}
+/** a list item opening at `at` (the line after its indent of `indent` columns),
+*  inside containers nested `level` deep */
+function listItem(at, indent, level, interruptsParagraph) {
+	const ordered = ORDERED.exec(at.text);
+	const marker = ordered ?? BULLET.exec(at.text);
+	if (!marker) return void 0;
+	const after = {
+		text: at.text.slice(marker[0].length),
+		col: at.col + marker[0].length
+	};
+	const empty = BLANK.test(after.text);
+	if (interruptsParagraph && (empty || ordered && Number(ordered[1]) !== 1)) return void 0;
+	const blanks = indentOf(after);
+	const gap = empty || blanks > 4 ? 1 : blanks;
+	return {
+		item: {
+			kind: "item",
+			level: level + 2,
+			indent: indent + marker[0].length + gap,
+			fresh: empty
+		},
+		rest: dropIndent(after, gap)
+	};
+}
+/** the HTML block starting at `text` (a line after its indent), if any */
+function htmlBlock(text) {
+	return text.startsWith("<") ? HTML_BLOCKS.find(([start]) => start.test(text)) : void 0;
+}
+/** whether a line that does not continue a paragraph's containers starts a
+*  block of its own (else it is a lazy continuation line of the paragraph) */
+function startsBlock(rest) {
+	const at = blockStart(rest);
+	if (!at) return false;
+	const text = at.text;
+	return text.startsWith(">") || fenceOpen(text) !== void 0 || THEMATIC_BREAK.test(text) || BULLET.test(text) || ORDERED.test(text) || ATX_HEADING.test(text) || htmlBlock(text)?.[2] === true;
+}
+/** whether `text` (a line after its indent) is a link reference definition that
+*  fits on it and that markdown-it takes: a label with more than blanks, a
+*  destination with balanced parentheses and a scheme its validateLink allows */
+function linkDefinition(text) {
+	const definition = LINK_DEFINITION.exec(text);
+	if (!definition || definition[1].trim() === "") return false;
+	let destination = definition[2];
+	if (destination.startsWith("<")) destination = destination.slice(1, -1);
+	else {
+		let depth = 0;
+		for (let i = 0; i < destination.length && depth >= 0; i++) {
+			const ch = destination[i];
+			if (ch === "\\") i++;
+			else if (ch === "(") depth = depth < 32 ? depth + 1 : -1;
+			else if (ch === ")") depth--;
+		}
+		if (depth !== 0) return false;
+	}
+	destination = destination.trim();
+	return !BAD_LINK.test(destination) || GOOD_DATA_LINK.test(destination);
+}
+/** the opening run of a fence at `text` (a line after its indent), if any */
+function fenceOpen(text) {
+	const open = FENCE_OPEN.exec(text);
+	if (!open) return void 0;
+	const run = open[1];
+	const info = open[2];
+	if (run.startsWith("`") && info.includes("`")) return void 0;
+	return {
+		char: run[0],
+		size: run.length,
+		info: info.trim()
+	};
+}
+/** whether the line is the closing run of `fence` */
+function closes(rest, fence) {
+	const at = blockStart(rest);
+	if (!at) return false;
+	let n = 0;
+	while (at.text[n] === fence.char) n++;
+	return n >= fence.size && BLANK.test(at.text.slice(n));
+}
+/** every fenced code block of a Markdown document, in document order */
+function markdownFences(source) {
+	const lines = source.split(/\r\n|\r|\n/);
+	const brokenLast = BLANK.test(lines[lines.length - 1]);
+	if (brokenLast) lines.pop();
+	const fences = [];
+	const stack = [];
+	const level = () => stack.length > 0 ? stack[stack.length - 1].level : 0;
+	let leaf = NONE;
+	let dropping;
+	const finish = (fence, closed) => {
+		fences.push({
+			line: fence.line,
+			endLine: fence.line + fence.content.length + (closed ? 1 : 0),
+			info: fence.info,
+			lang: (fence.info.split(/\s+/)[0] ?? "").toLowerCase(),
+			content: fence.content.join(""),
+			closed
+		});
+	};
+	for (let i = 0; i < lines.length; i++) {
+		let rest = {
+			text: lines[i],
+			col: 0
+		};
+		const lineBreak = i < lines.length - 1 || brokenLast ? "\n" : "";
+		let matched = 0;
+		let lead;
+		for (const container of stack) {
+			const next = continues(container, rest, lead ??= leading(rest));
+			if (!next) break;
+			rest = next;
+			if (container.kind === "quote") lead = void 0;
+			matched++;
+		}
+		const all = matched === stack.length;
+		if (dropping) {
+			if (all) {
+				dropping.lastBlank = BLANK.test(rest.text);
+				continue;
+			}
+			if (!dropping.lastBlank && !BLANK.test(rest.text) && !startsBlock(rest)) continue;
+			dropping = void 0;
+		}
+		if (leaf.kind === "fence" && all) {
+			if (closes(rest, leaf)) {
+				finish(leaf, true);
+				leaf = NONE;
+			} else leaf.content.push(dropIndent(rest, leaf.indent).text + lineBreak);
+			continue;
+		}
+		if (leaf.kind === "html" && all) {
+			if (leaf.end.test(dropIndent(rest, indentOf(rest)).text)) leaf = NONE;
+			continue;
+		}
+		if (!all) {
+			if (leaf.kind === "paragraph" && !BLANK.test(rest.text) && !startsBlock(rest)) continue;
+			if (leaf.kind === "fence") finish(leaf, false);
+			stack.length = matched;
+			leaf = NONE;
+		}
+		while (level() < MAX_NESTING && !BLANK.test(rest.text)) {
+			const at = blockStart(rest);
+			if (!at) break;
+			if (at.text.startsWith(">")) {
+				stack.push({
+					kind: "quote",
+					level: level() + 1
+				});
+				rest = afterQuoteMarker(at);
+			} else {
+				if (THEMATIC_BREAK.test(at.text)) break;
+				const opening = listItem(at, indentOf(rest), level(), leaf.kind === "paragraph");
+				if (!opening) break;
+				stack.push(opening.item);
+				rest = opening.rest;
+			}
+			leaf = NONE;
+		}
+		if (BLANK.test(rest.text)) {
+			if (leaf.kind === "paragraph") leaf = NONE;
+			continue;
+		}
+		if (level() >= MAX_NESTING) {
+			const quote = stack.findLastIndex((container) => container.kind === "quote");
+			if (quote < 0) break;
+			stack.length = quote + 1;
+			leaf = NONE;
+			dropping = { lastBlank: false };
+			continue;
+		}
+		const at = blockStart(rest);
+		if (!at) {
+			if (leaf.kind !== "paragraph") leaf = CODE;
+			continue;
+		}
+		const open = fenceOpen(at.text);
+		if (open) {
+			leaf = {
+				kind: "fence",
+				...open,
+				indent: indentOf(rest),
+				line: i + 1,
+				content: []
+			};
+			continue;
+		}
+		const html = htmlBlock(at.text);
+		if (html && (html[2] || leaf.kind !== "paragraph")) {
+			leaf = html[1].test(at.text) ? NONE : {
+				kind: "html",
+				end: html[1]
+			};
+			continue;
+		}
+		if (leaf.kind !== "paragraph" && linkDefinition(at.text)) leaf = NONE;
+		else if (ATX_HEADING.test(at.text) || THEMATIC_BREAK.test(at.text)) leaf = NONE;
+		else if (leaf.kind === "paragraph" && SETEXT_UNDERLINE.test(at.text)) leaf = NONE;
+		else leaf = PARAGRAPH;
+	}
+	if (leaf.kind === "fence") finish(leaf, false);
+	return fences;
+}
+//#endregion
 //#region ../notations/mermaid.ts
 /**
 * Every diagram type MERMAID_VERSION renders, spelled as its header keyword
@@ -381,7 +721,7 @@ function checkBpmnXml(raw, opts = {}) {
 *
 * Deliberately NOT here: FEEL semantics, hit-policy reachability, dead wiring.
 * Those need the FEEL engine and live in @designiq/decisions (`analyze_decision`),
-* which would drag a browser-side dependency into this zero-dep CLI.
+* which would drag a browser-side dependency into this CLI.
 */
 function checkDmnXml(raw, opts = {}) {
 	const file = opts.file ?? "<dmn>";
@@ -453,34 +793,27 @@ function checkDmnXml(raw, opts = {}) {
 const COMMON_MERMAID_TYPES = "flowchart, sequenceDiagram, classDiagram, stateDiagram-v2, erDiagram, gantt, pie, mindmap";
 /**
 * Mermaid's own first step (its type detection, @designiq/notations/mermaid
-* mirrors it): after the front matter, directives and comments, the first
-* line must start with a diagram type. Light on purpose: the grammar itself
-* needs mermaid and a DOM, which the validator never loads; the web viewer
-* shows those errors live. A WARN, not an ERROR: .mmd files a content repo
-* already keeps (snippets, a zenuml diagram mermaid does not bundle) turn
-* up as models with this notation, and must neither fail its CI nor block a
-* save.
+* mirrors it) for a ```mermaid fence opening on document line `line`: after
+* the front matter, directives and comments, the diagram's first line must
+* start with a diagram type. Light on purpose: the grammar itself needs
+* mermaid and a DOM, which the validator never loads; the Markdown view
+* shows those errors live. The message names the document's line (a Finding
+* has no line of its own).
 */
-function mermaidHeaderProblem(raw) {
-	const header = mermaidHeader(raw);
-	if (!header) return `empty Mermaid diagram: the first line must name a diagram type (${COMMON_MERMAID_TYPES}, …)`;
+function mermaidFenceProblem(content, line) {
+	const header = mermaidHeader(content);
+	if (!header) return `line ${line}: empty Mermaid diagram: the first line must name a diagram type (${COMMON_MERMAID_TYPES}, …)`;
 	if (header.diagramType) return void 0;
 	const word = header.text.split(/[\s:;]/, 1)[0];
-	return `line ${header.line}: '${word}' is not a Mermaid diagram type (${COMMON_MERMAID_TYPES}, …)`;
+	return `line ${line + header.line}: '${word}' is not a Mermaid diagram type (${COMMON_MERMAID_TYPES}, …)`;
 }
-/** notation id → the check of its DSL's header line (a WARN under its own
-*  rule id); a DSL without one stays as lenient as its extractor */
-const DSL_HEADER_CHECKS = { mermaid: {
-	ruleId: "mermaid/diagram-type",
-	problem: mermaidHeaderProblem
-} };
 /**
 * Baseline parse gate for models WITHOUT a dedicated checker (any registered
 * notation that is not .bpmn/.dmn): a discovered model must at minimum parse
 * per its notation's mediaKind — a broken .tt/.vc.json used to pass
 * validation untouched. Pure: no filesystem, no process.exit. Deliberately
-* mechanical: notation-specific structure checks arrive with the per-notation
-* checkers (epic #118, step 3).
+* mechanical: notation-specific structure checks are the per-notation
+* checkers' (epic #118, step 3; checkSchemaModel runs this gate first).
 */
 function checkModelBaseline(raw, opts) {
 	const file = opts.file ?? `<${opts.notation}>`;
@@ -507,37 +840,181 @@ function checkModelBaseline(raw, opts) {
 			if (wf !== true) err(`not well-formed XML: ${wf.err.msg}`);
 			break;
 		}
-		case "dsl": {
+		case "dsl":
 			try {
 				extractModelGraph(opts.notation, raw);
 			} catch (e) {
 				err(`not parseable: ${e.message}`);
 			}
-			const header = DSL_HEADER_CHECKS[opts.notation];
-			const problem = header?.problem(raw);
-			if (header && problem) findings.push({
+			break;
+		case "markdown": for (const fence of markdownFences(raw)) {
+			const problem = fence.lang === "mermaid" ? mermaidFenceProblem(fence.content, fence.line) : void 0;
+			if (problem) findings.push({
 				severity: "WARN",
-				ruleId: header.ruleId,
+				ruleId: "mermaid/diagram-type",
 				file,
 				message: problem
 			});
-			break;
 		}
 	}
 	return findings;
 }
+/** a schema model's issue location as the canvases print it ("nodes.1.id"),
+*  "(root)" for the document itself */
+const issuePath = (path) => path.join(".") || "(root)";
+const schemaError = (ruleId, file) => (issue) => ({
+	severity: "ERROR",
+	ruleId,
+	file,
+	message: `${issuePath(issue.path)}: ${issue.message}`
+});
+/**
+* The ids a Team Topology or Context Map canvas cannot hold although its
+* schema model takes them: diagram-js keeps its elements in a plain object,
+* so an id that names a built-in object property ("constructor",
+* "__proto__") reads as already added and the import fails. The Value Chain
+* schema model refuses these ids itself; the other two do not yet.
+*/
+function builtInPropertyIds(collections) {
+	return Object.entries(collections).flatMap(([collection, elements]) => (Array.isArray(elements) ? elements : []).flatMap((element, index) => {
+		const id = element?.id;
+		return typeof id === "string" && Object.hasOwn(Object.prototype, id) ? [{
+			path: [
+				collection,
+				index,
+				"id"
+			],
+			message: `the id "${id}" is reserved: it names a built-in property of JavaScript objects`
+		}] : [];
+	}));
+}
+/**
+* The context-map rules the canvas enforces itself: its importer refuses a
+* repeated id (CmImporter.assertImportable), so the file does not open. The
+* other strategic-DDD rules are advisory there: the canvas opens the map and
+* marks the finding, so a save must not refuse it either.
+*/
+const CONTEXT_MAP_REFUSED_RULES = /* @__PURE__ */ new Set(["unique-ids"]);
+/** the path of every repeated id, in the order validateDocument's unique-ids
+*  rule reports them (contexts, then relationships): its findings name no
+*  position, and an agent must know which of two entries to change */
+function repeatedIdPaths({ contexts, relationships }) {
+	const seen = /* @__PURE__ */ new Set();
+	return Object.entries({
+		contexts,
+		relationships
+	}).flatMap(([collection, elements]) => elements.flatMap(({ id }, index) => {
+		const repeated = seen.has(id);
+		seen.add(id);
+		return repeated ? [issuePath([
+			collection,
+			index,
+			"id"
+		])] : [];
+	}));
+}
+function checkTeamTopology(raw, file) {
+	const parsed = parseDocument(JSON.parse(raw));
+	if (!parsed.ok) return parsed.issues.map(schemaError("team-topology/schema", file));
+	const { nodes, interactions, flows, annotations } = parsed.document;
+	return builtInPropertyIds({
+		nodes,
+		interactions,
+		flows,
+		annotations
+	}).map(schemaError("team-topology/schema", file));
+}
+function checkContextMap(raw, file) {
+	const parsed = parseDocumentText(raw);
+	const issues = parsed.ok ? [] : parsed.issues ?? [{
+		path: [],
+		message: parsed.error
+	}];
+	if (issues.some(({ path }) => path.length === 0 || path[0] === "version")) return issues.map(schemaError("context-map/schema", file));
+	const { contexts, relationships } = JSON.parse(raw);
+	const schemaFindings = [...issues, ...builtInPropertyIds({
+		contexts,
+		relationships
+	})].map(schemaError("context-map/schema", file));
+	if (!parsed.ok) return schemaFindings;
+	const repeatedIds = repeatedIdPaths(parsed.document);
+	const subject = (finding) => {
+		const path = finding.rule === "unique-ids" ? repeatedIds.shift() : void 0;
+		if (path) return `${path}: `;
+		return finding.relationshipId === void 0 ? "" : `relationship "${finding.relationshipId}": `;
+	};
+	const { errors, warnings } = validateDocument(parsed.document);
+	return [...schemaFindings, ...[...errors, ...warnings].map((finding) => {
+		const refused = CONTEXT_MAP_REFUSED_RULES.has(finding.rule);
+		return {
+			severity: refused ? "ERROR" : "WARN",
+			ruleId: refused ? "context-map/schema" : "context-map/semantics",
+			file,
+			message: `${subject(finding)}${finding.message} (${finding.rule})`
+		};
+	})];
+}
+function checkValueChain(raw, file) {
+	return documentIssues(JSON.parse(raw)).map(schemaError("value-chain/schema", file));
+}
+/** each JSON notation's schema model, read the way its canvas reads the file
+*  (a Map, not an object: the notation id may be a caller's free text such
+*  as "constructor") */
+const SCHEMA_CHECKS = /* @__PURE__ */ new Map([
+	["team-topology", {
+		ruleId: "team-topology/schema",
+		check: checkTeamTopology
+	}],
+	["context-map", {
+		ruleId: "context-map/schema",
+		check: checkContextMap
+	}],
+	["value-chain", {
+		ruleId: "value-chain/schema",
+		check: checkValueChain
+	}]
+]);
+/**
+* The schema check of a Miragon JSON notation (Team Topology, Context Map,
+* Value Chain): the file is parsed with the notation's schema model, the
+* same parse its canvas opens it with, so everything the model refuses (a
+* duplicate or reserved id, a coordinate out of range, a newer version) is
+* an ERROR — a save would otherwise land a file the canvas cannot open.
+* Text that is no JSON keeps the baseline's finding, and a notation without
+* a schema model gets the baseline alone. Pure: no filesystem, no
+* process.exit.
+*/
+function checkSchemaModel(raw, opts) {
+	const baseline = checkModelBaseline(raw, opts);
+	const schema = SCHEMA_CHECKS.get(opts.notation);
+	if (!schema || baseline.length > 0 || byId(opts.notation)?.docShape === "structured") return baseline;
+	const file = opts.file ?? `<${opts.notation}>`;
+	try {
+		return schema.check(raw, file);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return [{
+			severity: "ERROR",
+			ruleId: schema.ruleId,
+			file,
+			message: `(root): could not be checked: ${reason}`
+		}];
+	}
+}
 /**
 * THE one check dispatch: the platform check for whatever notation `ctx.path`
-* is — full checkers for BPMN/DMN, the mediaKind baseline for everything
-* else, plus the generic dangling-reference rule for ANY notation with a
-* refs emitter; `undefined` when the path matches no registered notation
-* (the file is not a model; nothing to check). Consumed by the CLI (runCli)
-* AND the Live Host's save gate (application/content.ts) so both always agree.
+* is — full checkers for BPMN/DMN, the schema model for the Miragon JSON
+* notations, the mediaKind baseline for everything else, plus the generic
+* dangling-reference rule for ANY notation with a refs emitter; `undefined`
+* when the path matches no registered notation (the file is not a model;
+* nothing to check) or `ctx.notation` names none (a mistyped id must not
+* pass a file unchecked). Consumed by the CLI (runCli) AND the Live Host's
+* save gate (application/content.ts) so both always agree.
 */
 function checkModel(raw, ctx) {
 	const notation = ctx.notation ?? byExtension(ctx.path)?.id;
-	if (!notation) return void 0;
-	return [...notation === "bpmn" ? checkBpmnXml(raw, { file: ctx.path }).findings : notation === "dmn" ? checkDmnXml(raw, { file: ctx.path }).findings : checkModelBaseline(raw, {
+	if (!notation || !byId(notation)) return void 0;
+	return [...notation === "bpmn" ? checkBpmnXml(raw, { file: ctx.path }).findings : notation === "dmn" ? checkDmnXml(raw, { file: ctx.path }).findings : checkSchemaModel(raw, {
 		file: ctx.path,
 		notation
 	}), ...checkRefs(notation, raw, ctx)];
@@ -586,7 +1063,7 @@ async function runCli() {
 	/** optional single-model filter (a model file stem) */
 	const only = argv[0];
 	const rel = (p) => p.startsWith("/") ? relative(ROOT, p) : p;
-	const { CONTENT_CONFIG_FILE, contentConfigConflict, discoverModels, legacyContentConfigFile, loadContentConfig } = await import("./content-Dld6ZUbs.js");
+	const { CONTENT_CONFIG_FILE, contentConfigConflict, discoverModels, legacyContentConfigFile, loadContentConfig } = await import("./content-CE4SulnP.js");
 	const cfg = loadContentConfig(ROOT);
 	if (!cfg) {
 		console.error(notContentRepoError(ROOT));
@@ -649,4 +1126,4 @@ async function runCli() {
 	process.exit(errorCount === 0 ? 0 : 1);
 }
 //#endregion
-export { runCli as a, checkModelBaseline as i, checkDmnXml as n, checkModel as r, checkBpmnXml as t };
+export { checkSchemaModel as a, checkModelBaseline as i, checkDmnXml as n, runCli as o, checkModel as r, checkBpmnXml as t };

package/dist/validate.js

@@ -1 +1 @@
-export { t as checkBpmnXml, n as checkDmnXml, r as checkModel, i as checkModelBaseline, a as runCli } from "./validate-Dy2lNoBR.js";
+export { t as checkBpmnXml, n as checkDmnXml, r as checkModel, i as checkModelBaseline, a as checkSchemaModel, o as runCli } from "./validate-BqkEd0ma.js";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@miragon/design-iq-validator",
-  "version": "5.4.0",
+  "version": "5.6.0",
   "type": "module",
-  "description": "Platform-owned validator for designIQ content repos — designiq.yml discovery, BPMN/DMN structure and diagram coverage, cross-model references, and a parse check for every other notation. Runs against any checkout via --root; never executes content-repo code.",
+  "description": "Platform-owned validator for designIQ content repos — designiq.yml discovery, BPMN/DMN structure and diagram coverage, cross-model references, the schema check of Team Topologies, Context Maps and Value Chains, and a parse check for every other notation. Runs against any checkout via --root; never executes content-repo code.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -32,10 +32,14 @@
   "publishConfig": {
     "access": "public"
   },
-  "//": "fast-xml-parser stays a RUNTIME dependency although src/ no longer imports it directly: tsdown inlines @designiq/notations (whose extract.ts imports it) but keeps npm deps external, so the published dist/ resolves it from here. Removing it breaks the npm artifact at import time while the workspace keeps working.",
+  "//": "fast-xml-parser stays a RUNTIME dependency although src/ no longer imports it directly: tsdown inlines @designiq/notations (whose extract.ts imports it) but keeps npm deps external, so the published dist/ resolves it from here. Removing it breaks the npm artifact at import time while the workspace keeps working. zod is a RUNTIME dependency for the same reason: src/ never imports it, but the team-topologies and context-maps schema models take it as a peer, and the published package is what provides it.",
   "dependencies": {
+    "@miragon/context-maps-schema-model": "0.3.0",
+    "@miragon/team-topologies-schema-model": "0.11.2",
+    "@miragon/value-chain-schema-model": "0.5.0",
     "fast-xml-parser": "5.11.2",
-    "yaml": "2.9.1"
+    "yaml": "2.9.1",
+    "zod": "4.6.7"
   },
   "devDependencies": {
     "tsdown": "0.23.1",