@metaobjectsdev/metadata 0.9.0 → 0.10.0

package/dist/template/template-schema.js

@@ -5,9 +5,9 @@
 // carries the LLM-overlay attrs. References (@payloadRef, @textRef) are plain
 // strings here — resolution against a real payload / text source is render-time
 // `verify` scope (Plan #3), not load-time validation.
-import { ATTR_SUBTYPE_STRING, ATTR_SUBTYPE_INT, ATTR_SUBTYPE_STRINGARRAY, } from "../core/attr/attr-constants.js";
+import { ATTR_SUBTYPE_STRING, ATTR_SUBTYPE_INT, } from "../core/attr/attr-constants.js";
 import { SUBTYPE_BASE } from "../shared/base-types.js";
-import { TEMPLATE_SUBTYPE_PROMPT, TEMPLATE_SUBTYPE_OUTPUT, TEMPLATE_SUBTYPE_TOOLCALL, TEMPLATE_ATTR_PAYLOAD_REF, TEMPLATE_ATTR_TEXT_REF, TEMPLATE_ATTR_FORMAT, TEMPLATE_ATTR_MAX_CHARS, TEMPLATE_ATTR_OWNER, TEMPLATE_ATTR_SINCE, TEMPLATE_ATTR_REQUIRED_TAGS, TEMPLATE_ATTR_MAX_TOKENS, TEMPLATE_ATTR_REQUIRED_SLOTS, TEMPLATE_ATTR_MODEL, TEMPLATE_ATTR_TOOL_NAME, TEMPLATE_FORMATS, TEMPLATE_ATTR_PROMPT_STYLE, PROMPT_STYLE_DEFAULT, PROMPT_STYLES, TEMPLATE_ATTR_KIND, TEMPLATE_KINDS, TEMPLATE_KIND_DEFAULT, TEMPLATE_ATTR_SUBJECT_REF, TEMPLATE_ATTR_HTML_BODY_REF, TEMPLATE_ATTR_TEXT_BODY_REF, } from "./template-constants.js";
+import { TEMPLATE_SUBTYPE_PROMPT, TEMPLATE_SUBTYPE_OUTPUT, TEMPLATE_SUBTYPE_TOOLCALL, TEMPLATE_ATTR_PAYLOAD_REF, TEMPLATE_ATTR_TEXT_REF, TEMPLATE_ATTR_FORMAT, TEMPLATE_ATTR_MAX_CHARS, TEMPLATE_ATTR_OWNER, TEMPLATE_ATTR_SINCE, TEMPLATE_ATTR_REQUIRED_TAGS, TEMPLATE_ATTR_RESPONSE_REF, TEMPLATE_ATTR_MAX_TOKENS, TEMPLATE_ATTR_REQUIRED_SLOTS, TEMPLATE_ATTR_MODEL, TEMPLATE_ATTR_TOOL_NAME, TEMPLATE_FORMATS, TEMPLATE_ATTR_PROMPT_STYLE, PROMPT_STYLE_DEFAULT, PROMPT_STYLES, TEMPLATE_ATTR_KIND, TEMPLATE_KINDS, TEMPLATE_KIND_DEFAULT, TEMPLATE_ATTR_SUBJECT_REF, TEMPLATE_ATTR_HTML_BODY_REF, TEMPLATE_ATTR_TEXT_BODY_REF, } from "./template-constants.js";
 // Generic attrs shared by template.prompt and template.output.
 const genericAttrs = [
     {
@@ -55,7 +55,8 @@ const genericAttrs = [
     },
     {
         name: TEMPLATE_ATTR_REQUIRED_TAGS,
-        valueType: ATTR_SUBTYPE_STRINGARRAY,
+        valueType: ATTR_SUBTYPE_STRING,
+        isArray: true,
         required: false,
         description: "Output tags the rendered text must contain (drives the verify output-tag check).",
     },
@@ -114,7 +115,8 @@ const promptOverlayAttrs = [
     },
     {
         name: TEMPLATE_ATTR_REQUIRED_SLOTS,
-        valueType: ATTR_SUBTYPE_STRINGARRAY,
+        valueType: ATTR_SUBTYPE_STRING,
+        isArray: true,
         required: false,
         description: "Slots that must resolve at render time (drives the verify check).",
     },
@@ -124,6 +126,12 @@ const promptOverlayAttrs = [
         required: false,
         description: "Target model id (LLM-specific).",
     },
+    {
+        name: TEMPLATE_ATTR_RESPONSE_REF,
+        valueType: ATTR_SUBTYPE_STRING,
+        required: false,
+        description: "Optional ref to the response value-object this prompt expects (peer of @payloadRef; drives typed LLM-call trace derivation).",
+    },
 ];
 // Toolcall attrs (template.toolcall only — does NOT inherit genericAttrs).
 // Per ADR-0011: vendor-agnostic in core; vendor wire details (retry semantics,

package/dist/template/template-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"template-schema.js","sourceRoot":"","sources":["../../src/template/template-schema.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,EAAE;AACF,kFAAkF;AAClF,4EAA4E;AAC5E,8EAA8E;AAC9E,gFAAgF;AAChF,sDAAsD;AAGtD,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,yBAAyB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,mBAAmB,EACnB,2BAA2B,EAC3B,wBAAwB,EACxB,4BAA4B,EAC5B,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,0BAA0B,EAC1B,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,yBAAyB,EACzB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,yBAAyB,CAAC;AAEjC,+DAA+D;AAC/D,MAAM,YAAY,GAAiB;IACjC;QACE,IAAI,EAAE,yBAAyB;QAC/B,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,IAAI;QACd,WAAW,EAAE,sFAAsF;KACpG;IACD;QACE,IAAI,EAAE,sBAAsB;QAC5B,SAAS,EAAE,mBAAmB;QAC9B,gFAAgF;QAChF,gFAAgF;QAChF,iFAAiF;QACjF,kFAAkF;QAClF,8BAA8B;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,mGAAmG;KACjH;IACD;QACE,IAAI,EAAE,oBAAoB;QAC1B,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,MAAM;QACf,aAAa,EAAE,CAAC,GAAG,gBAAgB,CAAC;QACpC,WAAW,EAAE,yEAAyE;KACvF;IACD;QACE,IAAI,EAAE,uBAAuB;QAC7B,SAAS,EAAE,gBAAgB;QAC3B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,qDAAqD;KACnE;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,yCAAyC;KACvD;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,0DAA0D;KACxE;IACD;QACE,IAAI,EAAE,2BAA2B;QACjC,SAAS,EAAE,wBAAwB;QACnC,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,kFAAkF;KAChG;CACF,CAAC;AAEF,qFAAqF;AACrF,iFAAiF;AACjF,MAAM,eAAe,GAAe;IAClC,IAAI,EAAE,0BAA0B;IAChC,SAAS,EAAE,mBAAmB;IAC9B,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE,oBAAoB;IAC7B,aAAa,EAAE,CAAC,GAAG,aAAa,CAAC;IACjC,WAAW,EACT,qMAAqM;CACxM,CAAC;AAEF,kDAAkD;AAClD,EAAE;AACF,4EAA4E;AAC5E,kFAAkF;AAClF,mFAAmF;AACnF,yEAAyE;AACzE,MAAM,eAAe,GAAiB;IACpC;QACE,IAAI,EAAE,kBAAkB;QACxB,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,qBAAqB;QAC9B,aAAa,EAAE,CAAC,GAAG,cAAc,CAAC;QAClC,WAAW,EACT,uJAAuJ;KAC1J;IACD;QACE,IAAI,EAAE,yBAAyB;QAC/B,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,+GAA+G;KAC7H;IACD;QACE,IAAI,EAAE,2BAA2B;QACjC,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,4GAA4G;KAC1H;IACD;QACE,IAAI,EAAE,2BAA2B;QACjC,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,mGAAmG;KACjH;CACF,CAAC;AAEF,4CAA4C;AAC5C,MAAM,kBAAkB,GAAiB;IACvC;QACE,IAAI,EAAE,wBAAwB;QAC9B,SAAS,EAAE,gBAAgB;QAC3B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,sDAAsD;KACpE;IACD;QACE,IAAI,EAAE,4BAA4B;QAClC,SAAS,EAAE,wBAAwB;QACnC,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,mEAAmE;KACjF;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,iCAAiC;KAC/C;CACF,CAAC;AAEF,2EAA2E;AAC3E,+EAA+E;AAC/E,uEAAuE;AACvE,mFAAmF;AACnF,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,mDAAmD;AACnD,EAAE;AACF,iFAAiF;AACjF,gFAAgF;AAChF,oEAAoE;AACpE,MAAM,aAAa,GAAiB;IAClC;QACE,IAAI,EAAE,uBAAuB;QAC7B,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,IAAI;QACd,WAAW,EAAE,8DAA8D;KAC5E;IACD;QACE,IAAI,EAAE,yBAAyB;QAC/B,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,IAAI;QACd,WAAW,EAAE,yEAAyE;KACvF;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,yCAAyC;KACvD;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,SAAS,EAAE,mBAAmB;QAC9B,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,0DAA0D;KACxE;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAuB;IAC9D,CAAC,YAAY,EAAE,EAAE,CAAC;IAClB,CAAC,uBAAuB,EAAE,CAAC,GAAG,YAAY,EAAE,GAAG,kBAAkB,CAAC,CAAC;IACnE,CAAC,uBAAuB,EAAE,CAAC,GAAG,YAAY,EAAE,eAAe,EAAE,GAAG,eAAe,CAAC,CAAC;IACjF,CAAC,yBAAyB,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC;CAChD,CAAC,CAAC"}
+{"version":3,"file":"template-schema.js","sourceRoot":"","sources":["../../src/template/template-schema.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaobjectsdev/metadata",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Metamodel loader, types, and constants for the MetaObjects standard.",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,7 +17,12 @@
       "default": "./dist/core/index.js"
     }
   },
-  "files": ["dist", "src", "README.md", "LICENSE"],
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc -p .",
     "typecheck": "tsc -p tsconfig.typecheck.json",
@@ -27,24 +32,30 @@
   "author": "Doug Mealing <doug@dougmealing.com>",
   "homepage": "https://metaobjects.dev",
   "bugs": {
-  "url": "https://github.com/metaobjectsdev/metaobjects/issues"
-},
-"repository": {
-  "type": "git",
-  "url": "https://github.com/metaobjectsdev/metaobjects.git",
-  "directory": "server/typescript/packages/metadata"
-},
-"keywords": ["metaobjects", "metadata", "schema", "loader", "typescript"],
-"publishConfig": {
-"access": "public"
-},
-"dependencies": {
-  "yaml": "^2.9.0"
-},
-"devDependencies": {
-  "@metaobjectsdev/conformance": "0.1.0",
-  "@stryker-mutator/core": "^9.6.1",
-  "bun-types": "latest",
-  "typescript": "^5.6.0"
-}
+    "url": "https://github.com/metaobjectsdev/metaobjects/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/metaobjectsdev/metaobjects.git",
+    "directory": "server/typescript/packages/metadata"
+  },
+  "keywords": [
+    "metaobjects",
+    "metadata",
+    "schema",
+    "loader",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@metaobjectsdev/conformance": "0.1.0",
+    "@stryker-mutator/core": "^9.6.1",
+    "bun-types": "latest",
+    "typescript": "^5.6.0"
+  }
 }

