@miragon/design-iq-validator 5.5.0 → 5.6.0

package/README.md

@@ -3,13 +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` 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.
+`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-DjtZJTGk.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-Bsv9ZLFd.js → content-Bu1bNrez.js}

@@ -537,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 = {
@@ -801,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-wjC_epKd.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-Bsv9ZLFd.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-DjtZJTGk.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-Bsv9ZLFd.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 = [];
@@ -718,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>";
@@ -809,8 +812,8 @@ function mermaidFenceProblem(content, line) {
 * 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}>`;
@@ -856,18 +859,162 @@ function checkModelBaseline(raw, opts) {
 	}
 	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)];
@@ -916,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-wjC_epKd.js");
+	const { CONTENT_CONFIG_FILE, contentConfigConflict, discoverModels, legacyContentConfigFile, loadContentConfig } = await import("./content-CE4SulnP.js");
 	const cfg = loadContentConfig(ROOT);
 	if (!cfg) {
 		console.error(notContentRepoError(ROOT));
@@ -979,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-DjtZJTGk.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.5.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",