@primmel/primmel 1.19.0 → 1.21.0

package/dist-cli/primmel.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // scripts/check.mts
-import { existsSync as existsSync7, readdirSync as readdirSync6, statSync as statSync4, writeFileSync } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync7, statSync as statSync4, writeFileSync } from "node:fs";
+import { join as join9 } from "node:path";
 
 // src/check.ts
 import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
@@ -186,6 +186,52 @@ function createDuplicateIdChecker() {
 // src/ser-des/parse.ts
 function parse(mmelString, parsers, options = {}) {
   const tokens = tokenizeWithPositions(mmelString);
+  const declarations = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const tok = tokens[i++];
+    const cfg = parsers[tok.value];
+    if (!cfg) {
+      if (options.strict) {
+        throw new Error(
+          `Unknown keyword "${tok.value}" at line ${tok.start.line} col ${tok.start.col}. Use lenient mode (default) to skip unknown keywords.`
+        );
+      }
+      continue;
+    }
+    if (cfg.takesID) {
+      if (i + 1 > tokens.length) {
+        throw new Error(
+          `Keyword "${tok.value}" at line ${tok.start.line} col ${tok.start.col} expects an ID and payload, but only ${tokens.length - i + 1} token(s) remain.`
+        );
+      }
+      const idTok = tokens[i++];
+      const payloadTok = tokens[i++];
+      declarations.push({
+        keyword: tok.value,
+        id: idTok.value,
+        payload: payloadTok.value,
+        start: tok.start,
+        end: payloadTok.end
+      });
+    } else {
+      if (i >= tokens.length) {
+        throw new Error(
+          `Keyword "${tok.value}" at line ${tok.start.line} col ${tok.start.col} expects a payload, but no tokens remain.`
+        );
+      }
+      const payloadTok = tokens[i++];
+      declarations.push({
+        keyword: tok.value,
+        payload: payloadTok.value,
+        start: tok.start,
+        end: payloadTok.end
+      });
+    }
+  }
+  return parseDeclarations(declarations, parsers, options);
+}
+function parseDeclarations(declarations, parsers, options = {}) {
   const dupChecker = createDuplicateIdChecker();
   const constructs = [];
   let ctx = {
@@ -196,7 +242,6 @@ function parse(mmelString, parsers, options = {}) {
     roles: {},
     processes: {},
     // The abstract-process models (smart TODO.roadmap/40 batch 2)
-    processModels: {},
     pages: {},
     gateways: {},
     regs: {},
@@ -258,11 +303,10 @@ function parse(mmelString, parsers, options = {}) {
     evaluationDimensions: {},
     evaluationProfiles: {},
     // The certificate rendering contract (batch 3)
+    attestations: {},
     certificateTemplates: {},
     // The certification workflow step register (batch 3)
-    workflowConfigs: {},
     // The named pipeline stages (batch 5)
-    workflowStages: {},
     // The verification pathways (batch 3)
     verificationPathways: {},
     // The selection rules (batch 3)
@@ -298,8 +342,6 @@ function parse(mmelString, parsers, options = {}) {
     documentModules: {},
     informativeAnnexes: {},
     partAnnexes: {},
-    demoWorlds: {},
-    storylines: {},
     // Primmel v3 twin interface (TODO.roadmap/32)
     connectorProfiles: {},
     // Primmel v3 continuous compliance (TODO.roadmap/34)
@@ -322,11 +364,23 @@ function parse(mmelString, parsers, options = {}) {
     // Issue collection (duplicate IDs, etc.)
     issues: []
   };
-  let i = 0;
-  while (i < tokens.length) {
-    const tok = tokens[i++];
-    const keyword = tok.value;
+  for (const decl of declarations) {
+    const tok = { start: decl.start };
+    const keyword = decl.keyword;
     const cfg = parsers[keyword];
+    if (cfg?.deprecated) {
+      ctx.issues.push({
+        severity: "warning",
+        code: "construct-deprecated",
+        construct: keyword,
+        message: `construct "${keyword}" at line ${tok.start.line} col ${tok.start.col} is deprecated: ${cfg.deprecated} (construct-deprecated)`,
+        position: {
+          line: tok.start.line,
+          col: tok.start.col,
+          offset: tok.start.offset
+        }
+      });
+    }
     if (!cfg) {
       if (options.strict) {
         throw new Error(
@@ -337,13 +391,8 @@ function parse(mmelString, parsers, options = {}) {
     }
     let updateCtx;
     if (cfg.takesID) {
-      if (i + 1 > tokens.length) {
-        throw new Error(
-          `Keyword "${keyword}" at line ${tok.start.line} col ${tok.start.col} expects an ID and payload, but only ${tokens.length - i + 1} token(s) remain.`
-        );
-      }
-      const idTok = tokens[i++];
-      const payloadTok = tokens[i++];
+      const idTok = { value: decl.id ?? "", start: decl.start };
+      const payloadTok = { value: decl.payload ?? "", end: decl.start };
       if (cfg.field) {
         const issue = dupChecker.check(
           cfg.field,
@@ -361,24 +410,19 @@ function parse(mmelString, parsers, options = {}) {
           id: idTok.value,
           keyword,
           start: tok.start,
-          end: payloadTok.end
+          end: decl.end ?? payloadTok.end
         });
       }
       updateCtx = cfg.parse(idTok.value, payloadTok.value);
     } else {
-      if (i >= tokens.length) {
-        throw new Error(
-          `Keyword "${keyword}" at line ${tok.start.line} col ${tok.start.col} expects a payload, but no tokens remain.`
-        );
-      }
-      const payloadTok = tokens[i++];
+      const payloadTok = { value: decl.payload ?? "", end: decl.start };
       if (options.withProvenance) {
         constructs.push({
           field: cfg.field ?? keyword,
           id: "",
           keyword,
           start: tok.start,
-          end: payloadTok.end
+          end: decl.end ?? payloadTok.end
         });
       }
       updateCtx = cfg.parse(payloadTok.value);
@@ -1867,10 +1911,21 @@ var parseDataClass = function(id, data) {
         result.helper = details.trim() === "true";
         return;
       }
+      if (head === "overlay") {
+        result.overlay = details.replace(/[{}\s]/g, "") === "true";
+        return;
+      }
       if (head === "extends") {
         result.extends = details.trim();
         return;
       }
+      const lutaml = head.match(/^attribute\s+(\S+?)\s*,\s*(\S+)\s*$/);
+      if (lutaml) {
+        result.attributes.push(
+          parseLutamlAttribute(lutaml[1], lutaml[2], details)
+        );
+        return;
+      }
       result.attributes.push(parseDataAttribute(head, details));
     },
     { construct: "class", id }
@@ -1880,6 +1935,52 @@ var parseDataClass = function(id, data) {
     return ctx;
   };
 };
+var parseLutamlAttribute = (name, type, details) => {
+  const result = {
+    id: name,
+    type,
+    modality: "",
+    cardinality: "",
+    definition: "",
+    ref: [],
+    satisfy: [],
+    _relations: { ref: [] },
+    surface: "lutaml"
+  };
+  const wrapped = details.startsWith("{") ? details : `{ ${details} }`;
+  forEachEntry(
+    wrapped,
+    (keyword, value, peek) => {
+      if (keyword === "definition") {
+        result.definition = unwrapped(value);
+      } else if (keyword === "cardinality") {
+        result.cardinality = value().trim();
+      } else if (keyword === "modality") {
+        result.modality = value();
+      } else if (keyword === "values") {
+        const facets = /* @__PURE__ */ new Set([
+          "definition",
+          "cardinality",
+          "values",
+          "modality",
+          "reference"
+        ]);
+        const vals = [value()];
+        while (peek() !== void 0 && !facets.has(peek())) {
+          vals.push(value());
+        }
+        result.enumValues = vals;
+      } else if (keyword === "reference") {
+        result._relations.ref = tokenizePackage(value());
+      } else {
+        value();
+      }
+      return true;
+    },
+    { construct: "class", id: name }
+  );
+  return result;
+};
 var parseDataAttribute = (basic, details) => {
   const result = {
     id: "",
@@ -1953,6 +2054,7 @@ var resolveDataClass = function(ctx, unresolved) {
     ...unresolved.store !== void 0 ? { store: unresolved.store } : {},
     ...unresolved.indexes !== void 0 ? { indexes: unresolved.indexes } : {},
     ...unresolved.helper !== void 0 ? { helper: unresolved.helper } : {},
+    ...unresolved.overlay !== void 0 ? { overlay: unresolved.overlay } : {},
     ...unresolved.extends !== void 0 ? { extends: unresolved.extends } : {},
     ...unresolved.description !== void 0 ? { description: unresolved.description } : {},
     ...unresolved.ref !== void 0 ? { ref: unresolved.ref } : {}
@@ -1987,6 +2089,9 @@ var dumpDataClass = function(dataclass) {
   if (dataclass.helper !== void 0) {
     out += "  helper { " + dataclass.helper + " }\n";
   }
+  if (dataclass.overlay) {
+    out += "  overlay { true }\n";
+  }
   if (dataclass.extends) {
     out += "  extends { " + dataclass.extends + " }\n";
   }
@@ -2006,6 +2111,26 @@ var dumpDataClass = function(dataclass) {
   return out;
 };
 var toDataAttributeModel = (attribute) => {
+  if (attribute.surface === "lutaml") {
+    const lutaml = "  attribute " + attribute.id + ", " + attribute.type + " {";
+    const facets = [];
+    if (attribute.definition !== "") {
+      facets.push('definition "' + escapeString(attribute.definition) + '"');
+    }
+    if (attribute.cardinality !== "") {
+      facets.push("cardinality " + attribute.cardinality);
+    }
+    if (attribute.enumValues && attribute.enumValues.length > 0) {
+      facets.push("values " + attribute.enumValues.join(" "));
+    }
+    if (attribute.modality !== "") {
+      facets.push("modality " + attribute.modality);
+    }
+    if (facets.length === 0) {
+      return lutaml + " }\n";
+    }
+    return lutaml + " " + facets.join(" ") + " }\n";
+  }
   let out = "  " + attribute.id;
   if (attribute.type !== "") {
     out += ": " + attribute.type;
@@ -2398,6 +2523,8 @@ function readQuantityBlock(content) {
       out.uncertainty = coerceValueToken(t[i++]);
     } else if (cmd === "tolerance") {
       out.tolerance = coerceValueToken(t[i++]);
+    } else if (cmd === "provenance") {
+      out.provenance = readProvenanceBlock(unwrapBlock(t[i++]));
     } else {
       unwrapBlock(t[i++]);
     }
@@ -2405,7 +2532,53 @@ function readQuantityBlock(content) {
   return out;
 }
 function needsQuantityBlock(v) {
-  return v.quantityKind !== void 0 || v.uncertainty !== void 0 || v.tolerance !== void 0;
+  return v.quantityKind !== void 0 || v.uncertainty !== void 0 || v.tolerance !== void 0 || v.provenance !== void 0;
+}
+function readProvenanceBlock(content) {
+  const out = { source: "" };
+  const t = tokenize(content);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i >= t.length) {
+      break;
+    }
+    if (cmd === "source") {
+      out.source = stripWrapping(t[i++]);
+    } else if (cmd === "page") {
+      out.page = String(coerceValueToken(t[i++]));
+    } else if (cmd === "entry_wording") {
+      out.entryWording = stripWrapping(t[i++]);
+    } else if (cmd === "read_at") {
+      out.readAt = stripColon(stripWrapping(t[i++]));
+    } else if (cmd === "declaration") {
+      out.declaration = stripColon(stripWrapping(t[i++]));
+    } else if (cmd === "verdict") {
+      out.verdict = stripColon(stripWrapping(t[i++]));
+    } else {
+      unwrapBlock(t[i++]);
+    }
+  }
+  return out;
+}
+function dumpProvenanceBlock(p) {
+  const parts = ['source "' + escapeString(p.source) + '"'];
+  if (p.page !== void 0) {
+    parts.push("page " + dumpScalarToken(p.page));
+  }
+  if (p.entryWording !== void 0) {
+    parts.push('entry_wording "' + escapeString(p.entryWording) + '"');
+  }
+  if (p.readAt !== void 0) {
+    parts.push("read_at " + dumpScalarToken(p.readAt));
+  }
+  if (p.declaration !== void 0) {
+    parts.push("declaration " + dumpScalarToken(p.declaration));
+  }
+  if (p.verdict !== void 0) {
+    parts.push("verdict " + dumpScalarToken(p.verdict));
+  }
+  return "{ " + parts.join(" ") + " }";
 }
 function dumpScalarToken(v) {
   if (typeof v === "number") {
@@ -2440,6 +2613,9 @@ function dumpQuantityBlock(v) {
   if (v.tolerance !== void 0) {
     parts.push("tolerance " + dumpScalarToken(v.tolerance));
   }
+  if (v.provenance !== void 0) {
+    parts.push("provenance " + dumpProvenanceBlock(v.provenance));
+  }
   return "{ " + parts.join(" ") + " }";
 }
 
@@ -3074,6 +3250,8 @@ var parseProcess = function(id, data) {
         result.machineSteps = tokenize(stripWrapping(value())).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
       } else if (keyword === "name") {
         result.name = unwrapped(value);
+      } else if (keyword === "overlay") {
+        result.overlay = value() === "true";
       } else if (keyword === "actor") {
         result._relations.actor = value();
       } else if (keyword === "parent") {
@@ -3329,6 +3507,9 @@ function dumpDoes(flow) {
 var dumpProcess = function(process2, ctx) {
   let out = "process " + process2.id + " {\n";
   out += '  name "' + escapeString(process2.name) + '"\n';
+  if (process2.overlay) {
+    out += "  overlay true\n";
+  }
   if (process2.summary) {
     out += '  summary "' + escapeString(process2.summary) + '"\n';
   }
@@ -3568,348 +3749,52 @@ var dumpProcess = function(process2, ctx) {
   return out;
 };
 
-// src/ser-des/config/processModel.ts
-function parseProcessSequence(block) {
-  return tokenizePackage(block).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
-}
-function parseProcessRegister(id, block) {
-  const register = {
-    id,
-    label: "",
-    clause: "",
-    maintainer: "",
-    published: "",
-    entries: ""
-  };
-  forEachEntry(
-    block,
-    (keyword, value) => {
-      if (keyword === "label") {
-        register.label = stripWrapping(value());
-      } else if (keyword === "clause") {
-        register.clause = stripWrapping(value());
-      } else if (keyword === "maintainer") {
-        register.maintainer = stripWrapping(value());
-      } else if (keyword === "published") {
-        register.published = stripWrapping(value());
-      } else if (keyword === "entries") {
-        register.entries = stripWrapping(value());
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "process_model register", id }
-  );
-  return register;
+// src/ser-des/config/verificationPathway.ts
+var VERIFICATION_KINDS = [
+  "initial",
+  "subsequent",
+  "periodic",
+  "in-service"
+];
+var TRIGGER_KINDS = ["timer", "signal"];
+var LIMITS_MODES = ["same-as-type-evaluation", "override"];
+function readIdList(block) {
+  return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
 }
-var parseProcessModel = (id, data) => {
-  const model = {
-    id,
-    sequence: [],
-    registers: [],
-    source: { doc: "", clause: "" }
-  };
-  forEachEntry(
-    data,
-    (keyword, value, peek) => {
-      if (keyword === "sequence") {
-        model.sequence = parseProcessSequence(unwrapBlock(value()));
-      } else if (keyword === "register") {
-        const regId = stripWrapping(value());
-        const head = peek();
-        if (head === void 0 || !head.startsWith("{")) {
-          throw new Error(
-            `Parsing error: process_model. ID ${id}: register ${regId} is missing its block`
-          );
-        }
-        model.registers.push(parseProcessRegister(regId, unwrapBlock(value())));
-      } else if (keyword === "source") {
-        model.source = readSource(unwrapBlock(value()));
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "process_model", id }
-  );
-  return (ctx) => {
-    ctx.processModels[id] = model;
-    return ctx;
-  };
-};
-function dumpProcessSequence(sequence) {
-  if (sequence.length === 0) {
-    return "";
+function readWindow(block) {
+  const window = { years: 0, months: 0 };
+  const t = tokenize(unwrapBlock(block));
+  for (let i = 0; i + 1 < t.length; i += 2) {
+    if (t[i] === "years") {
+      window.years = parseInt(stripWrapping(t[i + 1]), 10) || 0;
+    } else if (t[i] === "months") {
+      window.months = parseInt(stripWrapping(t[i + 1]), 10) || 0;
+    }
   }
-  return "sequence { " + sequence.map(dumpBareSafe).join(" ") + " }";
+  return window;
 }
-function dumpProcessRegister(r, indent) {
-  let out = indent + "register " + dumpBareSafe(r.id) + " {\n";
-  if (r.label) {
-    out += indent + '  label "' + escapeString(r.label) + '"\n';
-  }
-  if (r.clause) {
-    out += indent + '  clause "' + escapeString(r.clause) + '"\n';
-  }
-  if (r.maintainer) {
-    out += indent + "  maintainer " + dumpBareSafe(r.maintainer) + "\n";
-  }
-  if (r.published) {
-    out += indent + '  published "' + escapeString(r.published) + '"\n';
+function dumpWindow(w, indent) {
+  let out = indent + "window {";
+  if (w.years > 0) {
+    out += " years " + w.years;
   }
-  if (r.entries) {
-    out += indent + '  entries "' + escapeString(r.entries) + '"\n';
+  if (w.months > 0) {
+    out += " months " + w.months;
   }
-  out += indent + "}\n";
-  return out;
+  return out + " }\n";
 }
-var dumpProcessModel = function(m) {
-  let out = "process_model " + m.id + " {\n";
-  const seq = dumpProcessSequence(m.sequence);
-  if (seq) {
-    out += "  " + seq + "\n";
-  }
-  for (const r of m.registers) {
-    out += dumpProcessRegister(r, "  ");
+function dumpSourceLines(src, indent) {
+  if (!src.doc && !src.clause) {
+    return "";
   }
-  if (m.source.doc || m.source.clause) {
-    out += "  source {\n";
-    if (m.source.doc) {
-      out += '    doc "' + escapeString(m.source.doc) + '"\n';
-    }
-    if (m.source.clause) {
-      out += '    clause "' + escapeString(m.source.clause) + '"\n';
-    }
-    out += "  }\n";
+  let out = indent + "source {\n";
+  if (src.doc) {
+    out += indent + '  doc "' + escapeString(src.doc) + '"\n';
   }
-  out += "}\n";
-  return out;
-};
-
-// src/ser-des/config/workflowConfig.ts
-var WORKFLOW_PHASES = [
-  "intake",
-  "dispatch",
-  "testing",
-  "evaluation",
-  "issuance"
-];
-function readTokenList(block) {
-  return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
-}
-function dumpTokenList(keyword, ids, indent) {
-  if (ids.length === 0) {
-    return "";
+  if (src.clause) {
+    out += indent + '  clause "' + escapeString(src.clause) + '"\n';
   }
-  return indent + keyword + " { " + ids.map(dumpBareSafe).join(" ") + " }\n";
-}
-var parseWorkflowConfig = (id, data) => {
-  const config = { id, overlay: false, steps: [] };
-  forEachEntry(
-    data,
-    (keyword, value) => {
-      if (keyword === "overlay") {
-        config.overlay = value() === "true";
-      } else if (keyword === "step") {
-        const step = {
-          id: stripWrapping(stripColon(value())),
-          phase: null,
-          actor: null,
-          label: null,
-          description: null,
-          inputs: [],
-          outputs: [],
-          gates: []
-        };
-        forEachEntry(
-          unwrapBlock(value()),
-          (k2, v2) => {
-            if (k2 === "phase") {
-              const p = stripWrapping(v2());
-              if (!WORKFLOW_PHASES.includes(p)) {
-                throw new Error(
-                  `Parsing error: workflow_config. ID ${id}: Unknown phase "${p}" (valid: ${WORKFLOW_PHASES.join(", ")})`
-                );
-              }
-              step.phase = p;
-            } else if (k2 === "actor") {
-              step.actor = stripWrapping(v2());
-            } else if (k2 === "label") {
-              step.label = stripWrapping(v2());
-            } else if (k2 === "description") {
-              step.description = stripWrapping(v2());
-            } else if (k2 === "inputs") {
-              step.inputs = readTokenList(v2());
-            } else if (k2 === "outputs") {
-              step.outputs = readTokenList(v2());
-            } else if (k2 === "gates") {
-              step.gates = readTokenList(v2());
-            } else {
-              return false;
-            }
-            return true;
-          },
-          { construct: "workflow_config", id }
-        );
-        config.steps.push(step);
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "workflow_config", id }
-  );
-  return (ctx) => {
-    ctx.workflowConfigs[id] = config;
-    return ctx;
-  };
-};
-var dumpWorkflowConfig = function(c) {
-  let out = "workflow_config " + dumpBareSafe(c.id) + " {\n";
-  if (c.overlay) {
-    out += "  overlay true\n";
-  }
-  for (const s of c.steps) {
-    out += "  step " + dumpBareSafe(s.id) + " {\n";
-    if (s.phase) {
-      out += "    phase " + s.phase + "\n";
-    }
-    if (s.actor) {
-      out += "    actor " + dumpBareSafe(s.actor) + "\n";
-    }
-    if (s.label) {
-      out += '    label "' + escapeString(s.label) + '"\n';
-    }
-    if (s.description) {
-      out += '    description "' + escapeString(s.description) + '"\n';
-    }
-    out += dumpTokenList("inputs", s.inputs, "    ");
-    out += dumpTokenList("outputs", s.outputs, "    ");
-    if (s.gates.length > 0) {
-      out += "    gates { " + s.gates.map((g) => '"' + escapeString(g) + '"').join(" ") + " }\n";
-    }
-    out += "  }\n";
-  }
-  out += "}\n";
-  return out;
-};
-
-// src/ser-des/config/workflowStage.ts
-function readTokenList2(block) {
-  return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
-}
-function dumpTokenList2(keyword, ids) {
-  if (ids.length === 0) {
-    return "";
-  }
-  return "  " + keyword + " { " + ids.map(dumpBareSafe).join(" ") + " }\n";
-}
-var parseWorkflowStage = (id, data) => {
-  const stage = {
-    id,
-    label: "",
-    description: "",
-    elements: [],
-    startEvent: "",
-    endEvents: [],
-    approvals: [],
-    gateways: []
-  };
-  forEachEntry(
-    data,
-    (keyword, value) => {
-      if (keyword === "label") {
-        stage.label = stripWrapping(value());
-      } else if (keyword === "description") {
-        stage.description = stripWrapping(value());
-      } else if (keyword === "elements") {
-        stage.elements = readTokenList2(value());
-      } else if (keyword === "start_event") {
-        stage.startEvent = stripWrapping(value());
-      } else if (keyword === "end_events") {
-        stage.endEvents = readTokenList2(value());
-      } else if (keyword === "approvals") {
-        stage.approvals = readTokenList2(value());
-      } else if (keyword === "gateways") {
-        stage.gateways = readTokenList2(value());
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "workflow_stage", id }
-  );
-  return (ctx) => {
-    ctx.workflowStages[id] = stage;
-    return ctx;
-  };
-};
-var dumpWorkflowStage = function(s) {
-  let out = "workflow_stage " + dumpBareSafe(s.id) + " {\n";
-  if (s.label) {
-    out += '  label "' + escapeString(s.label) + '"\n';
-  }
-  if (s.description) {
-    out += '  description "' + escapeString(s.description) + '"\n';
-  }
-  out += dumpTokenList2("elements", s.elements);
-  if (s.startEvent) {
-    out += "  start_event " + dumpBareSafe(s.startEvent) + "\n";
-  }
-  out += dumpTokenList2("end_events", s.endEvents);
-  out += dumpTokenList2("approvals", s.approvals);
-  out += dumpTokenList2("gateways", s.gateways);
-  out += "}\n";
-  return out;
-};
-
-// src/ser-des/config/verificationPathway.ts
-var VERIFICATION_KINDS = [
-  "initial",
-  "subsequent",
-  "periodic",
-  "in-service"
-];
-var TRIGGER_KINDS = ["timer", "signal"];
-var LIMITS_MODES = ["same-as-type-evaluation", "override"];
-function readIdList(block) {
-  return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
-}
-function readWindow(block) {
-  const window = { years: 0, months: 0 };
-  const t = tokenize(unwrapBlock(block));
-  for (let i = 0; i + 1 < t.length; i += 2) {
-    if (t[i] === "years") {
-      window.years = parseInt(stripWrapping(t[i + 1]), 10) || 0;
-    } else if (t[i] === "months") {
-      window.months = parseInt(stripWrapping(t[i + 1]), 10) || 0;
-    }
-  }
-  return window;
-}
-function dumpWindow(w, indent) {
-  let out = indent + "window {";
-  if (w.years > 0) {
-    out += " years " + w.years;
-  }
-  if (w.months > 0) {
-    out += " months " + w.months;
-  }
-  return out + " }\n";
-}
-function dumpSourceLines(src, indent) {
-  if (!src.doc && !src.clause) {
-    return "";
-  }
-  let out = indent + "source {\n";
-  if (src.doc) {
-    out += indent + '  doc "' + escapeString(src.doc) + '"\n';
-  }
-  if (src.clause) {
-    out += indent + '  clause "' + escapeString(src.clause) + '"\n';
-  }
-  return out + indent + "}\n";
+  return out + indent + "}\n";
 }
 var parseVerificationPathway = (id, data) => {
   const pathway = {
@@ -9169,6 +9054,227 @@ function parseInstances(block) {
   }
   return out;
 }
+function parseProgramArgs(block) {
+  const out = {};
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const key = stripColon(t[i++]);
+    if (i >= t.length) {
+      break;
+    }
+    if (t[i] === ":") {
+      i++;
+    }
+    if (i < t.length) {
+      const read = readValueToken(t, i);
+      out[key] = stripWrapping(read.text);
+      i = read.next;
+    }
+  }
+  return out;
+}
+function parseVerify(block) {
+  const v = { read: "", tolerance: "" };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i >= t.length) {
+      break;
+    }
+    if (cmd === "read") {
+      v.read = stripWrapping(t[i++]);
+    } else if (cmd === "tolerance") {
+      v.tolerance = stripWrapping(t[i++]);
+    } else {
+      unwrapBlock(t[i++]);
+    }
+  }
+  return v;
+}
+function parseProgramBody(block, entryKeyword, makeEntry, parseEntryFacets, errCtx) {
+  const program = {
+    description: "",
+    entries: [],
+    sourceRefs: []
+  };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const command = t[i++];
+    if (i >= t.length) {
+      throw new Error(
+        `Parsing error: ${errCtx}: Expecting value for ${command}`
+      );
+    }
+    if (command === "description") {
+      program.description = stripWrapping(t[i++]);
+    } else if (command === "source") {
+      program.sourceRefs.push(readSource(unwrapBlock(t[i++])));
+    } else if (command === "ref") {
+      const rr = parseRef(t, i, stripWrapping, unwrapBlock);
+      foldRefIntoLegacy(program, rr.ref);
+      i = rr.next;
+    } else if (command === entryKeyword) {
+      const entry = makeEntry();
+      let value = t[i++];
+      if (!value.startsWith("{")) {
+        entry.order = Number(stripWrapping(value));
+        value = i < t.length && t[i].startsWith("{") ? t[i++] : "";
+      }
+      if (value.startsWith("{")) {
+        parseEntryFacets(unwrapBlock(value), entry);
+      }
+      program.entries.push(entry);
+    } else {
+      i = skipUnknownValue(t, i, command);
+    }
+  }
+  return program;
+}
+function parsePreparation(block, id) {
+  return parseProgramBody(
+    block,
+    "step",
+    () => ({
+      order: null,
+      action: "",
+      drive: "",
+      args: {},
+      hold: "",
+      verify: null
+    }),
+    (stepBlock, step) => {
+      forEachEntry(
+        stepBlock,
+        (facet, value) => {
+          if (facet === "action") {
+            step.action = unwrapped(value);
+          } else if (facet === "drive") {
+            step.drive = stripWrapping(value());
+          } else if (facet === "args") {
+            step.args = parseProgramArgs(unwrapBlock(value()));
+          } else if (facet === "hold") {
+            step.hold = stripWrapping(value());
+          } else if (facet === "verify") {
+            step.verify = parseVerify(unwrapBlock(value()));
+          } else {
+            return false;
+          }
+          return true;
+        },
+        { construct: "conformance_test.preparation", id }
+      );
+    },
+    `conformance_test.preparation. ID ${id}`
+  );
+}
+function parseStimulus(block, id) {
+  return parseProgramBody(
+    block,
+    "point",
+    () => ({
+      order: null,
+      drive: "",
+      args: {},
+      hold: "",
+      freshWithin: "",
+      acceptance: ""
+    }),
+    (pointBlock, point) => {
+      forEachEntry(
+        pointBlock,
+        (facet, value) => {
+          if (facet === "drive") {
+            point.drive = stripWrapping(value());
+          } else if (facet === "args") {
+            point.args = parseProgramArgs(unwrapBlock(value()));
+          } else if (facet === "hold") {
+            point.hold = stripWrapping(value());
+          } else if (facet === "fresh_within") {
+            point.freshWithin = stripWrapping(value());
+          } else if (facet === "acceptance") {
+            point.acceptance = stripWrapping(value());
+          } else {
+            return false;
+          }
+          return true;
+        },
+        { construct: "conformance_test.stimulus", id }
+      );
+    },
+    `conformance_test.stimulus. ID ${id}`
+  );
+}
+function dumpProgramArgs(args2) {
+  const keys = Object.keys(args2);
+  if (keys.length === 0) {
+    return "";
+  }
+  return " args { " + keys.map((k) => k + ': "' + escapeString(args2[k]) + '"').join(" ") + " }";
+}
+function dumpPreparation(program) {
+  let out = "  preparation {\n";
+  if (program.description !== "") {
+    out += '    description "' + escapeString(program.description) + '"\n';
+  }
+  for (const step of program.entries) {
+    out += "    step" + (step.order !== null ? " " + step.order : "") + " {";
+    if (step.action !== "") {
+      out += ' action "' + escapeString(step.action) + '"';
+    }
+    if (step.drive !== "") {
+      out += " drive " + dumpBareSafe(step.drive);
+    }
+    out += dumpProgramArgs(step.args);
+    if (step.hold !== "") {
+      out += " hold " + dumpBareSafe(step.hold);
+    }
+    if (step.verify) {
+      out += " verify {";
+      if (step.verify.read !== "") {
+        out += " read " + dumpBareSafe(step.verify.read);
+      }
+      if (step.verify.tolerance !== "") {
+        out += " tolerance " + dumpBareSafe(step.verify.tolerance);
+      }
+      out += " }";
+    }
+    out += " }\n";
+  }
+  for (const src of program.sourceRefs) {
+    out += dumpSourceRefAsRef(src, "    ", escapeString);
+  }
+  return out + "  }\n";
+}
+function dumpStimulus(program) {
+  let out = "  stimulus {\n";
+  if (program.description !== "") {
+    out += '    description "' + escapeString(program.description) + '"\n';
+  }
+  for (const point of program.entries) {
+    out += "    point" + (point.order !== null ? " " + point.order : "") + " {";
+    if (point.drive !== "") {
+      out += " drive " + dumpBareSafe(point.drive);
+    }
+    out += dumpProgramArgs(point.args);
+    if (point.hold !== "") {
+      out += " hold " + dumpBareSafe(point.hold);
+    }
+    if (point.freshWithin !== "") {
+      out += " fresh_within " + dumpBareSafe(point.freshWithin);
+    }
+    if (point.acceptance !== "") {
+      out += " acceptance " + dumpBareSafe(point.acceptance);
+    }
+    out += " }\n";
+  }
+  for (const src of program.sourceRefs) {
+    out += dumpSourceRefAsRef(src, "    ", escapeString);
+  }
+  return out + "  }\n";
+}
 var parseConformanceTest = function(id, data) {
   const result = {
     id,
@@ -9180,6 +9286,8 @@ var parseConformanceTest = function(id, data) {
     bindsTo: [],
     applicability: [],
     procedure: [],
+    preparation: null,
+    stimulus: null,
     measurements: [],
     kind: "",
     obligation: "",
@@ -9302,6 +9410,10 @@ var parseConformanceTest = function(id, data) {
         }
       } else if (keyword === "procedure_steps") {
         result.procedureSteps = readStringList(value());
+      } else if (keyword === "preparation") {
+        result.preparation = parsePreparation(unwrapBlock(value()), id);
+      } else if (keyword === "stimulus") {
+        result.stimulus = parseStimulus(unwrapBlock(value()), id);
       } else if (keyword === "kind") {
         result.kind = stripWrapping(value());
       } else if (keyword === "obligation") {
@@ -9432,6 +9544,12 @@ var dumpConformanceTest = function(ct) {
   if (ct.procedureSteps && ct.procedureSteps.length > 0) {
     out += "  procedure_steps { " + ct.procedureSteps.join(" ") + " }\n";
   }
+  if (ct.preparation) {
+    out += dumpPreparation(ct.preparation);
+  }
+  if (ct.stimulus) {
+    out += dumpStimulus(ct.stimulus);
+  }
   if (ct.measurements.length > 0) {
     out += "  validate_measurement {\n";
     for (const m of ct.measurements) {
@@ -10993,7 +11111,7 @@ function readLimit(block) {
     } else if (cmd === "notes") {
       limit.notes = stripWrapping(t[i++]);
     } else if (cmd === "quantity") {
-      const quantity = { kind: "", unit: "" };
+      const quantity2 = { kind: "", unit: "" };
       const qt = tokenize(unwrapBlock(t[i++]));
       let k = 0;
       while (k < qt.length) {
@@ -11002,14 +11120,14 @@ function readLimit(block) {
           break;
         }
         if (qc === "kind") {
-          quantity.kind = stripWrapping(qt[k++]);
+          quantity2.kind = stripWrapping(qt[k++]);
         } else if (qc === "unit") {
-          quantity.unit = stripWrapping(qt[k++]);
+          quantity2.unit = stripWrapping(qt[k++]);
         } else {
           unwrapBlock(qt[k++]);
         }
       }
-      limit.quantity = quantity;
+      limit.quantity = quantity2;
     } else if (cmd === "accepts") {
       limit.accepts = readAccepts(unwrapBlock(t[i++]));
     } else if (cmd === "acceptance") {
@@ -12450,6 +12568,8 @@ function parseDimension(id, block) {
       dim.source = readSource(unwrapBlock(t[i++]));
     } else if (cmd === "values") {
       dim.values = parseDimensionValues(unwrapBlock(t[i++]));
+    } else if (cmd === "payload_class") {
+      dim.payloadClass = stripColon(stripWrapping(t[i++]));
     } else if (cmd === "values_of") {
       dim.valuesOf = stripWrapping(t[i++]);
     } else if (cmd === "ref") {
@@ -12558,6 +12678,9 @@ function dumpDimension(d, indent) {
   if (d.description) {
     out += inner + 'description "' + escapeString(d.description) + '"\n';
   }
+  if (d.payloadClass) {
+    out += inner + "payload_class " + d.payloadClass + "\n";
+  }
   out += dumpSource2("reference", d.source, inner);
   if (d.valuesOf) {
     out += inner + "values_of " + d.valuesOf + "\n";
@@ -12955,6 +13078,8 @@ var parseAttributeDefinition = function(id, data) {
       result.note = stripWrapping(t[i++]);
     } else if (cmd === "irdi") {
       result.irdi = stripWrapping(t[i++]);
+    } else if (cmd === "class") {
+      result.classRef = stripColon(stripWrapping(t[i++]));
     } else if (cmd === "derived") {
       result.derived = stripWrapping(t[i++]);
     } else if (cmd === "ref") {
@@ -13034,6 +13159,9 @@ var dumpAttributeDefinition = function(a) {
   if (a.irdi) {
     out += '  irdi "' + escapeString(a.irdi) + '"\n';
   }
+  if (a.classRef) {
+    out += "  class " + a.classRef + "\n";
+  }
   if (a.derived) {
     out += '  derived "' + escapeString(a.derived) + '"\n';
   }
@@ -14177,6 +14305,16 @@ function parseInstanceHas(block, result) {
     }
   }
 }
+function readQuantity2(tokens) {
+  if (tokens.length === 0) {
+    return { value: "" };
+  }
+  const first = stripWrapping(tokens[0]);
+  if (tokens.length === 1) {
+    return { value: first };
+  }
+  return { value: first, unit: tokens.slice(1).map(stripWrapping).join(" ") };
+}
 var parseInstance = function(id, data) {
   const result = {
     id,
@@ -14198,6 +14336,13 @@ var parseInstance = function(id, data) {
     }
     if (cmd === "of") {
       result.of = stripWrapping(t[i++]);
+    } else if (t[i] === "=" && i + 1 < t.length) {
+      i++;
+      const valueTokens = [];
+      while (i < t.length && t[i] !== "}" && !(i + 1 < t.length && t[i + 1] === "=")) {
+        valueTokens.push(t[i++]);
+      }
+      result.has.attributes[cmd] = readQuantity2(valueTokens);
     } else if (cmd === "level") {
       result.level = stripWrapping(t[i++]);
     } else if (cmd === "model") {
@@ -14815,25 +14960,146 @@ var dumpEvaluationProfile = function(p) {
   return out;
 };
 
-// src/ser-des/config/certificateTemplate.ts
-var CERTIFICATE_OBLIGATIONS = ["mandatory", "optional"];
-function readIdList6(block) {
-  return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
-}
-var parseCertificateTemplate = (id, data) => {
-  const template = {
+// src/ser-des/config/attestation.ts
+var parseAttestation = (id, data) => {
+  const a = {
     id,
-    numberFormat: "",
-    dimensionLabels: null,
-    characteristics: [],
-    anrSection: null
+    subject: "",
+    promises: "",
+    basis: [],
+    authority: { role: "", name: "" },
+    statement: "",
+    limits: [],
+    claims: [],
+    referenceIds: []
   };
   forEachEntry(
     data,
     (keyword, value) => {
-      if (keyword === "number_format") {
-        template.numberFormat = stripWrapping(value());
-      } else if (keyword === "dimension_labels") {
+      if (keyword === "subject") {
+        a.subject = stripWrapping(stripColon(value()));
+      } else if (keyword === "promises") {
+        a.promises = stripWrapping(stripColon(value()));
+      } else if (keyword === "basis") {
+        const kind = stripWrapping(stripColon(value()));
+        const eid = stripWrapping(value());
+        a.basis.push({ kind, id: eid });
+      } else if (keyword === "authority") {
+        const role = stripWrapping(stripColon(value()));
+        const name = stripWrapping(value());
+        a.authority = { role, name };
+      } else if (keyword === "statement") {
+        a.statement = stripWrapping(value());
+      } else if (keyword === "limits") {
+        forEachEntry(
+          unwrapBlock(value()),
+          (label, text) => {
+            const limit = {
+              label: stripColon(label),
+              text: stripWrapping(text())
+            };
+            a.limits.push(limit);
+            return true;
+          },
+          { construct: "attestation", id }
+        );
+      } else if (keyword === "claims") {
+        forEachEntry(
+          unwrapBlock(value()),
+          (promise, claimValue) => {
+            const claim = {
+              promise: stripColon(promise),
+              declared: "",
+              validatedBy: ""
+            };
+            forEachEntry(
+              unwrapBlock(claimValue()),
+              (k2, v2) => {
+                if (k2 === "declared") {
+                  claim.declared = stripWrapping(stripColon(v2()));
+                } else if (k2 === "validated_by") {
+                  claim.validatedBy = stripWrapping(stripColon(v2()));
+                } else {
+                  return false;
+                }
+                return true;
+              },
+              { construct: "attestation", id }
+            );
+            a.claims.push(claim);
+            return true;
+          },
+          { construct: "attestation", id }
+        );
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "attestation", id }
+  );
+  return (ctx) => {
+    ctx.attestations[id] = a;
+    return ctx;
+  };
+};
+var dumpAttestation = function(a) {
+  let out = "attestation " + dumpBareSafe(a.id) + " {\n";
+  if (a.subject) {
+    out += "  subject " + dumpBareSafe(a.subject) + "\n";
+  }
+  if (a.promises) {
+    out += "  promises " + dumpBareSafe(a.promises) + "\n";
+  }
+  for (const b of a.basis) {
+    out += "  basis " + dumpBareSafe(b.kind) + ' "' + b.id.replace(/"/g, '\\"') + '"\n';
+  }
+  if (a.authority.role || a.authority.name) {
+    out += "  authority " + dumpBareSafe(a.authority.role) + ' "' + a.authority.name.replace(/"/g, '\\"') + '"\n';
+  }
+  if (a.statement) {
+    out += '  statement "' + a.statement.replace(/"/g, '\\"') + '"\n';
+  }
+  if (a.limits.length > 0) {
+    out += "  limits {\n";
+    for (const l of a.limits) {
+      out += "    " + dumpBareSafe(l.label) + ' "' + l.text.replace(/"/g, '\\"') + '"\n';
+    }
+    out += "  }\n";
+  }
+  if (a.claims.length > 0) {
+    out += "  claims {\n";
+    for (const c of a.claims) {
+      out += "    " + dumpBareSafe(c.promise) + " {\n";
+      out += "      declared " + dumpBareSafe(c.declared) + "\n";
+      out += "      validated_by " + dumpBareSafe(c.validatedBy) + "\n";
+      out += "    }\n";
+    }
+    out += "  }\n";
+  }
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/certificateTemplate.ts
+var CERTIFICATE_OBLIGATIONS = ["mandatory", "optional"];
+function readIdList6(block) {
+  return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+}
+var parseCertificateTemplate = (id, data) => {
+  const template = {
+    id,
+    numberFormat: "",
+    dimensionLabels: null,
+    characteristics: [],
+    anrSection: null
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "number_format") {
+        template.numberFormat = stripWrapping(value());
+      } else if (keyword === "dimension_labels") {
         const labels = { pattern: "", separator: "" };
         forEachEntry(
           unwrapBlock(value()),
@@ -15112,6 +15378,8 @@ var parseArtifactDefinition = function(id, data) {
       result.description = stripWrapping(t[i++]);
     } else if (cmd === "content_contract") {
       result.contentContract = parseContentContract(unwrapBlock(t[i++]));
+    } else if (cmd === "contract_from") {
+      result.contractFrom = stripColon(stripWrapping(t[i++]));
     } else if (cmd === "produced_when") {
       const kind = stripWrapping(t[i++] ?? "");
       if (kind === "per_interval") {
@@ -15167,6 +15435,9 @@ var dumpArtifactDefinition = function(d) {
   if (d.description) {
     out += '  description "' + escapeString(d.description) + '"\n';
   }
+  if (d.contractFrom) {
+    out += "  contract_from " + d.contractFrom + "\n";
+  }
   const c = d.contentContract;
   const hasContract = c.fields.length > 0 || c.structure || c.media.length > 0;
   if (hasContract) {
@@ -18170,6 +18441,68 @@ var dumpDecisionRule = function(r) {
   return out;
 };
 
+// src/ser-des/config/processSequence.ts
+function parseProcessSequence(block) {
+  return tokenizePackage(block).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+}
+function parseProcessRegister(id, block) {
+  const register = {
+    id,
+    label: "",
+    clause: "",
+    maintainer: "",
+    published: "",
+    entries: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "label") {
+        register.label = stripWrapping(value());
+      } else if (keyword === "clause") {
+        register.clause = stripWrapping(value());
+      } else if (keyword === "maintainer") {
+        register.maintainer = stripWrapping(value());
+      } else if (keyword === "published") {
+        register.published = stripWrapping(value());
+      } else if (keyword === "entries") {
+        register.entries = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "process_model register", id }
+  );
+  return register;
+}
+function dumpProcessSequence(sequence) {
+  if (sequence.length === 0) {
+    return "";
+  }
+  return "sequence { " + sequence.map(dumpBareSafe).join(" ") + " }";
+}
+function dumpProcessRegister(r, indent) {
+  let out = indent + "register " + dumpBareSafe(r.id) + " {\n";
+  if (r.label) {
+    out += indent + '  label "' + escapeString(r.label) + '"\n';
+  }
+  if (r.clause) {
+    out += indent + '  clause "' + escapeString(r.clause) + '"\n';
+  }
+  if (r.maintainer) {
+    out += indent + "  maintainer " + dumpBareSafe(r.maintainer) + "\n";
+  }
+  if (r.published) {
+    out += indent + '  published "' + escapeString(r.published) + '"\n';
+  }
+  if (r.entries) {
+    out += indent + '  entries "' + escapeString(r.entries) + '"\n';
+  }
+  out += indent + "}\n";
+  return out;
+}
+
 // src/ser-des/config/documentModule.ts
 var parseDocumentModule = (id, data) => {
   const module = {
@@ -18504,234 +18837,6 @@ var dumpPartAnnex = function(a) {
   return out;
 };
 
-// src/ser-des/config/storyline.ts
-function readRecordValue(token) {
-  if (token.startsWith("{")) {
-    return tokenize(unwrapBlock(token)).filter((s) => s.length > 0).map(coerceValueToken);
-  }
-  return coerceValueToken(token);
-}
-function readRecordFields(block) {
-  const fields = {};
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const key = t[i++];
-    if (i >= t.length) {
-      break;
-    }
-    fields[stripColon(key)] = readRecordValue(t[i++]);
-  }
-  return fields;
-}
-function dumpRecordFields(fields, indent) {
-  let out = "";
-  for (const [key, value] of Object.entries(fields)) {
-    if (Array.isArray(value)) {
-      out += indent + key + " { " + value.map(dumpScalarToken).join(" ") + " }\n";
-    } else {
-      out += indent + key + " " + dumpScalarToken(value) + "\n";
-    }
-  }
-  return out;
-}
-function parseParticipants(block) {
-  const sections = [];
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const sid = stripWrapping(t[i++]);
-    if (i >= t.length || !t[i].startsWith("{")) {
-      break;
-    }
-    const section = { id: sid, entries: [] };
-    const st = tokenize(unwrapBlock(t[i++]));
-    let j = 0;
-    while (j < st.length) {
-      const eid = stripWrapping(st[j++]);
-      if (j >= st.length || !st[j].startsWith("{")) {
-        break;
-      }
-      section.entries.push({
-        id: eid,
-        fields: readRecordFields(unwrapBlock(st[j++]))
-      });
-    }
-    sections.push(section);
-  }
-  return sections;
-}
-var parseDemoWorld = (id, data) => {
-  const world = {
-    id,
-    standard: "",
-    description: "",
-    participants: []
-  };
-  forEachEntry(
-    data,
-    (keyword, value) => {
-      if (keyword === "standard") {
-        world.standard = stripWrapping(value());
-      } else if (keyword === "description") {
-        world.description = stripWrapping(value());
-      } else if (keyword === "participants") {
-        world.participants = parseParticipants(unwrapBlock(value()));
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "demo_world", id }
-  );
-  return (ctx) => {
-    ctx.demoWorlds[id] = world;
-    return ctx;
-  };
-};
-var dumpDemoWorld = function(w) {
-  let out = "demo_world " + w.id + " {\n";
-  if (w.standard) {
-    out += "  standard " + dumpBareSafe(w.standard) + "\n";
-  }
-  if (w.description) {
-    out += '  description "' + escapeString(w.description) + '"\n';
-  }
-  if (w.participants.length > 0) {
-    out += "  participants {\n";
-    for (const s of w.participants) {
-      out += "    " + dumpBareSafe(s.id) + " {\n";
-      for (const e of s.entries) {
-        out += "      " + dumpBareSafe(e.id) + " {\n";
-        out += dumpRecordFields(e.fields, "        ");
-        out += "      }\n";
-      }
-      out += "    }\n";
-    }
-    out += "  }\n";
-  }
-  out += "}\n";
-  return out;
-};
-function parseSubjectEntries(block) {
-  const entries = [];
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const kind = stripWrapping(t[i++]);
-    if (i >= t.length) {
-      break;
-    }
-    const eid = stripWrapping(t[i++]);
-    const entry = { kind, id: eid, fields: {} };
-    if (i < t.length && t[i].startsWith("{")) {
-      entry.fields = readRecordFields(unwrapBlock(t[i++]));
-    }
-    entries.push(entry);
-  }
-  return entries;
-}
-var parseStoryline = (id, data) => {
-  const storyline = {
-    id,
-    name: "",
-    idPrefix: "",
-    party: { laboratory: "", authority: "" },
-    subject: [],
-    records: [],
-    notes: []
-  };
-  forEachEntry(
-    data,
-    (keyword, value, peek) => {
-      if (keyword === "name") {
-        storyline.name = stripWrapping(value());
-      } else if (keyword === "id_prefix") {
-        storyline.idPrefix = stripWrapping(value());
-      } else if (keyword === "party") {
-        const pt = tokenize(unwrapBlock(value()));
-        for (let j = 0; j + 1 < pt.length; j += 2) {
-          if (pt[j] === "laboratory") {
-            storyline.party.laboratory = stripWrapping(pt[j + 1]);
-          } else if (pt[j] === "authority") {
-            storyline.party.authority = stripWrapping(pt[j + 1]);
-          }
-        }
-      } else if (keyword === "subject") {
-        storyline.subject = parseSubjectEntries(unwrapBlock(value()));
-      } else if (keyword === "record") {
-        const store = stripWrapping(value());
-        const idHead = peek();
-        if (idHead === void 0 || idHead.startsWith("{")) {
-          throw new Error(
-            `Parsing error: storyline. ID ${id}: record ${store} is missing its id and block`
-          );
-        }
-        const rid = stripWrapping(value());
-        const blockHead = peek();
-        if (blockHead === void 0 || !blockHead.startsWith("{")) {
-          throw new Error(
-            `Parsing error: storyline. ID ${id}: record ${store} ${rid} is missing its block`
-          );
-        }
-        storyline.records.push({
-          store,
-          id: rid,
-          fields: readRecordFields(unwrapBlock(value()))
-        });
-      } else if (keyword === "note") {
-        storyline.notes.push(stripWrapping(value()));
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "storyline", id }
-  );
-  return (ctx) => {
-    ctx.storylines[id] = storyline;
-    return ctx;
-  };
-};
-var dumpStoryline = function(s) {
-  let out = "storyline " + s.id + " {\n";
-  if (s.name) {
-    out += '  name "' + escapeString(s.name) + '"\n';
-  }
-  if (s.idPrefix) {
-    out += "  id_prefix " + dumpBareSafe(s.idPrefix) + "\n";
-  }
-  if (s.party.laboratory || s.party.authority) {
-    out += "  party {";
-    if (s.party.laboratory) {
-      out += " laboratory " + dumpBareSafe(s.party.laboratory);
-    }
-    if (s.party.authority) {
-      out += " authority " + dumpBareSafe(s.party.authority);
-    }
-    out += " }\n";
-  }
-  if (s.subject.length > 0) {
-    out += "  subject {\n";
-    for (const e of s.subject) {
-      out += "    " + dumpBareSafe(e.kind) + " " + dumpBareSafe(e.id) + " {\n";
-      out += dumpRecordFields(e.fields, "      ");
-      out += "    }\n";
-    }
-    out += "  }\n";
-  }
-  for (const r of s.records) {
-    out += "  record " + dumpBareSafe(r.store) + " " + dumpBareSafe(r.id) + " {\n";
-    out += dumpRecordFields(r.fields, "    ");
-    out += "  }\n";
-  }
-  for (const n of s.notes) {
-    out += '  note "' + escapeString(n) + '"\n';
-  }
-  out += "}\n";
-  return out;
-};
-
 // src/ser-des/config/index.ts
 function defineConstruct(def) {
   return def;
@@ -18762,33 +18867,12 @@ var CONSTRUCTS = [
   }),
   // The abstract-process model's file-level home (smart TODO.roadmap/40
   // batch 2): the pipeline sequence + the participant/expert registers.
-  defineConstruct({
-    keyword: "process_model",
-    field: "processModels",
-    takesID: true,
-    parse: parseProcessModel,
-    dump: dumpProcessModel
-  }),
   // The certification workflow step register (smart TODO.roadmap/40
   // batch 3) — process-adjacent but NOT the abstract-process machinery;
   // the rec-overlay deep merge (OVERLAY_DEEP_MERGE_FIELDS) lands here.
-  defineConstruct({
-    keyword: "workflow_config",
-    field: "workflowConfigs",
-    takesID: true,
-    parse: parseWorkflowConfig,
-    dump: dumpWorkflowConfig
-  }),
   // The named pipeline stage (smart TODO.roadmap/40 batch 5) — groups
   // the workflow constructs per stage; the members-resolve discipline
   // is C142's.
-  defineConstruct({
-    keyword: "workflow_stage",
-    field: "workflowStages",
-    takesID: true,
-    parse: parseWorkflowStage,
-    dump: dumpWorkflowStage
-  }),
   defineConstruct({
     keyword: "approval",
     field: "approvals",
@@ -18964,6 +19048,16 @@ var CONSTRUCTS = [
   // The certificate rendering contract (smart TODO.roadmap/40 batch 3)
   // — form-adjacent (the certificate is the issuing-side document);
   // singleton per package.
+  // The attestation (the typed kernel; clause 19) — the claim that a
+  // third party has verified a subject against a declared promise set,
+  // carrying the lineage of the claims (C150/C151 check the references).
+  defineConstruct({
+    keyword: "attestation",
+    field: "attestations",
+    takesID: true,
+    parse: parseAttestation,
+    dump: dumpAttestation
+  }),
   defineConstruct({
     keyword: "certificate_template",
     field: "certificateTemplates",
@@ -19353,24 +19447,6 @@ var CONSTRUCTS = [
     parse: parsePartAnnex,
     dump: dumpPartAnnex
   }),
-  // The demo seeds (smart TODO.roadmap/40 batch 4) — one demo_world per
-  // package (file-level metadata + the OPEN participants registry) and
-  // one storyline per flow; the record-value sub-grammar follows the
-  // quantity.ts dumpScalarToken conventions.
-  defineConstruct({
-    keyword: "demo_world",
-    field: "demoWorlds",
-    takesID: true,
-    parse: parseDemoWorld,
-    dump: dumpDemoWorld
-  }),
-  defineConstruct({
-    keyword: "storyline",
-    field: "storylines",
-    takesID: true,
-    parse: parseStoryline,
-    dump: dumpStoryline
-  }),
   // Primmel v3 twin interface (TODO.roadmap/32 — doctrine ch. 14 §14.4):
   // the connector-profile registry. Endpoints and serve bindings are NOT
   // top-level constructs — they are subject anatomy slots (is.endpoints /
@@ -19432,7 +19508,12 @@ function buildParserConfig(constructs) {
     if (!c.field) {
       continue;
     }
-    const entry = { takesID: c.takesID, parse: c.parse, field: c.field };
+    const entry = {
+      takesID: c.takesID,
+      parse: c.parse,
+      field: c.field,
+      ...c.deprecated ? { deprecated: c.deprecated } : {}
+    };
     out[c.keyword] = entry;
     for (const alias of c.aliases ?? []) {
       out[alias] = entry;
@@ -19715,7 +19796,6 @@ var MERGE_FIELDS = [
   "processes",
   // The abstract-process models (smart TODO.roadmap/40 batch 2) compose
   // like the processes they sequence, with uses-no-redefine semantics.
-  "processModels",
   "pages",
   "gateways",
   "regs",
@@ -19769,6 +19849,7 @@ var MERGE_FIELDS = [
   // like the subject anatomy they extend, with uses-no-redefine
   // semantics.
   "promiseSets",
+  "attestations",
   // The applicant-facing documentation register (smart TODO.roadmap/40
   // batch 3) composes with uses-no-redefine semantics.
   "applicationDeclarations",
@@ -19782,10 +19863,8 @@ var MERGE_FIELDS = [
   "certificateTemplates",
   // The certification workflow step register (smart TODO.roadmap/40
   // batch 3) — the rec-overlay deep merge (OVERLAY_DEEP_MERGE_FIELDS).
-  "workflowConfigs",
   // The named pipeline stages (smart TODO.roadmap/40 batch 5) compose
   // with uses-no-redefine semantics.
-  "workflowStages",
   // The verification pathways (smart TODO.roadmap/40 batch 3) compose
   // with uses-no-redefine semantics.
   "verificationPathways",
@@ -19837,8 +19916,6 @@ var MERGE_FIELDS = [
   "documentModules",
   "informativeAnnexes",
   "partAnnexes",
-  "demoWorlds",
-  "storylines",
   // The pre-existing drift closed (the packages-as-SSOT epic): these
   // collections existed as constructs but were never merged, so `uses`
   // composition silently dropped them — comments, predicates, the
@@ -19861,13 +19938,17 @@ var OVERLAY_DEEP_MERGE_FIELDS = /* @__PURE__ */ new Set([
   // The workflow step register (B3.7): a rec package's overlay-marked
   // workflow_config merges field-wise into the core skeleton (steps
   // union by id in first-seen order, gates append as a union).
-  "workflowConfigs",
   // The OIML-CS test-report checklist (B3.10): a rec package's
   // overlay-marked test_report_checklist merges field-wise into the
   // oiml-cs base — entry scalars land IN PLACE (the base order
   // survives; append-at-end would reorder the composition-point
   // entries to the tail).
-  "testReportChecklists"
+  "testReportChecklists",
+  // The entity classes (the smart core's #data plane): a rec
+  // package's overlay-marked class merges field-wise into the core's
+  // — attributes union by id in first-seen order (the rec's added
+  // fields land beside the core's), scalars override.
+  "dataclasses"
 ]);
 function isPlainRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -20029,7 +20110,7 @@ function composePackage(rootDir, options, rootManifest, withProvenance = false)
       )) {
         const prior = pm.get(key);
         if (prior !== void 0) {
-          const isOverlay = typeof value === "object" && value !== null && value.overlay === true && (field === "terms" || OVERLAY_DEEP_MERGE_FIELDS.has(field));
+          const isOverlay = typeof value === "object" && value !== null && value.overlay === true && (field === "terms" || field === "processes" || OVERLAY_DEEP_MERGE_FIELDS.has(field));
           if (!isOverlay) {
             throw new CompositionError(
               "uses-no-redefine",
@@ -20794,10 +20875,8 @@ var TIER_BY_FIELD = {
   certificateTemplates: "secondary",
   // The certification workflow step register (smart TODO.roadmap/40
   // batch 3) — operational wiring, tertiary.
-  workflowConfigs: "tertiary",
   // The named pipeline stages (smart TODO.roadmap/40 batch 5) —
   // operational wiring, tertiary.
-  workflowStages: "tertiary",
   // The verification pathways (smart TODO.roadmap/40 batch 3) —
   // operational wiring, tertiary.
   verificationPathways: "tertiary",
@@ -20837,7 +20916,6 @@ var TIER_BY_FIELD = {
   // Process models (smart TODO.roadmap/40 batch 2) are tertiary beside
   // processes: the pipeline sequence/registers are the abstract-process
   // model's file-level furniture.
-  processModels: "tertiary",
   // Document modules (smart TODO.roadmap/40 batch 2) are tertiary beside
   // processes: the module is the pipeline's document-level furniture.
   documentModules: "tertiary",
@@ -20863,8 +20941,6 @@ var TIER_BY_FIELD = {
   // the model.
   informativeAnnexes: "cross-cutting",
   partAnnexes: "cross-cutting",
-  demoWorlds: "tertiary",
-  storylines: "tertiary",
   // Invariants (smart gap-close E9) are cross-cutting beside notes: the
   // typed replacement for the note-family encoding — doctrine about the
   // model, not machinery inside it (the enforcement claims point at the
@@ -21842,6 +21918,29 @@ var CHECK_RULES = [
     "normal",
     "TODO.roadmap/03"
   ),
+  // ── the power-type discipline (the reconfiguration phase 8; the CDD
+  // family's central modelling relationship, and the CDDAL interop
+  // requirement): every instance can serve as the definition of further
+  // instantiation. C155 keeps the of-chain coherent — an instance that
+  // instantiates another instance carries no upward subject-chain link,
+  // and the of-graph is acyclic. C156 reaches the definition side: a
+  // class's extends names a class or an instance.
+  R(
+    "C155",
+    "power-type-chain",
+    "instantiation",
+    "error",
+    "normal",
+    "the reconfiguration phase 8 (TODO.reconfigure/09-subjects-twins-attestation.md, the power-type clause)"
+  ),
+  R(
+    "C156",
+    "class-extends-resolves",
+    "instantiation",
+    "warning",
+    "normal",
+    "the reconfiguration phase 8 (TODO.reconfigure/09-subjects-twins-attestation.md, the power-type clause)"
+  ),
   // ── mapping (TODO.roadmap/04) ─────────────────────────────────────
   R(
     "C21",
@@ -22068,28 +22167,6 @@ var CHECK_RULES = [
     "normal",
     "smart TODO.roadmap/40 batch 4 (the packages-as-SSOT epic)"
   ),
-  // C129 (smart TODO.roadmap/40 batch 4; the packages-as-SSOT epic): the
-  // demo-seed shapes — the storyline's id_prefix pattern (register-free),
-  // the party laboratory/authority → the demo_world participant seeds
-  // (gated on that register), the record stores → the entity-class stores
-  // (gated), and the in-construct record cross-references (a record field
-  // keyed by a sibling record's store names a sibling of that store —
-  // ungated). Field-level discipline stays app-side.
-  R(
-    "C129",
-    "storyline-shape",
-    "composition",
-    "error",
-    "normal",
-    "smart TODO.roadmap/40 batch 4 (the packages-as-SSOT epic)"
-  ),
-  // C130 (smart TODO.roadmap/40 batch 3; the packages-as-SSOT epic): the
-  // identity_slot / aspect registers — the ≥1-presentation shape leg, the
-  // aspect reference legs (term_ref → term, component → instrument
-  // component, attribute → attribute_definition, contains → identity path
-  // OR bare attribute/dimension id), and the R28 bind-path consumer leg
-  // (model.identity.<slot> / model.aspects.<id> in requirement/test
-  // binds_to), each leg gated on its target register (the C58 doctrine).
   R(
     "C130",
     "identity-and-aspect-references",
@@ -22845,6 +22922,106 @@ var CHECK_RULES = [
     "normal",
     "smart architecture-gaps-2026-07.md E10, data/schemas/test-sequences.yaml"
   ),
+  // ── the executable test programs (smart TODO.twin-demo/03 — the
+  // model-drive bindings) ──
+  // The conformance test's preparation/stimulus facets are the
+  // machine-executable half of the test declaration. C147 is the
+  // program shape: entry orders are positive integers unique in the
+  // program; a preparation step carries action AND/OR drive; a verify
+  // block carries read AND tolerance; a stimulus point carries a drive
+  // and an acceptance reference. C148 is the duration discipline: hold
+  // and fresh_within parse as duration windows (the serve contract's
+  // vocabulary), and a stimulus point declares fresh_within (§14.12's
+  // no-stale-semantics doctrine). Reference RESOLUTION (the drive
+  // operation names against the twin kind's declared vocabulary, the
+  // acceptance/tolerance refs against requirement nodes) is the
+  // consumer-side conformance leg's job — the kernel checks
+  // syntax/shape only (the C92/C93 vs R39 split).
+  R(
+    "C147",
+    "test-program-shape",
+    "base",
+    "error",
+    "normal",
+    "smart TODO.twin-demo/03 (the model-drive bindings)"
+  ),
+  R(
+    "C148",
+    "test-program-duration",
+    "base",
+    "error",
+    "normal",
+    "smart TODO.twin-demo/03 (the model-drive bindings)"
+  ),
+  // ── the deprecation report (phase 2 of the reconfiguration): a
+  // construct whose definition carries a migration note warns on every
+  // use; the retirement phase removes the constructs and the rule
+  // burns down to empty.
+  R(
+    "C154",
+    "construct-deprecated",
+    "base",
+    "warning",
+    "normal",
+    "the reconfiguration phase 2 (TODO.reconfigure/09-migration-plan.md)"
+  ),
+  // ── the attestation (the typed kernel, clause 19): the claim that a
+  // third party has verified a subject against a declared promise set.
+  // C150 resolves its subject, promise set, basis, authority, and claim
+  // references; C151 requires the claim lineage — a mandatory
+  // characteristic is carried by lineage, never restated.
+  // ── the typed kernel R3 (the reconfiguration): the closed-derivation
+  // rule. A derivation expression names only declared definitions —
+  // calculations, tables, symbols, measurements, and attributes — and
+  // the checker rejects anything else, naming the missing declaration.
+  R(
+    "C149",
+    "closed-derivation-references-declared",
+    "quantities",
+    "error",
+    "normal",
+    "the typed kernel R3 (TODO.reconfigure/03-typed-kernel.md)"
+  ),
+  R(
+    "C150",
+    "attestation-references-resolve",
+    "attestation",
+    "error",
+    "normal",
+    "the typed kernel clause 19 (TODO.reconfigure/07-subjects-twins-attestation.md)"
+  ),
+  R(
+    "C151",
+    "attestation-claim-lineage",
+    "attestation",
+    "error",
+    "normal",
+    "the typed kernel clause 19 (TODO.reconfigure/07-subjects-twins-attestation.md)"
+  ),
+  // ── the typed payload rule (the typed kernel R2, clause 10): a
+  // dimension that declares payload_class types every value's
+  // definition — the class resolves, the payload fields are fields of
+  // that class, and every value carries its definition.
+  R(
+    "C152",
+    "payload-typed-by-class",
+    "quantities",
+    "error",
+    "normal",
+    "the typed kernel R2 (TODO.reconfigure/03-typed-kernel.md)"
+  ),
+  // ── the contract-derivation facet (the typed kernel, clause 10): an
+  // artifact definition whose content is the projection of declared
+  // claims derives its contract; the reference resolves and never
+  // combines with inline fields.
+  R(
+    "C153",
+    "artifact-contract-derivation",
+    "artifacts",
+    "error",
+    "normal",
+    "the typed kernel clause 10 (TODO.reconfigure/07-subjects-twins-attestation.md)"
+  ),
   // ── the per-test evaluation-formula traces (smart gap-close E11,
   // analysis/architecture-gaps-2026-07.md; the smart contract
   // data/schemas/formulas-used.yaml) ──
@@ -23192,6 +23369,50 @@ function activeRuleIds(level) {
   );
 }
 
+// src/instance-resolution.ts
+function classPrototype(standard, classId) {
+  const classes = new Map((standard.dataclasses ?? []).map((c) => [c.id, c]));
+  const instances = new Map((standard.instances ?? []).map((i) => [i.id, i]));
+  const seen = /* @__PURE__ */ new Set([classId]);
+  let cur = classes.get(classId);
+  while (cur && cur.extends) {
+    const target = cur.extends;
+    if (seen.has(target)) {
+      return null;
+    }
+    seen.add(target);
+    const inst = instances.get(target);
+    if (inst) {
+      return inst;
+    }
+    cur = classes.get(target);
+  }
+  return null;
+}
+function delegationSuccessors(standard) {
+  const out = /* @__PURE__ */ new Map();
+  for (const inst of standard.instances ?? []) {
+    const upward = inst.model || inst.group || inst.family;
+    if (upward) {
+      out.set(inst.id, upward);
+      continue;
+    }
+    if (!inst.of) {
+      continue;
+    }
+    const direct = (standard.instances ?? []).find((i) => i.id === inst.of);
+    if (direct) {
+      out.set(inst.id, direct.id);
+      continue;
+    }
+    const prototype = classPrototype(standard, inst.of);
+    if (prototype) {
+      out.set(inst.id, prototype.id);
+    }
+  }
+  return out;
+}
+
 // src/check-allowlist.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { join as join2 } from "path";
@@ -24092,7 +24313,9 @@ function checkPackage(dir, options = {}) {
     });
     standard = loaded.standard;
     for (const i of loaded.issues) {
-      if (i.code === "provides-unconsumed") {
+      if (i.code === "construct-deprecated") {
+        warn("C154", i.message);
+      } else if (i.code === "provides-unconsumed") {
         warn("C30", i.message);
       } else if (i.code === "extends-deprecated") {
         warn("C27", i.message);
@@ -24122,6 +24345,10 @@ function checkPackage(dir, options = {}) {
   issues.push(...checkDimensions(standard));
   issues.push(...checkReferences(standard));
   issues.push(...checkVerdictChains(standard));
+  issues.push(...checkClosedDerivations(standard));
+  issues.push(...checkAttestations(standard));
+  issues.push(...checkTypedPayloads(standard));
+  issues.push(...checkArtifactContracts(standard));
   const reqIds = new Set(
     (standard.requirements ?? []).map((r) => r.id)
   );
@@ -24131,12 +24358,11 @@ function checkPackage(dir, options = {}) {
   const attrIds = new Set(
     (standard.attributeDefinitions ?? []).map((a) => a.id)
   );
+  const roleIds = new Set((standard.roles ?? []).map((r) => r.id));
   const behaviorIds = new Set(
     (standard.behaviors ?? []).map((b) => b.id)
   );
-  const subjectIds = new Set(
-    (standard.subjects ?? []).map((s) => s.id)
-  );
+  const subjectIds = new Set((standard.subjects ?? []).map((s) => s.id));
   const symbolIds = new Set((standard.symbols ?? []).map((s) => s.id));
   const dimIds = /* @__PURE__ */ new Map();
   const dimCardinality = /* @__PURE__ */ new Map();
@@ -24694,7 +24920,7 @@ function checkPackage(dir, options = {}) {
   );
   for (const d of standard.artifactDefinitions ?? []) {
     const c = d.contentContract;
-    if (c.fields.length === 0) {
+    if (!d.contractFrom && c.fields.length === 0) {
       err(
         "C45",
         `artifact definition ${d.id}: content contract declares no fields \u2014 a definition must contract SOME content (artifact-def-contract)`
@@ -25280,15 +25506,6 @@ function checkPackage(dir, options = {}) {
         }
       }
     }
-    for (const m of standard.processModels ?? []) {
-      const where = `process_model ${m.id}`;
-      for (const s of m.sequence ?? []) {
-        resolveProcessRef(where, "sequence", s);
-      }
-      for (const r of m.registers ?? []) {
-        resolveOrganAp(`${where} register ${r.id}`, "maintainer", r.maintainer);
-      }
-    }
   }
   {
     const OCL_CHECK = /^ocl\{[\s\S]*\}$/;
@@ -25601,7 +25818,6 @@ function checkPackage(dir, options = {}) {
     }
   }
   {
-    const roleIds = new Set((standard.roles ?? []).map((r) => r.id));
     const KNOWN_OUTCOMES = new Set(MONITOR_OUTCOMES);
     const KNOWN_ACTIONS = new Set(MONITOR_ESCALATION_ACTIONS);
     const KNOWN_STREAMS = new Set(MONITOR_STREAMS);
@@ -25953,6 +26169,7 @@ function checkPackage(dir, options = {}) {
   };
   const instrumentIds = new Set((standard.instruments ?? []).map((i) => i.id));
   const instanceIds = new Set((standard.instances ?? []).map((i) => i.id));
+  const dataclassIds = new Set((standard.dataclasses ?? []).map((c) => c.id));
   const attrScopes = new Map(
     (standard.attributeDefinitions ?? []).map((a) => [a.id, a.scope])
   );
@@ -26057,10 +26274,43 @@ function checkPackage(dir, options = {}) {
         );
       }
     }
-    if (!subjectIds.has(inst.of) && !instrumentIds.has(inst.of)) {
+    if (!subjectIds.has(inst.of) && !instrumentIds.has(inst.of) && !instanceIds.has(inst.of) && !dataclassIds.has(inst.of)) {
       err(
         "C20",
-        `instance ${inst.id}: of "${inst.of}" is not a declared subject or instrument (instance-of-resolves)`
+        `instance ${inst.id}: of "${inst.of}" is not a declared subject, instrument, class, or instance (instance-of-resolves)`
+      );
+    }
+    if (instanceIds.has(inst.of)) {
+      const links = ["model", "group", "family"].filter(
+        (k) => inst[k]
+      );
+      if (links.length > 0) {
+        err(
+          "C155",
+          `instance ${inst.id}: of "${inst.of}" names an instance and the instance carries an upward ${links.join("/")} link \u2014 the power-type chain and the subject-chain profile do not mix (power-type-chain)`
+        );
+      }
+    }
+  }
+  const delegation = delegationSuccessors(standard);
+  const ofAdj = /* @__PURE__ */ new Map();
+  for (const [from, to] of delegation) {
+    if (instanceIds.has(to)) {
+      ofAdj.set(from, [to]);
+    }
+  }
+  const ofCycle = findCycle(ofAdj);
+  if (ofCycle) {
+    err(
+      "C155",
+      `the power-type of-chain is cyclic: ${ofCycle.join(" \u2192 ")} (power-type-chain)`
+    );
+  }
+  for (const c of standard.dataclasses ?? []) {
+    if (c.extends && !dataclassIds.has(c.extends) && !instanceIds.has(c.extends)) {
+      warn(
+        "C156",
+        `class ${c.id}: extends "${c.extends}" is not a declared class or instance (class-extends-resolves)`
       );
     }
   }
@@ -26803,6 +27053,97 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  {
+    for (const ct of standard.conformanceTests ?? []) {
+      const prep = ct.preparation;
+      if (prep) {
+        const orders = /* @__PURE__ */ new Set();
+        for (const step of prep.entries) {
+          const at = step.order !== null ? `preparation step ${step.order}` : "a preparation step";
+          if (step.order === null || !Number.isInteger(step.order) || step.order < 1) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares no positive-integer order (got ${step.order === null ? "none" : step.order}) \u2014 the step order is a positive integer (test-program-shape)`
+            );
+          } else if (orders.has(step.order)) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: preparation step order ${step.order} is declared twice \u2014 the order is unique within the program (test-program-shape)`
+            );
+          } else {
+            orders.add(step.order);
+          }
+          if (step.action === "" && step.drive === "") {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares neither action nor drive \u2014 a preparation step carries a prose action AND/OR a drive reference (test-program-shape)`
+            );
+          }
+          if (step.verify && (step.verify.read === "" || step.verify.tolerance === "")) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares a verify block without ${step.verify.read === "" ? "read" : "tolerance"} \u2014 the verification names what to read AND the tolerance reference (test-program-shape)`
+            );
+          }
+          if (step.hold !== "" && parseFreshnessWindow(step.hold) === null) {
+            err(
+              "C148",
+              `conformance_test ${ct.id}: ${at} hold "${step.hold}" is not a parseable duration (shorthand 500ms/5s/1min/1h/1d or ISO 8601 with fixed-length components, e.g. PT30M) (test-program-duration)`
+            );
+          }
+        }
+      }
+      const stim = ct.stimulus;
+      if (stim) {
+        const orders = /* @__PURE__ */ new Set();
+        for (const point of stim.entries) {
+          const at = point.order !== null ? `stimulus point ${point.order}` : "a stimulus point";
+          if (point.order === null || !Number.isInteger(point.order) || point.order < 1) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares no positive-integer order (got ${point.order === null ? "none" : point.order}) \u2014 the point order is a positive integer (test-program-shape)`
+            );
+          } else if (orders.has(point.order)) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: stimulus point order ${point.order} is declared twice \u2014 the order is unique within the program (test-program-shape)`
+            );
+          } else {
+            orders.add(point.order);
+          }
+          if (point.drive === "") {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares no drive \u2014 a stimulus point names the drive operation (test-program-shape)`
+            );
+          }
+          if (point.acceptance === "") {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares no acceptance \u2014 a stimulus point names the MPE/requirement node it is judged against (test-program-shape)`
+            );
+          }
+          if (point.hold !== "" && parseFreshnessWindow(point.hold) === null) {
+            err(
+              "C148",
+              `conformance_test ${ct.id}: ${at} hold "${point.hold}" is not a parseable duration (shorthand 500ms/5s/1min/1h/1d or ISO 8601 with fixed-length components, e.g. PT30M) (test-program-duration)`
+            );
+          }
+          if (point.freshWithin === "") {
+            err(
+              "C148",
+              `conformance_test ${ct.id}: ${at} declares no fresh_within \u2014 a measurement point's read carries its freshness bound (\xA714.12: no stale semantics) (test-program-duration)`
+            );
+          } else if (parseFreshnessWindow(point.freshWithin) === null) {
+            err(
+              "C148",
+              `conformance_test ${ct.id}: ${at} fresh_within "${point.freshWithin}" is not a parseable freshness window (shorthand 500ms/5s/1min/1h/1d or ISO 8601 with fixed-length components, e.g. PT5S) (test-program-duration)`
+            );
+          }
+        }
+      }
+    }
+  }
   {
     for (const fu of standard.formulasUsed ?? []) {
       if (stripWrapping(fu.id) === "") {
@@ -27219,67 +27560,6 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
-  {
-    const participantSeeds = /* @__PURE__ */ new Set();
-    for (const w of standard.demoWorlds ?? []) {
-      for (const section of w.participants ?? []) {
-        for (const e of section.entries ?? []) {
-          participantSeeds.add(e.id);
-        }
-      }
-    }
-    const entityStores = new Set(
-      (standard.dataclasses ?? []).map((c) => c.store).filter((s) => !!s)
-    );
-    for (const s of standard.storylines ?? []) {
-      const where = `storyline ${s.id}`;
-      if (s.idPrefix && !/^[a-z0-9-]+$/.test(s.idPrefix)) {
-        err(
-          "C129",
-          `${where}: id_prefix "${s.idPrefix}" does not match ^[a-z0-9-]+$ \u2014 the id-minting prefix is a lowercase slug (storyline-shape)`
-        );
-      }
-      if (participantSeeds.size > 0) {
-        for (const [slot, ref] of [
-          ["laboratory", s.party.laboratory],
-          ["authority", s.party.authority]
-        ]) {
-          if (ref && !participantSeeds.has(ref)) {
-            err(
-              "C129",
-              `${where}: party ${slot} "${ref}" is not a declared participant seed (storyline-shape)`
-            );
-          }
-        }
-      }
-      const siblingStores = /* @__PURE__ */ new Map();
-      for (const r of s.records ?? []) {
-        if (entityStores.size > 0 && !entityStores.has(r.store)) {
-          err(
-            "C129",
-            `${where}: record store "${r.store}" is not a declared entity-class store (storyline-shape)`
-          );
-        }
-        let ids = siblingStores.get(r.store);
-        if (!ids) {
-          ids = /* @__PURE__ */ new Set();
-          siblingStores.set(r.store, ids);
-        }
-        ids.add(r.id);
-      }
-      for (const r of s.records ?? []) {
-        for (const [key, value] of Object.entries(r.fields)) {
-          const targets = siblingStores.get(key);
-          if (targets !== void 0 && !Array.isArray(value) && !targets.has(String(value))) {
-            err(
-              "C129",
-              `${where}: record ${r.store} ${r.id}: ${key} "${String(value)}" is not a sibling ${key} record of this storyline (storyline-shape)`
-            );
-          }
-        }
-      }
-    }
-  }
   {
     const slotIds = new Set((standard.identitySlots ?? []).map((s) => s.id));
     const aspectIds = new Set((standard.aspects ?? []).map((a) => a.id));
@@ -27650,40 +27930,11 @@ function checkPackage(dir, options = {}) {
     }
   }
   {
-    const roleIds = new Set((standard.roles ?? []).map((r) => r.id));
-    const dataclassIds = /* @__PURE__ */ new Set();
+    const dataclassIds2 = /* @__PURE__ */ new Set();
     for (const c of standard.dataclasses ?? []) {
-      dataclassIds.add(c.id);
+      dataclassIds2.add(c.id);
       if (c.id.includes("#")) {
-        dataclassIds.add(c.id.slice(0, c.id.indexOf("#")));
-      }
-    }
-    const CLEAN_TOKEN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-    for (const w of standard.workflowConfigs ?? []) {
-      for (const s of w.steps ?? []) {
-        const where = `workflow_config ${w.id}: step ${s.id}`;
-        if (s.actor && roleIds.size > 0 && !roleIds.has(s.actor)) {
-          err(
-            "C137",
-            `${where}: actor "${s.actor}" is not a declared role (workflow-config-references)`
-          );
-        }
-        for (const [facet, list] of [
-          ["inputs", s.inputs],
-          ["outputs", s.outputs]
-        ]) {
-          for (const entry of list) {
-            if (!CLEAN_TOKEN.test(entry)) {
-              continue;
-            }
-            if (dataclassIds.size > 0 && !dataclassIds.has(entry)) {
-              err(
-                "C137",
-                `${where}: ${facet} entry "${entry}" is not a declared data class (workflow-config-references)`
-              );
-            }
-          }
-        }
+        dataclassIds2.add(c.id.slice(0, c.id.indexOf("#")));
       }
     }
   }
@@ -27920,35 +28171,6 @@ function checkPackage(dir, options = {}) {
         }
       }
     }
-    const stageApprovalIds = new Set((standard.approvals ?? []).map((a) => a.id));
-    const stageGatewayIds = new Set((standard.gateways ?? []).map((g) => g.id));
-    for (const s of standard.workflowStages ?? []) {
-      const where = `workflow_stage ${s.id}`;
-      for (const el of s.elements ?? []) {
-        if (gwProcessIds.size > 0 && !gwProcessIds.has(el)) {
-          err(
-            "C142",
-            `${where}: element "${el}" is not a declared process (gateway-edges-resolve)`
-          );
-        }
-      }
-      for (const a of s.approvals ?? []) {
-        if (stageApprovalIds.size > 0 && !stageApprovalIds.has(a)) {
-          err(
-            "C142",
-            `${where}: approval "${a}" is not a declared approval (gateway-edges-resolve)`
-          );
-        }
-      }
-      for (const g of s.gateways ?? []) {
-        if (stageGatewayIds.size > 0 && !stageGatewayIds.has(g)) {
-          err(
-            "C142",
-            `${where}: gateway "${g}" is not a declared gateway (gateway-edges-resolve)`
-          );
-        }
-      }
-    }
   }
   {
     const approvalRoleIds = new Set((standard.roles ?? []).map((r) => r.id));
@@ -29092,38 +29314,400 @@ function textAddressKey(item, segment) {
   }
   return false;
 }
-function checkSpellingCodes(standard) {
+function checkArtifactContracts(standard) {
   const issues = [];
   const err = (check, message) => issues.push({ check, severity: "error", message });
-  const warn = (check, message) => issues.push({ check, severity: "warning", message });
-  const m = standard.packageManifest;
-  if (m?.defaultSpelling) {
-    const parsed = parseSpellingCode(m.defaultSpelling);
-    if (typeof parsed === "string") {
+  const setIds = /* @__PURE__ */ new Set();
+  for (const ps of standard.promiseSets ?? []) {
+    setIds.add(ps.id);
+    setIds.add(`${ps.id}.promise_set`);
+  }
+  for (const s of standard.subjects ?? []) {
+    if ((s.is?.promises ?? []).length > 0) {
+      setIds.add(s.id);
+      setIds.add(`${s.id}.promise_set`);
+    }
+  }
+  for (const d of standard.artifactDefinitions ?? []) {
+    if (!d.contractFrom) {
+      continue;
+    }
+    if (!setIds.has(d.contractFrom)) {
       err(
-        "C89",
-        `package "${m.id}": default_spelling "${m.defaultSpelling}" \u2014 ${parsed} (spelling-code-wellformed)`
+        "C153",
+        `artifact_definition ${d.id}: contract_from "${d.contractFrom}" does not resolve to a declared promise set (artifact-contract-derivation)`
       );
     }
-    if ((m.spellings ?? []).length > 0 && !m.spellings.includes(m.defaultSpelling)) {
+    const c = d.contentContract;
+    if (c.fields.length > 0 || c.structure || c.media.length > 0) {
       err(
-        "C89",
-        `package "${m.id}": default_spelling "${m.defaultSpelling}" is not in the declared spellings set (spelling-code-wellformed)`
+        "C153",
+        `artifact_definition ${d.id}: declares both contract_from and inline contract fields \u2014 the derived contract is the referenced set's projection, never a restatement (artifact-contract-derivation)`
       );
     }
   }
-  for (const s of m?.spellings ?? []) {
-    const parsed = parseSpellingCode(s);
-    if (typeof parsed === "string") {
+  return issues;
+}
+function checkTypedPayloads(standard) {
+  const issues = [];
+  const err = (check, message) => issues.push({ check, severity: "error", message });
+  const classFields = /* @__PURE__ */ new Map();
+  for (const c of standard.dataclasses ?? []) {
+    classFields.set(c.id, new Set(c.attributes.map((a) => a.id)));
+  }
+  const instanceShape = (id) => {
+    const inst = (standard.instances ?? []).find((i) => i.id === id);
+    if (!inst) {
+      return void 0;
+    }
+    let cur = inst;
+    const seen = /* @__PURE__ */ new Set([cur.id]);
+    while (cur.of) {
+      const next = (standard.instances ?? []).find((i) => i.id === cur.of);
+      if (!next || seen.has(next.id)) {
+        break;
+      }
+      seen.add(next.id);
+      cur = next;
+    }
+    return cur.of !== "" ? classFields.get(cur.of) : void 0;
+  };
+  const typedFields = (id) => classFields.get(id) ?? instanceShape(id);
+  const checkDim = (owner, d) => {
+    if (!d.payloadClass) {
+      return;
+    }
+    const fields = typedFields(d.payloadClass);
+    if (!fields) {
       err(
-        "C89",
-        `package "${m.id}": declared spelling "${s}" \u2014 ${parsed} (spelling-code-wellformed)`
+        "C152",
+        `${owner} dimension ${d.id}: payload_class "${d.payloadClass}" is not a declared class (payload-typed-by-class)`
       );
+      return;
+    }
+    for (const v of d.values) {
+      const keys = Object.keys(v.payload ?? {});
+      if (keys.length === 0) {
+        err(
+          "C152",
+          `${owner} dimension ${d.id}: value ${v.id} carries no payload \u2014 a value of a payload_class dimension IS its definition (payload-typed-by-class)`
+        );
+        continue;
+      }
+      for (const key of keys) {
+        if (!fields.has(key)) {
+          err(
+            "C152",
+            `${owner} dimension ${d.id}: value ${v.id} payload field "${key}" is not a field of class "${d.payloadClass}" (payload-typed-by-class)`
+          );
+        }
+      }
+    }
+  };
+  for (const inst of standard.instruments ?? []) {
+    for (const d of inst.dimensions ?? []) {
+      checkDim(`instrument ${inst.id}`, d);
     }
   }
-  const texts = standard.texts ?? [];
-  if (texts.length === 0) {
-    return issues;
+  for (const d of standard.dimensions ?? []) {
+    checkDim("top-level", d);
+  }
+  for (const a of standard.attributeDefinitions ?? []) {
+    if (a.classRef && !typedFields(a.classRef)) {
+      err(
+        "C152",
+        `attribute_definition ${a.id}: class "${a.classRef}" is not a declared class (payload-typed-by-class)`
+      );
+    }
+  }
+  return issues;
+}
+function checkAttestations(standard) {
+  const issues = [];
+  const err = (check, message) => issues.push({ check, severity: "error", message });
+  const roleIds = new Set((standard.roles ?? []).map((r) => r.id));
+  const instanceIds = new Set((standard.instances ?? []).map((i) => i.id));
+  const verdictIds = new Set((standard.verdicts ?? []).map((v) => v.id));
+  const setViews = /* @__PURE__ */ new Map();
+  for (const ps of standard.promiseSets ?? []) {
+    setViews.set(ps.id, { promises: ps.promises });
+    setViews.set(`${ps.id}.promise_set`, { promises: ps.promises });
+  }
+  for (const s of standard.subjects ?? []) {
+    if ((s.is?.promises ?? []).length > 0) {
+      setViews.set(s.id, { promises: s.is.promises });
+    }
+  }
+  const resolveSet = (ref) => setViews.get(ref) ?? setViews.get(ref.split(".").slice(1).join(".")) ?? null;
+  const mandatoryOf = (view) => {
+    const out = /* @__PURE__ */ new Set();
+    for (const p of view.promises) {
+      if (p.certificate?.obligation === "mandatory") {
+        out.add(p.id);
+      }
+    }
+    return out;
+  };
+  for (const a of standard.attestations ?? []) {
+    if (!a.subject) {
+      err(
+        "C150",
+        `attestation ${a.id}: no subject facet (attestation-references-resolve)`
+      );
+    } else if (!instanceIds.has(a.subject)) {
+      err(
+        "C150",
+        `attestation ${a.id}: subject "${a.subject}" is not a declared instance (attestation-references-resolve)`
+      );
+    }
+    if (!a.promises) {
+      err(
+        "C150",
+        `attestation ${a.id}: no promises facet (attestation-references-resolve)`
+      );
+    }
+    const set = a.promises ? resolveSet(a.promises) : null;
+    if (a.promises && !set) {
+      err(
+        "C150",
+        `attestation ${a.id}: promises "${a.promises}" does not resolve to a declared promise set (attestation-references-resolve)`
+      );
+    }
+    for (const b of a.basis) {
+      if (!b.kind || !b.id) {
+        err(
+          "C150",
+          `attestation ${a.id}: a basis entry needs an evidence kind and an id (attestation-references-resolve)`
+        );
+      }
+    }
+    if (a.authority.role && roleIds.size > 0 && !roleIds.has(a.authority.role)) {
+      err(
+        "C150",
+        `attestation ${a.id}: authority role "${a.authority.role}" is not a declared role (attestation-references-resolve)`
+      );
+    }
+    const carried = new Set(a.claims.map((c) => c.promise));
+    for (const c of a.claims) {
+      if (set && !set.promises.some((p) => p.id === c.promise)) {
+        err(
+          "C150",
+          `attestation ${a.id}: claim "${c.promise}" is not a promise of "${a.promises}" (attestation-references-resolve)`
+        );
+      }
+      if (!c.declared) {
+        err(
+          "C151",
+          `attestation ${a.id}: claim "${c.promise}" carries no declaration reference (attestation-claim-lineage)`
+        );
+      }
+      if (!c.validatedBy) {
+        err(
+          "C151",
+          `attestation ${a.id}: claim "${c.promise}" carries no verdict reference (attestation-claim-lineage)`
+        );
+      } else if (verdictIds.size > 0 && !c.validatedBy.startsWith("/") && !verdictIds.has(c.validatedBy)) {
+        err(
+          "C150",
+          `attestation ${a.id}: claim "${c.promise}" names verdict "${c.validatedBy}", which is not declared (attestation-references-resolve)`
+        );
+      }
+    }
+    if (set) {
+      for (const pid of mandatoryOf(set)) {
+        if (!carried.has(pid)) {
+          err(
+            "C151",
+            `attestation ${a.id}: the mandatory promise "${pid}" of "${a.promises}" is carried by no claim \u2014 a mandatory characteristic is carried by lineage, never restated (attestation-claim-lineage)`
+          );
+        }
+      }
+    }
+  }
+  return issues;
+}
+var CLOSED_DERIVATION_STOP = /* @__PURE__ */ new Set([
+  "self",
+  "p",
+  "ocl",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  // OCL navigation and collection operators
+  "and",
+  "or",
+  "not",
+  "implies",
+  "if",
+  "then",
+  "else",
+  "endif",
+  "xor",
+  "let",
+  "in",
+  "exists",
+  "forAll",
+  "select",
+  "reject",
+  "collect",
+  "isEmpty",
+  "size",
+  "sum",
+  "min",
+  "max",
+  "abs",
+  "round",
+  "floor",
+  "sqrt",
+  "includes",
+  "excludes",
+  "includesAll",
+  "excludesAll",
+  "count",
+  "first",
+  "last",
+  "asSet",
+  "asOrderedSet",
+  "asSequence",
+  "asBag",
+  "sortedBy",
+  "iterate",
+  "oclIsUndefined",
+  "oclIsKindOf",
+  "oclIsTypeOf",
+  "allInstances",
+  // table-lookup engine vocabulary (the lookup facet names these)
+  "lookup",
+  "profile",
+  // OCL collection statistics and arithmetic
+  "average",
+  "mean",
+  "size",
+  "div",
+  "mod",
+  "collect"
+]);
+var CLOSED_DERIVATION_PATH_RE = /\b[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+/g;
+var CLOSED_DERIVATION_IDENT_RE = /[A-Za-z_][A-Za-z0-9_]*/g;
+function checkClosedDerivations(standard) {
+  const issues = [];
+  const err = (check, message) => issues.push({ check, severity: "error", message });
+  const declared = /* @__PURE__ */ new Set();
+  for (const c of standard.calculations ?? []) {
+    declared.add(c.id);
+    declared.add(c.name);
+  }
+  for (const tb of standard.tables ?? []) {
+    declared.add(tb.id);
+  }
+  for (const s of standard.symbols ?? []) {
+    declared.add(s.id);
+  }
+  for (const v of standard.variables ?? []) {
+    declared.add(v.id);
+  }
+  for (const a of standard.attributeDefinitions ?? []) {
+    declared.add(a.id);
+  }
+  for (const e of standard.enums ?? []) {
+    declared.add(e.id);
+  }
+  for (const d of standard.dataclasses ?? []) {
+    declared.add(d.id);
+  }
+  for (const inst of standard.instruments ?? []) {
+    for (const d of inst.dimensions ?? []) {
+      declared.add(d.id);
+    }
+  }
+  for (const d of standard.dimensions ?? []) {
+    declared.add(d.id);
+  }
+  for (const c of standard.calculations ?? []) {
+    if (c.output?.name) {
+      declared.add(c.output.name);
+    }
+    for (const i of c.inputs ?? []) {
+      declared.add(i.name);
+    }
+  }
+  const localsOf = (extra) => /* @__PURE__ */ new Set([...declared, ...extra]);
+  const checkExpression = (expr, locals, where) => {
+    if (!expr) {
+      return;
+    }
+    const noLiterals = expr.replace(/'[^']*'/g, " ");
+    const noLambdas = noLiterals.replace(
+      /\b([A-Za-z_][A-Za-z0-9_]*)\s*\|/g,
+      " "
+    );
+    const stripped = noLambdas.replace(CLOSED_DERIVATION_PATH_RE, " ");
+    const seen = /* @__PURE__ */ new Set();
+    for (const raw of stripped.match(CLOSED_DERIVATION_IDENT_RE) ?? []) {
+      if (CLOSED_DERIVATION_STOP.has(raw) || locals.has(raw) || seen.has(raw) || /^[a-z][0-9]?$/.test(raw)) {
+        continue;
+      }
+      seen.add(raw);
+      err(
+        "C149",
+        `${where}: expression references "${raw}", which no declared calculation, table, symbol, measurement, or attribute defines (closed-derivation-references-declared)`
+      );
+    }
+  };
+  for (const a of standard.attributeDefinitions ?? []) {
+    checkExpression(a.derived, localsOf([]), `attribute_definition ${a.id}`);
+  }
+  for (const c of standard.calculations ?? []) {
+    const inputs = (c.inputs ?? []).map((i) => i.name);
+    checkExpression(c.expression, localsOf(inputs), `calculation ${c.id}`);
+  }
+  for (const s of standard.symbols ?? []) {
+    if (s.formula?.expression) {
+      checkExpression(
+        s.formula.expression,
+        localsOf(s.formula.inputs ?? []),
+        `symbol ${s.id}`
+      );
+    }
+  }
+  for (const v of standard.verdicts ?? []) {
+    checkExpression(v.derive, localsOf(v.inputs ?? []), `verdict ${v.id}`);
+  }
+  return issues;
+}
+function checkSpellingCodes(standard) {
+  const issues = [];
+  const err = (check, message) => issues.push({ check, severity: "error", message });
+  const warn = (check, message) => issues.push({ check, severity: "warning", message });
+  const m = standard.packageManifest;
+  if (m?.defaultSpelling) {
+    const parsed = parseSpellingCode(m.defaultSpelling);
+    if (typeof parsed === "string") {
+      err(
+        "C89",
+        `package "${m.id}": default_spelling "${m.defaultSpelling}" \u2014 ${parsed} (spelling-code-wellformed)`
+      );
+    }
+    if ((m.spellings ?? []).length > 0 && !m.spellings.includes(m.defaultSpelling)) {
+      err(
+        "C89",
+        `package "${m.id}": default_spelling "${m.defaultSpelling}" is not in the declared spellings set (spelling-code-wellformed)`
+      );
+    }
+  }
+  for (const s of m?.spellings ?? []) {
+    const parsed = parseSpellingCode(s);
+    if (typeof parsed === "string") {
+      err(
+        "C89",
+        `package "${m.id}": declared spelling "${s}" \u2014 ${parsed} (spelling-code-wellformed)`
+      );
+    }
+  }
+  const texts = standard.texts ?? [];
+  if (texts.length === 0) {
+    return issues;
   }
   const elements = /* @__PURE__ */ new Map();
   const ID_COLLECTIONS = [
@@ -31076,9 +31660,229 @@ function renderJsonLd(prefixes, triples) {
 
 // src/export/retrieval.ts
 import { createHash } from "node:crypto";
-import { readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
-import { join as join5, relative } from "node:path";
-var RETRIEVAL_PROJECTION = "primmel-retrieval/1";
+import { readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
+import { join as join6, relative } from "node:path";
+
+// src/export/unitsdb.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
+import { join as join5 } from "node:path";
+function loadUnitsDb(dir) {
+  if (!dir) {
+    return null;
+  }
+  try {
+    const entries = [];
+    const jsonPath = join5(dir, "units.json");
+    if (!existsSync6(jsonPath)) {
+      return null;
+    }
+    const parsed = JSON.parse(readFileSync6(jsonPath, "utf8")).units;
+    if (!Array.isArray(parsed)) {
+      return null;
+    }
+    for (const u of parsed) {
+      const identifiers = u.identifiers ?? [];
+      const unitsml = identifiers.find((i) => i.type === "unitsml")?.id;
+      if (!unitsml) {
+        continue;
+      }
+      const nist = identifiers.find((i) => i.type === "nist")?.id;
+      const scale = u.scale_reference?.id;
+      const symbols = (u.symbols ?? []).map((s) => String(s.ascii ?? s.id)).filter(Boolean);
+      const entry = {
+        unitsml,
+        ...nist ? { nist } : {},
+        ...scale ? { scale } : {},
+        symbols
+      };
+      entries.push(entry);
+    }
+    const bySymbol = /* @__PURE__ */ new Map();
+    const byUnitsml = /* @__PURE__ */ new Map();
+    const spellings = (s) => [
+      s,
+      s.replace(/\*([a-zA-ZμΩ°]+)\^-1\b/g, "/$1")
+    ];
+    for (const e of entries) {
+      byUnitsml.set(e.unitsml, e);
+      for (const s of e.symbols) {
+        for (const sp of spellings(s)) {
+          bySymbol.set(sp, e);
+        }
+      }
+    }
+    return { bySymbol, byUnitsml };
+  } catch {
+    return null;
+  }
+}
+function unitsDbEntryFor(db, unit) {
+  return db?.bySymbol.get(unit) ?? null;
+}
+
+// src/export/yaml-lite.ts
+var NUMERIC2 = /^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/;
+function parseScalar(raw) {
+  const s = raw.trim();
+  if (s === "" || s === "~" || s === "null" || s === "Null" || s === "NULL") {
+    return null;
+  }
+  if (s === "true" || s === "True" || s === "TRUE") {
+    return true;
+  }
+  if (s === "false" || s === "False" || s === "FALSE") {
+    return false;
+  }
+  if (NUMERIC2.test(s)) {
+    return Number(s);
+  }
+  if (s[0] === '"' || s[0] === "'") {
+    return unquote(s, s[0]);
+  }
+  return s;
+}
+function unquote(s, q) {
+  if (s.length < 2 || s[s.length - 1] !== q) {
+    return s;
+  }
+  const body = s.slice(1, -1);
+  if (q === "'") {
+    return body.replace(/''/g, "'");
+  }
+  let out = "";
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c !== "\\" || i === body.length - 1) {
+      out += c;
+      continue;
+    }
+    const e = body[++i];
+    if (e === "n") {
+      out += "\n";
+    } else if (e === "t") {
+      out += "	";
+    } else if (e === "r") {
+      out += "\r";
+    } else if (e === "0") {
+      out += "\0";
+    } else if (e === "\\" || e === '"') {
+      out += e;
+    } else {
+      out += "\\" + e;
+    }
+  }
+  return out;
+}
+function splitKey(text) {
+  const colon = text.indexOf(":");
+  if (colon <= 0) {
+    return null;
+  }
+  const key = text.slice(0, colon);
+  if (/[\s"']/.test(key)) {
+    return null;
+  }
+  return [key, text.slice(colon + 1)];
+}
+function parseValue(lines, i, indent) {
+  if (i >= lines.length) {
+    return [i, null];
+  }
+  const t = lines[i].text;
+  if (t === "-" || t.startsWith("- ")) {
+    return parseSequence(lines, i, indent);
+  }
+  return parseMapping(lines, i, indent);
+}
+function parseSequence(lines, i, indent) {
+  const out = [];
+  while (i < lines.length && lines[i].indent === indent && (lines[i].text === "-" || lines[i].text.startsWith("- "))) {
+    const content = lines[i].text === "-" ? "" : lines[i].text.slice(2).trim();
+    if (content === "") {
+      i++;
+      const next = i < lines.length ? lines[i].indent : -1;
+      if (next > indent) {
+        const [end, value] = parseValue(lines, i, next);
+        out.push(value);
+        i = end;
+      } else {
+        out.push(null);
+      }
+      continue;
+    }
+    const nested = content === "-" || content.startsWith("- ");
+    if (nested || splitKey(content) !== null) {
+      lines[i] = { indent: indent + 2, text: content };
+      const [end, value] = nested ? parseSequence(lines, i, indent + 2) : parseMapping(lines, i, indent + 2);
+      out.push(value);
+      i = end;
+    } else {
+      out.push(parseScalar(content));
+      i++;
+    }
+  }
+  return [i, out];
+}
+function parseMapping(lines, i, indent) {
+  const map = {};
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.indent !== indent || line.text === "-" || line.text.startsWith("- ")) {
+      break;
+    }
+    const kv = splitKey(line.text);
+    if (!kv) {
+      break;
+    }
+    const [key, rest] = kv;
+    i++;
+    if (rest.trim() === "") {
+      const next = i < lines.length ? lines[i].indent : -1;
+      if (next > indent) {
+        const [end, value] = parseValue(lines, i, next);
+        map[key] = value;
+        i = end;
+      } else {
+        map[key] = null;
+      }
+    } else {
+      map[key] = parseScalar(rest);
+    }
+  }
+  return [i, map];
+}
+function parseYamlBlock(text) {
+  const scanned = [];
+  for (const raw of text.split("\n")) {
+    if (raw.trim() === "") {
+      continue;
+    }
+    scanned.push({
+      indent: raw.length - raw.trimStart().length,
+      text: raw.trim()
+    });
+  }
+  if (scanned.length === 0 || splitKey(scanned[0].text) === null) {
+    return void 0;
+  }
+  const bases = /* @__PURE__ */ new Set([
+    scanned[0].indent,
+    scanned[1]?.indent ?? scanned[0].indent
+  ]);
+  for (const base of bases) {
+    const lines = scanned.map(
+      (l) => l === scanned[0] && l.indent < base ? { indent: base, text: l.text } : l
+    );
+    const [end, map] = parseMapping(lines, 0, base);
+    if (end === lines.length && Object.keys(map).length > 0) {
+      return map;
+    }
+  }
+  return void 0;
+}
+
+// src/export/retrieval.ts
+var RETRIEVAL_PROJECTION = "primmel-retrieval/2";
 var RETRIEVAL_FACET_VERSION = "retrieval-facet/1";
 function sortDeep(v) {
   if (Array.isArray(v)) {
@@ -31107,7 +31911,7 @@ function* walkPackage(dir) {
     if (entry === ".DS_Store") {
       continue;
     }
-    const p = join5(dir, entry);
+    const p = join6(dir, entry);
     if (statSync3(p).isDirectory()) {
       yield* walkPackage(p);
     } else {
@@ -31120,7 +31924,7 @@ function packageSourceHash(dir) {
   for (const file of walkPackage(dir)) {
     h.update(relative(dir, file));
     h.update("\0");
-    h.update(createHash("sha256").update(readFileSync6(file)).digest());
+    h.update(createHash("sha256").update(readFileSync7(file)).digest());
     h.update("\n");
   }
   return h.digest("hex");
@@ -31235,11 +32039,94 @@ function passportOf(unit) {
     expression: unit.expression ?? "",
     units: unit.units ?? [],
     applicability: applicabilitySummary(unit.applicability),
-    acceptance: unit.acceptance ?? "",
+    acceptance: acceptanceSummary(unit),
     provenance: (unit.clauses ?? []).map((c) => c.urn),
     content_hash: unit.content_hash
   };
 }
+function acceptanceDecisionOf(a) {
+  if (!a) {
+    return void 0;
+  }
+  const out = {
+    ...present(a.rule) ? { rule: a.rule } : {}
+  };
+  if (a.guardBand) {
+    out.guard_band = { kind: a.guardBand.kind, value: a.guardBand.value };
+  }
+  if (a.uncertainty) {
+    out.uncertainty = { max_ratio_to_mpe: a.uncertainty.maxRatioToMpe };
+  }
+  if (present(a.criterion)) {
+    out.criterion = a.criterion;
+  }
+  if (a.statistics) {
+    out.statistics = {
+      method: a.statistics.method,
+      on_basis_of: a.statistics.onBasisOf,
+      permits: a.statistics.permits
+    };
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function criteriaItemOf(c) {
+  const item = { name: c.item };
+  if (present(c.requirementId)) {
+    item.target = c.requirementId;
+  }
+  if (present(c.criterion)) {
+    item.criterion = c.criterion;
+  }
+  if (present(c.passIf)) {
+    item.pass_if = c.passIf;
+  }
+  if (c.accepts) {
+    item.accepts = {
+      verdict: c.accepts.verdict,
+      op: c.accepts.op,
+      limit: c.accepts.limit
+    };
+  }
+  if (c.optional) {
+    item.optional = true;
+  }
+  if (present(c.description)) {
+    item.description = c.description;
+  }
+  if (present(c.reference)) {
+    item.reference = c.reference;
+  }
+  return item;
+}
+function testAcceptanceCriteriaOf(t) {
+  const out = {
+    ...present(t.acceptanceCriteriaType) ? { type: t.acceptanceCriteriaType } : {},
+    ...present(t.acceptanceCriteriaDescription) ? { description: t.acceptanceCriteriaDescription } : {},
+    ...present(t.acceptancePassIf) ? { pass_if: t.acceptancePassIf } : {},
+    ...presentList(t.acceptanceCriteria) ? { items: t.acceptanceCriteria.map(criteriaItemOf) } : {}
+  };
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function acceptanceSummary(unit) {
+  if (unit.accepts) {
+    return `${unit.accepts.verdict} ${unit.accepts.op} ${unit.accepts.limit}`;
+  }
+  const criteria = unit.acceptance_criteria;
+  if (criteria && typeof criteria === "object") {
+    const passIf = criteria["pass_if"];
+    if (present(passIf)) {
+      return passIf;
+    }
+    const description = criteria["description"];
+    if (present(description)) {
+      return description;
+    }
+  }
+  if (unit.acceptance?.rule) {
+    return unit.acceptance.rule;
+  }
+  return "";
+}
 var BASE_URN_PARTS = /^urn:oiml:pub:([rdbge]):(\d[\d-]*)(?::(\d{4}))?$/i;
 function retrievalDocParts(baseUrn) {
   const m = BASE_URN_PARTS.exec(baseUrn);
@@ -31398,6 +32285,8 @@ function scopeOf(id) {
 var present = (s) => typeof s === "string" && s.length > 0;
 var presentList = (xs) => xs && xs.length > 0 ? xs : void 0;
 function requirementUnit(r) {
+  const decision = acceptanceDecisionOf(r.limit?.acceptance);
+  const criteria = present(r.acceptanceCriteria) ? parseYamlBlock(r.acceptanceCriteria) ?? r.acceptanceCriteria : void 0;
   return assemble(
     {
       id: r.id,
@@ -31415,9 +32304,14 @@ function requirementUnit(r) {
       ...presentList(r.applicability) ? { applicability: r.applicability } : {},
       ...presentList(r.bindsTo) ? { binds_to: r.bindsTo } : {},
       ...r.limit?.accepts ? {
-        acceptance: `${r.limit.accepts.verdict} ${r.limit.accepts.op} ${r.limit.accepts.limit}`
+        accepts: {
+          verdict: r.limit.accepts.verdict,
+          op: r.limit.accepts.op,
+          limit: r.limit.accepts.limit
+        }
       } : {},
-      ...present(r.acceptanceCriteria) ? { acceptance_criteria: r.acceptanceCriteria } : {},
+      ...decision ? { acceptance: decision } : {},
+      ...criteria !== void 0 ? { acceptance_criteria: criteria } : {},
       ...present(r.verificationMethod) ? {
         verification: {
           method: r.verificationMethod,
@@ -31433,16 +32327,10 @@ function requirementUnit(r) {
 function conformanceTestUnit(t) {
   const payload = {
     ...present(t.kind) ? { test_kind: t.kind } : {},
-    ...present(t.methodRef) ? { method_ref: t.methodRef } : {},
-    ...presentList(t.preconditions) ? {
-      preconditions: t.preconditions.map((p) => ({
-        id: p.id,
-        check: p.check,
-        description: p.description,
-        on_violation: p.onViolation
-      }))
-    } : {}
+    ...present(t.methodRef) ? { method_ref: t.methodRef } : {}
   };
+  const decision = acceptanceDecisionOf(t.acceptance);
+  const criteria = testAcceptanceCriteriaOf(t);
   return assemble(
     {
       id: t.id,
@@ -31456,7 +32344,17 @@ function conformanceTestUnit(t) {
       ...presentList(t.applicability) ? { applicability: t.applicability } : {},
       ...presentList(t.targets) ? { targets: t.targets } : {},
       ...presentList(t.bindsTo) ? { binds_to: t.bindsTo } : {},
-      ...present(t.acceptancePassIf) ? { acceptance: t.acceptancePassIf } : present(t.acceptanceCriteriaDescription) ? { acceptance: t.acceptanceCriteriaDescription } : {},
+      ...decision ? { acceptance: decision } : {},
+      ...criteria ? { acceptance_criteria: criteria } : {},
+      ...presentList(t.preconditions) ? {
+        preconditions: t.preconditions.map((p) => ({
+          id: p.id,
+          check: p.check,
+          ...present(p.description) ? { description: p.description } : {},
+          ...present(p.onViolation) ? { on_violation: p.onViolation } : {},
+          ...present(p.onUnresolvable) ? { on_unresolvable: p.onUnresolvable } : {}
+        }))
+      } : {},
       ...presentList(t.dependencies) ? { dependencies: t.dependencies } : {},
       ...Object.keys(payload).length > 0 ? { payload } : {}
     },
@@ -31615,9 +32513,15 @@ function constraintUnit(c) {
       ...present(c.name) ? { name: c.name } : {},
       ...present(c.violationMeaning) ? { statement: c.violationMeaning } : {},
       ...present(c.check) ? { expression: c.check } : {},
+      // The violation semantics first-class (ask 8) — the construct's
+      // own keyword vocabulary, out of the payload grab bag. `statement`
+      // and `expression` stay: the generic prose/expression slots the
+      // passport and the consumer's grounding text read.
+      ...present(c.check) ? { check: c.check } : {},
+      ...present(c.violationMeaning) ? { violation_meaning: c.violationMeaning } : {},
+      ...present(c.onViolation) ? { on_violation: c.onViolation } : {},
       payload: {
-        ...present(c.stereotype) ? { stereotype: c.stereotype } : {},
-        ...present(c.onViolation) ? { on_violation: c.onViolation } : {}
+        ...present(c.stereotype) ? { stereotype: c.stereotype } : {}
       }
     },
     collectClauses(c)
@@ -31640,7 +32544,7 @@ function characteristicUnit(v) {
         ...presentList(v.inputs) ? { expression_inputs: v.inputs } : {}
       } : {},
       ...units ? { units } : {},
-      ...v.acceptance && present(v.acceptance.rule) ? { acceptance: v.acceptance.rule } : {},
+      ...acceptanceDecisionOf(v.acceptance) ? { acceptance: acceptanceDecisionOf(v.acceptance) } : {},
       ...Object.keys(payload).length > 0 ? { payload } : {}
     },
     collectClauses(v)
@@ -31697,6 +32601,76 @@ function sequenceUnit(s) {
     collectClauses({ sourceRefs: s.sourceRefs, refs: s.refs })
   );
 }
+function conditionSetUnit(cs, registers, db = null) {
+  const unitsBySymbol = /* @__PURE__ */ new Map();
+  for (const reg of registers ?? []) {
+    const siUnitByKind = new Map(reg.kinds.map((k) => [k.id, k.siUnit]));
+    for (const u of reg.units ?? []) {
+      const siUnit = siUnitByKind.get(u.kind);
+      if (siUnit) {
+        unitsBySymbol.set(u.symbol, {
+          kind: u.kind,
+          factorToSI: u.factorToSI,
+          offsetToSI: u.offsetToSI,
+          siUnit
+        });
+      }
+    }
+  }
+  const siOf = (value, unit) => {
+    const def = unitsBySymbol.get(unit);
+    if (!def) {
+      return void 0;
+    }
+    const n = Number(String(value).replace(",", "."));
+    if (!Number.isFinite(n)) {
+      return void 0;
+    }
+    return { value: n * def.factorToSI + def.offsetToSI, unit: def.siUnit };
+  };
+  const payload = {
+    role: cs.role,
+    ...cs.subject ? { subject: cs.subject } : {},
+    entries: cs.entries.map((e) => {
+      const si = siOf(e.value, e.unit);
+      const ud = unitsDbEntryFor(db, e.unit);
+      return {
+        quantity_kind: e.quantityKind,
+        value: e.value,
+        unit: e.unit,
+        tolerance: e.tolerance,
+        ...si ? { si } : {},
+        ...ud ? {
+          unitsdb: {
+            unitsml: ud.unitsml,
+            ...ud.scale ? { scale: ud.scale } : {}
+          }
+        } : {},
+        ...e.note ? { note: e.note } : {}
+      };
+    })
+  };
+  return assemble(
+    {
+      id: `/condition/${cs.id}`,
+      kind: "condition_set",
+      name: cs.id,
+      statement: [
+        `${cs.role} condition set`,
+        ...cs.description ? [cs.description] : [],
+        ...cs.entries.map(
+          (e) => `${e.quantityKind.replace(/_/g, " ")}: ${e.value} ${e.unit} \xB1${e.tolerance}`
+        )
+      ].join(" \u2014 "),
+      payload
+    },
+    collectClauses({
+      sourceRefs: cs.sources,
+      refs: cs.refs,
+      source: cs.source
+    })
+  );
+}
 function noteUnit(n) {
   return assemble(
     {
@@ -31737,11 +32711,16 @@ function dimensionUnit(d) {
   const payload = {
     ...present(d.scope) ? { scope: d.scope } : {},
     ...present(d.cardinality) ? { cardinality: d.cardinality } : {},
+    // The typed payload (the typed kernel R2): a value IS its
+    // definition — the class's fields ride the value, and the class
+    // reference rides the dimension.
+    ...present(d.payloadClass) ? { payload_class: d.payloadClass } : {},
     values: d.values.map((v) => ({
       id: v.id,
       ...present(v.label) ? { label: v.label } : {},
       ...presentList(v.implies) ? { implies: v.implies } : {},
-      ...present(v.termRef) ? { term_ref: v.termRef } : {}
+      ...present(v.termRef) ? { term_ref: v.termRef } : {},
+      ...Object.keys(v.payload ?? {}).length > 0 ? { payload: v.payload } : {}
     }))
   };
   return assemble(
@@ -31796,6 +32775,7 @@ function packageBlock(standard) {
   };
 }
 function exportStandardRetrieval(standard, options = {}) {
+  const unitsDb = loadUnitsDb(process.env.UNITSDB_DIR);
   const pkg = packageBlock(standard);
   const built = [];
   const push = (content, elementId) => {
@@ -31834,6 +32814,9 @@ function exportStandardRetrieval(standard, options = {}) {
   for (const s of standard.testSequences ?? []) {
     push(sequenceUnit(s), s.id);
   }
+  for (const cs of standard.conditionSets ?? []) {
+    push(conditionSetUnit(cs, standard.quantityRegisters, unitsDb), cs.id);
+  }
   for (const n of standard.notes ?? []) {
     push(noteUnit(n), n.id);
   }
@@ -32113,18 +33096,171 @@ function exportPackageImpact(dir) {
   };
 }
 
+// src/export/cddal.ts
+import { readFileSync as readFileSync8, readdirSync as readdirSync5 } from "node:fs";
+import { basename, join as join7, resolve as resolve5 } from "node:path";
+var CDDAL_PROJECTION_VERSION = "primmel-cddal/1";
+function escapeCddalString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function quote(s) {
+  return `"${escapeCddalString(s)}"`;
+}
+function safeSymbol(id) {
+  const s = id.replace(/[^A-Za-z0-9_]+/g, "_");
+  return /^[0-9]/.test(s) ? `N${s}` : s;
+}
+function isSafeIdentifier(id) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(id);
+}
+function codeAssignment(id) {
+  return isSafeIdentifier(id) ? id : quote(id);
+}
+function quantity(v) {
+  return quote(
+    v.unit !== void 0 && v.unit !== "" ? `${v.value} ${v.unit}` : String(v.value)
+  );
+}
+function readL10n(files, read) {
+  const out = /* @__PURE__ */ new Map();
+  const block = /text\s+([\w./#-]+)\s*\{([\s\S]*?)\}/g;
+  const spell = /spell\s+([\w-]+)\s+"((?:[^"\\]|\\.)*)"/g;
+  for (const f of files.filter((f2) => /(^|\/)l10n\.[^/]+\.prl$/.test(f2))) {
+    const src = read(f);
+    for (const m of src.matchAll(block)) {
+      const addr = m[1];
+      const tail = addr.split("/").pop() ?? addr;
+      for (const sp of (m[2] ?? "").matchAll(spell)) {
+        const list = out.get(tail) ?? [];
+        list.push({ tag: sp[1], value: sp[2] });
+        out.set(tail, list);
+      }
+    }
+  }
+  return out;
+}
+function l10nDefinitions(l10n, id, field) {
+  return l10n.get(`${id}.${field}`) ?? [];
+}
+function projectCddal(model, packageId, l10n = /* @__PURE__ */ new Map()) {
+  const lines = [
+    `# ${CDDAL_PROJECTION_VERSION} \u2014 the dictionary subset of ${packageId}`,
+    "# (generated by primmel export cddal \u2014 never authored, never re-imported)",
+    ""
+  ];
+  const stats = {
+    classes: 0,
+    instances: 0,
+    assignments: 0,
+    properties: 0,
+    valueLists: 0
+  };
+  const attrDefs = new Map(
+    (model.attributeDefinitions ?? []).map((a) => [a.id, a])
+  );
+  for (const c of model.dataclasses) {
+    stats.classes++;
+    lines.push(`instance ${safeSymbol(c.id)} < MDC_C002 {`);
+    lines.push(`  code: ${codeAssignment(c.id)}`);
+    if (c.description) {
+      lines.push(`  definition.en: ${quote(c.description)}`);
+      for (const alt of l10nDefinitions(l10n, c.id, "description")) {
+        lines.push(`  definition.${alt.tag}: ${quote(alt.value)}`);
+      }
+    }
+    lines.push(
+      `  superclass: ${c.extends !== void 0 ? safeSymbol(c.extends) : "UNIVERSE"}`
+    );
+    if (c.attributes.length > 0) {
+      lines.push(
+        `  applicable_properties: { ${c.attributes.map((a) => safeSymbol(a.id)).join(", ")} }`
+      );
+    }
+    lines.push("}");
+    lines.push("");
+    for (const a of c.attributes) {
+      const def = attrDefs.get(a.id);
+      if (!def) {
+        continue;
+      }
+      const irdi = def.irdi || def.correspondences?.find((x) => x.scheme === "iec-cdd")?.concept;
+      stats.properties++;
+      lines.push(`instance ${safeSymbol(a.id)} < MDC_C003 {`);
+      lines.push(
+        `  code: ${codeAssignment(irdi !== void 0 && irdi !== "" ? irdi : a.id)}`
+      );
+      if (def.definition) {
+        lines.push(`  definition.en: ${quote(def.definition)}`);
+        for (const alt of l10nDefinitions(l10n, a.id, "definition")) {
+          lines.push(`  definition.${alt.tag}: ${quote(alt.value)}`);
+        }
+      }
+      lines.push("}");
+      lines.push("");
+    }
+  }
+  for (const e of model.enums ?? []) {
+    stats.valueLists++;
+    lines.push(`instance ${safeSymbol(e.id)} < MDC_C005 {`);
+    lines.push(`  code: ${codeAssignment(e.id)}`);
+    if (e.values.length > 0) {
+      lines.push(
+        `  MDC_P043: ( ${e.values.map((v) => safeSymbol(v.id)).join(", ")} )`
+      );
+    }
+    lines.push("}");
+    lines.push("");
+    for (const v of e.values) {
+      lines.push(`instance ${safeSymbol(v.id)} < MDC_C010 {`);
+      lines.push(`  code: ${codeAssignment(v.id)}`);
+      lines.push("}");
+      lines.push("");
+    }
+  }
+  for (const inst of model.instances) {
+    stats.instances++;
+    lines.push(`instance ${safeSymbol(inst.id)} < MDC_C002 {`);
+    lines.push(`  code: ${codeAssignment(inst.id)}`);
+    if (inst.of) {
+      lines.push(`  superclass: ${safeSymbol(inst.of)}`);
+    }
+    for (const [id, v] of Object.entries(inst.has?.attributes ?? {})) {
+      stats.assignments++;
+      lines.push(`  ${safeSymbol(id)}: ${quantity(v)}`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  if (stats.classes === 0 && stats.instances === 0 && stats.valueLists === 0) {
+    throw new Error(
+      "no dictionary content: the CDDAL projection carries classes and instances"
+    );
+  }
+  return {
+    version: CDDAL_PROJECTION_VERSION,
+    cddal: lines.join("\n"),
+    stats
+  };
+}
+function exportPackageCddal(dir) {
+  const model = loadPackage(dir);
+  const l10nFiles = readdirSync5(dir).filter((e) => /^l10n\.[^/]+\.prl$/.test(e)).map((e) => join7(dir, e));
+  const l10n = readL10n(l10nFiles, (p) => readFileSync8(p, "utf8"));
+  return projectCddal(model, basename(resolve5(dir)), l10n);
+}
+
 // src/package-diff.ts
-import { existsSync as existsSync6, readdirSync as readdirSync5, readFileSync as readFileSync7 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
 function packageMappings(dir, standard) {
   const profiles = [...standard.mapProfiles ?? []];
-  if (existsSync6(dir)) {
-    for (const entry of readdirSync5(dir).sort()) {
+  if (existsSync7(dir)) {
+    for (const entry of readdirSync6(dir).sort()) {
       if (!entry.endsWith(".prm")) {
         continue;
       }
       profiles.push(
-        ...prmToMapProfiles(loadPrm(readFileSync7(join6(dir, entry), "utf8")))
+        ...prmToMapProfiles(loadPrm(readFileSync9(join8(dir, entry), "utf8")))
       );
     }
   }
@@ -32133,17 +33269,17 @@ function packageMappings(dir, standard) {
 }
 function packageClauseTexts(dir) {
   const out = /* @__PURE__ */ new Map();
-  const prdDir = join6(dir, "sources-prd");
-  if (!existsSync6(prdDir)) {
+  const prdDir = join8(dir, "sources-prd");
+  if (!existsSync7(prdDir)) {
     return out;
   }
-  for (const entry of readdirSync5(prdDir).sort()) {
+  for (const entry of readdirSync6(prdDir).sort()) {
     if (!entry.endsWith(".sentences.json")) {
       continue;
     }
     let payload;
     try {
-      payload = JSON.parse(readFileSync7(join6(prdDir, entry), "utf8"));
+      payload = JSON.parse(readFileSync9(join8(prdDir, entry), "utf8"));
     } catch {
       continue;
     }
@@ -32193,18 +33329,18 @@ function diffPackageDirs(dirA, dirB, options = {}) {
 // scripts/check.mts
 var CHECK_USAGE = "Usage: primmel check [--strict] [--audit] [--coverage] [--rules] [--with <pkg-id>=<dir>]\u2026 <package-dir>";
 var DIFF_USAGE = "Usage: primmel diff [--json] [--exit-code] [--compare-texts] [--with <pkg-id>=<dir>]\u2026 <a> <b>";
-var EXPORT_USAGE = "Usage: primmel export reqif|rdf|retrieval|impact <package-dir> [--out <file>] [--format turtle|jsonld]";
+var EXPORT_USAGE = "Usage: primmel export reqif|rdf|retrieval|impact|cddal <package-dir> [--out <file>] [--format turtle|jsonld]";
 function readablePackageDirProblem(target, needsManifest) {
   try {
     if (!statSync4(target).isDirectory()) {
       return "not a directory";
     }
-    readdirSync6(target);
+    readdirSync7(target);
   } catch (e) {
     const err = e;
     return err.code === "ENOENT" ? "no such directory" : err.message;
   }
-  if (needsManifest && !existsSync7(join7(target, "package.primmel"))) {
+  if (needsManifest && !existsSync8(join9(target, "package.primmel"))) {
     return "no package.primmel found";
   }
   return null;
@@ -32363,7 +33499,7 @@ function diffCli(args2) {
 }
 function exportCli(args2) {
   const surface = args2[0];
-  if (surface !== "reqif" && surface !== "rdf" && surface !== "retrieval" && surface !== "impact") {
+  if (surface !== "reqif" && surface !== "rdf" && surface !== "retrieval" && surface !== "impact" && surface !== "cddal") {
     console.error(EXPORT_USAGE);
     process.exit(2);
   }
@@ -32398,7 +33534,11 @@ function exportCli(args2) {
   let document;
   let summary;
   try {
-    if (surface === "impact") {
+    if (surface === "cddal") {
+      const result = exportPackageCddal(dir);
+      document = result.cddal;
+      summary = `${n(result.stats.classes, "class", "classes")}, ${n(result.stats.instances, "instance", "instances")}, ${n(result.stats.assignments, "assignment", "assignments")}`;
+    } else if (surface === "impact") {
       const result = exportPackageImpact(dir);
       document = result.json;
       const s = result.stats;