@primmel/primmel 1.10.0 → 1.11.1

package/dist-cli/primmel.mjs

@@ -249,6 +249,18 @@ function parse(mmelString, parsers, options = {}) {
     duals: {},
     // Primmel v3 ISO/IEC 17000 activity taxonomy (TODO.roadmap/39)
     activityArchetypes: {},
+    // Primmel v3 certification-framework model (smart TODO.roadmap/40)
+    participantKinds: {},
+    governanceOrgans: {},
+    declarationKinds: {},
+    declarationStatuses: {},
+    declarationGates: {},
+    schemeDefinitions: {},
+    schemeLifecycles: {},
+    frameworkDocuments: {},
+    documentPrecedences: {},
+    autoInclusions: {},
+    decisionRules: {},
     // Primmel v3 twin interface (TODO.roadmap/32)
     connectorProfiles: {},
     // Primmel v3 continuous compliance (TODO.roadmap/34)
@@ -13791,6 +13803,1450 @@ var dumpActivityArchetype = function(a) {
   return out;
 };
 
+// src/ser-des/config/participantKind.ts
+function parseCompetence(block) {
+  const competence = {
+    delegates_to: "",
+    clause: "",
+    note: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "delegates_to") {
+        competence.delegates_to = stripWrapping(value());
+      } else if (keyword === "clause") {
+        competence.clause = stripWrapping(value());
+      } else if (keyword === "note") {
+        competence.note = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "participant_kind competence", id: "" }
+  );
+  return competence;
+}
+function parseApproval2(block) {
+  const approval = {
+    decided_by: "",
+    on_recommendation_of: "",
+    procedure: "",
+    clause: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "decided_by") {
+        approval.decided_by = stripWrapping(value());
+      } else if (keyword === "on_recommendation_of") {
+        approval.on_recommendation_of = stripWrapping(value());
+      } else if (keyword === "procedure") {
+        approval.procedure = stripWrapping(value());
+      } else if (keyword === "clause") {
+        approval.clause = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "participant_kind approval", id: "" }
+  );
+  return approval;
+}
+function parseSubkind(id, block) {
+  const subkind = {
+    id,
+    label: "",
+    term: "",
+    definition: "",
+    data_flag: "",
+    acceptance: "",
+    acceptance_note: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "label") {
+        subkind.label = stripWrapping(value());
+      } else if (keyword === "term") {
+        subkind.term = stripWrapping(value());
+      } else if (keyword === "definition") {
+        subkind.definition = stripWrapping(value());
+      } else if (keyword === "data_flag") {
+        subkind.data_flag = stripWrapping(value());
+      } else if (keyword === "acceptance") {
+        subkind.acceptance = stripWrapping(value());
+      } else if (keyword === "acceptance_note") {
+        subkind.acceptance_note = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "participant_kind subkind", id }
+  );
+  return subkind;
+}
+var parseParticipantKind = (id, data) => {
+  const kind = {
+    id,
+    label: "",
+    term: "",
+    clause: "",
+    definition: "",
+    member: "",
+    competence: null,
+    approval: null,
+    approved_by: "",
+    designated_by: "",
+    declaration: "",
+    admission: "",
+    becomes: "",
+    procedure: "",
+    subkinds: [],
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value, peek) => {
+      if (keyword === "label") {
+        kind.label = stripWrapping(value());
+      } else if (keyword === "term") {
+        kind.term = stripWrapping(value());
+      } else if (keyword === "clause") {
+        kind.clause = stripWrapping(value());
+      } else if (keyword === "definition") {
+        kind.definition = stripWrapping(value());
+      } else if (keyword === "member") {
+        kind.member = stripWrapping(value());
+      } else if (keyword === "competence") {
+        kind.competence = parseCompetence(unwrapBlock(value()));
+      } else if (keyword === "approval") {
+        kind.approval = parseApproval2(unwrapBlock(value()));
+      } else if (keyword === "approved_by") {
+        kind.approved_by = stripWrapping(value());
+      } else if (keyword === "designated_by") {
+        kind.designated_by = stripWrapping(value());
+      } else if (keyword === "declaration") {
+        kind.declaration = stripWrapping(value());
+      } else if (keyword === "admission") {
+        kind.admission = stripWrapping(value());
+      } else if (keyword === "becomes") {
+        kind.becomes = stripWrapping(value());
+      } else if (keyword === "procedure") {
+        kind.procedure = stripWrapping(value());
+      } else if (keyword === "subkind") {
+        const subId = stripWrapping(value());
+        const head = peek();
+        if (head === void 0 || !head.startsWith("{")) {
+          throw new Error(
+            `Parsing error: participant_kind. ID ${id}: subkind ${subId} is missing its block`
+          );
+        }
+        kind.subkinds.push(parseSubkind(subId, unwrapBlock(value())));
+      } else if (keyword === "source") {
+        kind.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "participant_kind", id }
+  );
+  return (ctx) => {
+    ctx.participantKinds[id] = kind;
+    return ctx;
+  };
+};
+function dumpCompetence(c) {
+  let out = "  competence {\n";
+  if (c.delegates_to) {
+    out += "    delegates_to " + dumpBareSafe(c.delegates_to) + "\n";
+  }
+  if (c.clause) {
+    out += '    clause "' + escapeString(c.clause) + '"\n';
+  }
+  if (c.note) {
+    out += '    note "' + escapeString(c.note) + '"\n';
+  }
+  out += "  }\n";
+  return out;
+}
+function dumpApproval2(a) {
+  let out = "  approval {\n";
+  if (a.decided_by) {
+    out += "    decided_by " + dumpBareSafe(a.decided_by) + "\n";
+  }
+  if (a.on_recommendation_of) {
+    out += "    on_recommendation_of " + dumpBareSafe(a.on_recommendation_of) + "\n";
+  }
+  if (a.procedure) {
+    out += '    procedure "' + escapeString(a.procedure) + '"\n';
+  }
+  if (a.clause) {
+    out += '    clause "' + escapeString(a.clause) + '"\n';
+  }
+  out += "  }\n";
+  return out;
+}
+function dumpSubkind(s) {
+  let out = "  subkind " + dumpBareSafe(s.id) + " {\n";
+  if (s.label) {
+    out += '    label "' + escapeString(s.label) + '"\n';
+  }
+  if (s.term) {
+    out += '    term "' + escapeString(s.term) + '"\n';
+  }
+  if (s.definition) {
+    out += '    definition "' + escapeString(s.definition) + '"\n';
+  }
+  if (s.data_flag) {
+    out += '    data_flag "' + escapeString(s.data_flag) + '"\n';
+  }
+  if (s.acceptance) {
+    out += "    acceptance " + dumpBareSafe(s.acceptance) + "\n";
+  }
+  if (s.acceptance_note) {
+    out += '    acceptance_note "' + escapeString(s.acceptance_note) + '"\n';
+  }
+  out += "  }\n";
+  return out;
+}
+var dumpParticipantKind = function(k) {
+  let out = "participant_kind " + k.id + " {\n";
+  if (k.label) {
+    out += '  label "' + escapeString(k.label) + '"\n';
+  }
+  if (k.term) {
+    out += '  term "' + escapeString(k.term) + '"\n';
+  }
+  if (k.clause) {
+    out += '  clause "' + escapeString(k.clause) + '"\n';
+  }
+  if (k.definition) {
+    out += '  definition "' + escapeString(k.definition) + '"\n';
+  }
+  if (k.member) {
+    out += "  member " + dumpBareSafe(k.member) + "\n";
+  }
+  if (k.competence) {
+    out += dumpCompetence(k.competence);
+  }
+  if (k.approval) {
+    out += dumpApproval2(k.approval);
+  }
+  if (k.approved_by) {
+    out += "  approved_by " + dumpBareSafe(k.approved_by) + "\n";
+  }
+  if (k.designated_by) {
+    out += "  designated_by " + dumpBareSafe(k.designated_by) + "\n";
+  }
+  if (k.declaration) {
+    out += "  declaration " + dumpBareSafe(k.declaration) + "\n";
+  }
+  if (k.admission) {
+    out += '  admission "' + escapeString(k.admission) + '"\n';
+  }
+  if (k.becomes) {
+    out += "  becomes " + dumpBareSafe(k.becomes) + "\n";
+  }
+  if (k.procedure) {
+    out += '  procedure "' + escapeString(k.procedure) + '"\n';
+  }
+  for (const s of k.subkinds) {
+    out += dumpSubkind(s);
+  }
+  if (k.source.doc || k.source.clause) {
+    out += "  source {\n";
+    if (k.source.doc) {
+      out += '    doc "' + escapeString(k.source.doc) + '"\n';
+    }
+    if (k.source.clause) {
+      out += '    clause "' + escapeString(k.source.clause) + '"\n';
+    }
+    out += "  }\n";
+  }
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/governanceOrgan.ts
+var parseGovernanceOrgan = (id, data) => {
+  const organ = {
+    id,
+    label: "",
+    term: "",
+    clause: "",
+    mandate: "",
+    sub_committee_of: "",
+    independent_of: "",
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "label") {
+        organ.label = stripWrapping(value());
+      } else if (keyword === "term") {
+        organ.term = stripWrapping(value());
+      } else if (keyword === "clause") {
+        organ.clause = stripWrapping(value());
+      } else if (keyword === "mandate") {
+        organ.mandate = stripWrapping(value());
+      } else if (keyword === "sub_committee_of") {
+        organ.sub_committee_of = stripWrapping(value());
+      } else if (keyword === "independent_of") {
+        organ.independent_of = stripWrapping(value());
+      } else if (keyword === "source") {
+        organ.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "governance_organ", id }
+  );
+  return (ctx) => {
+    ctx.governanceOrgans[id] = organ;
+    return ctx;
+  };
+};
+var dumpGovernanceOrgan = function(o) {
+  let out = "governance_organ " + o.id + " {\n";
+  if (o.label) {
+    out += '  label "' + escapeString(o.label) + '"\n';
+  }
+  if (o.term) {
+    out += '  term "' + escapeString(o.term) + '"\n';
+  }
+  if (o.clause) {
+    out += '  clause "' + escapeString(o.clause) + '"\n';
+  }
+  if (o.mandate) {
+    out += '  mandate "' + escapeString(o.mandate) + '"\n';
+  }
+  if (o.sub_committee_of) {
+    out += "  sub_committee_of " + dumpBareSafe(o.sub_committee_of) + "\n";
+  }
+  if (o.independent_of) {
+    out += "  independent_of " + dumpBareSafe(o.independent_of) + "\n";
+  }
+  if (o.source.doc || o.source.clause) {
+    out += "  source {\n";
+    if (o.source.doc) {
+      out += '    doc "' + escapeString(o.source.doc) + '"\n';
+    }
+    if (o.source.clause) {
+      out += '    clause "' + escapeString(o.source.clause) + '"\n';
+    }
+    out += "  }\n";
+  }
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/declaration.ts
+function parseContentSlot(id, block) {
+  const slot = { id, clause: "", description: "" };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "clause") {
+        slot.clause = stripWrapping(value());
+      } else if (keyword === "description") {
+        slot.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "declaration_kind content", id }
+  );
+  return slot;
+}
+var parseDeclarationKind = (id, data) => {
+  const kind = {
+    id,
+    label: "",
+    holder: "",
+    clause: "",
+    procedure: "",
+    definition: "",
+    scope_model: "",
+    scheme_a_obligation: "",
+    content: [],
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value, peek) => {
+      if (keyword === "label") {
+        kind.label = stripWrapping(value());
+      } else if (keyword === "holder") {
+        kind.holder = stripWrapping(value());
+      } else if (keyword === "clause") {
+        kind.clause = stripWrapping(value());
+      } else if (keyword === "procedure") {
+        kind.procedure = stripWrapping(value());
+      } else if (keyword === "definition") {
+        kind.definition = stripWrapping(value());
+      } else if (keyword === "scope_model") {
+        kind.scope_model = stripWrapping(value());
+      } else if (keyword === "scheme_a_obligation") {
+        kind.scheme_a_obligation = stripWrapping(value());
+      } else if (keyword === "content") {
+        const slotId = stripWrapping(value());
+        const head = peek();
+        if (head === void 0 || !head.startsWith("{")) {
+          throw new Error(
+            `Parsing error: declaration_kind. ID ${id}: content ${slotId} is missing its block`
+          );
+        }
+        kind.content.push(parseContentSlot(slotId, unwrapBlock(value())));
+      } else if (keyword === "source") {
+        kind.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "declaration_kind", id }
+  );
+  return (ctx) => {
+    ctx.declarationKinds[id] = kind;
+    return ctx;
+  };
+};
+function dumpContentSlot(s) {
+  let out = "  content " + dumpBareSafe(s.id) + " {\n";
+  if (s.clause) {
+    out += '    clause "' + escapeString(s.clause) + '"\n';
+  }
+  if (s.description) {
+    out += '    description "' + escapeString(s.description) + '"\n';
+  }
+  out += "  }\n";
+  return out;
+}
+function dumpSourceBlock(src) {
+  let out = "  source {\n";
+  if (src.doc) {
+    out += '    doc "' + escapeString(src.doc) + '"\n';
+  }
+  if (src.clause) {
+    out += '    clause "' + escapeString(src.clause) + '"\n';
+  }
+  out += "  }\n";
+  return out;
+}
+var dumpDeclarationKind = function(k) {
+  let out = "declaration_kind " + k.id + " {\n";
+  if (k.label) {
+    out += '  label "' + escapeString(k.label) + '"\n';
+  }
+  if (k.holder) {
+    out += "  holder " + dumpBareSafe(k.holder) + "\n";
+  }
+  if (k.clause) {
+    out += '  clause "' + escapeString(k.clause) + '"\n';
+  }
+  if (k.procedure) {
+    out += '  procedure "' + escapeString(k.procedure) + '"\n';
+  }
+  if (k.definition) {
+    out += '  definition "' + escapeString(k.definition) + '"\n';
+  }
+  if (k.scope_model) {
+    out += "  scope_model " + dumpBareSafe(k.scope_model) + "\n";
+  }
+  if (k.scheme_a_obligation) {
+    out += '  scheme_a_obligation "' + escapeString(k.scheme_a_obligation) + '"\n';
+  }
+  for (const s of k.content) {
+    out += dumpContentSlot(s);
+  }
+  if (k.source.doc || k.source.clause) {
+    out += dumpSourceBlock(k.source);
+  }
+  out += "}\n";
+  return out;
+};
+var parseDeclarationStatus = (id, data) => {
+  const status = { id, description: "" };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "description") {
+        status.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "declaration_status", id }
+  );
+  return (ctx) => {
+    ctx.declarationStatuses[id] = status;
+    return ctx;
+  };
+};
+var dumpDeclarationStatus = function(s) {
+  let out = "declaration_status " + s.id + " {\n";
+  if (s.description) {
+    out += '  description "' + escapeString(s.description) + '"\n';
+  }
+  out += "}\n";
+  return out;
+};
+var parseDeclarationGate = (id, data) => {
+  const gate = {
+    id,
+    clause: "",
+    statement: "",
+    holder: "",
+    declaration: "",
+    blocks: [],
+    blocks_note: "",
+    scope_checked: [],
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "clause") {
+        gate.clause = stripWrapping(value());
+      } else if (keyword === "statement") {
+        gate.statement = stripWrapping(value());
+      } else if (keyword === "holder") {
+        gate.holder = stripWrapping(value());
+      } else if (keyword === "declaration") {
+        gate.declaration = stripWrapping(value());
+      } else if (keyword === "blocks") {
+        gate.blocks = tokenizePackage(unwrapBlock(value())).filter(
+          (s) => s.length > 0
+        );
+      } else if (keyword === "blocks_note") {
+        gate.blocks_note = stripWrapping(value());
+      } else if (keyword === "scope_checked") {
+        gate.scope_checked = tokenizePackage(unwrapBlock(value())).filter(
+          (s) => s.length > 0
+        );
+      } else if (keyword === "source") {
+        gate.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "declaration_gate", id }
+  );
+  return (ctx) => {
+    ctx.declarationGates[id] = gate;
+    return ctx;
+  };
+};
+var dumpDeclarationGate = function(g) {
+  let out = "declaration_gate " + g.id + " {\n";
+  if (g.clause) {
+    out += '  clause "' + escapeString(g.clause) + '"\n';
+  }
+  if (g.statement) {
+    out += '  statement "' + escapeString(g.statement) + '"\n';
+  }
+  if (g.holder) {
+    out += "  holder " + dumpBareSafe(g.holder) + "\n";
+  }
+  if (g.declaration) {
+    out += "  declaration " + dumpBareSafe(g.declaration) + "\n";
+  }
+  if (g.blocks.length > 0) {
+    out += "  blocks { " + g.blocks.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (g.blocks_note) {
+    out += '  blocks_note "' + escapeString(g.blocks_note) + '"\n';
+  }
+  if (g.scope_checked.length > 0) {
+    out += "  scope_checked { " + g.scope_checked.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (g.source.doc || g.source.clause) {
+    out += dumpSourceBlock(g.source);
+  }
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/scheme.ts
+function parseDemonstration(block) {
+  const demonstration = {
+    method: "",
+    clause: "",
+    basis: [],
+    note: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "method") {
+        demonstration.method = stripWrapping(value());
+      } else if (keyword === "clause") {
+        demonstration.clause = stripWrapping(value());
+      } else if (keyword === "basis") {
+        demonstration.basis = tokenizePackage(unwrapBlock(value())).filter(
+          (s) => s.length > 0
+        );
+      } else if (keyword === "note") {
+        demonstration.note = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_definition demonstration", id: "" }
+  );
+  return demonstration;
+}
+var parseSchemeDefinition = (id, data) => {
+  const scheme = {
+    id,
+    label: "",
+    term: "",
+    clause: "",
+    definition: "",
+    demonstration: null,
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "label") {
+        scheme.label = stripWrapping(value());
+      } else if (keyword === "term") {
+        scheme.term = stripWrapping(value());
+      } else if (keyword === "clause") {
+        scheme.clause = stripWrapping(value());
+      } else if (keyword === "definition") {
+        scheme.definition = stripWrapping(value());
+      } else if (keyword === "demonstration") {
+        scheme.demonstration = parseDemonstration(unwrapBlock(value()));
+      } else if (keyword === "source") {
+        scheme.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_definition", id }
+  );
+  return (ctx) => {
+    ctx.schemeDefinitions[id] = scheme;
+    return ctx;
+  };
+};
+function dumpSourceBlock2(src) {
+  let out = "  source {\n";
+  if (src.doc) {
+    out += '    doc "' + escapeString(src.doc) + '"\n';
+  }
+  if (src.clause) {
+    out += '    clause "' + escapeString(src.clause) + '"\n';
+  }
+  out += "  }\n";
+  return out;
+}
+var dumpSchemeDefinition = function(s) {
+  let out = "scheme_definition " + s.id + " {\n";
+  if (s.label) {
+    out += '  label "' + escapeString(s.label) + '"\n';
+  }
+  if (s.term) {
+    out += '  term "' + escapeString(s.term) + '"\n';
+  }
+  if (s.clause) {
+    out += '  clause "' + escapeString(s.clause) + '"\n';
+  }
+  if (s.definition) {
+    out += '  definition "' + escapeString(s.definition) + '"\n';
+  }
+  if (s.demonstration) {
+    const d = s.demonstration;
+    out += "  demonstration {\n";
+    if (d.method) {
+      out += "    method " + dumpBareSafe(d.method) + "\n";
+    }
+    if (d.clause) {
+      out += '    clause "' + escapeString(d.clause) + '"\n';
+    }
+    if (d.basis.length > 0) {
+      out += "    basis { " + d.basis.map(dumpBareSafe).join(" ") + " }\n";
+    }
+    if (d.note) {
+      out += '    note "' + escapeString(d.note) + '"\n';
+    }
+    out += "  }\n";
+  }
+  if (s.source.doc || s.source.clause) {
+    out += dumpSourceBlock2(s.source);
+  }
+  out += "}\n";
+  return out;
+};
+function parseEntry(block) {
+  const entry = {
+    action: "",
+    automatic: false,
+    clause: "",
+    conditions_ref: "",
+    description: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "action") {
+        entry.action = stripWrapping(value());
+      } else if (keyword === "automatic") {
+        entry.automatic = value() === "true";
+      } else if (keyword === "clause") {
+        entry.clause = stripWrapping(value());
+      } else if (keyword === "conditions_ref") {
+        entry.conditions_ref = stripWrapping(value());
+      } else if (keyword === "description") {
+        entry.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_lifecycle entry", id: "" }
+  );
+  return entry;
+}
+function parseTransition(block) {
+  const facets = {
+    clause: "",
+    decided_by: "",
+    on_proposal_of: "",
+    description: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "clause") {
+        facets.clause = stripWrapping(value());
+      } else if (keyword === "decided_by") {
+        facets.decided_by = stripWrapping(value());
+      } else if (keyword === "on_proposal_of") {
+        facets.on_proposal_of = stripWrapping(value());
+      } else if (keyword === "description") {
+        facets.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_lifecycle transition", id: "" }
+  );
+  return facets;
+}
+function parseTrigger(id, block) {
+  const trigger = {
+    id,
+    kind: "",
+    action: "",
+    windowYears: 0,
+    windowMonths: 0,
+    clause: "",
+    deferrable: false,
+    deferral_note: "",
+    description: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "kind") {
+        trigger.kind = stripWrapping(value());
+      } else if (keyword === "action") {
+        trigger.action = stripWrapping(value());
+      } else if (keyword === "window") {
+        const wt = tokenizePackage(unwrapBlock(value()));
+        for (let i = 0; i + 1 < wt.length; i += 2) {
+          if (wt[i] === "years") {
+            trigger.windowYears = parseInt(stripWrapping(wt[i + 1]), 10) || 0;
+          } else if (wt[i] === "months") {
+            trigger.windowMonths = parseInt(stripWrapping(wt[i + 1]), 10) || 0;
+          }
+        }
+      } else if (keyword === "clause") {
+        trigger.clause = stripWrapping(value());
+      } else if (keyword === "deferrable") {
+        trigger.deferrable = value() === "true";
+      } else if (keyword === "deferral_note") {
+        trigger.deferral_note = stripWrapping(value());
+      } else if (keyword === "description") {
+        trigger.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_lifecycle trigger", id }
+  );
+  return trigger;
+}
+var parseSchemeLifecycle = (id, data) => {
+  const lifecycle = {
+    id,
+    applies_to: "",
+    initial: "",
+    entry: null,
+    transitions: [],
+    triggers: [],
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value, peek) => {
+      if (keyword === "applies_to") {
+        lifecycle.applies_to = stripWrapping(value());
+      } else if (keyword === "initial") {
+        lifecycle.initial = stripWrapping(value());
+      } else if (keyword === "entry") {
+        lifecycle.entry = parseEntry(unwrapBlock(value()));
+      } else if (keyword === "transition") {
+        const from = stripWrapping(value());
+        const arrow = peek();
+        if (arrow === void 0 || arrow !== "->" && arrow !== "\u2192") {
+          throw new Error(
+            `Parsing error: scheme_lifecycle. ID ${id}: transition ${from} is missing its '->'`
+          );
+        }
+        value();
+        const to = stripWrapping(value());
+        let action = "";
+        if (peek() === "action") {
+          value();
+          action = stripWrapping(value());
+        }
+        const head = peek();
+        if (head === void 0 || !head.startsWith("{")) {
+          throw new Error(
+            `Parsing error: scheme_lifecycle. ID ${id}: transition ${from} -> ${to} is missing its block`
+          );
+        }
+        const facets = parseTransition(unwrapBlock(value()));
+        lifecycle.transitions.push({ from, to, action, ...facets });
+      } else if (keyword === "trigger") {
+        const trigId = stripWrapping(value());
+        const head = peek();
+        if (head === void 0 || !head.startsWith("{")) {
+          throw new Error(
+            `Parsing error: scheme_lifecycle. ID ${id}: trigger ${trigId} is missing its block`
+          );
+        }
+        lifecycle.triggers.push(parseTrigger(trigId, unwrapBlock(value())));
+      } else if (keyword === "source") {
+        lifecycle.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "scheme_lifecycle", id }
+  );
+  return (ctx) => {
+    ctx.schemeLifecycles[id] = lifecycle;
+    return ctx;
+  };
+};
+var dumpSchemeLifecycle = function(l) {
+  let out = "scheme_lifecycle " + l.id + " {\n";
+  if (l.applies_to) {
+    out += "  applies_to " + dumpBareSafe(l.applies_to) + "\n";
+  }
+  if (l.initial) {
+    out += "  initial " + dumpBareSafe(l.initial) + "\n";
+  }
+  if (l.entry) {
+    const e = l.entry;
+    out += "  entry {\n";
+    if (e.action) {
+      out += "    action " + dumpBareSafe(e.action) + "\n";
+    }
+    out += "    automatic " + (e.automatic ? "true" : "false") + "\n";
+    if (e.clause) {
+      out += '    clause "' + escapeString(e.clause) + '"\n';
+    }
+    if (e.conditions_ref) {
+      out += "    conditions_ref " + dumpBareSafe(e.conditions_ref) + "\n";
+    }
+    if (e.description) {
+      out += '    description "' + escapeString(e.description) + '"\n';
+    }
+    out += "  }\n";
+  }
+  for (const t of l.transitions) {
+    out += "  transition " + dumpBareSafe(t.from) + " -> " + dumpBareSafe(t.to);
+    if (t.action) {
+      out += " action " + dumpBareSafe(t.action);
+    }
+    out += " {\n";
+    if (t.clause) {
+      out += '    clause "' + escapeString(t.clause) + '"\n';
+    }
+    if (t.decided_by) {
+      out += "    decided_by " + dumpBareSafe(t.decided_by) + "\n";
+    }
+    if (t.on_proposal_of) {
+      out += "    on_proposal_of " + dumpBareSafe(t.on_proposal_of) + "\n";
+    }
+    if (t.description) {
+      out += '    description "' + escapeString(t.description) + '"\n';
+    }
+    out += "  }\n";
+  }
+  for (const tr of l.triggers) {
+    out += "  trigger " + dumpBareSafe(tr.id) + " {\n";
+    if (tr.kind) {
+      out += "    kind " + dumpBareSafe(tr.kind) + "\n";
+    }
+    if (tr.action) {
+      out += "    action " + dumpBareSafe(tr.action) + "\n";
+    }
+    if (tr.windowYears > 0 || tr.windowMonths > 0) {
+      let w = "    window {";
+      if (tr.windowYears > 0) {
+        w += " years " + tr.windowYears;
+      }
+      if (tr.windowMonths > 0) {
+        w += " months " + tr.windowMonths;
+      }
+      out += w + " }\n";
+    }
+    if (tr.clause) {
+      out += '    clause "' + escapeString(tr.clause) + '"\n';
+    }
+    if (tr.deferrable) {
+      out += "    deferrable true\n";
+    }
+    if (tr.deferral_note) {
+      out += '    deferral_note "' + escapeString(tr.deferral_note) + '"\n';
+    }
+    if (tr.description) {
+      out += '    description "' + escapeString(tr.description) + '"\n';
+    }
+    out += "  }\n";
+  }
+  if (l.source.doc || l.source.clause) {
+    out += dumpSourceBlock2(l.source);
+  }
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/frameworkDocument.ts
+function dumpSourceBlock3(src) {
+  let out = "  source {\n";
+  if (src.doc) {
+    out += '    doc "' + escapeString(src.doc) + '"\n';
+  }
+  if (src.clause) {
+    out += '    clause "' + escapeString(src.clause) + '"\n';
+  }
+  out += "  }\n";
+  return out;
+}
+var parseFrameworkDocument = (id, data) => {
+  const doc = {
+    id,
+    rank: 0,
+    doc: "",
+    title: "",
+    approved_by: "",
+    clause: "",
+    note: "",
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "rank") {
+        doc.rank = parseInt(stripWrapping(value()), 10) || 0;
+      } else if (keyword === "doc") {
+        doc.doc = stripWrapping(value());
+      } else if (keyword === "title") {
+        doc.title = stripWrapping(value());
+      } else if (keyword === "approved_by") {
+        doc.approved_by = stripWrapping(value());
+      } else if (keyword === "clause") {
+        doc.clause = stripWrapping(value());
+      } else if (keyword === "note") {
+        doc.note = stripWrapping(value());
+      } else if (keyword === "source") {
+        doc.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "framework_document", id }
+  );
+  return (ctx) => {
+    ctx.frameworkDocuments[id] = doc;
+    return ctx;
+  };
+};
+var dumpFrameworkDocument = function(d) {
+  let out = "framework_document " + d.id + " {\n";
+  if (d.rank > 0) {
+    out += "  rank " + d.rank + "\n";
+  }
+  if (d.doc) {
+    out += '  doc "' + escapeString(d.doc) + '"\n';
+  }
+  if (d.title) {
+    out += '  title "' + escapeString(d.title) + '"\n';
+  }
+  if (d.approved_by) {
+    out += "  approved_by " + dumpBareSafe(d.approved_by) + "\n";
+  }
+  if (d.clause) {
+    out += '  clause "' + escapeString(d.clause) + '"\n';
+  }
+  if (d.note) {
+    out += '  note "' + escapeString(d.note) + '"\n';
+  }
+  if (d.source.doc || d.source.clause) {
+    out += dumpSourceBlock3(d.source);
+  }
+  out += "}\n";
+  return out;
+};
+var parseDocumentPrecedence = (id, data) => {
+  const rule = {
+    id,
+    clause: "",
+    statement: "",
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "clause") {
+        rule.clause = stripWrapping(value());
+      } else if (keyword === "statement") {
+        rule.statement = stripWrapping(value());
+      } else if (keyword === "source") {
+        rule.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "document_precedence", id }
+  );
+  return (ctx) => {
+    ctx.documentPrecedences[id] = rule;
+    return ctx;
+  };
+};
+var dumpDocumentPrecedence = function(p) {
+  let out = "document_precedence " + p.id + " {\n";
+  if (p.clause) {
+    out += '  clause "' + escapeString(p.clause) + '"\n';
+  }
+  if (p.statement) {
+    out += '  statement "' + escapeString(p.statement) + '"\n';
+  }
+  if (p.source.doc || p.source.clause) {
+    out += dumpSourceBlock3(p.source);
+  }
+  out += "}\n";
+  return out;
+};
+function parseCondition(id, block) {
+  const condition = { id, clause: "", description: "" };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "clause") {
+        condition.clause = stripWrapping(value());
+      } else if (keyword === "description") {
+        condition.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "auto_inclusion condition", id }
+  );
+  return condition;
+}
+var parseAutoInclusion = (id, data) => {
+  const inclusion = {
+    id,
+    clause: "",
+    statement: "",
+    conditions: [],
+    note: "",
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value, peek) => {
+      if (keyword === "clause") {
+        inclusion.clause = stripWrapping(value());
+      } else if (keyword === "statement") {
+        inclusion.statement = stripWrapping(value());
+      } else if (keyword === "condition") {
+        const condId = stripWrapping(value());
+        const head = peek();
+        if (head === void 0 || !head.startsWith("{")) {
+          throw new Error(
+            `Parsing error: auto_inclusion. ID ${id}: condition ${condId} is missing its block`
+          );
+        }
+        inclusion.conditions.push(parseCondition(condId, unwrapBlock(value())));
+      } else if (keyword === "note") {
+        inclusion.note = stripWrapping(value());
+      } else if (keyword === "source") {
+        inclusion.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "auto_inclusion", id }
+  );
+  return (ctx) => {
+    ctx.autoInclusions[id] = inclusion;
+    return ctx;
+  };
+};
+var dumpAutoInclusion = function(a) {
+  let out = "auto_inclusion " + a.id + " {\n";
+  if (a.clause) {
+    out += '  clause "' + escapeString(a.clause) + '"\n';
+  }
+  if (a.statement) {
+    out += '  statement "' + escapeString(a.statement) + '"\n';
+  }
+  for (const c of a.conditions) {
+    out += "  condition " + dumpBareSafe(c.id) + " {\n";
+    if (c.clause) {
+      out += '    clause "' + escapeString(c.clause) + '"\n';
+    }
+    if (c.description) {
+      out += '    description "' + escapeString(c.description) + '"\n';
+    }
+    out += "  }\n";
+  }
+  if (a.note) {
+    out += '  note "' + escapeString(a.note) + '"\n';
+  }
+  if (a.source.doc || a.source.clause) {
+    out += dumpSourceBlock3(a.source);
+  }
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/decisionRule.ts
+function parseVoteRule(block) {
+  const rule = {
+    threshold: 0,
+    base: "",
+    clause: "",
+    description: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "threshold") {
+        rule.threshold = parseFloat(stripWrapping(value())) || 0;
+      } else if (keyword === "base") {
+        rule.base = stripWrapping(value());
+      } else if (keyword === "clause") {
+        rule.clause = stripWrapping(value());
+      } else if (keyword === "description") {
+        rule.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "decision_rule voting rule", id: "" }
+  );
+  return rule;
+}
+function parseOtherProposals(block) {
+  const rule = {
+    in_meeting: 0,
+    by_correspondence: "",
+    description: ""
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "in_meeting") {
+        rule.in_meeting = parseFloat(stripWrapping(value())) || 0;
+      } else if (keyword === "by_correspondence") {
+        rule.by_correspondence = stripWrapping(value());
+      } else if (keyword === "description") {
+        rule.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "decision_rule other_proposals", id: "" }
+  );
+  return rule;
+}
+function parseVoting(block) {
+  const voting = {
+    in_meeting: null,
+    by_correspondence: null,
+    other_proposals: null,
+    proxies_max: 0,
+    abstentions: "",
+    reason_on_against_or_abstain: false
+  };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "in_meeting") {
+        voting.in_meeting = parseVoteRule(unwrapBlock(value()));
+      } else if (keyword === "by_correspondence") {
+        voting.by_correspondence = parseVoteRule(unwrapBlock(value()));
+      } else if (keyword === "other_proposals") {
+        voting.other_proposals = parseOtherProposals(unwrapBlock(value()));
+      } else if (keyword === "proxies_max") {
+        voting.proxies_max = parseInt(stripWrapping(value()), 10) || 0;
+      } else if (keyword === "abstentions") {
+        voting.abstentions = stripWrapping(value());
+      } else if (keyword === "reason_on_against_or_abstain") {
+        voting.reason_on_against_or_abstain = value() === "true";
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "decision_rule voting", id: "" }
+  );
+  return voting;
+}
+function parseLegacyKind(id, block) {
+  const kind = { id, clause: "", description: "" };
+  forEachEntry(
+    block,
+    (keyword, value) => {
+      if (keyword === "clause") {
+        kind.clause = stripWrapping(value());
+      } else if (keyword === "description") {
+        kind.description = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "decision_rule legacy_kind", id }
+  );
+  return kind;
+}
+function parseIdList(value) {
+  return tokenizePackage(unwrapBlock(value)).filter((s) => s.length > 0);
+}
+var parseDecisionRule = (id, data) => {
+  const rule = {
+    id,
+    organ: "",
+    kind: "",
+    clause: "",
+    description: "",
+    on_recommendation_of: "",
+    independent_of: "",
+    decides: [],
+    voting: null,
+    tasks: [],
+    scope: [],
+    principle: "",
+    legacy_kinds: [],
+    income: "",
+    no_entrance_fees_for: [],
+    source: { doc: "", clause: "" }
+  };
+  forEachEntry(
+    data,
+    (keyword, value, peek) => {
+      if (keyword === "organ") {
+        rule.organ = stripWrapping(value());
+      } else if (keyword === "kind") {
+        rule.kind = stripWrapping(value());
+      } else if (keyword === "clause") {
+        rule.clause = stripWrapping(value());
+      } else if (keyword === "description") {
+        rule.description = stripWrapping(value());
+      } else if (keyword === "on_recommendation_of") {
+        rule.on_recommendation_of = stripWrapping(value());
+      } else if (keyword === "independent_of") {
+        rule.independent_of = stripWrapping(value());
+      } else if (keyword === "decides") {
+        rule.decides = parseIdList(value());
+      } else if (keyword === "voting") {
+        rule.voting = parseVoting(unwrapBlock(value()));
+      } else if (keyword === "tasks") {
+        rule.tasks = parseIdList(value());
+      } else if (keyword === "scope") {
+        rule.scope = parseIdList(value());
+      } else if (keyword === "principle") {
+        rule.principle = stripWrapping(value());
+      } else if (keyword === "legacy_kind") {
+        const kindId = stripWrapping(value());
+        const head = peek();
+        if (head === void 0 || !head.startsWith("{")) {
+          throw new Error(
+            `Parsing error: decision_rule. ID ${id}: legacy_kind ${kindId} is missing its block`
+          );
+        }
+        rule.legacy_kinds.push(parseLegacyKind(kindId, unwrapBlock(value())));
+      } else if (keyword === "income") {
+        rule.income = stripWrapping(value());
+      } else if (keyword === "no_entrance_fees_for") {
+        rule.no_entrance_fees_for = parseIdList(value());
+      } else if (keyword === "source") {
+        rule.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "decision_rule", id }
+  );
+  return (ctx) => {
+    ctx.decisionRules[id] = rule;
+    return ctx;
+  };
+};
+function dumpVoteRule(label, rule) {
+  let out = "    " + label + " {\n";
+  if (rule.threshold > 0) {
+    out += "      threshold " + rule.threshold + "\n";
+  }
+  if (rule.base) {
+    out += "      base " + dumpBareSafe(rule.base) + "\n";
+  }
+  if (rule.clause) {
+    out += '      clause "' + escapeString(rule.clause) + '"\n';
+  }
+  if (rule.description) {
+    out += '      description "' + escapeString(rule.description) + '"\n';
+  }
+  out += "    }\n";
+  return out;
+}
+function dumpVoting(v) {
+  let out = "  voting {\n";
+  if (v.in_meeting) {
+    out += dumpVoteRule("in_meeting", v.in_meeting);
+  }
+  if (v.by_correspondence) {
+    out += dumpVoteRule("by_correspondence", v.by_correspondence);
+  }
+  if (v.other_proposals) {
+    const o = v.other_proposals;
+    out += "    other_proposals {\n";
+    if (o.in_meeting > 0) {
+      out += "      in_meeting " + o.in_meeting + "\n";
+    }
+    if (o.by_correspondence) {
+      out += "      by_correspondence " + dumpBareSafe(o.by_correspondence) + "\n";
+    }
+    if (o.description) {
+      out += '      description "' + escapeString(o.description) + '"\n';
+    }
+    out += "    }\n";
+  }
+  if (v.proxies_max > 0) {
+    out += "    proxies_max " + v.proxies_max + "\n";
+  }
+  if (v.abstentions) {
+    out += "    abstentions " + dumpBareSafe(v.abstentions) + "\n";
+  }
+  if (v.reason_on_against_or_abstain) {
+    out += "    reason_on_against_or_abstain true\n";
+  }
+  out += "  }\n";
+  return out;
+}
+function dumpIdList3(label, ids, indent) {
+  return indent + label + " { " + ids.map(dumpBareSafe).join(" ") + " }\n";
+}
+var dumpDecisionRule = function(r) {
+  let out = "decision_rule " + r.id + " {\n";
+  if (r.organ) {
+    out += "  organ " + dumpBareSafe(r.organ) + "\n";
+  }
+  if (r.kind) {
+    out += "  kind " + dumpBareSafe(r.kind) + "\n";
+  }
+  if (r.clause) {
+    out += '  clause "' + escapeString(r.clause) + '"\n';
+  }
+  if (r.description) {
+    out += '  description "' + escapeString(r.description) + '"\n';
+  }
+  if (r.on_recommendation_of) {
+    out += "  on_recommendation_of " + dumpBareSafe(r.on_recommendation_of) + "\n";
+  }
+  if (r.independent_of) {
+    out += "  independent_of " + dumpBareSafe(r.independent_of) + "\n";
+  }
+  if (r.decides.length > 0) {
+    out += dumpIdList3("decides", r.decides, "  ");
+  }
+  if (r.voting) {
+    out += dumpVoting(r.voting);
+  }
+  if (r.tasks.length > 0) {
+    out += dumpIdList3("tasks", r.tasks, "  ");
+  }
+  if (r.scope.length > 0) {
+    out += dumpIdList3("scope", r.scope, "  ");
+  }
+  if (r.principle) {
+    out += "  principle " + dumpBareSafe(r.principle) + "\n";
+  }
+  for (const k of r.legacy_kinds) {
+    out += "  legacy_kind " + dumpBareSafe(k.id) + " {\n";
+    if (k.clause) {
+      out += '    clause "' + escapeString(k.clause) + '"\n';
+    }
+    if (k.description) {
+      out += '    description "' + escapeString(k.description) + '"\n';
+    }
+    out += "  }\n";
+  }
+  if (r.income) {
+    out += "  income " + dumpBareSafe(r.income) + "\n";
+  }
+  if (r.no_entrance_fees_for.length > 0) {
+    out += dumpIdList3("no_entrance_fees_for", r.no_entrance_fees_for, "  ");
+  }
+  if (r.source.doc || r.source.clause) {
+    out += "  source {\n";
+    if (r.source.doc) {
+      out += '    doc "' + escapeString(r.source.doc) + '"\n';
+    }
+    if (r.source.clause) {
+      out += '    clause "' + escapeString(r.source.clause) + '"\n';
+    }
+    out += "  }\n";
+  }
+  out += "}\n";
+  return out;
+};
+
 // src/ser-des/config/index.ts
 function defineConstruct(def) {
   return def;
@@ -14109,6 +15565,91 @@ var CONSTRUCTS = [
     parse: parseActivityArchetype,
     dump: dumpActivityArchetype
   }),
+  // Primmel v3 certification-framework model (smart TODO.roadmap/40; the
+  // packages-as-SSOT epic): the participant-kind register + the organs.
+  defineConstruct({
+    keyword: "participant_kind",
+    field: "participantKinds",
+    takesID: true,
+    parse: parseParticipantKind,
+    dump: dumpParticipantKind
+  }),
+  defineConstruct({
+    keyword: "governance_organ",
+    field: "governanceOrgans",
+    takesID: true,
+    parse: parseGovernanceOrgan,
+    dump: dumpGovernanceOrgan
+  }),
+  // The framework's Declaration machinery (B 18:2025 §5.5–5.6; PD-08).
+  defineConstruct({
+    keyword: "declaration_kind",
+    field: "declarationKinds",
+    takesID: true,
+    parse: parseDeclarationKind,
+    dump: dumpDeclarationKind
+  }),
+  defineConstruct({
+    keyword: "declaration_status",
+    field: "declarationStatuses",
+    takesID: true,
+    parse: parseDeclarationStatus,
+    dump: dumpDeclarationStatus
+  }),
+  defineConstruct({
+    keyword: "declaration_gate",
+    field: "declarationGates",
+    takesID: true,
+    parse: parseDeclarationGate,
+    dump: dumpDeclarationGate
+  }),
+  // The two-Scheme architecture (B 18:2025 3.37/3.38, §5.4) + the
+  // per-category lifecycle machines (clause 15).
+  defineConstruct({
+    keyword: "scheme_definition",
+    field: "schemeDefinitions",
+    takesID: true,
+    parse: parseSchemeDefinition,
+    dump: dumpSchemeDefinition
+  }),
+  defineConstruct({
+    keyword: "scheme_lifecycle",
+    field: "schemeLifecycles",
+    takesID: true,
+    parse: parseSchemeLifecycle,
+    dump: dumpSchemeLifecycle
+  }),
+  // The governing-document hierarchy (clause 6) + precedence + the §4.2
+  // auto-inclusion blocks.
+  defineConstruct({
+    keyword: "framework_document",
+    field: "frameworkDocuments",
+    takesID: true,
+    parse: parseFrameworkDocument,
+    dump: dumpFrameworkDocument
+  }),
+  defineConstruct({
+    keyword: "document_precedence",
+    field: "documentPrecedences",
+    takesID: true,
+    parse: parseDocumentPrecedence,
+    dump: dumpDocumentPrecedence
+  }),
+  defineConstruct({
+    keyword: "auto_inclusion",
+    field: "autoInclusions",
+    takesID: true,
+    parse: parseAutoInclusion,
+    dump: dumpAutoInclusion
+  }),
+  // The organs' decision rules (clauses 9–16).
+  defineConstruct({
+    keyword: "decision_rule",
+    field: "decisionRules",
+    takesID: true,
+    parse: parseDecisionRule,
+    dump: dumpDecisionRule
+  }),
   // 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 /
@@ -14268,7 +15809,8 @@ var CONVENTION_DIRS = [
   "entities",
   "specification",
   "execution",
-  "evaluation"
+  "evaluation",
+  "framework"
 ];
 function collectPrlFiles(dir) {
   const out = [];
@@ -14505,7 +16047,38 @@ var MERGE_FIELDS = [
   // `uses` like every doctrine collection, with uses-no-redefine
   // protection.
   "formulasUsed",
-  "texts"
+  "texts",
+  // The certification-framework registers (smart TODO.roadmap/40; the
+  // packages-as-SSOT epic) — the framework package's participant kinds
+  // and organs compose into every scheme-side model through `uses`.
+  "participantKinds",
+  "governanceOrgans",
+  "declarationKinds",
+  "declarationStatuses",
+  "declarationGates",
+  "schemeDefinitions",
+  "schemeLifecycles",
+  "frameworkDocuments",
+  "documentPrecedences",
+  "autoInclusions",
+  "decisionRules",
+  // 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
+  // artifact registers, the activity archetypes, connector profiles,
+  // monitors, passports, dataspaces, policies, and the top-level
+  // dimensions all compose with the same no-redefine semantics now.
+  "comments",
+  "predicates",
+  "artifactDefinitions",
+  "artifactInstances",
+  "activityArchetypes",
+  "connectorProfiles",
+  "monitors",
+  "passports",
+  "dataspaces",
+  "policies",
+  "dimensions"
 ];
 function parsePackageContent(dir, options) {
   const chunks = chunkify(packageFiles(dir));
@@ -16440,6 +18013,24 @@ var CHECK_RULES = [
     "normal",
     "smart AGENTS.d/07 (TODO.editor/05 Q3)"
   ),
+  // C120 (smart TODO.roadmap/40; the packages-as-SSOT epic): the
+  // certification-framework registers' cross-references resolve —
+  // participant_kind organ/declaration/kind edges, organ sub-committee
+  // and independence edges, declaration holder + gate edges (incl. the
+  // gate's blocked processes), scheme-lifecycle organ edges + the
+  // entry's conditions_ref + trigger actions, framework_document
+  // approving organs, decision_rule organ + exemption edges. Per-
+  // register gating (the C58 doctrine): an edge is checked only when
+  // its target register is in composition scope. Mirror of the OIML
+  // SMART linker's R25.
+  R(
+    "C120",
+    "framework-references-resolve",
+    "composition",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 (the packages-as-SSOT epic)"
+  ),
   // ── quantities / time / duality (TODO.roadmap/06) ─────────────────
   R(
     "C32",
@@ -17407,7 +18998,7 @@ function loadAllowlist(dir) {
       }
     } else if (cmd === "allowlist_entry") {
       const block = unwrapBlock(tokens[i++] ?? "");
-      const entry = parseEntry(block);
+      const entry = parseEntry2(block);
       issues.push(...validateEntry(entry));
       if (entry.rule && entry.match && entry.reason && entry.auditRef) {
         allowlist.entries.push(entry);
@@ -17425,7 +19016,7 @@ function loadAllowlist(dir) {
   }
   return { allowlist, issues };
 }
-function parseEntry(block) {
+function parseEntry2(block) {
   const entry = {
     rule: "",
     match: "",
@@ -19024,6 +20615,126 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  const organIds = new Set((standard.governanceOrgans ?? []).map((o) => o.id));
+  const kindIds = new Set((standard.participantKinds ?? []).map((k) => k.id));
+  const declIds = new Set((standard.declarationKinds ?? []).map((d) => d.id));
+  const autoInclusionIds = new Set(
+    (standard.autoInclusions ?? []).map((a) => a.id)
+  );
+  const frameworkProcessIds = new Set(
+    (standard.processes ?? []).map((p) => p.id)
+  );
+  const resolveOrgan = (where, facet, id) => {
+    if (organIds.size > 0 && id !== "" && !organIds.has(id)) {
+      err(
+        "C120",
+        `${where}: ${facet} "${id}" is not a declared governance organ (framework-references-resolve)`
+      );
+    }
+  };
+  const resolveKind = (where, facet, id) => {
+    if (kindIds.size > 0 && id !== "" && !kindIds.has(id)) {
+      err(
+        "C120",
+        `${where}: ${facet} "${id}" is not a declared participant kind (framework-references-resolve)`
+      );
+    }
+  };
+  const resolveDeclaration = (where, facet, id) => {
+    if (declIds.size > 0 && id !== "" && !declIds.has(id)) {
+      err(
+        "C120",
+        `${where}: ${facet} "${id}" is not a declared declaration kind (framework-references-resolve)`
+      );
+    }
+  };
+  for (const o of standard.governanceOrgans ?? []) {
+    resolveOrgan(
+      `governance_organ ${o.id}`,
+      "sub_committee_of",
+      o.sub_committee_of
+    );
+    resolveOrgan(
+      `governance_organ ${o.id}`,
+      "independent_of",
+      o.independent_of
+    );
+  }
+  for (const k of standard.participantKinds ?? []) {
+    const where = `participant_kind ${k.id}`;
+    resolveOrgan(where, "approved_by", k.approved_by);
+    resolveKind(where, "designated_by", k.designated_by);
+    resolveKind(where, "becomes", k.becomes);
+    resolveDeclaration(where, "declaration", k.declaration);
+    if (k.approval) {
+      resolveOrgan(where, "approval.decided_by", k.approval.decided_by);
+      resolveOrgan(
+        where,
+        "approval.on_recommendation_of",
+        k.approval.on_recommendation_of
+      );
+    }
+  }
+  for (const d of standard.declarationKinds ?? []) {
+    resolveKind(`declaration_kind ${d.id}`, "holder", d.holder);
+  }
+  for (const g of standard.declarationGates ?? []) {
+    const where = `declaration_gate ${g.id}`;
+    resolveKind(where, "holder", g.holder);
+    resolveDeclaration(where, "declaration", g.declaration);
+    if (frameworkProcessIds.size > 0) {
+      for (const b of g.blocks) {
+        if (!frameworkProcessIds.has(b)) {
+          err(
+            "C120",
+            `${where}: blocks "${b}" is not a declared process (framework-references-resolve)`
+          );
+        }
+      }
+    }
+  }
+  for (const l of standard.schemeLifecycles ?? []) {
+    const where = `scheme_lifecycle ${l.id}`;
+    if (autoInclusionIds.size > 0 && l.entry && l.entry.conditions_ref !== "" && !autoInclusionIds.has(l.entry.conditions_ref)) {
+      err(
+        "C120",
+        `${where}: entry.conditions_ref "${l.entry.conditions_ref}" is not a declared auto_inclusion block (framework-references-resolve)`
+      );
+    }
+    const actionIds = new Set(l.transitions.map((t) => t.action));
+    for (const t of l.transitions) {
+      resolveOrgan(
+        `${where} transition ${t.action}`,
+        "decided_by",
+        t.decided_by
+      );
+      resolveOrgan(
+        `${where} transition ${t.action}`,
+        "on_proposal_of",
+        t.on_proposal_of
+      );
+    }
+    for (const tr of l.triggers) {
+      if (tr.action !== "" && !actionIds.has(tr.action)) {
+        err(
+          "C120",
+          `${where}: trigger ${tr.id} fires action "${tr.action}", which no transition of the machine declares (framework-references-resolve)`
+        );
+      }
+    }
+  }
+  for (const d of standard.frameworkDocuments ?? []) {
+    resolveOrgan(`framework_document ${d.id}`, "approved_by", d.approved_by);
+  }
+  for (const r of standard.decisionRules ?? []) {
+    const where = `decision_rule ${r.id}`;
+    resolveOrgan(where, "organ", r.organ);
+    resolveOrgan(where, "on_recommendation_of", r.on_recommendation_of);
+    resolveOrgan(where, "independent_of", r.independent_of);
+    for (const k of r.no_entrance_fees_for) {
+      resolveKind(where, "no_entrance_fees_for", k);
+    }
+  }
   {
     const SEGREGATION_CASE_PERSONNEL = "case_personnel";
     const segregationProcessIds = new Set(