package/src/attr-schema-validate.ts

@@ -12,7 +12,21 @@
 //                                      MetaAttr instance's own validateValue.
 //   3. allowedValues honored        — declared attrs with a non-empty
 //                                      allowedValues set must hold a member value.
-//   4. Undeclared attrs             — NOT an error, NOT a warning (open policy).
+//   4. Undeclared attrs             — under strict load (ADR-0023) an own
+//                                      @-attr that matches NO per-type attr
+//                                      schema AND NO commonAttr is an
+//                                      ERR_UNKNOWN_ATTR. In lax mode (strict
+//                                      false) it stays the legacy open policy:
+//                                      NOT an error, NOT a warning. Own-only,
+//                                      so an inherited/overlaid declared attr
+//                                      (validated on its declaring node) is fine.
+//   5. Structural-child placement    — FR-033: under strict load a STRUCTURAL
+//      (Check 0b)                       child (field/identity/source/… — not an
+//                                      attr) not admitted by the parent's
+//                                      registered childRules is ERR_CHILD_NOT_
+//                                      ALLOWED (the structural analogue of #4). A
+//                                      no-op under today's wildcard childRules —
+//                                      the rail strict per-subtype rules use in S1.
 //
 // `default` values are NOT auto-applied — A3 is pure validation, not mutation.
 //
