@primmel/primmel 1.12.0 → 1.13.0

package/dist-cli/primmel.mjs

@@ -220,10 +220,12 @@ 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: {},
@@ -269,6 +271,9 @@ function parse(mmelString, parsers, options = {}) {
     // 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)
@@ -5663,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 = {
@@ -5755,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++;
         }
@@ -5970,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) {
@@ -6058,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);
   }
@@ -8452,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) {
@@ -8492,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)) {
@@ -9465,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) {
@@ -9519,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") {
@@ -9658,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++]);
         }
@@ -9702,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") {
@@ -9737,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") {
@@ -9951,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);
     }
@@ -10658,7 +10853,7 @@ function dumpSource2(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) {
@@ -10795,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++]);
         }
@@ -11021,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") {
@@ -11151,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") {
@@ -11346,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,
@@ -11390,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") {
@@ -11401,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") {
@@ -11461,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";
   }
@@ -11518,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") {
@@ -12049,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 {
@@ -12643,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) {
@@ -12704,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 {
@@ -12897,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 {
@@ -16081,6 +16355,310 @@ var dumpInformativeAnnex = function(a) {
   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;
@@ -16305,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",
@@ -16334,6 +16922,16 @@ 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",
@@ -16526,6 +17124,34 @@ var CONSTRUCTS = [
     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 /
@@ -16890,10 +17516,12 @@ 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
@@ -16950,6 +17578,9 @@ var MERGE_FIELDS = [
   // 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
@@ -17823,10 +18454,12 @@ 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
@@ -17857,6 +18490,9 @@ var TIER_BY_FIELD = {
   // 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
@@ -18991,6 +19627,90 @@ var CHECK_RULES = [
     "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",
@@ -23694,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(