@primmel/primmel 1.11.1 → 1.13.0

package/dist-cli/primmel.mjs

@@ -195,6 +195,8 @@ function parse(mmelString, parsers, options = {}) {
     approvals: {},
     roles: {},
     processes: {},
+    // The abstract-process models (smart TODO.roadmap/40 batch 2)
+    processModels: {},
     pages: {},
     gateways: {},
     regs: {},
@@ -218,11 +220,16 @@ function parse(mmelString, parsers, options = {}) {
     forms: {},
     subforms: {},
     symbols: {},
+    formulaNotes: {},
     calculations: {},
     verdicts: {},
     referenceMaterials: {},
     testPointSets: {},
+    commonTestConditions: {},
     competenceKinds: {},
+    // The ISO/IEC 17067 scheme-type register (smart TODO.roadmap/40 batch 2)
+    schemeActivityKinds: {},
+    schemeTypes: {},
     predicates: {},
     constraints: {},
     discrepancyRecords: {},
@@ -261,6 +268,12 @@ function parse(mmelString, parsers, options = {}) {
     documentPrecedences: {},
     autoInclusions: {},
     decisionRules: {},
+    // The document modules + informative annexes (smart TODO.roadmap/40 batch 2)
+    documentModules: {},
+    informativeAnnexes: {},
+    partAnnexes: {},
+    demoWorlds: {},
+    storylines: {},
     // Primmel v3 twin interface (TODO.roadmap/32)
     connectorProfiles: {},
     // Primmel v3 continuous compliance (TODO.roadmap/34)
@@ -2364,15 +2377,18 @@ function parseParamList(block, allowInitial = false) {
   const t = tokenize(block);
   let i = 0;
   while (i < t.length) {
-    const name = stripColon(t[i++]);
+    const head = t[i++];
+    const name = stripColon(head);
     if (!name) {
       break;
     }
-    let type = "";
+    let typed = head.endsWith(":");
     if (i < t.length && t[i] === ":") {
+      typed = true;
       i++;
     }
-    if (i < t.length) {
+    let type = "";
+    if (typed && i < t.length) {
       type = stripWrapping(t[i++]);
     }
     const param = { name, type };
@@ -2532,6 +2548,131 @@ function parseSegregation(block) {
   }
   return out;
 }
+function parseProcessEvidence(block) {
+  const out = [];
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const eid = stripWrapping(t[i++]);
+    if (!eid) {
+      break;
+    }
+    const entry = { id: eid, description: "", required: false };
+    if (i < t.length && t[i].startsWith("{")) {
+      forEachEntry(
+        unwrapBlock(t[i++]),
+        (keyword, value) => {
+          if (keyword === "description") {
+            entry.description = stripWrapping(value());
+          } else if (keyword === "required") {
+            entry.required = stripWrapping(value()) === "true";
+          } else {
+            return false;
+          }
+          return true;
+        },
+        { construct: "process evidence", id: eid }
+      );
+    }
+    out.push(entry);
+  }
+  return out;
+}
+function parseProcessDecision(block) {
+  const decision = { rule: "", clause: "" };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "rule") {
+        decision.rule = stripWrapping(value());
+      } else if (keyword === "clause") {
+        decision.clause = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "process decision", id: "" }
+  );
+  return decision;
+}
+function parseProcessDeclaration(block) {
+  const declaration = { kind: "", action: "" };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "kind") {
+        declaration.kind = stripWrapping(value());
+      } else if (keyword === "action") {
+        declaration.action = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "process declaration", id: "" }
+  );
+  return declaration;
+}
+function parseProcessWindows(block) {
+  const out = [];
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (cmd !== "window") {
+      i = skipUnknownEntry(t, i);
+      continue;
+    }
+    const wid = stripWrapping(t[i++]);
+    const entry = {
+      id: wid,
+      kind: "",
+      clause: "",
+      anchor: "",
+      applies_to: "",
+      windowYears: 0,
+      windowMonths: 0,
+      breach: "",
+      description: ""
+    };
+    if (i < t.length && t[i].startsWith("{")) {
+      forEachEntry(
+        unwrapBlock(t[i++]),
+        (keyword, value) => {
+          if (keyword === "kind") {
+            entry.kind = stripWrapping(value());
+          } else if (keyword === "clause") {
+            entry.clause = stripWrapping(value());
+          } else if (keyword === "anchor") {
+            entry.anchor = stripWrapping(value());
+          } else if (keyword === "applies_to") {
+            entry.applies_to = stripWrapping(value());
+          } else if (keyword === "window") {
+            const wt = tokenizePackage(unwrapBlock(value()));
+            for (let k = 0; k + 1 < wt.length; k += 2) {
+              if (wt[k] === "years") {
+                entry.windowYears = parseInt(stripWrapping(wt[k + 1]), 10) || 0;
+              } else if (wt[k] === "months") {
+                entry.windowMonths = parseInt(stripWrapping(wt[k + 1]), 10) || 0;
+              }
+            }
+          } else if (keyword === "breach") {
+            entry.breach = stripWrapping(value());
+          } else if (keyword === "description") {
+            entry.description = stripWrapping(value());
+          } else {
+            return false;
+          }
+          return true;
+        },
+        { construct: "process window", id: wid }
+      );
+    }
+    out.push(entry);
+  }
+  return out;
+}
 function parseProcessInstances(block) {
   const out = { by: "", values: {} };
   const t = tokenize(block);
@@ -2783,6 +2924,18 @@ var parseProcess = function(id, data) {
     instances: null,
     childComposition: "all",
     does: null,
+    // The abstract-process model (smart TODO.roadmap/40 batch 2)
+    summary: "",
+    roles: [],
+    organs: [],
+    participantKinds: [],
+    evidence: [],
+    decision: null,
+    declaration: null,
+    dischargesGate: "",
+    realizedBy: [],
+    approvedBy: [],
+    windows: [],
     source: null,
     provisionRefs: [],
     _relations: {
@@ -2863,6 +3016,28 @@ var parseProcess = function(id, data) {
         result.invariants = parseOclList(unwrapBlock(value()));
       } else if (keyword === "activity_kind") {
         result.activityKinds = tokenize(stripWrapping(value())).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+      } else if (keyword === "summary") {
+        result.summary = unwrapped(value);
+      } else if (keyword === "roles") {
+        result.roles = tokenize(stripWrapping(value())).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+      } else if (keyword === "organs") {
+        result.organs = tokenize(stripWrapping(value())).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+      } else if (keyword === "participant_kinds") {
+        result.participantKinds = tokenize(stripWrapping(value())).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+      } else if (keyword === "evidence") {
+        result.evidence = parseProcessEvidence(unwrapBlock(value()));
+      } else if (keyword === "decision") {
+        result.decision = parseProcessDecision(unwrapBlock(value()));
+      } else if (keyword === "declaration") {
+        result.declaration = parseProcessDeclaration(unwrapBlock(value()));
+      } else if (keyword === "discharges_gate") {
+        result.dischargesGate = stripWrapping(value());
+      } else if (keyword === "realized_by") {
+        result.realizedBy = tokenize(stripWrapping(value())).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+      } else if (keyword === "approved_by") {
+        result.approvedBy = tokenize(stripWrapping(value())).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+      } else if (keyword === "windows") {
+        result.windows = parseProcessWindows(unwrapBlock(value()));
       } else if (keyword === "segregation") {
         result.segregation = parseSegregation(unwrapBlock(value()));
       } else if (keyword === "preconditions") {
@@ -3046,6 +3221,9 @@ function dumpDoes(flow) {
 var dumpProcess = function(process2, ctx) {
   let out = "process " + process2.id + " {\n";
   out += '  name "' + escapeString(process2.name) + '"\n';
+  if (process2.summary) {
+    out += '  summary "' + escapeString(process2.summary) + '"\n';
+  }
   if (process2.actor !== null) {
     out += "  actor " + process2.actor.id + "\n";
   }
@@ -3096,6 +3274,94 @@ var dumpProcess = function(process2, ctx) {
   if (process2.activityKinds && process2.activityKinds.length > 0) {
     out += "  activity_kind { " + process2.activityKinds.map(dumpBareSafe).join(" ") + " }\n";
   }
+  if (process2.roles && process2.roles.length > 0) {
+    out += "  roles { " + process2.roles.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (process2.organs && process2.organs.length > 0) {
+    out += "  organs { " + process2.organs.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (process2.participantKinds && process2.participantKinds.length > 0) {
+    out += "  participant_kinds { " + process2.participantKinds.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (process2.evidence && process2.evidence.length > 0) {
+    out += "  evidence {\n";
+    for (const e of process2.evidence) {
+      out += "    " + dumpBareSafe(e.id) + " {";
+      if (e.description) {
+        out += ' description "' + escapeString(e.description) + '"';
+      }
+      if (e.required) {
+        out += " required true";
+      }
+      out += " }\n";
+    }
+    out += "  }\n";
+  }
+  if (process2.decision) {
+    out += "  decision {";
+    if (process2.decision.rule) {
+      out += " rule " + dumpBareSafe(process2.decision.rule);
+    }
+    if (process2.decision.clause) {
+      out += ' clause "' + escapeString(process2.decision.clause) + '"';
+    }
+    out += " }\n";
+  }
+  if (process2.declaration) {
+    out += "  declaration {";
+    if (process2.declaration.kind) {
+      out += " kind " + dumpBareSafe(process2.declaration.kind);
+    }
+    if (process2.declaration.action) {
+      out += " action " + dumpBareSafe(process2.declaration.action);
+    }
+    out += " }\n";
+  }
+  if (process2.dischargesGate) {
+    out += "  discharges_gate " + dumpBareSafe(process2.dischargesGate) + "\n";
+  }
+  if (process2.realizedBy && process2.realizedBy.length > 0) {
+    out += "  realized_by { " + process2.realizedBy.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (process2.approvedBy && process2.approvedBy.length > 0) {
+    out += "  approved_by { " + process2.approvedBy.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (process2.windows && process2.windows.length > 0) {
+    out += "  windows {\n";
+    for (const w of process2.windows) {
+      out += "    window " + dumpBareSafe(w.id) + " {\n";
+      if (w.kind) {
+        out += "      kind " + dumpBareSafe(w.kind) + "\n";
+      }
+      if (w.clause) {
+        out += '      clause "' + escapeString(w.clause) + '"\n';
+      }
+      if (w.anchor) {
+        out += "      anchor " + dumpBareSafe(w.anchor) + "\n";
+      }
+      if (w.applies_to) {
+        out += "      applies_to " + dumpBareSafe(w.applies_to) + "\n";
+      }
+      if (w.windowYears > 0 || w.windowMonths > 0) {
+        out += "      window {";
+        if (w.windowYears > 0) {
+          out += " years " + w.windowYears;
+        }
+        if (w.windowMonths > 0) {
+          out += " months " + w.windowMonths;
+        }
+        out += " }\n";
+      }
+      if (w.breach) {
+        out += "      breach " + dumpBareSafe(w.breach) + "\n";
+      }
+      if (w.description) {
+        out += '      description "' + escapeString(w.description) + '"\n';
+      }
+      out += "    }\n";
+    }
+    out += "  }\n";
+  }
   if (process2.segregation && process2.segregation.length > 0) {
     out += "  segregation {\n";
     for (const s of process2.segregation) {
@@ -3180,6 +3446,125 @@ 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;
+}
+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 "";
+  }
+  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;
+}
+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, "  ");
+  }
+  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";
+  }
+  out += "}\n";
+  return out;
+};
+
 // src/ser-des/config/provision.ts
 var parseProvision = function(id, data) {
   const result = {
@@ -5283,6 +5668,47 @@ var dumpSymbol = function(s) {
   return out;
 };
 
+// src/ser-des/config/formulaNote.ts
+function readIdList(block) {
+  return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+}
+var parseFormulaNote = (id, data) => {
+  const note = {
+    id,
+    text: "",
+    appliesTo: []
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "text") {
+        note.text = stripWrapping(value());
+      } else if (keyword === "applies_to") {
+        note.appliesTo = readIdList(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "formula_note", id }
+  );
+  return (ctx) => {
+    ctx.formulaNotes[id] = note;
+    return ctx;
+  };
+};
+var dumpFormulaNote = function(n) {
+  let out = "formula_note " + n.id + " {\n";
+  if (n.text) {
+    out += '  text "' + escapeString(n.text) + '"\n';
+  }
+  if (n.appliesTo.length > 0) {
+    out += "  applies_to { " + n.appliesTo.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  out += "}\n";
+  return out;
+};
+
 // src/ser-des/config/calculation.ts
 var parseCalculation = function(id, data) {
   const result = {
@@ -5375,6 +5801,16 @@ var parseCalculation = function(id, data) {
           result.lookup = parseLookup(unwrapBlock(t[i++]));
         } else if (command === "profile") {
           result.profile = stripWrapping(t[i++]);
+        } else if (command === "variant") {
+          const vid = stripWrapping(t[i++]);
+          if (i >= t.length || !t[i].startsWith("{")) {
+            throw new Error(
+              `Parsing error: calculation. ID ${id}: variant ${vid} is missing its block`
+            );
+          }
+          (result.variants ??= []).push(
+            parseVariant(vid, unwrapBlock(t[i++]), id)
+          );
         } else {
           i++;
         }
@@ -5590,6 +6026,102 @@ function parseLookup(block) {
   }
   return lookup;
 }
+var VARIANT_TYPES = [
+  "expression",
+  "table_lookup",
+  "profile_lookup",
+  "pass_fail"
+];
+function parseVariant(vid, block, calcId) {
+  const variant = {
+    id: vid,
+    type: "",
+    label: "",
+    description: "",
+    params: [],
+    expression: "",
+    lookup: null,
+    profile: ""
+  };
+  const t = tokenizePackage(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i >= t.length) {
+      break;
+    }
+    if (cmd === "type") {
+      const type = stripWrapping(t[i++]);
+      if (!VARIANT_TYPES.includes(type)) {
+        throw new Error(
+          `Parsing error: calculation. ID ${calcId}: variant ${vid}: Unknown variant type "${type}" (valid: ${VARIANT_TYPES.join(", ")})`
+        );
+      }
+      variant.type = type;
+    } else if (cmd === "label") {
+      variant.label = stripWrapping(t[i++]);
+    } else if (cmd === "description") {
+      variant.description = stripWrapping(t[i++]);
+    } else if (cmd === "params") {
+      variant.params = tokenize(stripWrapping(t[i++])).map(stripWrapping).filter((s) => s.length > 0);
+    } else if (cmd === "expression") {
+      variant.expression = stripWrapping(t[i++]);
+    } else if (cmd === "lookup") {
+      variant.lookup = parseLookup(unwrapBlock(t[i++]));
+    } else if (cmd === "profile") {
+      variant.profile = stripWrapping(t[i++]);
+    } else {
+      unwrapBlock(t[i++]);
+    }
+  }
+  return variant;
+}
+function dumpLookupFields(l) {
+  let out = "";
+  if (l.key) {
+    out += "key " + l.key + " ";
+  }
+  if (l.variable) {
+    out += "variable " + l.variable + " ";
+  }
+  if (l.multiplier) {
+    out += "multiplier " + l.multiplier + " ";
+  }
+  if (l.defaultTier) {
+    out += "default_tier { factor " + l.defaultTier.factor;
+    if (l.defaultTier.mode) {
+      out += " mode " + l.defaultTier.mode;
+    }
+    out += " } ";
+  }
+  return out;
+}
+function dumpVariant(v) {
+  let out = "  variant " + dumpBareSafe(v.id) + " {\n";
+  if (v.type) {
+    out += "    type " + v.type + "\n";
+  }
+  if (v.label) {
+    out += '    label "' + escapeString(v.label) + '"\n';
+  }
+  if (v.description) {
+    out += '    description "' + escapeString(v.description) + '"\n';
+  }
+  if (v.params.length > 0) {
+    out += "    params { " + v.params.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (v.expression) {
+    out += '    expression "' + escapeString(v.expression) + '"\n';
+  }
+  if (v.lookup) {
+    out += "    lookup { " + dumpLookupFields(v.lookup) + "}\n";
+  }
+  if (v.profile) {
+    out += "    profile " + dumpBareSafe(v.profile) + "\n";
+  }
+  out += "  }\n";
+  return out;
+}
 var resolveCalculation = function(ctx, unresolved) {
   const ref = [];
   for (const id of unresolved._relations.ref) {
@@ -5678,28 +6210,14 @@ var dumpCalculation = function(c) {
     out += "  params { " + c.params.join(" ") + " }\n";
   }
   if (c.lookup) {
-    out += "  lookup { ";
-    if (c.lookup.key) {
-      out += "key " + c.lookup.key + " ";
-    }
-    if (c.lookup.variable) {
-      out += "variable " + c.lookup.variable + " ";
-    }
-    if (c.lookup.multiplier) {
-      out += "multiplier " + c.lookup.multiplier + " ";
-    }
-    if (c.lookup.defaultTier) {
-      out += "default_tier { factor " + c.lookup.defaultTier.factor;
-      if (c.lookup.defaultTier.mode) {
-        out += " mode " + c.lookup.defaultTier.mode;
-      }
-      out += " } ";
-    }
-    out += "}\n";
+    out += "  lookup { " + dumpLookupFields(c.lookup) + "}\n";
   }
   if (c.profile) {
     out += "  profile " + c.profile + "\n";
   }
+  for (const v of c.variants ?? []) {
+    out += dumpVariant(v);
+  }
   for (const src of c.sourceRefs ?? (c.sourceRef && (c.sourceRef.doc || c.sourceRef.clause) ? [c.sourceRef] : [])) {
     out += dumpSourceRefAsRef(src, "  ", escapeString);
   }
@@ -8072,7 +8590,7 @@ var VALID_SERIES_REDUCTIONS = [
   "worst_case",
   "max_abs_over_window"
 ];
-function readIdList(block) {
+function readIdList2(block) {
   return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
 }
 var parseVerdict = function(id, data) {
@@ -8112,7 +8630,7 @@ var parseVerdict = function(id, data) {
       } else if (keyword === "derive" || keyword === "expression") {
         result.derive = unwrapped(value);
       } else if (keyword === "inputs" || keyword === "uses") {
-        result.inputs = readIdList(value());
+        result.inputs = readIdList2(value());
       } else if (keyword === "series_reduction") {
         const v = value();
         if (!VALID_SERIES_REDUCTIONS.includes(v)) {
@@ -8457,6 +8975,202 @@ var dumpReferenceMaterial = function(m) {
   return out;
 };
 
+// src/ser-des/config/schemeType.ts
+var SCHEME_ACTIVITY_FAMILIES = [
+  "common",
+  "determination",
+  "attestation",
+  "surveillance"
+];
+var ATTESTATION_OBJECTS = [
+  "product_type",
+  "batch",
+  "ongoing_production",
+  "service_or_process"
+];
+function parseKindList(value) {
+  return tokenizePackage(unwrapBlock(value)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+}
+var parseSchemeActivityKind = (id, data) => {
+  const kind = {
+    id,
+    family: "common",
+    row: "",
+    label: "",
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "family") {
+        const family = stripWrapping(value());
+        if (!SCHEME_ACTIVITY_FAMILIES.includes(family)) {
+          throw new Error(
+            `Parsing error: scheme_activity_kind. ID ${id}: Unknown family "${family}" (valid: ${SCHEME_ACTIVITY_FAMILIES.join(", ")})`
+          );
+        }
+        kind.family = family;
+      } else if (keyword === "row") {
+        kind.row = stripWrapping(value());
+      } else if (keyword === "label") {
+        kind.label = stripWrapping(value());
+      } else if (keyword === "source") {
+        kind.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_activity_kind", id }
+  );
+  return (ctx) => {
+    ctx.schemeActivityKinds[id] = kind;
+    return ctx;
+  };
+};
+function parseSchemeSurveillance(block) {
+  const surveillance = { required: false, activities: [] };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "required") {
+        surveillance.required = stripWrapping(value()) === "true";
+      } else if (keyword === "activities") {
+        surveillance.activities = parseKindList(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_type surveillance", id: "" }
+  );
+  return surveillance;
+}
+var parseSchemeType = (id, data) => {
+  const type = {
+    id,
+    label: "",
+    clause: "",
+    description: "",
+    sampling: "",
+    attestationObject: "",
+    determination: [],
+    attestation: [],
+    surveillance: null,
+    notes: [],
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "label") {
+        type.label = stripWrapping(value());
+      } else if (keyword === "clause") {
+        type.clause = stripWrapping(value());
+      } else if (keyword === "description") {
+        type.description = stripWrapping(value());
+      } else if (keyword === "sampling") {
+        type.sampling = stripWrapping(value());
+      } else if (keyword === "attestation_object") {
+        const object = stripWrapping(value());
+        if (!ATTESTATION_OBJECTS.includes(object)) {
+          throw new Error(
+            `Parsing error: scheme_type. ID ${id}: Unknown attestation_object "${object}" (valid: ${ATTESTATION_OBJECTS.join(", ")})`
+          );
+        }
+        type.attestationObject = object;
+      } else if (keyword === "determination") {
+        type.determination = parseKindList(value());
+      } else if (keyword === "attestation") {
+        type.attestation = parseKindList(value());
+      } else if (keyword === "surveillance") {
+        type.surveillance = parseSchemeSurveillance(unwrapBlock(value()));
+      } else if (keyword === "notes") {
+        type.notes = tokenizePackage(unwrapBlock(value())).map(stripWrapping).filter((s) => s.length > 0);
+      } else if (keyword === "source") {
+        type.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_type", id }
+  );
+  return (ctx) => {
+    ctx.schemeTypes[id] = type;
+    return ctx;
+  };
+};
+function dumpSource(source, indent) {
+  if (!source.doc && !source.clause) {
+    return "";
+  }
+  let out = indent + "source {\n";
+  if (source.doc) {
+    out += indent + '  doc "' + escapeString(source.doc) + '"\n';
+  }
+  if (source.clause) {
+    out += indent + '  clause "' + escapeString(source.clause) + '"\n';
+  }
+  out += indent + "}\n";
+  return out;
+}
+var dumpSchemeActivityKind = function(k) {
+  let out = "scheme_activity_kind " + k.id + " {\n";
+  out += "  family " + k.family + "\n";
+  if (k.row) {
+    out += '  row "' + escapeString(k.row) + '"\n';
+  }
+  if (k.label) {
+    out += '  label "' + escapeString(k.label) + '"\n';
+  }
+  out += dumpSource(k.source, "  ");
+  out += "}\n";
+  return out;
+};
+var dumpSchemeType = function(t) {
+  let out = "scheme_type " + t.id + " {\n";
+  if (t.label) {
+    out += '  label "' + escapeString(t.label) + '"\n';
+  }
+  if (t.clause) {
+    out += '  clause "' + escapeString(t.clause) + '"\n';
+  }
+  if (t.description) {
+    out += '  description "' + escapeString(t.description) + '"\n';
+  }
+  if (t.sampling) {
+    out += '  sampling "' + escapeString(t.sampling) + '"\n';
+  }
+  if (t.attestationObject) {
+    out += "  attestation_object " + t.attestationObject + "\n";
+  }
+  if (t.determination.length > 0) {
+    out += "  determination { " + t.determination.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (t.attestation.length > 0) {
+    out += "  attestation { " + t.attestation.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (t.surveillance) {
+    out += "  surveillance {\n";
+    out += "    required " + (t.surveillance.required ? "true" : "false") + "\n";
+    if (t.surveillance.activities.length > 0) {
+      out += "    activities { " + t.surveillance.activities.map(dumpBareSafe).join(" ") + " }\n";
+    }
+    out += "  }\n";
+  }
+  if (t.notes.length > 0) {
+    out += "  notes {\n";
+    for (const n of t.notes) {
+      out += '    "' + escapeString(n) + '"\n';
+    }
+    out += "  }\n";
+  }
+  out += dumpSource(t.source, "  ");
+  out += "}\n";
+  return out;
+};
+
 // src/ser-des/config/predicate.ts
 var parsePredicate = function(id, data) {
   const result = {
@@ -8889,8 +9603,65 @@ var dumpTestPointSet = function(s) {
   return out;
 };
 
+// src/ser-des/config/commonTestCondition.ts
+var parseCommonTestCondition = (id, data) => {
+  const condition = {
+    id,
+    title: "",
+    reference: "",
+    description: "",
+    source: null
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "title") {
+        condition.title = stripWrapping(value());
+      } else if (keyword === "reference") {
+        condition.reference = stripWrapping(value());
+      } else if (keyword === "description") {
+        condition.description = stripWrapping(value());
+      } else if (keyword === "source") {
+        condition.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "common_test_condition", id }
+  );
+  return (ctx) => {
+    ctx.commonTestConditions[id] = condition;
+    return ctx;
+  };
+};
+var dumpCommonTestCondition = function(c) {
+  let out = "common_test_condition " + c.id + " {\n";
+  if (c.title) {
+    out += '  title "' + escapeString(c.title) + '"\n';
+  }
+  if (c.reference) {
+    out += '  reference "' + escapeString(c.reference) + '"\n';
+  }
+  if (c.description) {
+    out += '  description "' + escapeString(c.description) + '"\n';
+  }
+  if (c.source && (c.source.doc || c.source.clause)) {
+    out += "  source {\n";
+    if (c.source.doc) {
+      out += '    doc "' + escapeString(c.source.doc) + '"\n';
+    }
+    if (c.source.clause) {
+      out += '    clause "' + escapeString(c.source.clause) + '"\n';
+    }
+    out += "  }\n";
+  }
+  out += "}\n";
+  return out;
+};
+
 // src/ser-des/config/requirement.ts
-function readIdList2(block) {
+function readIdList3(block) {
   return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
 }
 function readAccepts(block) {
@@ -8943,7 +9714,7 @@ function readLimit(block) {
     if (cmd === "expression") {
       limit.expression = stripWrapping(t[i++]);
     } else if (cmd === "uses") {
-      limit.uses = readIdList2(t[i++]);
+      limit.uses = readIdList3(t[i++]);
     } else if (cmd === "modality") {
       limit.modality = stripWrapping(t[i++]);
     } else if (cmd === "relative_to") {
@@ -9082,7 +9853,7 @@ function readParameters(block) {
             }
           }
         } else if (pc === "enum_values") {
-          param.enumValues = readIdList2(pt[j++]);
+          param.enumValues = readIdList3(pt[j++]);
         } else {
           unwrapBlock(pt[j++]);
         }
@@ -9126,7 +9897,7 @@ var parseRequirement = function(id, data) {
     } else if (cmd === "guidance") {
       result.guidance = stripWrapping(t[i++]);
     } else if (cmd === "binds_to") {
-      result.bindsTo = readIdList2(t[i++]);
+      result.bindsTo = readIdList3(t[i++]);
     } else if (cmd === "subjects") {
       result.subjects = readSubjects(unwrapBlock(t[i++]));
     } else if (cmd === "parameters") {
@@ -9161,7 +9932,7 @@ var parseRequirement = function(id, data) {
         }
       }
     } else if (cmd === "dependencies") {
-      result.dependencies = readIdList2(t[i++]);
+      result.dependencies = readIdList3(t[i++]);
     } else if (cmd === "source_discrepancy") {
       result.sourceDiscrepancy = parseSourceDiscrepancy(unwrapBlock(t[i++]));
     } else if (cmd === "source" || cmd === "reference") {
@@ -9375,9 +10146,9 @@ var parseRequirementClass = function(id, data) {
     } else if (cmd === "applicability") {
       result.applicability = parseApplicability(unwrapBlock(t[i++]));
     } else if (cmd === "dependencies") {
-      result.dependencies = readIdList2(t[i++]);
+      result.dependencies = readIdList3(t[i++]);
     } else if (cmd === "reference") {
-      result.referenceIds = readIdList2(t[i++]);
+      result.referenceIds = readIdList3(t[i++]);
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
@@ -10074,7 +10845,7 @@ function dumpComposedOf(decl, indent) {
 }
 
 // src/ser-des/config/subject.ts
-function dumpSource(keyword, src, indent) {
+function dumpSource2(keyword, src, indent) {
   if (!src || !src.doc && !src.clause) {
     return "";
   }
@@ -10082,7 +10853,7 @@ function dumpSource(keyword, src, indent) {
   return `${indent}${keyword} { doc "${escapeString(src.doc)}" clause "${escapeString(src.clause)}"${frag} }
 `;
 }
-function readIdList3(block) {
+function readIdList4(block) {
   return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
 }
 function dumpIdList(keyword, ids, indent) {
@@ -10219,9 +10990,9 @@ var parseInstrument = function(id, data) {
           break;
         }
         if (fc === "dimensions") {
-          result.familyDefaultDimensions = readIdList3(ft[j++]);
+          result.familyDefaultDimensions = readIdList4(ft[j++]);
         } else if (fc === "parameters") {
-          result.familyDefaultParameters = readIdList3(ft[j++]);
+          result.familyDefaultParameters = readIdList4(ft[j++]);
         } else {
           unwrapBlock(ft[j++]);
         }
@@ -10445,7 +11216,7 @@ function parseDimensionValues(block) {
         } else if (cmd === "description") {
           value.description = stripWrapping(vt[j++]);
         } else if (cmd === "implies") {
-          value.implies = readIdList3(vt[j++]);
+          value.implies = readIdList4(vt[j++]);
         } else if (cmd === "term_ref") {
           value.termRef = stripWrapping(vt[j++]);
         } else if (cmd === "payload") {
@@ -10509,7 +11280,7 @@ function dumpDimension(d, indent) {
   if (d.description) {
     out += inner + 'description "' + escapeString(d.description) + '"\n';
   }
-  out += dumpSource("reference", d.source, inner);
+  out += dumpSource2("reference", d.source, inner);
   if (d.valuesOf) {
     out += inner + "values_of " + d.valuesOf + "\n";
   }
@@ -10575,9 +11346,9 @@ function parseModelGroup(block) {
     if (cmd === "definition") {
       mg.definition = stripWrapping(t[i++]);
     } else if (cmd === "identical_characteristics") {
-      mg.identicalCharacteristics = readIdList3(t[i++]);
+      mg.identicalCharacteristics = readIdList4(t[i++]);
     } else if (cmd === "identical_attributes") {
-      mg.identicalAttributes = readIdList3(t[i++]);
+      mg.identicalAttributes = readIdList4(t[i++]);
     } else if (cmd === "group_by") {
       mg.groupBy = stripWrapping(t[i++]);
     } else if (cmd === "note") {
@@ -10631,7 +11402,7 @@ var dumpInstrument = function(inst) {
       }
       out += " }\n";
     }
-    out += dumpSource("source", m.source, "    ");
+    out += dumpSource2("source", m.source, "    ");
     out += "  }\n";
   }
   for (const c of inst.components ?? []) {
@@ -10671,7 +11442,7 @@ var dumpInstrument = function(inst) {
     if (s.note) {
       out += '    note "' + escapeString(s.note) + '"\n';
     }
-    out += dumpSource("source", s.source, "    ");
+    out += dumpSource2("source", s.source, "    ");
     out += "  }\n";
   }
   if (inst.definition) {
@@ -10751,7 +11522,7 @@ var dumpInstrument = function(inst) {
       out += dumpSourceRefAsRef(s, "    ", escapeString);
     }
     for (const s of inst.modelGroup.sampleSelection ?? []) {
-      out += dumpSource("sample_selection", s, "    ");
+      out += dumpSource2("sample_selection", s, "    ");
     }
     out += "  }\n";
   }
@@ -10770,6 +11541,80 @@ var dumpInstrument = function(inst) {
   out += "}\n";
   return out;
 };
+function parsePairList(block) {
+  const decl = {
+    key: "",
+    value: "",
+    keyDimension: "",
+    components: []
+  };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i > t.length) {
+      break;
+    }
+    if (cmd === "key") {
+      decl.key = stripWrapping(t[i++]);
+    } else if (cmd === "value") {
+      decl.value = stripWrapping(t[i++]);
+    } else if (cmd === "key_dimension") {
+      decl.keyDimension = stripWrapping(t[i++]);
+    } else if (cmd === "component") {
+      const cid = stripWrapping(t[i++]);
+      const component = { id: cid, name: "", source: null };
+      if (i < t.length && t[i].startsWith("{")) {
+        const et = tokenize(unwrapBlock(t[i++]));
+        let j = 0;
+        while (j < et.length) {
+          const ec = et[j++];
+          if (j >= et.length) {
+            break;
+          }
+          if (ec === "name") {
+            component.name = stripWrapping(et[j++]);
+          } else if (ec === "source") {
+            component.source = readSource(unwrapBlock(et[j++]));
+          } else {
+            unwrapBlock(et[j++]);
+          }
+        }
+      }
+      decl.components.push(component);
+    } else {
+      i = skipUnknownValue(t, i, cmd);
+    }
+  }
+  return decl;
+}
+function dumpPairList(decl) {
+  let out = "  pair_list {\n";
+  out += "    key " + dumpBareSafe(decl.key) + "\n";
+  out += "    value " + dumpBareSafe(decl.value) + "\n";
+  if (decl.keyDimension) {
+    out += "    key_dimension " + dumpBareSafe(decl.keyDimension) + "\n";
+  }
+  for (const c of decl.components) {
+    out += "    component " + dumpBareSafe(c.id) + " {\n";
+    if (c.name) {
+      out += '      name "' + escapeString(c.name) + '"\n';
+    }
+    if (c.source && (c.source.doc || c.source.clause)) {
+      out += "      source {\n";
+      if (c.source.doc) {
+        out += '        doc "' + escapeString(c.source.doc) + '"\n';
+      }
+      if (c.source.clause) {
+        out += '        clause "' + escapeString(c.source.clause) + '"\n';
+      }
+      out += "      }\n";
+    }
+    out += "    }\n";
+  }
+  out += "  }\n";
+  return out;
+}
 var parseAttributeDefinition = function(id, data) {
   const result = {
     id,
@@ -10814,6 +11659,8 @@ var parseAttributeDefinition = function(id, data) {
       result.unit = stripWrapping(t[i++]);
     } else if (cmd === "value_type") {
       result.valueType = stripWrapping(t[i++]);
+    } else if (cmd === "pair_list") {
+      result.pairList = parsePairList(unwrapBlock(t[i++]));
     } else if (cmd === "origin") {
       result.origin = stripWrapping(t[i++]);
     } else if (cmd === "scope") {
@@ -10825,7 +11672,7 @@ var parseAttributeDefinition = function(id, data) {
     } else if (cmd === "enum") {
       result.enumRef = stripWrapping(t[i++]);
     } else if (cmd === "enum_values") {
-      result.enumValues = readIdList3(t[i++]);
+      result.enumValues = readIdList4(t[i++]);
     } else if (cmd === "note") {
       result.note = stripWrapping(t[i++]);
     } else if (cmd === "irdi") {
@@ -10885,6 +11732,9 @@ var dumpAttributeDefinition = function(a) {
   if (a.valueType) {
     out += "  value_type " + a.valueType + "\n";
   }
+  if (a.pairList) {
+    out += dumpPairList(a.pairList);
+  }
   if (a.origin) {
     out += "  origin " + a.origin + "\n";
   }
@@ -10942,11 +11792,11 @@ var parseCapability = function(id, data) {
     } else if (cmd === "abstract") {
       result.abstract = stripWrapping(t[i++]) === "true";
     } else if (cmd === "extends") {
-      result.extends = readIdList3(t[i++]);
+      result.extends = readIdList4(t[i++]);
     } else if (cmd === "requires") {
-      result.requires = readIdList3(t[i++]);
+      result.requires = readIdList4(t[i++]);
     } else if (cmd === "has_parameters") {
-      result.hasParameters = readIdList3(t[i++]);
+      result.hasParameters = readIdList4(t[i++]);
     } else if (cmd === "satisfies_requirements") {
       result.satisfiesRequirements = readReference(t[i++]);
     } else if (cmd === "verified_by_tests" || cmd === "verified_by") {
@@ -11473,7 +12323,7 @@ function readPromises(block) {
       } else if (cmd === "statement") {
         p.statement = stripWrapping(inner[j++]);
       } else if (cmd === "verified_by") {
-        p.verifiedBy = readIdList3(inner[j++]);
+        p.verifiedBy = readIdList4(inner[j++]);
       } else if (cmd === "source") {
         p.source = readSource(unwrapBlock(inner[j++]));
       } else {
@@ -11763,7 +12613,7 @@ function dumpSubjectPromises(promises) {
       out += '        statement "' + escapeString(p.statement) + '"\n';
     }
     out += dumpIdList("verified_by", p.verifiedBy, "        ");
-    out += dumpSource("source", p.source ?? null, "        ");
+    out += dumpSource2("source", p.source ?? null, "        ");
     out += "      }\n";
   }
   out += "    }\n";
@@ -11795,7 +12645,7 @@ function dumpSubjectCharacteristics(map) {
       if (c.unit) {
         out += '        unit "' + escapeString(c.unit) + '"\n';
       }
-      out += dumpSource("source", c.source ?? null, "        ");
+      out += dumpSource2("source", c.source ?? null, "        ");
       out += "      }\n";
       continue;
     }
@@ -12067,7 +12917,7 @@ var instanceConstruct = {
 };
 
 // src/ser-des/config/artifact.ts
-function readIdList4(block) {
+function readIdList5(block) {
   return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
 }
 function dumpIdList2(keyword, ids, indent) {
@@ -12128,7 +12978,7 @@ function readContractMedia(block) {
           break;
         }
         if (cmd === "kinds") {
-          m.kinds = readIdList4(inner[j++]);
+          m.kinds = readIdList5(inner[j++]);
         } else if (cmd === "role") {
           m.role = stripWrapping(inner[j++]);
         } else {
@@ -12321,7 +13171,7 @@ var parseArtifactInstance = function(id, data) {
     } else if (cmd === "content") {
       result.content = readValueMap2(unwrapBlock(t[i++]));
     } else if (cmd === "links") {
-      result.links = readIdList4(t[i++]);
+      result.links = readIdList5(t[i++]);
     } else if (cmd === "reference") {
       result.referenceIds = readReference3(t[i++]);
     } else {
@@ -15247,6 +16097,568 @@ var dumpDecisionRule = function(r) {
   return out;
 };
 
+// src/ser-des/config/documentModule.ts
+var parseDocumentModule = (id, data) => {
+  const module = {
+    id,
+    document: "",
+    title: "",
+    edition: "",
+    year: 0,
+    namespace: "",
+    sequence: [],
+    registers: [],
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value, peek) => {
+      if (keyword === "document") {
+        module.document = stripWrapping(value());
+      } else if (keyword === "title") {
+        module.title = stripWrapping(value());
+      } else if (keyword === "edition") {
+        module.edition = stripWrapping(value());
+      } else if (keyword === "year") {
+        module.year = parseInt(stripWrapping(value()), 10) || 0;
+      } else if (keyword === "namespace") {
+        module.namespace = stripWrapping(value());
+      } else if (keyword === "sequence") {
+        module.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: document_module. ID ${id}: register ${regId} is missing its block`
+          );
+        }
+        module.registers.push(
+          parseProcessRegister(regId, unwrapBlock(value()))
+        );
+      } else if (keyword === "source") {
+        module.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "document_module", id }
+  );
+  return (ctx) => {
+    ctx.documentModules[id] = module;
+    return ctx;
+  };
+};
+var dumpDocumentModule = function(m) {
+  let out = "document_module " + m.id + " {\n";
+  if (m.document) {
+    out += '  document "' + escapeString(m.document) + '"\n';
+  }
+  if (m.title) {
+    out += '  title "' + escapeString(m.title) + '"\n';
+  }
+  if (m.edition) {
+    out += '  edition "' + escapeString(m.edition) + '"\n';
+  }
+  if (m.year) {
+    out += "  year " + m.year + "\n";
+  }
+  if (m.namespace) {
+    out += "  namespace " + dumpBareSafe(m.namespace) + "\n";
+  }
+  const seq = dumpProcessSequence(m.sequence);
+  if (seq) {
+    out += "  " + seq + "\n";
+  }
+  for (const r of m.registers) {
+    out += dumpProcessRegister(r, "  ");
+  }
+  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";
+  }
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/informativeAnnex.ts
+var ANNEX_DOCUMENT_ROLES = ["informative"];
+function parseAnnexDocument(block, annexId) {
+  const doc = {
+    id: "",
+    title: "",
+    edition: 0,
+    year: 0,
+    role: "",
+    source: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "id") {
+        doc.id = stripWrapping(value());
+      } else if (keyword === "title") {
+        doc.title = stripWrapping(value());
+      } else if (keyword === "edition") {
+        doc.edition = parseInt(stripWrapping(value()), 10) || 0;
+      } else if (keyword === "year") {
+        doc.year = parseInt(stripWrapping(value()), 10) || 0;
+      } else if (keyword === "role") {
+        const role = stripWrapping(value());
+        if (!ANNEX_DOCUMENT_ROLES.includes(role)) {
+          throw new Error(
+            `Parsing error: informative_annex. ID ${annexId}: Unknown document role "${role}" (valid: ${ANNEX_DOCUMENT_ROLES.join(", ")})`
+          );
+        }
+        doc.role = role;
+      } else if (keyword === "source") {
+        doc.source = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "informative_annex document", id: annexId }
+  );
+  return doc;
+}
+function parseAnnexHighlight(id, block) {
+  const highlight = {
+    id,
+    clause: "",
+    title: "",
+    statement: "",
+    dischargedBy: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "clause") {
+        highlight.clause = stripWrapping(value());
+      } else if (keyword === "title") {
+        highlight.title = stripWrapping(value());
+      } else if (keyword === "statement") {
+        highlight.statement = stripWrapping(value());
+      } else if (keyword === "discharged_by") {
+        highlight.dischargedBy = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "informative_annex highlight", id }
+  );
+  return highlight;
+}
+var parseInformativeAnnex = (id, data) => {
+  const annex = {
+    id,
+    document: { id: "", title: "", edition: 0, year: 0, role: "", source: "" },
+    appliesTo: "",
+    appliedBy: "",
+    scope: "",
+    numberingCaution: "",
+    highlights: []
+  };
+  forEachEntry(
+    data,
+    (keyword, value, peek) => {
+      if (keyword === "document") {
+        annex.document = parseAnnexDocument(unwrapBlock(value()), id);
+      } else if (keyword === "applies_to") {
+        annex.appliesTo = stripWrapping(value());
+      } else if (keyword === "applied_by") {
+        annex.appliedBy = stripWrapping(value());
+      } else if (keyword === "scope") {
+        annex.scope = stripWrapping(value());
+      } else if (keyword === "numbering_caution") {
+        annex.numberingCaution = stripWrapping(value());
+      } else if (keyword === "highlight") {
+        const hlId = stripWrapping(value());
+        const head = peek();
+        if (head === void 0 || !head.startsWith("{")) {
+          throw new Error(
+            `Parsing error: informative_annex. ID ${id}: highlight ${hlId} is missing its block`
+          );
+        }
+        annex.highlights.push(parseAnnexHighlight(hlId, unwrapBlock(value())));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "informative_annex", id }
+  );
+  return (ctx) => {
+    ctx.informativeAnnexes[id] = annex;
+    return ctx;
+  };
+};
+var dumpInformativeAnnex = function(a) {
+  let out = "informative_annex " + a.id + " {\n";
+  out += "  document {\n";
+  if (a.document.id) {
+    out += '    id "' + escapeString(a.document.id) + '"\n';
+  }
+  if (a.document.title) {
+    out += '    title "' + escapeString(a.document.title) + '"\n';
+  }
+  if (a.document.edition) {
+    out += "    edition " + a.document.edition + "\n";
+  }
+  if (a.document.year) {
+    out += "    year " + a.document.year + "\n";
+  }
+  if (a.document.role) {
+    out += "    role " + dumpBareSafe(a.document.role) + "\n";
+  }
+  if (a.document.source) {
+    out += '    source "' + escapeString(a.document.source) + '"\n';
+  }
+  out += "  }\n";
+  if (a.appliesTo) {
+    out += "  applies_to " + dumpBareSafe(a.appliesTo) + "\n";
+  }
+  if (a.appliedBy) {
+    out += '  applied_by "' + escapeString(a.appliedBy) + '"\n';
+  }
+  if (a.scope) {
+    out += '  scope "' + escapeString(a.scope) + '"\n';
+  }
+  if (a.numberingCaution) {
+    out += '  numbering_caution "' + escapeString(a.numberingCaution) + '"\n';
+  }
+  for (const h of a.highlights) {
+    out += "  highlight " + dumpBareSafe(h.id) + " {\n";
+    if (h.clause) {
+      out += '    clause "' + escapeString(h.clause) + '"\n';
+    }
+    if (h.title) {
+      out += '    title "' + escapeString(h.title) + '"\n';
+    }
+    if (h.statement) {
+      out += '    statement "' + escapeString(h.statement) + '"\n';
+    }
+    if (h.dischargedBy) {
+      out += '    discharged_by "' + escapeString(h.dischargedBy) + '"\n';
+    }
+    out += "  }\n";
+  }
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/partAnnex.ts
+var PART_ANNEX_OBLIGATIONS = ["normative", "informative"];
+var parsePartAnnex = (id, data) => {
+  const annex = {
+    id,
+    letter: "",
+    title: "",
+    obligation: "",
+    summary: "",
+    realization: "",
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "letter") {
+        annex.letter = stripWrapping(value());
+      } else if (keyword === "title") {
+        annex.title = stripWrapping(value());
+      } else if (keyword === "obligation") {
+        const obligation = stripWrapping(value());
+        if (!PART_ANNEX_OBLIGATIONS.includes(obligation)) {
+          throw new Error(
+            `Parsing error: part_annex. ID ${id}: Unknown obligation "${obligation}" (valid: ${PART_ANNEX_OBLIGATIONS.join(", ")})`
+          );
+        }
+        annex.obligation = obligation;
+      } else if (keyword === "summary") {
+        annex.summary = stripWrapping(value());
+      } else if (keyword === "realization") {
+        annex.realization = stripWrapping(value());
+      } else if (keyword === "source") {
+        annex.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "part_annex", id }
+  );
+  return (ctx) => {
+    ctx.partAnnexes[id] = annex;
+    return ctx;
+  };
+};
+var dumpPartAnnex = function(a) {
+  let out = "part_annex " + a.id + " {\n";
+  if (a.letter) {
+    out += '  letter "' + escapeString(a.letter) + '"\n';
+  }
+  if (a.title) {
+    out += '  title "' + escapeString(a.title) + '"\n';
+  }
+  if (a.obligation) {
+    out += "  obligation " + dumpBareSafe(a.obligation) + "\n";
+  }
+  if (a.summary) {
+    out += '  summary "' + escapeString(a.summary) + '"\n';
+  }
+  if (a.realization) {
+    out += '  realization "' + escapeString(a.realization) + '"\n';
+  }
+  if (a.source.doc || a.source.clause) {
+    out += "  source {\n";
+    if (a.source.doc) {
+      out += '    doc "' + escapeString(a.source.doc) + '"\n';
+    }
+    if (a.source.clause) {
+      out += '    clause "' + escapeString(a.source.clause) + '"\n';
+    }
+    out += "  }\n";
+  }
+  out += "}\n";
+  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;
@@ -15275,6 +16687,15 @@ var CONSTRUCTS = [
     resolve: resolveProcess,
     dump: dumpProcess
   }),
+  // 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
+  }),
   defineConstruct({
     keyword: "approval",
     field: "approvals",
@@ -15462,6 +16883,16 @@ var CONSTRUCTS = [
     resolve: resolveSymbol,
     dump: dumpSymbol
   }),
+  // The symbol-annotation register (smart TODO.roadmap/40 batch 4) —
+  // one note text applying to many symbols; rides right after the
+  // symbols in the dump order.
+  defineConstruct({
+    keyword: "formula_note",
+    field: "formulaNotes",
+    takesID: true,
+    parse: parseFormulaNote,
+    dump: dumpFormulaNote
+  }),
   defineConstruct({
     keyword: "calculation",
     field: "calculations",
@@ -15491,12 +16922,38 @@ var CONSTRUCTS = [
     parse: parseTestPointSet,
     dump: dumpTestPointSet
   }),
+  // The model-wide common test-conditions register (smart
+  // TODO.roadmap/40 batch 4) — one entry per condition; the citation
+  // string stays free (the linker owns the citation semantics).
+  defineConstruct({
+    keyword: "common_test_condition",
+    field: "commonTestConditions",
+    takesID: true,
+    parse: parseCommonTestCondition,
+    dump: dumpCommonTestCondition
+  }),
+  defineConstruct({
+    keyword: "competence_kind",
+    field: "competenceKinds",
+    takesID: true,
+    parse: parseCompetenceKind,
+    dump: dumpCompetenceKind
+  }),
+  // The ISO/IEC 17067 scheme-type register (smart TODO.roadmap/40 batch
+  // 2): the Table-1 activity menus + the scheme types.
+  defineConstruct({
+    keyword: "scheme_activity_kind",
+    field: "schemeActivityKinds",
+    takesID: true,
+    parse: parseSchemeActivityKind,
+    dump: dumpSchemeActivityKind
+  }),
   defineConstruct({
-    keyword: "competence_kind",
-    field: "competenceKinds",
+    keyword: "scheme_type",
+    field: "schemeTypes",
     takesID: true,
-    parse: parseCompetenceKind,
-    dump: dumpCompetenceKind
+    parse: parseSchemeType,
+    dump: dumpSchemeType
   }),
   // The relation registry (docs/primmel/18): declared ref predicates.
   defineConstruct({
@@ -15650,6 +17107,51 @@ var CONSTRUCTS = [
     parse: parseDecisionRule,
     dump: dumpDecisionRule
   }),
+  // The per-document content modules + the informative annexes (smart
+  // TODO.roadmap/40 batch 2) — first-class what the directory convention
+  // carried; the declared namespace pin C119 prefers.
+  defineConstruct({
+    keyword: "document_module",
+    field: "documentModules",
+    takesID: true,
+    parse: parseDocumentModule,
+    dump: dumpDocumentModule
+  }),
+  defineConstruct({
+    keyword: "informative_annex",
+    field: "informativeAnnexes",
+    takesID: true,
+    parse: parseInformativeAnnex,
+    dump: dumpInformativeAnnex
+  }),
+  // The rec's own annex-volume index (smart TODO.roadmap/40 batch 4) —
+  // NOT the external-guidance informative_annex; the normative/
+  // informative obligation mark is the register's point.
+  defineConstruct({
+    keyword: "part_annex",
+    field: "partAnnexes",
+    takesID: true,
+    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 /
@@ -15992,6 +17494,9 @@ var MERGE_FIELDS = [
   "approvals",
   "roles",
   "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",
@@ -16011,11 +17516,18 @@ var MERGE_FIELDS = [
   "forms",
   "subforms",
   "symbols",
+  "formulaNotes",
   "calculations",
   "verdicts",
   "referenceMaterials",
   "testPointSets",
+  "commonTestConditions",
   "competenceKinds",
+  // The ISO/IEC 17067 scheme-type register (smart TODO.roadmap/40 batch
+  // 2) composes like every register — the scheme-side packages resolve
+  // their manifest `scheme_type` against it through `uses` (C122).
+  "schemeActivityKinds",
+  "schemeTypes",
   "constraints",
   "discrepancyRecords",
   "stateMachines",
@@ -16062,6 +17574,13 @@ var MERGE_FIELDS = [
   "documentPrecedences",
   "autoInclusions",
   "decisionRules",
+  // The document modules + informative annexes (smart TODO.roadmap/40
+  // batch 2) compose like the framework registers they sit beside.
+  "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
@@ -16156,6 +17675,11 @@ function composePackage(rootDir, options, rootManifest, withProvenance = false)
   }
   const ownedScopes = /* @__PURE__ */ new Map();
   const harvestScopes = (id, ctx) => {
+    for (const m of Object.values(ctx.documentModules)) {
+      if (m.namespace !== "" && !ownedScopes.has(m.namespace)) {
+        ownedScopes.set(m.namespace, id);
+      }
+    }
     for (const key of Object.keys(ctx.requirementClasses)) {
       if (!ownedScopes.has(key)) {
         ownedScopes.set(key, id);
@@ -16907,6 +18431,11 @@ var TIER_BY_FIELD = {
   variables: "foundations",
   figures: "foundations",
   activityArchetypes: "foundations",
+  // The ISO/IEC 17067 scheme-type register (smart TODO.roadmap/40 batch
+  // 2) is foundations beside the activity archetypes: a vocabulary other
+  // content classifies against.
+  schemeActivityKinds: "foundations",
+  schemeTypes: "foundations",
   connectorProfiles: "foundations",
   subjects: "primary",
   instruments: "primary",
@@ -16925,12 +18454,21 @@ var TIER_BY_FIELD = {
   forms: "secondary",
   subforms: "secondary",
   symbols: "secondary",
+  formulaNotes: "tertiary",
   calculations: "secondary",
   verdicts: "secondary",
   tables: "secondary",
   testPointSets: "secondary",
+  commonTestConditions: "tertiary",
   referenceMaterials: "secondary",
   processes: "tertiary",
+  // 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",
   pages: "tertiary",
   dataclasses: "tertiary",
   regs: "tertiary",
@@ -16947,6 +18485,14 @@ var TIER_BY_FIELD = {
   viewProfiles: "tertiary",
   provisions: "tertiary",
   notes: "cross-cutting",
+  // Informative annexes (smart TODO.roadmap/40 batch 2) are
+  // cross-cutting beside notes: an annex binds cited guidance into the
+  // module — annotation about the document set, not machinery inside
+  // 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
@@ -18031,6 +19577,140 @@ var CHECK_RULES = [
     "normal",
     "smart TODO.roadmap/40 (the packages-as-SSOT epic)"
   ),
+  // C121 (smart TODO.roadmap/40 batch 2; the packages-as-SSOT epic): the
+  // abstract-process model's framework bindings resolve — the process's
+  // roles / organs / participant_kinds lists, the decision rule, the
+  // declaration kind + the sign|update action vocabulary, the discharged
+  // declaration gate, realized_by → process, approved_by → approval, and
+  // the calendar windows' shape (kind vocabulary; exactly one of
+  // years/months); the process_model's sequence members and register
+  // maintainers ride the same rule. Per-register gating (the C58
+  // doctrine): an edge is checked only when its target register is in
+  // composition scope.
+  R(
+    "C121",
+    "abstract-process-references-resolve",
+    "process",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 2 (the packages-as-SSOT epic)"
+  ),
+  // C122 (smart TODO.roadmap/40 batch 2; the packages-as-SSOT epic): the
+  // ISO/IEC 17067 register is composable — a manifest's scheme_type
+  // token resolves against the composed scheme_type register when one is
+  // in scope, and a scheme_type's determination / attestation /
+  // surveillance.activities entries resolve against the composed
+  // scheme_activity_kind menus. Per-register gating (the C58 doctrine);
+  // the register-free fallback stays (the C89 spelling precedent), and
+  // C98's hard-coded no-surveillance set defers to the register's
+  // surveillance.required when the register is in scope.
+  R(
+    "C122",
+    "scheme-type-resolves",
+    "composition",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 2 (the packages-as-SSOT epic)"
+  ),
+  // C123 (smart TODO.roadmap/40 batch 2; the packages-as-SSOT epic): the
+  // document module's edges resolve — sequence members → process,
+  // register maintainers → governance_organ (per-register gated, the C58
+  // doctrine), the declared namespace is an absolute requirement-
+  // namespace path (the pin C119 now prefers over the requirement_class-
+  // id derivation), and the informative annex's applies_to names a known
+  // package (locator-gated, the C97-class resolution discipline).
+  R(
+    "C123",
+    "document-module-references-resolve",
+    "composition",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 2 (the packages-as-SSOT epic)"
+  ),
+  // C124 (smart TODO.roadmap/40 batch 4; the packages-as-SSOT epic): the
+  // attribute_definition pair_list block's declaration shape — the key
+  // and value slots are required, component ids are unique within the
+  // block, and the key_dimension names a declared applicability
+  // dimension when the dimension register is in composition scope
+  // (per-register gating, the C58 doctrine). The closed-registry-over-
+  // values leg quantifies over app-side records and stays app-side.
+  R(
+    "C124",
+    "pair-list-shape",
+    "base",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 4 (the packages-as-SSOT epic)"
+  ),
+  // C125 (smart TODO.roadmap/40 batch 4; the packages-as-SSOT epic): the
+  // calculation variant block's declaration shape — variant ids unique
+  // within the owning calculation, and the type-conditional facets
+  // present (expression ⇒ expression, table_lookup ⇒ lookup,
+  // profile_lookup ⇒ profile; the top-level shape discipline mirrored
+  // onto the realization). The variant's params are engine call-site
+  // names and deliberately carry NO params-resolve leg.
+  R(
+    "C125",
+    "formula-variant-shape",
+    "base",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 4 (the packages-as-SSOT epic)"
+  ),
+  // C126 (smart TODO.roadmap/40 batch 4; the packages-as-SSOT epic): the
+  // formula_note register's reverse applicability resolves — every
+  // applies_to entry names a declared symbol when the symbol register is
+  // in composition scope (per-register gating, the C58 doctrine).
+  R(
+    "C126",
+    "formula-note-targets-resolve",
+    "composition",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 4 (the packages-as-SSOT epic)"
+  ),
+  // C127 (smart TODO.roadmap/40 batch 4; the packages-as-SSOT epic): the
+  // common_test_condition register's declaration shape — the description
+  // is required (the one facet both YAML shapes carry); the title stays
+  // optional (the r91 keyed-map entries carry none) and the reference a
+  // free citation string (no kernel leg — the linker owns the citation
+  // semantics).
+  R(
+    "C127",
+    "common-test-condition-shape",
+    "base",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 4 (the packages-as-SSOT epic)"
+  ),
+  // C128 (smart TODO.roadmap/40 batch 4; the packages-as-SSOT epic): the
+  // part_annex register's declaration shape — letters unique per package
+  // (the index keys on the printed letter) and the source provenance
+  // required; the obligation vocabulary is parse-enforced upstream and
+  // carries no check leg.
+  R(
+    "C128",
+    "part-annex-shape",
+    "base",
+    "error",
+    "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)"
+  ),
   // ── quantities / time / duality (TODO.roadmap/06) ─────────────────
   R(
     "C32",
@@ -20757,6 +22437,12 @@ function checkPackage(dir, options = {}) {
             );
             continue;
           }
+          if (s.period !== "" || s.barred.length > 0) {
+            err(
+              "C59",
+              `process ${p.id}: segregation constraint "${s.id}" is case_personnel_disjoint but declares ${s.period !== "" ? `period "${s.period}"` : "barred relations"} \u2014 a disjoint constraint is ONLY a pair; the period/barred facets belong to consultancy_bar (segregation-members-resolve)`
+            );
+          }
           const [a, b] = s.pair;
           if (a === b) {
             err(
@@ -20778,9 +22464,151 @@ function checkPackage(dir, options = {}) {
               `process ${p.id}: segregation constraint "${s.id}" is declared on process "${p.id}" but neither pair member is "${p.id}" \u2014 the constrained process owns its segregation constraints (segregation-members-resolve)`
             );
           }
+        } else {
+          if (s.barred.length === 0) {
+            err(
+              "C59",
+              `process ${p.id}: segregation constraint "${s.id}" is consultancy_bar but bars no client relation \u2014 the barred list is required (segregation-members-resolve)`
+            );
+          }
+          if (s.pair.length > 0) {
+            err(
+              "C59",
+              `process ${p.id}: segregation constraint "${s.id}" is consultancy_bar but declares a pair \u2014 the pair is the case_personnel_disjoint shape; a bar carries barred relations and an optional period only (segregation-members-resolve)`
+            );
+          }
+        }
+      }
+    }
+  }
+  {
+    const apRoleIds = new Set((standard.roles ?? []).map((r) => r.id));
+    const apGateIds = new Set((standard.declarationGates ?? []).map((g) => g.id));
+    const apRuleIds = new Set((standard.decisionRules ?? []).map((r) => r.id));
+    const apApprovalIds = new Set((standard.approvals ?? []).map((a) => a.id));
+    const resolveOrganAp = (where, facet, id) => {
+      if (organIds.size > 0 && id !== "" && !organIds.has(id)) {
+        err(
+          "C121",
+          `${where}: ${facet} "${id}" is not a declared governance organ (abstract-process-references-resolve)`
+        );
+      }
+    };
+    const resolveKindAp = (where, facet, id) => {
+      if (kindIds.size > 0 && id !== "" && !kindIds.has(id)) {
+        err(
+          "C121",
+          `${where}: ${facet} "${id}" is not a declared participant kind (abstract-process-references-resolve)`
+        );
+      }
+    };
+    const resolveDeclarationAp = (where, facet, id) => {
+      if (declIds.size > 0 && id !== "" && !declIds.has(id)) {
+        err(
+          "C121",
+          `${where}: ${facet} "${id}" is not a declared declaration kind (abstract-process-references-resolve)`
+        );
+      }
+    };
+    const resolveProcessRef = (where, facet, id) => {
+      if (frameworkProcessIds.size > 0 && !frameworkProcessIds.has(id)) {
+        err(
+          "C121",
+          `${where}: ${facet} "${id}" is not a declared process (abstract-process-references-resolve)`
+        );
+      }
+    };
+    for (const p of standard.processes ?? []) {
+      const where = `process ${p.id}`;
+      if (apRoleIds.size > 0) {
+        for (const r of p.roles ?? []) {
+          if (!apRoleIds.has(r)) {
+            err(
+              "C121",
+              `${where}: roles "${r}" is not a declared role (abstract-process-references-resolve)`
+            );
+          }
+        }
+      }
+      for (const o of p.organs ?? []) {
+        resolveOrganAp(where, "organs", o);
+      }
+      for (const k of p.participantKinds ?? []) {
+        resolveKindAp(where, "participant_kinds", k);
+      }
+      if (p.decision) {
+        if (p.decision.rule === "") {
+          err(
+            "C121",
+            `${where}: the decision facet declares no rule \u2014 a decision names the decision_rule it applies (abstract-process-references-resolve)`
+          );
+        } else if (apRuleIds.size > 0 && !apRuleIds.has(p.decision.rule)) {
+          err(
+            "C121",
+            `${where}: decision.rule "${p.decision.rule}" is not a declared decision rule (abstract-process-references-resolve)`
+          );
+        }
+      }
+      if (p.declaration) {
+        if (p.declaration.kind === "") {
+          err(
+            "C121",
+            `${where}: the declaration facet declares no kind \u2014 a declaration names the declaration_kind it signs or updates (abstract-process-references-resolve)`
+          );
+        } else {
+          resolveDeclarationAp(where, "declaration.kind", p.declaration.kind);
+        }
+        if (p.declaration.action !== "sign" && p.declaration.action !== "update") {
+          err(
+            "C121",
+            `${where}: declaration action "${p.declaration.action || "(none)"}" \u2014 a declaration is signed or updated (valid: sign, update) (abstract-process-references-resolve)`
+          );
+        }
+      }
+      if (p.dischargesGate !== "" && apGateIds.size > 0 && !apGateIds.has(p.dischargesGate)) {
+        err(
+          "C121",
+          `${where}: discharges_gate "${p.dischargesGate}" is not a declared declaration gate (abstract-process-references-resolve)`
+        );
+      }
+      for (const r of p.realizedBy ?? []) {
+        resolveProcessRef(where, "realized_by", r);
+      }
+      if (apApprovalIds.size > 0) {
+        for (const a of p.approvedBy ?? []) {
+          if (!apApprovalIds.has(a)) {
+            err(
+              "C121",
+              `${where}: approved_by "${a}" is not a declared approval (abstract-process-references-resolve)`
+            );
+          }
+        }
+      }
+      for (const w of p.windows ?? []) {
+        const wwhere = `${where} window ${w.id}`;
+        if (w.kind !== "max_elapsed" && w.kind !== "min_elapsed") {
+          err(
+            "C121",
+            `${wwhere}: kind "${w.kind || "(none)"}" \u2014 a calendar window is a deadline or a cooling-off (valid: max_elapsed, min_elapsed) (abstract-process-references-resolve)`
+          );
+        }
+        if (w.windowYears > 0 === w.windowMonths > 0) {
+          err(
+            "C121",
+            `${wwhere}: the window duration declares ${w.windowYears > 0 ? "both years and months" : "neither years nor months"} \u2014 exactly one is required (the scheme_lifecycle window sub-grammar) (abstract-process-references-resolve)`
+          );
         }
       }
     }
+    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]*\}$/;
@@ -21852,6 +23680,86 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  {
+    const schemeTypeIds = new Set((standard.schemeTypes ?? []).map((t) => t.id));
+    const menuIds = new Set(
+      (standard.schemeActivityKinds ?? []).map((k) => k.id)
+    );
+    const manifestSchemeType = standard.packageManifest?.schemeType;
+    if (schemeTypeIds.size > 0 && manifestSchemeType && !schemeTypeIds.has(manifestSchemeType)) {
+      err(
+        "C122",
+        `package "${standard.packageManifest.id}": scheme_type "${manifestSchemeType}" is not a declared scheme type of the in-scope ISO/IEC 17067 register (scheme-type-resolves)`
+      );
+    }
+    if (menuIds.size > 0) {
+      const resolveMenuEntry = (where, facet, id) => {
+        if (!menuIds.has(id)) {
+          err(
+            "C122",
+            `${where}: ${facet} "${id}" is not a declared scheme activity kind (scheme-type-resolves)`
+          );
+        }
+      };
+      for (const t of standard.schemeTypes ?? []) {
+        const where = `scheme_type ${t.id}`;
+        for (const d of t.determination) {
+          resolveMenuEntry(where, "determination", d);
+        }
+        for (const a of t.attestation) {
+          resolveMenuEntry(where, "attestation", a);
+        }
+        for (const s of t.surveillance?.activities ?? []) {
+          resolveMenuEntry(where, "surveillance.activities", s);
+        }
+      }
+    }
+  }
+  {
+    const dmOrganIds = new Set(
+      (standard.governanceOrgans ?? []).map((o) => o.id)
+    );
+    const dmProcessIds = new Set((standard.processes ?? []).map((p) => p.id));
+    for (const m of standard.documentModules ?? []) {
+      const where = `document_module ${m.id}`;
+      if (m.namespace !== "" && !m.namespace.startsWith("/")) {
+        err(
+          "C123",
+          `${where}: namespace "${m.namespace}" is not an absolute requirement-namespace path (e.g. /req/cs/${m.id}) \u2014 the declared pin C119 guards must be a path (document-module-references-resolve)`
+        );
+      }
+      if (dmProcessIds.size > 0) {
+        for (const s of m.sequence ?? []) {
+          if (!dmProcessIds.has(s)) {
+            err(
+              "C123",
+              `${where}: sequence "${s}" is not a declared process (document-module-references-resolve)`
+            );
+          }
+        }
+      }
+      if (dmOrganIds.size > 0) {
+        for (const r of m.registers ?? []) {
+          if (r.maintainer !== "" && !dmOrganIds.has(r.maintainer)) {
+            err(
+              "C123",
+              `${where} register ${r.id}: maintainer "${r.maintainer}" is not a declared governance organ (document-module-references-resolve)`
+            );
+          }
+        }
+      }
+    }
+    if (options.resolvePackage) {
+      for (const a of standard.informativeAnnexes ?? []) {
+        if (a.appliesTo !== "" && !resolveDepManifest(a.appliesTo)) {
+          err(
+            "C123",
+            `informative_annex ${a.id}: applies_to "${a.appliesTo}" does not resolve to a known package \u2014 the CASCO layer the annex applies to must resolve (document-module-references-resolve)`
+          );
+        }
+      }
+    }
+  }
   if (productManifest?.kind === "certification_program") {
     const mapsTo = productManifest.mapsTo ?? [];
     if (mapsTo.length === 0) {
@@ -21880,7 +23788,11 @@ function checkPackage(dir, options = {}) {
       }
     }
     const SCHEME_TYPES_WITHOUT_SURVEILLANCE = /* @__PURE__ */ new Set(["type_1a", "type_1b"]);
-    if (productManifest.schemeType && SCHEME_TYPES_WITHOUT_SURVEILLANCE.has(productManifest.schemeType)) {
+    const registerEntry = (standard.schemeTypes ?? []).find(
+      (t) => t.id === productManifest.schemeType
+    );
+    const noSurveillance = registerEntry ? !registerEntry.surveillance?.required : SCHEME_TYPES_WITHOUT_SURVEILLANCE.has(productManifest.schemeType ?? "");
+    if (productManifest.schemeType && noSurveillance) {
       const claims = [];
       if ((standard.monitors ?? []).length > 0) {
         claims.push(
@@ -22502,6 +24414,169 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  for (const a of standard.attributeDefinitions ?? []) {
+    const pl = a.pairList;
+    if (!pl) {
+      continue;
+    }
+    const where = `attribute_definition ${a.id}: pair_list`;
+    if (!pl.key) {
+      err("C124", `${where}: the key slot is required (pair-list-shape)`);
+    }
+    if (!pl.value) {
+      err("C124", `${where}: the value slot is required (pair-list-shape)`);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const c of pl.components) {
+      if (seen.has(c.id)) {
+        err(
+          "C124",
+          `${where}: component "${c.id}" is declared twice (pair-list-shape)`
+        );
+      }
+      seen.add(c.id);
+    }
+    if (pl.keyDimension && dimIds.size > 0 && !dimIds.has(pl.keyDimension)) {
+      err(
+        "C124",
+        `${where}: key_dimension "${pl.keyDimension}" is not a declared applicability dimension (pair-list-shape)`
+      );
+    }
+  }
+  for (const c of standard.calculations ?? []) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const v of c.variants ?? []) {
+      const where = `calculation ${c.id}: variant ${v.id}`;
+      if (seen.has(v.id)) {
+        err(
+          "C125",
+          `${where}: the variant id is declared twice (formula-variant-shape)`
+        );
+      }
+      seen.add(v.id);
+      if (v.type === "expression" && !v.expression) {
+        err(
+          "C125",
+          `${where}: type expression requires the expression facet (formula-variant-shape)`
+        );
+      }
+      if (v.type === "table_lookup" && !v.lookup) {
+        err(
+          "C125",
+          `${where}: type table_lookup requires the lookup block (formula-variant-shape)`
+        );
+      }
+      if (v.type === "profile_lookup" && !v.profile) {
+        err(
+          "C125",
+          `${where}: type profile_lookup requires the profile facet (formula-variant-shape)`
+        );
+      }
+    }
+  }
+  if (symbolIds.size > 0) {
+    for (const n of standard.formulaNotes ?? []) {
+      for (const s of n.appliesTo ?? []) {
+        if (!symbolIds.has(s)) {
+          err(
+            "C126",
+            `formula_note ${n.id}: applies_to "${s}" is not a declared symbol (formula-note-targets-resolve)`
+          );
+        }
+      }
+    }
+  }
+  for (const c of standard.commonTestConditions ?? []) {
+    if (!c.description) {
+      err(
+        "C127",
+        `common_test_condition ${c.id}: the description is required \u2014 a condition entry carries its normative text (common-test-condition-shape)`
+      );
+    }
+  }
+  {
+    const seenLetters = /* @__PURE__ */ new Map();
+    for (const a of standard.partAnnexes ?? []) {
+      if (a.letter) {
+        const prior = seenLetters.get(a.letter);
+        if (prior !== void 0) {
+          err(
+            "C128",
+            `part_annex ${a.id}: letter "${a.letter}" is already declared by ${prior} \u2014 the annex-volume index keys on the printed letter (part-annex-shape)`
+          );
+        } else {
+          seenLetters.set(a.letter, a.id);
+        }
+      }
+      if (!a.source?.doc) {
+        err(
+          "C128",
+          `part_annex ${a.id}: the source provenance is required \u2014 a documentary register entry cites its part (part-annex-shape)`
+        );
+      }
+    }
+  }
+  {
+    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)`
+            );
+          }
+        }
+      }
+    }
+  }
   for (const d of standard.duals ?? []) {
     if (d.attribute && !attrIds.has(d.attribute)) {
       err(