@@ -30,7 +44,9 @@
 import type { MetaData } from "./shared/meta-data.js";
 import { ParseError } from "./errors.js";
 import type { AttrSchema, TypeRegistry } from "./registry.js";
+import { childRuleMatches } from "./registry.js";
 import { TYPE_FIELD } from "./shared/base-types.js";
+import { ATTR_SUBTYPE_PROPERTIES } from "./core/attr/attr-constants.js";
 import {
   FIELD_SUBTYPE_ENUM,
   FIELD_ATTR_VALUES,
@@ -57,13 +73,18 @@ export interface AttrSchemaValidationResult {
 export function validateAttrSchema(
   root: MetaData,
   registry: TypeRegistry,
+  // ADR-0023 — strict load closes the open-attr policy: an own @-attr matching
+  // no per-type schema and no commonAttr → ERR_UNKNOWN_ATTR. Defaults false so
+  // existing lax callers keep the legacy open policy; the library's own loader
+  // (and the conformance runner) load strict.
+  strict = false,
 ): AttrSchemaValidationResult {
   const errors: ParseError[] = [];
   // Tracks (type.subType) pairs for which ERR_PROVIDER_ATTR_CONFLICT has already
   // been emitted. The conflict is a registry-state condition, not a per-node
   // condition — emit it once per (type, subType), not once per node instance.
   const reportedConflicts = new Set<string>();
-  walk(root, registry, errors, reportedConflicts);
+  walk(root, registry, errors, reportedConflicts, strict);
   return { errors, warnings: [] };
 }
 
@@ -72,10 +93,11 @@ function walk(
   registry: TypeRegistry,
   errors: ParseError[],
   reportedConflicts: Set<string>,
+  strict: boolean,
 ): void {
-  validateNode(node, registry, errors, reportedConflicts);
+  validateNode(node, registry, errors, reportedConflicts, strict);
   for (const child of node.ownChildren()) {
-    walk(child, registry, errors, reportedConflicts);
+    walk(child, registry, errors, reportedConflicts, strict);
   }
 }
 
@@ -90,6 +112,7 @@ function validateNode(
   registry: TypeRegistry,
   errors: ParseError[],
   reportedConflicts: Set<string>,
+  strict: boolean,
 ): void {
   // Build the effective schema in a single pass: per-type attrs win on name
   // collision; common attrs fill in for unclaimed names. Surface common-vs-per-type
@@ -118,6 +141,75 @@ function validateNode(
     byName.set(ca.name, ca);
   }
 
+  // --- Check 0 (ADR-0023): strict-load undeclared-attr rejection ---
+  //
+  // Runs BEFORE the byName.size early-return: a node type with no per-type
+  // schema and no common attrs (byName empty) must still reject an authored
+  // @-attr under strict. Own-attrs only — an inherited/overlaid declared attr
+  // was validated on its declaring node and never appears in ownMetaAttrs().
+  // An own attr matching neither a per-type schema entry nor a commonAttr is
+  // a made-up attribute → ERR_UNKNOWN_ATTR (closing the open policy). In lax
+  // mode this stays a no-op (legacy open-attr behavior).
+  if (strict) {
+    for (const inst of node.ownMetaAttrs()) {
+      // attr.properties is a first-class, registered, canonical attr subtype
+      // whose designed purpose is an arbitrary-named structural property bag
+      // (its NAME is intentionally not declared by any per-type schema). It is
+      // sanctioned vocabulary, not a made-up attribute, so strict-attr exempts
+      // a materialized properties-attr from ERR_UNKNOWN_ATTR. (A typo'd plain
+      // @-attr still fails — only the `properties` subtype is exempt.)
+      if (inst.subType === ATTR_SUBTYPE_PROPERTIES) continue;
+      if (!byName.has(inst.name)) {
+        errors.push(
+          new ParseError(
+            `Unknown attribute '@${inst.name}' on ${nodeLabel(node)} — ` +
+              `not declared by any registered provider for ${typeKey}`,
+            { code: "ERR_UNKNOWN_ATTR", source: node.source },
+          ),
+        );
+      }
+    }
+  }
+
+  // --- Check 0b (FR-033): strict-load structural-child placement ---
+  //
+  // The structural analogue of Check 0. A STRUCTURAL child (field/identity/
+  // source/validator/… — attrs never appear in ownChildren()) must be admitted
+  // by the parent's registered childRules under the same wildcard match
+  // semantics used everywhere (childType/childSubType/childName may be "*", and
+  // childSubType may be a list). A child the rules do not admit → ERR_CHILD_NOT_
+  // ALLOWED. A NO-OP today: every parent carries wildcard structural childRules
+  // (e.g. field.* / validator.*) that admit everything — the rail strict
+  // per-subtype rules will use in S1. Lax mode keeps the legacy open policy.
+  //
+  // An UNREGISTERED parent (no def) cannot be judged here (ERR_UNKNOWN_TYPE /
+  // ERR_UNKNOWN_SUBTYPE is reported elsewhere); skip so we never double-report.
+  if (strict) {
+    const parentDef = registry.find(node.type, node.subType);
+    if (parentDef !== undefined) {
+      const rules = parentDef.childRules;
+      for (const child of node.ownChildren()) {
+        const admitted = rules.some((r) =>
+          childRuleMatches(r, {
+            type: child.type,
+            subType: child.subType,
+            name: child.name,
+          }),
+        );
+        if (!admitted) {
+          errors.push(
+            new ParseError(
+              `Child ${nodeLabel(child)} is not allowed under ${nodeLabel(node)} — ` +
+                `no registered child rule for ${typeKey} admits ` +
+                `(type='${child.type}', subType='${child.subType}', name='${child.name}')`,
+              { code: "ERR_CHILD_NOT_ALLOWED", source: node.source },
+            ),
+          );
+        }
+      }
+    }
+  }
+
   if (byName.size === 0) return;
 
   // --- Check 1: required attrs present ---

package/src/constraint-validate.ts

@@ -0,0 +1,363 @@
+// FR-033 — the metamodel contradiction validator (spec §3.1, the six checks).
+//
+// `validateConstraints(effective, registry)` runs the six contradiction checks over
+// the merged constraint graph and returns one MetaModelError per contradiction
+// (code ERR_INVALID_METAMODEL_CONSTRAINT). It is the cross-validation pass: the merge
+// (constraint-merge.ts) is purely additive, so this pass is the ONLY place a bad
+// provider set is rejected. Wired into composeRegistry's seal-time bootstrap so a
+// contradictory library provider set fails fast (mirrors ADR-0023 strictness).
+//
+// The six checks (spec §3.1):
+//   1. Dangling ref       — a parents/children rule references an unregistered type.subType.
+//   2. Unsatisfiable req.  — a required child (min>=1) whose concrete type.subType is
+//                            not admitted under that parent (after merge).
+//   3. Bad cardinality     — min>max (max non-null), max:0 with min>=1, or min<0.
+//   4. Closed-set clash    — child C claims parent P via `parents`, but P's OWN children
+//                            is a CLOSED set (no `*` wildcard) that does not admit C.
+//   5. Required-child cycle— following required (min>=1) child edges forms a cycle.
+//   6. Conflicting attr    — same attr name contributed twice (across providers or the
+//                            extends chain) with a conflicting valueType/required/default.
+
+import type {
+  AttrSchema,
+  ChildRule,
+  TypeRegistry,
+  TypeDefinition,
+} from "./registry.js";
+import { childRuleMatches } from "./registry.js";
+import { CHILD_RULE_WILDCARD } from "./shared/structural.js";
+import { SUBTYPE_BASE } from "./shared/base-types.js";
+import { MetaModelError } from "./errors.js";
+import type { EffectiveConstraints } from "./constraint-merge.js";
+
+const CODE = "ERR_INVALID_METAMODEL_CONSTRAINT" as const;
+
+/** Run the six contradiction checks; one MetaModelError per contradiction. */
+export function validateConstraints(
+  effective: Map<string, EffectiveConstraints>,
+  registry: TypeRegistry,
+): MetaModelError[] {
+  const errors: MetaModelError[] = [];
+  const registered = new Set(
+    registry.allTypes().map((id) => `${id.type}.${id.subType}`),
+  );
+
+  const sortedKeys = [...effective.keys()].sort();
+
+  for (const k of sortedKeys) {
+    const eff = effective.get(k)!;
+
+    // --- #1 dangling ref (children) + #3 bad cardinality.
+    for (const rule of eff.children) {
+      checkDangling(k, rule, registered, errors);
+      checkCardinality(k, rule, errors);
+    }
+
+    // --- #1 dangling ref (parents).
+    for (const parent of eff.parents) {
+      if (!registered.has(parent)) {
+        errors.push(
+          err(`dangling: type "${k}" claims parent "${parent}", which is not registered.`),
+        );
+      }
+    }
+
+    // --- #2 unsatisfiable required child.
+    for (const rule of eff.children) {
+      checkUnsatisfiable(k, rule, registered, errors);
+    }
+  }
+
+  // --- #4 closed-set clash: a child's `parents` claim vs the parent's OWN children.
+  for (const id of registry.allTypes()) {
+    const childKey = `${id.type}.${id.subType}`;
+    const def = registry.find(id.type, id.subType);
+    for (const parent of def?.parents ?? []) {
+      checkClosedSetClash(childKey, id.type, id.subType, parent, registry, errors);
+    }
+  }
+
+  // --- #5 required-child cycle.
+  checkRequiredCycles(effective, sortedKeys, errors);
+
+  // --- #6 conflicting attr redefinition (across the extends chain + providers).
+  for (const id of registry.allTypes()) {
+    checkAttrConflicts(id.type, id.subType, registry, registered, errors);
+  }
+
+  return errors;
+}
+
+function err(detail: string): MetaModelError {
+  return new MetaModelError(`Invalid metamodel constraint — ${detail}`, { code: CODE });
+}
+
+/** #1 — a concrete (non-wildcard) child rule whose type.subType is unregistered. */
+function checkDangling(
+  parentKey: string,
+  rule: ChildRule,
+  registered: ReadonlySet<string>,
+  errors: MetaModelError[],
+): void {
+  if (rule.childType === CHILD_RULE_WILDCARD) return; // a wildcard names nothing
+  const subTypes = subTypesOf(rule);
+  for (const sub of subTypes) {
+    if (sub === CHILD_RULE_WILDCARD) continue; // wildcard subtype names nothing
+    const refKey = `${rule.childType}.${sub}`;
+    if (!registered.has(refKey)) {
+      errors.push(
+        err(
+          `dangling: child rule on "${parentKey}" references "${refKey}", which is not registered.`,
+        ),
+      );
+    }
+  }
+}
+
+/** #3 — min<0, min>max (max non-null), or max:0 with min>=1. */
+function checkCardinality(
+  parentKey: string,
+  rule: ChildRule,
+  errors: MetaModelError[],
+): void {
+  const min = rule.min ?? 0;
+  const max = rule.max ?? null;
+  const label = describeRule(rule);
+  if (min < 0) {
+    errors.push(err(`bad cardinality on "${parentKey}" (${label}): min ${min} < 0.`));
+    return;
+  }
+  if (max !== null && max < min) {
+    errors.push(
+      err(`bad cardinality on "${parentKey}" (${label}): min ${min} > max ${max}.`),
+    );
+    return;
+  }
+  if (max === 0 && min >= 1) {
+    errors.push(
+      err(`bad cardinality on "${parentKey}" (${label}): max 0 with min ${min} >= 1.`),
+    );
+  }
+}
+
+/**
+ * #2 — a required child rule (min>=1) naming concrete subtype(s) where NONE of the
+ * named type.subTypes is admitted under this parent (after merge). A required rule
+ * with a wildcard type is always satisfiable; a required rule naming a concrete
+ * subtype that is registered AND covered by an admitting rule (the rule itself, or
+ * another rule) is satisfiable. Unsatisfiable iff the required child cannot be placed.
+ */
+function checkUnsatisfiable(
+  parentKey: string,
+  rule: ChildRule,
+  registered: ReadonlySet<string>,
+  errors: MetaModelError[],
+): void {
+  const min = rule.min ?? 0;
+  if (min < 1) return; // optional → nothing to satisfy
+  if (rule.childType === CHILD_RULE_WILDCARD) return; // any child satisfies it
+
+  // A required rule must name at least one concrete, REGISTERED subtype that some
+  // rule (incl. itself) admits. If none of its named subtypes is registered, the
+  // required child can never be instantiated → unsatisfiable.
+  const subTypes = subTypesOf(rule);
+  const concrete = subTypes.filter((s) => s !== CHILD_RULE_WILDCARD);
+  if (concrete.length === 0) return; // required of `type.*` — any registered subtype satisfies
+
+  const anyRegistered = concrete.some((s) => registered.has(`${rule.childType}.${s}`));
+  if (!anyRegistered) {
+    errors.push(
+      err(
+        `unsatisfiable required child on "${parentKey}" (${describeRule(rule)}): ` +
+          `min ${min} but no named subtype of "${rule.childType}" is registered.`,
+      ),
+    );
+  }
+}
+
+/**
+ * #4 — child C declares parent P via `parents`, but P's OWN children is a CLOSED set
+ * (no `*` wildcard rule) that does not admit C. An OPEN parent (any `*` rule) admits
+ * anything → no clash.
+ */
+function checkClosedSetClash(
+  childKey: string,
+  childType: string,
+  childSubType: string,
+  parentKey: string,
+  registry: TypeRegistry,
+  errors: MetaModelError[],
+): void {
+  const parentDef = lookup(parentKey, registry);
+  if (parentDef === undefined) return; // dangling parent — reported by #1
+
+  const ownRules = parentDef.childRules;
+  const isOpen = ownRules.some((r) => isWildcardRule(r));
+  if (isOpen) return; // open parent admits anything
+
+  const admits = ownRules.some((r) =>
+    childRuleMatches(r, { type: childType, subType: childSubType, name: CHILD_RULE_WILDCARD }),
+  );
+  if (!admits) {
+    errors.push(
+      err(
+        `closed-set clash: child "${childKey}" claims parent "${parentKey}", but ` +
+          `"${parentKey}"'s children is a closed set (no wildcard) that does not admit it.`,
+      ),
+    );
+  }
+}
+
+/**
+ * #5 — required-child cycle: following required (min>=1) child edges forms a cycle.
+ * An edge A→B exists when A has a required rule naming a concrete subtype B. A cycle
+ * with no non-required escape can never bottom out (A requires B requires A).
+ */
+function checkRequiredCycles(
+  effective: Map<string, EffectiveConstraints>,
+  sortedKeys: string[],
+  errors: MetaModelError[],
+): void {
+  // Build the required-edge adjacency: A → each concrete required child subtype.
+  const edges = new Map<string, string[]>();
+  for (const k of sortedKeys) {
+    const targets: string[] = [];
+    for (const rule of effective.get(k)!.children) {
+      if ((rule.min ?? 0) < 1) continue;
+      if (rule.childType === CHILD_RULE_WILDCARD) continue;
+      for (const sub of subTypesOf(rule)) {
+        if (sub === CHILD_RULE_WILDCARD) continue;
+        targets.push(`${rule.childType}.${sub}`);
+      }
+    }
+    edges.set(k, targets);
+  }
+
+  // DFS for back-edges; report each distinct cycle once (keyed by its sorted node set).
+  const WHITE = 0,
+    GRAY = 1,
+    BLACK = 2;
+  const color = new Map<string, number>();
+  const reported = new Set<string>();
+  const stack: string[] = [];
+
+  const visit = (node: string): void => {
+    color.set(node, GRAY);
+    stack.push(node);
+    for (const next of edges.get(node) ?? []) {
+      if (!edges.has(next)) continue; // unregistered target — #1/#2 handles it
+      const c = color.get(next) ?? WHITE;
+      if (c === GRAY) {
+        // Back-edge → cycle. Extract the cycle slice from the stack.
+        const idx = stack.indexOf(next);
+        const cycle = stack.slice(idx);
+        const sig = [...cycle].sort().join(",");
+        if (!reported.has(sig)) {
+          reported.add(sig);
+          errors.push(
+            err(
+              `required-child cycle that cannot bottom out: ${cycle.concat(next).join(" -> ")}.`,
+            ),
+          );
+        }
+      } else if (c === WHITE) {
+        visit(next);
+      }
+    }
+    stack.pop();
+    color.set(node, BLACK);
+  };
+
+  for (const k of sortedKeys) {
+    if ((color.get(k) ?? WHITE) === WHITE) visit(k);
+  }
+}
+
+/**
+ * #6 — the same attr name contributed twice (across providers, or down the extends
+ * chain) with a CONFLICTING valueType / required / default. Walks each type's own
+ * attrs + its derived super (`<type>.base`) chain and compares same-name pairs.
+ */
+function checkAttrConflicts(
+  type: string,
+  subType: string,
+  registry: TypeRegistry,
+  registered: ReadonlySet<string>,
+  errors: MetaModelError[],
+): void {
+  // Collect (attr, source-key) along the own → super chain.
+  const seen = new Map<string, { attr: AttrSchema; from: string }>();
+  const reported = new Set<string>();
+
+  let curType: string | undefined = type;
+  let curSub: string | undefined = subType;
+  const guard = new Set<string>();
+  while (curType !== undefined && curSub !== undefined) {
+    const k = `${curType}.${curSub}`;
+    if (guard.has(k)) break;
+    guard.add(k);
+    const def = registry.find(curType, curSub);
+    if (def !== undefined) {
+      for (const attr of def.attributes) {
+        const prior = seen.get(attr.name);
+        if (prior === undefined) {
+          seen.set(attr.name, { attr, from: k });
+        } else if (attrsConflict(prior.attr, attr)) {
+          const sig = `${attr.name}|${prior.from}|${k}`;
+          if (!reported.has(sig)) {
+            reported.add(sig);
+            errors.push(
+              err(
+                `conflicting attr redefinition: attr "${attr.name}" is declared on ` +
+                  `"${prior.from}" and "${k}" with a conflicting valueType/required/default.`,
+              ),
+            );
+          }
+        }
+      }
+    }
+    // Advance up the derived super chain (`<type>.base`).
+    if (curSub === SUBTYPE_BASE) break;
+    const baseKey = `${curType}.${SUBTYPE_BASE}`;
+    if (!registered.has(baseKey)) break;
+    curSub = SUBTYPE_BASE;
+  }
+}
+
+/** Two same-name attrs conflict iff valueType, required, or default differ. */
+function attrsConflict(a: AttrSchema, b: AttrSchema): boolean {
+  return (
+    a.valueType !== b.valueType ||
+    a.required !== b.required ||
+    !Object.is(a.default, b.default)
+  );
+}
+
+// --- helpers ---------------------------------------------------------------
+
+function subTypesOf(rule: ChildRule): string[] {
+  const s = rule.childSubType;
+  return typeof s === "string" ? [s] : [...s];
+}
+
+function isWildcardRule(rule: ChildRule): boolean {
+  // An OPEN hook is a TYPE-wildcard rule (`*.*` / `*` of any subType) — it admits a
+  // child of any type, so a new type can land under this parent. A `field.*` rule is
+  // NOT open in this sense: it admits any field SUBTYPE but no other type, so a
+  // `policy` child still clashes. Per spec §3.1 #4, the open escape is a `*` (type)
+  // wildcard rule.
+  return rule.childType === CHILD_RULE_WILDCARD;
+}
+
+function describeRule(rule: ChildRule): string {
+  const sub = Array.isArray(rule.childSubType)
+    ? `[${rule.childSubType.join(",")}]`
+    : rule.childSubType;
+  return `${rule.childType}.${sub} ${rule.childName}`;
+}
+
+function lookup(key: string, registry: TypeRegistry): TypeDefinition | undefined {
+  const dot = key.indexOf(".");
+  if (dot < 0) return undefined;
+  return registry.find(key.slice(0, dot), key.slice(dot + 1));
+}