@primmel/primmel 1.14.0 → 1.16.0

package/dist-cli/primmel.mjs

@@ -261,6 +261,8 @@ function parse(mmelString, parsers, options = {}) {
     certificateTemplates: {},
     // The certification workflow step register (batch 3)
     workflowConfigs: {},
+    // The named pipeline stages (batch 5)
+    workflowStages: {},
     // The verification pathways (batch 3)
     verificationPathways: {},
     // The selection rules (batch 3)
@@ -589,1730 +591,1785 @@ function unwrapped(value) {
   return unwrapBlock(x);
 }
 
-// src/ser-des/config/approval.ts
-var parseApproval = function(id, data) {
-  const result = {
-    id,
-    name: "",
-    modality: "",
-    actor: null,
-    approver: null,
-    records: [],
-    ref: [],
-    _relations: {
-      actor: "",
-      approver: "",
-      records: [],
-      ref: []
+// src/ser-des/config/series.ts
+function parseSeriesDecl(block) {
+  const decl = { axes: [], cellSymbol: "", cellUnit: "" };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (cmd !== "axis" && cmd !== "cell") {
+      if (i < t.length) {
+        unwrapBlock(t[i - 1]);
+      }
+      continue;
     }
-  };
-  forEachEntry(
-    data,
-    (keyword, value) => {
-      if (keyword === "modality") {
-        result.modality = value();
-      } else if (keyword === "name") {
-        result.name = unwrapped(value);
-      } else if (keyword === "actor") {
-        result._relations.actor = value();
-      } else if (keyword === "approve_by") {
-        result._relations.approver = value();
-      } else if (keyword === "approval_record") {
-        result._relations.records = tokenizePackage(value());
-      } else if (keyword === "reference") {
-        result._relations.ref = tokenizePackage(value());
-      } else {
-        return false;
+    if (cmd === "axis") {
+      const axis = {
+        id: stripWrapping(t[i++]),
+        unit: "",
+        type: "",
+        role: ""
+      };
+      if (i < t.length && t[i].startsWith("{")) {
+        const ablock = unwrapBlock(t[i++]);
+        const at = tokenize(ablock);
+        let j = 0;
+        while (j < at.length) {
+          const ac = at[j++];
+          if (j >= at.length) {
+            break;
+          }
+          if (ac === "unit") {
+            axis.unit = stripWrapping(at[j++]);
+          } else if (ac === "type") {
+            axis.type = stripWrapping(at[j++]);
+          } else if (ac === "role") {
+            axis.role = stripWrapping(at[j++]);
+          } else {
+            unwrapBlock(at[j++]);
+          }
+        }
+      }
+      decl.axes.push(axis);
+    } else {
+      const cblock = unwrapBlock(t[i++]);
+      const ct = tokenize(cblock);
+      let j = 0;
+      while (j < ct.length) {
+        const cc = ct[j++];
+        if (j >= ct.length) {
+          break;
+        }
+        if (cc === "symbol") {
+          decl.cellSymbol = stripWrapping(ct[j++]);
+        } else if (cc === "unit") {
+          decl.cellUnit = stripWrapping(ct[j++]);
+        } else {
+          unwrapBlock(ct[j++]);
+        }
       }
-      return true;
-    },
-    { construct: "approval", id }
-  );
-  return (ctx) => {
-    ctx.approvals[id] = result;
-    return ctx;
-  };
-};
-var resolveApproval = function(ctx, unresolved) {
-  const { _relations, ...rest } = unresolved;
-  const p = { ...rest, records: [], ref: [] };
-  if (_relations.actor !== "") {
-    p.actor = resolveFromContext(ctx, "roles", _relations.actor) ?? null;
-  }
-  if (_relations.approver !== "") {
-    p.approver = resolveFromContext(ctx, "roles", _relations.approver) ?? null;
-  }
-  for (const id of _relations.records) {
-    const r = resolveFromContext(ctx, "regs", id);
-    if (r !== void 0) {
-      p.records.push(r);
     }
   }
-  for (const id of _relations.ref) {
-    const r = resolveFromContext(ctx, "references", id);
-    if (r !== void 0) {
-      p.ref.push(r);
+  return decl;
+}
+function dumpSeriesDecl(decl) {
+  let out = "series { ";
+  for (const a of decl.axes) {
+    out += "axis " + a.id + " { ";
+    if (a.unit) {
+      out += 'unit "' + escapeString(a.unit) + '" ';
+    }
+    if (a.type) {
+      out += "type " + a.type + " ";
+    }
+    if (a.role) {
+      out += "role " + a.role + " ";
     }
+    out += "} ";
   }
-  return p;
-};
-var dumpApproval = function(approval) {
-  let out = "approval " + approval.id + " {\n";
-  out += '  name "' + escapeString(approval.name) + '"\n';
-  if (approval.actor !== null) {
-    out += "  actor " + approval.actor.id + "\n";
+  out += "cell { ";
+  if (decl.cellSymbol) {
+    out += "symbol " + decl.cellSymbol + " ";
   }
-  out += "  modality " + approval.modality + "\n";
-  if (approval.approver !== null) {
-    out += "  approve_by " + approval.approver.id + "\n";
+  if (decl.cellUnit) {
+    out += 'unit "' + escapeString(decl.cellUnit) + '" ';
   }
-  if (approval.records.length > 0) {
-    out += "  approval_record {\n";
-    for (const dr of approval.records) {
-      out += "    " + dr.id + "\n";
+  out += "} }";
+  return out;
+}
+
+// src/ser-des/config/ref.ts
+function parseRef(t, i, stripWrapping2, unwrapBlock2) {
+  const predicate = stripWrapping2(t[i++] ?? "");
+  const target = stripWrapping2(t[i++] ?? "");
+  const ref = { predicate, target };
+  if (i < t.length && t[i].startsWith("{")) {
+    const block = unwrapBlock2(t[i++]);
+    const m = /note\s+"([^"]*)"/.exec(block) ?? /note\s+(\S+)/.exec(block);
+    if (m) {
+      ref.note = m[1];
     }
-    out += "  }\n";
   }
-  if (approval.ref.length > 0) {
-    out += "  reference {\n";
-    for (const r of approval.ref) {
-      out += "    " + r.id + "\n";
-    }
-    out += "  }\n";
+  return { ref, next: i };
+}
+function parseRefFromReaders(value, peek, stripWrapping2, unwrapBlock2) {
+  const parts = [value(), value()];
+  const next = peek();
+  if (next && next.startsWith("{")) {
+    parts.push(value());
+  }
+  return parseRef(parts, 0, stripWrapping2, unwrapBlock2).ref;
+}
+function dumpRefs(refs, indent, escapeString2) {
+  if (!refs || refs.length === 0) {
+    return "";
+  }
+  let out = "";
+  for (const r of refs) {
+    out += `${indent}ref ${r.predicate} "${escapeString2(r.target)}"`;
+    out += r.note ? ` {
+${indent}  note "${escapeString2(r.note)}"
+${indent}}
+` : "\n";
   }
-  out += "}\n";
   return out;
-};
-
-// src/ser-des/config/data.ts
-var parseEnum = (id, data) => {
-  const result = {
-    id,
-    values: []
-  };
-  forEachEntry(
-    data,
-    (_vid, value) => {
-      result.values.push(parseEnumValue(_vid, value()));
-      return true;
-    },
-    { construct: "enum", id }
-  );
-  return (ctx) => {
-    ctx.enums[id] = result;
-    return ctx;
-  };
-};
-var parseEnumValue = (id, data) => {
-  const ev = {
-    id,
-    value: ""
-  };
-  forEachEntry(
-    data,
-    (command, value) => {
-      if (command === "definition") {
-        ev.value = unwrapped(value);
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "enum value", id }
-  );
-  return ev;
-};
-var parseRegistry = function(id, data) {
-  const result = {
-    id,
-    title: "",
-    data: null,
-    _relations: {
-      data: ""
+}
+function refTargetToSourceRef(target) {
+  const m = /^(urn:[^#]+)(?:#(.+))?$/.exec(target);
+  if (!m) {
+    return null;
+  }
+  const anchor = m[2];
+  if (!anchor) {
+    return { doc: target, clause: "" };
+  }
+  if (anchor.startsWith("clause-")) {
+    const rest = anchor.slice("clause-".length);
+    const slash = rest.indexOf("/");
+    if (slash >= 0) {
+      return {
+        doc: m[1],
+        clause: rest.slice(0, slash),
+        fragment: rest.slice(slash + 1)
+      };
     }
-  };
-  forEachEntry(
-    data,
-    (command, value) => {
-      if (command === "title") {
-        result.title = unwrapped(value);
-      } else if (command === "data_class") {
-        result._relations.data = value();
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "registry", id }
-  );
-  return (ctx) => {
-    ctx.regs[id] = result;
-    return ctx;
-  };
-};
-var parseDataClass = function(id, data) {
-  const result = {
-    id,
-    attributes: []
-  };
-  forEachAttribute(
-    data,
-    (basic, details) => {
-      if (basic.startsWith("ref ")) {
-        const m = basic.match(/^ref\s+(\S+)\s+"([^"]*)"$/);
-        if (m) {
-          const ref = { predicate: m[1], target: m[2] };
-          if (details) {
-            const noteMatch = /note\s+"([^"]*)"/.exec(details) ?? /note\s+(\S+)/.exec(details);
-            if (noteMatch) {
-              ref.note = noteMatch[1];
-            }
-          }
-          result.ref ??= [];
-          result.ref.push(ref);
-          return;
-        }
-      }
-      const head = basic.trim();
-      if (head === "store") {
-        result.store = details.trim();
-        return;
-      }
-      if (head === "description") {
-        result.description = stripWrapping(details.trim());
-        return;
-      }
-      if (head === "indexes") {
-        result.indexes = details.split(/\s+/).filter((x) => x.length > 0);
-        return;
-      }
-      if (head === "helper") {
-        result.helper = details.trim() === "true";
-        return;
-      }
-      if (head === "extends") {
-        result.extends = details.trim();
-        return;
-      }
-      result.attributes.push(parseDataAttribute(head, details));
-    },
-    { construct: "class", id }
-  );
-  return (ctx) => {
-    ctx.dataclasses[id] = result;
-    return ctx;
-  };
-};
-var parseDataAttribute = (basic, details) => {
-  const result = {
-    id: "",
-    type: "",
-    modality: "",
-    cardinality: "",
-    definition: "",
-    ref: [],
-    satisfy: [],
-    _relations: {
-      ref: []
-    }
-  };
-  const cardMatch = basic.match(/^(.*?)\s*\[([\d*][^\]]*)\]\s*$/);
-  if (cardMatch) {
-    result.cardinality = cardMatch[2].trim();
-    basic = cardMatch[1];
-  }
-  const colonIndex = basic.indexOf(":");
-  if (colonIndex !== -1) {
-    result.type = basic.substr(colonIndex + 1, basic.length - colonIndex - 1).trim();
-    basic = basic.substr(0, colonIndex);
+    return { doc: m[1], clause: rest };
   }
-  result.id = basic.trim();
-  forEachEntry(
-    details,
-    (keyword, value) => {
-      if (keyword === "modality") {
-        result.modality = value();
-      } else if (keyword === "definition") {
-        result.definition = unwrapped(value);
-      } else if (keyword === "reference") {
-        result._relations.ref = tokenizePackage(value());
-      } else if (keyword === "satisfy") {
-        result.satisfy = tokenizePackage(value());
-      } else if (keyword === "on_delete") {
-        result.onDelete = value();
-      } else if (keyword === "deprecated") {
-        result.deprecated = value() === "true";
-      } else if (keyword === "enum_values") {
-        result.enumValues = tokenizePackage(value());
-      } else if (keyword === "required") {
-        result.required = value() === "true";
-      } else if (keyword === "unit") {
-        result.unit = unwrapped(value);
-      } else if (keyword === "default") {
-        result.defaultValue = unwrapped(value);
-      } else {
-        return false;
-      }
+  return { doc: target, clause: "" };
+}
+function foldRefIntoLegacy(el, ref) {
+  if (ref.predicate === "derives-from") {
+    const roleChannel = el.fieldReferences ?? el.formReferences;
+    const hasProvenanceSlot = "source" in el || "sourceRef" in el || el.sourceRefs !== void 0;
+    if (roleChannel && !hasProvenanceSlot) {
+      roleChannel.push({ urn: ref.target, role: "source" });
       return true;
-    },
-    { construct: "data attribute", id: result.id }
-  );
-  return result;
-};
-var resolveDataClass = function(ctx, unresolved) {
-  const attributes = unresolved.attributes.map((attr) => {
-    const resolved = { ...attr, ref: [] };
-    for (const id of attr._relations.ref) {
-      const r = resolveFromContext(ctx, "references", id);
-      if (r !== void 0) {
-        resolved.ref.push(r);
-      }
     }
-    return resolved;
-  });
-  return {
-    id: unresolved.id,
-    attributes,
-    ...unresolved.store !== void 0 ? { store: unresolved.store } : {},
-    ...unresolved.indexes !== void 0 ? { indexes: unresolved.indexes } : {},
-    ...unresolved.helper !== void 0 ? { helper: unresolved.helper } : {},
-    ...unresolved.extends !== void 0 ? { extends: unresolved.extends } : {},
-    ...unresolved.description !== void 0 ? { description: unresolved.description } : {},
-    ...unresolved.ref !== void 0 ? { ref: unresolved.ref } : {}
-  };
-};
-var resolveRegistry = function(ctx, unresolved) {
-  const { _relations, ...rest } = unresolved;
-  const p = { ...rest, data: null };
-  if (_relations.data !== "") {
-    const dc = resolveFromContext(
-      ctx,
-      "dataclasses",
-      _relations.data
-    );
-    if (dc !== void 0) {
-      p.data = dc;
+    const b = refTargetToSourceRef(ref.target);
+    if (!b) {
+      return false;
     }
+    (el.sourceRefs ??= []).push(b);
+    if ("source" in el && !el.source) {
+      el.source = b;
+    }
+    if ("sourceRef" in el && !el.sourceRef) {
+      el.sourceRef = b;
+    }
+    if ("reference" in el && !el.reference) {
+      el.reference = b.doc;
+    }
+    return true;
   }
-  return p;
-};
-var dumpDataClass = function(dataclass) {
-  let out = "class " + dataclass.id + " {\n";
-  if (dataclass.store) {
-    out += "  store { " + dataclass.store + " }\n";
-  }
-  if (dataclass.description) {
-    out += '  description { "' + escapeString(dataclass.description) + '" }\n';
-  }
-  if (dataclass.indexes && dataclass.indexes.length > 0) {
-    out += "  indexes { " + dataclass.indexes.join(" ") + " }\n";
-  }
-  if (dataclass.helper !== void 0) {
-    out += "  helper { " + dataclass.helper + " }\n";
-  }
-  if (dataclass.extends) {
-    out += "  extends { " + dataclass.extends + " }\n";
+  if (ref.predicate === "cites") {
+    if (el.fieldReferences) {
+      el.fieldReferences.push({ urn: ref.target, role: "reference" });
+    } else if (el.formReferences) {
+      el.formReferences.push({ urn: ref.target, role: "reference" });
+    } else if (el.referenceIds) {
+      el.referenceIds.push(ref.target);
+    }
+    return true;
   }
-  if (dataclass.ref && dataclass.ref.length > 0) {
-    for (const r of dataclass.ref) {
-      out += "  ref " + r.predicate + ' "' + escapeString(r.target) + '"';
-      if (r.note) {
-        out += ' { note "' + escapeString(r.note) + '" }';
-      }
-      out += "\n";
+  const CITATION_ROLES = [
+    "requirement",
+    "test-procedure",
+    "calculation",
+    "report-format",
+    "method"
+  ];
+  if (CITATION_ROLES.includes(ref.predicate)) {
+    const channel = el.fieldReferences ?? el.formReferences;
+    if (!channel) {
+      return false;
     }
+    channel.push({ urn: ref.target, role: ref.predicate });
+    return true;
   }
-  for (const a of dataclass.attributes) {
-    out += toDataAttributeModel(a);
+  return false;
+}
+function dumpSourceRefAsRef(src, indent, escapeString2) {
+  if (src.doc && src.doc.startsWith("urn:")) {
+    const anchor = `${src.doc}${src.clause ? "#clause-" + src.clause : ""}${src.fragment ? "/" + src.fragment : ""}`;
+    return `${indent}ref derives-from "${escapeString2(anchor)}"
+`;
   }
-  out += "}\n";
-  return out;
-};
-var toDataAttributeModel = (attribute) => {
-  let out = "  " + attribute.id;
-  if (attribute.type !== "") {
-    out += ": " + attribute.type;
+  return `${indent}source { doc "${escapeString2(src.doc ?? "")}" clause "${escapeString2(String(src.clause ?? ""))}"` + (src.fragment ? ` fragment "${escapeString2(src.fragment)}"` : "") + " }\n";
+}
+
+// src/ser-des/config/correspondence.ts
+function parseCorresponds(t, i, stripWrapping2) {
+  if (t[i] === void 0) {
+    throw new Error(
+      "Parsing error: corresponds: Expecting value for corresponds (the scheme and the concept)"
+    );
   }
-  if (attribute.cardinality !== "") {
-    out += "[" + attribute.cardinality + "]";
+  const scheme = stripWrapping2(t[i++]);
+  if (t[i] === void 0) {
+    throw new Error(
+      "Parsing error: corresponds: Expecting value for corresponds (the concept)"
+    );
   }
-  out += " {\n";
-  out += '    definition "' + escapeString(attribute.definition) + '"\n';
-  if (attribute.modality !== "") {
-    out += "    modality " + attribute.modality + "\n";
-  }
-  if (attribute.onDelete) {
-    out += "    on_delete " + attribute.onDelete + "\n";
-  }
-  if (attribute.deprecated) {
-    out += "    deprecated true\n";
-  }
-  if (attribute.enumValues && attribute.enumValues.length > 0) {
-    out += "    enum_values { " + attribute.enumValues.join(" ") + " }\n";
-  }
-  if (attribute.required !== void 0) {
-    out += "    required " + (attribute.required ? "true" : "false") + "\n";
-  }
-  if (attribute.unit) {
-    out += '    unit "' + escapeString(attribute.unit) + '"\n';
+  const corr = {
+    scheme,
+    concept: stripWrapping2(t[i++]),
+    projections: []
+  };
+  if (i < t.length && t[i].startsWith("{")) {
+    const block = unwrapBlock(t[i++]);
+    forEachEntry(
+      block,
+      (keyword, value, peek) => {
+        if (keyword === "projection") {
+          const codec = stripWrapping2(value());
+          const entries = [];
+          const next = peek();
+          if (next && next.startsWith("{")) {
+            forEachEntry(
+              unwrapBlock(value()),
+              (k, kv) => {
+                entries.push({ key: k, value: stripWrapping2(kv()) });
+                return true;
+              },
+              { construct: "corresponds.projection", id: codec }
+            );
+          }
+          corr.projections.push({ codec, entries });
+          return true;
+        }
+        return false;
+      },
+      { construct: "corresponds", id: corr.scheme }
+    );
   }
-  if (attribute.defaultValue !== void 0) {
-    out += '    default "' + escapeString(attribute.defaultValue) + '"\n';
+  return { corr, next: i };
+}
+function parseCorrespondsFromReaders(value, peek, stripWrapping2) {
+  const parts = [value(), value()];
+  const next = peek();
+  if (next && next.startsWith("{")) {
+    parts.push(value());
   }
-  if (attribute.satisfy.length > 0) {
-    out += "    satisfy {\n";
-    for (const s of attribute.satisfy) {
-      out += "      " + s + "\n";
-    }
-    out += "    }\n";
+  return parseCorresponds(parts, 0, stripWrapping2).corr;
+}
+function dumpCorrespondences(corrs, indent, escapeString2, dumpBareSafe2) {
+  if (!corrs || corrs.length === 0) {
+    return "";
   }
-  if (attribute.ref.length > 0) {
-    out += "    reference {\n";
-    for (const r of attribute.ref) {
-      out += "      " + r.id + "\n";
+  let out = "";
+  for (const c of corrs) {
+    out += `${indent}corresponds ${dumpBareSafe2(c.scheme)} "${escapeString2(c.concept)}"`;
+    if (c.projections.length === 0) {
+      out += "\n";
+      continue;
     }
-    out += "    }\n";
-  }
-  out += "  }\n";
-  return out;
-};
-var dumpEnumValue = (ev) => {
-  let out = "  " + ev.id + " {\n";
-  out += '    definition "' + escapeString(ev.value) + '"\n';
-  out += "  }\n";
-  return out;
-};
-var dumpEnum = function(en) {
-  let out = "enum " + en.id + " {\n";
-  for (const v of en.values) {
-    out += dumpEnumValue(v);
-  }
-  out += "}\n";
-  return out;
-};
-var dumpRegistry = function(reg) {
-  let out = "data_registry " + reg.id + " {\n";
-  out += '  title "' + escapeString(reg.title) + '"\n';
-  if (reg.data !== null) {
-    out += "  data_class " + reg.data.id + "\n";
-  }
-  out += "}\n";
-  return out;
-};
-var parseVariable = function(id, data) {
-  const result = {
-    id,
-    type: "",
-    definition: "",
-    description: ""
-  };
-  forEachEntry(
-    data,
-    (keyword, value) => {
-      if (keyword === "type") {
-        result.type = value();
-      } else if (keyword === "definition") {
-        result.definition = unwrapped(value);
-      } else if (keyword === "description") {
-        result.description = unwrapped(value);
-      } else {
-        return false;
+    out += " {\n";
+    for (const p of c.projections) {
+      out += `${indent}  projection ${dumpBareSafe2(p.codec)} {`;
+      for (const e of p.entries) {
+        out += ` ${dumpBareSafe2(e.key)} ${dumpBareSafe2(e.value)}`;
       }
-      return true;
-    },
-    { construct: "variable", id }
-  );
-  return (ctx) => {
-    ctx.variables[id] = result;
-    return ctx;
-  };
-};
-var dumpVariable = function(v) {
-  let out = "variable " + v.id + " {\n";
-  if (v.type !== "") {
-    out += "  type " + v.type + "\n";
-  }
-  if (v.definition !== "") {
-    out += '  definition "' + escapeString(v.definition) + '"\n';
-  }
-  if (v.description !== "") {
-    out += '  description "' + escapeString(v.description) + '"\n';
+      out += " }\n";
+    }
+    out += `${indent}}
+`;
   }
-  out += "}\n";
   return out;
-};
+}
 
-// src/ser-des/config/event.ts
-var parseEndEvent = function(id, data) {
-  const result = {
-    id,
-    eventType: "end"
+// src/ser-des/config/sourceDiscrepancy.ts
+var VALID_RESOLUTIONS = ["follows_clause_x", "annotated_only"];
+function parseSourceDiscrepancy(block) {
+  const sd = {
+    summary: "",
+    sources: [],
+    resolution: "",
+    rationale: ""
   };
-  if (data !== "") {
-    const t = tokenizePackage(data);
-    if (t.length > 0) {
-      throw new Error(
-        `Parsing error: end_event. ID ${id}: Expecting empty body`
-      );
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i >= t.length) {
+      break;
     }
-  }
-  return (ctx) => {
-    ctx.events[id] = result;
-    return ctx;
-  };
-};
-var parseSignalCatchEvent = function(id, data) {
-  const result = {
-    id,
-    eventType: "signalcatch",
-    signal: ""
-  };
-  if (data !== "") {
-    const t = tokenizePackage(data);
-    let i = 0;
-    while (i < t.length) {
-      const command = t[i++];
-      if (i < t.length) {
-        if (command === "catch") {
-          result.signal = unwrapBlock(t[i++]);
-        } else {
-          i++;
-        }
-      } else {
+    if (cmd === "summary") {
+      sd.summary = stripWrapping(t[i++]);
+    } else if (cmd === "sources") {
+      sd.sources = tokenize(stripWrapping(t[i++])).map(stripWrapping).filter((s) => s.length > 0);
+    } else if (cmd === "resolution") {
+      const r = stripWrapping(t[i++]);
+      if (!VALID_RESOLUTIONS.includes(r)) {
         throw new Error(
-          `Parsing error: Signal Catch Event. ID ${id}: Expecting value for ${command}`
+          `Parsing error: source_discrepancy: Unknown resolution ${r} (valid: ${VALID_RESOLUTIONS.join(
+            ", "
+          )})`
         );
       }
+      sd.resolution = r;
+    } else if (cmd === "rationale") {
+      sd.rationale = stripWrapping(t[i++]);
+    } else {
+      unwrapBlock(t[i++]);
     }
   }
-  return (ctx) => {
-    ctx.events[id] = result;
-    return ctx;
-  };
-};
-var parseStartEvent = function(id, data) {
-  const result = {
-    id,
-    eventType: "start"
-  };
-  if (data !== "") {
-    const t = tokenizePackage(data);
-    if (t.length > 0) {
-      throw new Error(
-        `Parsing error: end_event. ID ${id}: Expecting empty body`
-      );
-    }
+  return sd;
+}
+function dumpSourceDiscrepancy(sd, indent) {
+  let out = indent + "source_discrepancy { ";
+  out += 'summary "' + escapeString(sd.summary) + '" ';
+  out += "sources { " + sd.sources.map((s) => '"' + escapeString(s) + '"').join(" ") + " } ";
+  out += "resolution " + sd.resolution + " ";
+  out += 'rationale "' + escapeString(sd.rationale) + '" ';
+  out += "}";
+  return out;
+}
+
+// src/ser-des/config/field-parser.ts
+function readValueToken(t, i) {
+  const tok = t[i] ?? "";
+  if (!tok.startsWith("ocl{")) {
+    return { text: tok, next: i + 1 };
   }
-  return (ctx) => {
-    ctx.events[id] = result;
-    return ctx;
-  };
-};
-var parseTimerEvent = function(id, data) {
-  const result = {
-    id,
-    eventType: "timer",
-    type: "",
-    para: ""
-  };
-  if (data !== "") {
-    const t = tokenizePackage(data);
-    let i = 0;
-    while (i < t.length) {
-      const command = t[i++];
-      if (i < t.length) {
-        if (command === "type") {
-          result.type = t[i++];
-        } else if (command === "para") {
-          result.para = unwrapBlock(t[i++]);
-        } else {
-          i++;
+  const delta = (s) => (s.match(/\{/g) || []).length - (s.match(/\}/g) || []).length;
+  let text = tok;
+  let depth = delta(tok);
+  let j = i + 1;
+  while (depth > 0 && j < t.length) {
+    const nt = t[j++];
+    depth += delta(nt);
+    text += " " + nt;
+  }
+  return { text, next: j };
+}
+function parseValueEntries(raw) {
+  const inner = raw.trim().replace(/^[[{]/, "").replace(/[\]}]$/, "");
+  const t = tokenizePackage(inner);
+  const out = [];
+  let i = 0;
+  while (i < t.length) {
+    const entry = stripWrapping(t[i++].replace(/,$/, ""));
+    if (!entry) {
+      continue;
+    }
+    if (i < t.length && t[i].startsWith("{")) {
+      const lb = tokenizePackage(unwrapBlock(t[i++]));
+      let label = "";
+      for (let k = 0; k + 1 < lb.length; k += 2) {
+        if (lb[k] === "label") {
+          label = stripWrapping(lb[k + 1]);
         }
-      } else {
-        throw new Error(
-          `Parsing error: Timer Event. ID ${id}: Expecting value for ${command}`
-        );
       }
+      out.push({ value: entry, label });
+    } else {
+      out.push(entry);
     }
   }
-  return (ctx) => {
-    ctx.events[id] = result;
-    return ctx;
-  };
-};
-var dumpEvent = function(event) {
-  if (event.eventType === "start") {
-    return dumpStartEvent(event);
-  }
-  if (event.eventType === "end") {
-    return dumpEndEvent(event);
-  }
-  if (event.eventType === "signalcatch") {
-    return dumpSignalCatchEvent(event);
-  }
-  if (event.eventType === "timer") {
-    return dumpTimerEvent(event);
-  }
-  return "";
-};
-function dumpEndEvent(end) {
-  return "end_event " + end.id + " {\n}\n";
+  return out;
 }
-function dumpSignalCatchEvent(sc) {
-  let out = "signal_catch_event " + sc.id + " {\n";
-  if (sc.signal !== "") {
-    out += '  catch "' + escapeString(sc.signal) + '"\n';
+function dumpValueEntry(e) {
+  if (typeof e === "string") {
+    return e;
   }
-  out += "}\n";
-  return out;
+  return e.value + ' { label "' + escapeString(e.label) + '" }';
 }
-function dumpStartEvent(s) {
-  return "start_event " + s.id + " {\n}\n";
+function dumpBareSafe(v) {
+  return /[\s{}"]/.test(v) || v.endsWith(":") || v.startsWith("#") || v.startsWith("//") ? '"' + escapeString(v) + '"' : v;
 }
-function dumpTimerEvent(te) {
-  let out = "timer_event " + te.id + " {\n";
-  if (te.type !== "") {
-    out += "  type " + te.type + "\n";
+function stripColon(x) {
+  return x.endsWith(":") ? x.slice(0, -1) : x;
+}
+function readBalanced(t, i) {
+  const first = t[i] ?? "";
+  if (!first.startsWith("[")) {
+    return { text: first, next: i + 1 };
   }
-  if (te.para !== "") {
-    out += '  para "' + escapeString(te.para) + '"\n';
+  let text = first;
+  let j = i + 1;
+  while (!text.includes("]") && j < t.length) {
+    text += " " + t[j++];
   }
-  out += "}\n";
-  return out;
+  return { text, next: j };
 }
-
-// src/ser-des/config/gateway.ts
-var parseExclusiveGate = function(id, data) {
-  const gateway = {
-    id,
-    gatewayType: "exclusive_gateway",
-    label: ""
-  };
-  forEachEntry(
-    data,
-    (command, value) => {
-      if (command === "label") {
-        gateway.label = unwrapped(value);
-      } else {
-        return false;
-      }
-      return true;
-    },
-    { construct: "Exclusive gateway", id }
-  );
-  return (ctx) => {
-    ctx.gateways[id] = gateway;
-    return ctx;
-  };
-};
-var dumpGateway = function(gate) {
-  if (gate.gatewayType === "exclusive_gateway") {
-    return dumpEGate(gate);
-  }
-  return "";
-};
-function dumpEGate(egate) {
-  let out = "exclusive_gateway " + egate.id + " {\n";
-  if (egate.label !== "") {
-    out += '  label "' + escapeString(egate.label) + '"\n';
+function subBlockTokens(block) {
+  return tokenizePackage(block).map((s) => s.replace(/^;+|;+$/g, "")).filter((s) => s.length > 0);
+}
+function readEntryTokens(value) {
+  if (value.startsWith("{")) {
+    return subBlockTokens(unwrapBlock(value)).flatMap((s) => s.split(",")).map((s) => stripWrapping(s.trim())).filter((s) => s.length > 0);
   }
-  out += "}\n";
-  return out;
+  const single = stripWrapping(value);
+  return single === "" ? [] : [single];
 }
-
-// src/ser-des/config/metadata.ts
-var parseMetadata = function(token) {
-  const metadata = {
-    schema: "",
-    author: "",
-    title: "",
-    edition: "",
-    namespace: "",
-    shortname: ""
-  };
-  if (token !== "") {
-    const t = tokenizePackage(token);
-    let i = 0;
-    while (i < t.length) {
-      const keyword = t[i++];
-      if (i < t.length) {
-        if (keyword === "title") {
-          metadata.title = stripWrapping(t[i++]);
-        } else if (keyword === "schema") {
-          metadata.schema = stripWrapping(t[i++]);
-        } else if (keyword === "edition") {
-          metadata.edition = stripWrapping(t[i++]);
-        } else if (keyword === "author") {
-          metadata.author = stripWrapping(t[i++]);
-        } else if (keyword === "namespace") {
-          metadata.namespace = stripWrapping(t[i++]);
-        } else if (keyword === "shortname") {
-          metadata.shortname = stripWrapping(t[i++]);
-        } else {
-          throw new Error(
-            "Parsing error: metadata. Unknown keyword " + keyword
-          );
-        }
-      } else {
-        throw new Error(
-          "Parsing error: metadata. Expecting value for " + keyword
-        );
-      }
+function readSource(block) {
+  const src = { doc: "", clause: "" };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i >= t.length) {
+      break;
     }
-  }
-  return (ctx) => {
-    ctx.metadata = metadata;
-    return ctx;
-  };
-};
-
-// src/ser-des/config/ref.ts
-function parseRef(t, i, stripWrapping2, unwrapBlock2) {
-  const predicate = stripWrapping2(t[i++] ?? "");
-  const target = stripWrapping2(t[i++] ?? "");
-  const ref = { predicate, target };
-  if (i < t.length && t[i].startsWith("{")) {
-    const block = unwrapBlock2(t[i++]);
-    const m = /note\s+"([^"]*)"/.exec(block) ?? /note\s+(\S+)/.exec(block);
-    if (m) {
-      ref.note = m[1];
+    if (cmd === "doc") {
+      src.doc = stripWrapping(t[i++]);
+    } else if (cmd === "clause") {
+      src.clause = stripWrapping(t[i++]);
+    } else if (cmd === "fragment") {
+      src.fragment = stripWrapping(t[i++]);
+    } else {
+      unwrapBlock(t[i++]);
     }
   }
-  return { ref, next: i };
+  return src;
 }
-function parseRefFromReaders(value, peek, stripWrapping2, unwrapBlock2) {
-  const parts = [value(), value()];
-  const next = peek();
-  if (next && next.startsWith("{")) {
-    parts.push(value());
+function readFieldHead(t, i) {
+  const name = t[i++];
+  if (name === void 0) {
+    return null;
   }
-  return parseRef(parts, 0, stripWrapping2, unwrapBlock2).ref;
-}
-function dumpRefs(refs, indent, escapeString2) {
-  if (!refs || refs.length === 0) {
-    return "";
+  let type = "";
+  if (t[i] === ":") {
+    i++;
+    type = t[i++] ?? "";
+    if (t[i] && t[i].startsWith("[") && t[i].endsWith("]")) {
+      i++;
+    }
   }
-  let out = "";
-  for (const r of refs) {
-    out += `${indent}ref ${r.predicate} "${escapeString2(r.target)}"`;
-    out += r.note ? ` {
-${indent}  note "${escapeString2(r.note)}"
-${indent}}
-` : "\n";
-  }
-  return out;
-}
-function refTargetToSourceRef(target) {
-  const m = /^(urn:[^#]+)(?:#(.+))?$/.exec(target);
-  if (!m) {
+  const blockToken = t[i++];
+  if (blockToken === void 0 || !blockToken.startsWith("{")) {
     return null;
   }
-  const anchor = m[2];
-  if (!anchor) {
-    return { doc: target, clause: "" };
+  return { name, type, block: unwrapBlock(blockToken), next: i };
+}
+function parseFormField(name, block, type) {
+  const field = {
+    name,
+    type: type || "string",
+    typeDeclared: !!type,
+    label: "",
+    definition: "",
+    unit: "",
+    symbol: "",
+    verdict: "",
+    targets: [],
+    dimension: "",
+    enumRef: "",
+    pattern: "",
+    required: false,
+    requiredWhen: "",
+    refs: [],
+    measurementMethod: "",
+    calculationId: null,
+    calculationBindings: [],
+    derivation: "",
+    evaluation: null,
+    values: [],
+    trueLabel: "",
+    falseLabel: "",
+    enumValues: [],
+    defaultValue: "",
+    hasDefault: false,
+    referenceIds: [],
+    fieldReferences: [],
+    specificationReference: "",
+    applicability: [],
+    sourceDiscrepancy: null,
+    fields: [],
+    itemsType: "",
+    subformRef: null
+  };
+  if (!block || !block.trim()) {
+    return field;
   }
-  if (anchor.startsWith("clause-")) {
-    const rest = anchor.slice("clause-".length);
-    const slash = rest.indexOf("/");
-    if (slash >= 0) {
-      return {
-        doc: m[1],
-        clause: rest.slice(0, slash),
-        fragment: rest.slice(slash + 1)
-      };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i >= t.length) {
+      break;
+    }
+    if (cmd === "label") {
+      field.label = stripWrapping(t[i++]);
+    } else if (cmd === "definition") {
+      field.definition = stripWrapping(t[i++]);
+    } else if (cmd === "description") {
+      field.description = stripWrapping(t[i++]);
+    } else if (cmd === "type") {
+      field.type = stripWrapping(t[i++]);
+      field.typeDeclared = true;
+    } else if (cmd === "unit") {
+      field.unit = stripWrapping(t[i++]);
+    } else if (cmd === "symbol") {
+      field.symbol = stripWrapping(t[i++]);
+    } else if (cmd === "verdict") {
+      field.verdict = stripWrapping(t[i++]);
+    } else if (cmd === "targets") {
+      field.targets = tokenizePackage(t[i++]).map(stripWrapping);
+    } else if (cmd === "dimension") {
+      field.dimension = stripWrapping(t[i++]);
+    } else if (cmd === "enum") {
+      field.enumRef = stripWrapping(t[i++]);
+    } else if (cmd === "pattern") {
+      field.pattern = stripWrapping(t[i++]);
+    } else if (cmd === "scope") {
+      field.scope = stripWrapping(t[i++]);
+    } else if (cmd === "examples") {
+      field.examples = stripWrapping(t[i++]);
+    } else if (cmd === "bind") {
+      field.bind = stripWrapping(t[i++]);
+    } else if (cmd === "required") {
+      field.required = stripWrapping(t[i++]) === "true";
+    } else if (cmd === "required_when") {
+      const read = readValueToken(t, i);
+      field.requiredWhen = stripWrapping(read.text);
+      i = read.next;
+    } else if (cmd === "measurement_method") {
+      field.measurementMethod = stripWrapping(t[i++]);
+    } else if (cmd === "calculation") {
+      const read = readValueToken(t, i);
+      field.calculationId = stripWrapping(read.text);
+      i = read.next;
+    } else if (cmd === "calculation_bindings") {
+      field.calculationBindings = parseCalculationBindings(unwrapBlock(t[i++]));
+    } else if (cmd === "derivation") {
+      field.derivation = stripWrapping(t[i++]);
+    } else if (cmd === "evaluation") {
+      field.evaluation = parseEvaluation(unwrapBlock(t[i++]));
+    } else if (cmd === "values") {
+      const read = readBalanced(t, i);
+      field.values = parseValueEntries(read.text);
+      i = read.next;
+    } else if (cmd === "default") {
+      field.defaultValue = stripWrapping(t[i++]);
+      field.hasDefault = true;
+    } else if (cmd === "true_label") {
+      field.trueLabel = stripWrapping(t[i++]);
+    } else if (cmd === "false_label") {
+      field.falseLabel = stripWrapping(t[i++]);
+    } else if (cmd === "enum_values") {
+      field.enumValues = parseValueEntries(t[i++]);
+    } else if (cmd === "min_items") {
+      const raw = stripWrapping(t[i++]);
+      const n = parseInt(raw, 10);
+      field.minItems = isNaN(n) ? raw : n;
+    } else if (cmd === "max_items") {
+      const raw = stripWrapping(t[i++]);
+      const n = parseInt(raw, 10);
+      field.maxItems = isNaN(n) ? raw : n;
+    } else if (cmd === "items") {
+      const iblock = unwrapBlock(t[i++]);
+      const it = tokenize(iblock);
+      const typeParts = [];
+      let k = 0;
+      while (k < it.length && it[k] !== "fields") {
+        if (it[k] === "unit" && k + 1 < it.length) {
+          field.itemsUnit = stripWrapping(it[k + 1]);
+          k += 2;
+        } else {
+          typeParts.push(it[k++]);
+        }
+      }
+      field.itemsType = typeParts.join(" ");
+      if (it[k] === "fields") {
+        k++;
+        if (k < it.length) {
+          field.fields = parseNestedFields(unwrapBlock(it[k]));
+        }
+      }
+    } else if (cmd === "series") {
+      field.series = parseSeriesDecl(unwrapBlock(t[i++]));
+    } else if (cmd === "fields") {
+      field.fields = parseNestedFields(unwrapBlock(t[i++]));
+    } else if (cmd === "subform_ref") {
+      const subformId = stripWrapping(t[i++]);
+      const refBlock = i < t.length ? unwrapBlock(t[i++]) : "";
+      field.subformRef = parseSubformRef(subformId, refBlock);
+      if (!field.type || field.type === "string") {
+        field.type = "array";
+      }
+    } else if (cmd === "reference") {
+      field.referenceIds = tokenizePackage(t[i++]).map(stripWrapping);
+    } else if (cmd === "references") {
+      field.fieldReferences = parseRoleReferences(unwrapBlock(t[i++]));
+    } else if (cmd === "ref") {
+      const r = parseRef(t, i, stripWrapping, unwrapBlock);
+      if (!foldRefIntoLegacy(field, r.ref)) {
+        field.refs.push(r.ref);
+      }
+      i = r.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (field.correspondences ??= []).push(cc.corr);
+      i = cc.next;
+    } else if (cmd === "specification_reference") {
+      field.specificationReference = stripWrapping(t[i++]);
+    } else if (cmd === "applicability") {
+      field.applicability = parseApplicability(unwrapBlock(t[i++]));
+    } else if (cmd === "source_discrepancy") {
+      field.sourceDiscrepancy = parseSourceDiscrepancy(unwrapBlock(t[i++]));
+    } else {
+      unwrapBlock(t[i++]);
     }
-    return { doc: m[1], clause: rest };
   }
-  return { doc: target, clause: "" };
+  return field;
 }
-function foldRefIntoLegacy(el, ref) {
-  if (ref.predicate === "derives-from") {
-    const roleChannel = el.fieldReferences ?? el.formReferences;
-    const hasProvenanceSlot = "source" in el || "sourceRef" in el || el.sourceRefs !== void 0;
-    if (roleChannel && !hasProvenanceSlot) {
-      roleChannel.push({ urn: ref.target, role: "source" });
-      return true;
+function parseCalculationBindings(block) {
+  const out = [];
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const key = stripColon(t[i++]);
+    if (i >= t.length) {
+      break;
     }
-    const b = refTargetToSourceRef(ref.target);
-    if (!b) {
-      return false;
+    if (t[i] === ":") {
+      i++;
     }
-    (el.sourceRefs ??= []).push(b);
-    if ("source" in el && !el.source) {
-      el.source = b;
+    if (i < t.length) {
+      out.push({ inputName: key, pathExpr: stripWrapping(t[i++]) });
     }
-    if ("sourceRef" in el && !el.sourceRef) {
-      el.sourceRef = b;
+  }
+  return out;
+}
+function parseEvaluation(block) {
+  const rule = { rule: "", condition: "", referenceId: null };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i >= t.length) {
+      break;
     }
-    if ("reference" in el && !el.reference) {
-      el.reference = b.doc;
+    if (cmd === "rule") {
+      rule.rule = stripWrapping(t[i++]);
+    } else if (cmd === "verdict") {
+      rule.verdict = stripWrapping(t[i++]);
+    } else if (cmd === "op") {
+      rule.op = stripWrapping(t[i++]);
+    } else if (cmd === "limit") {
+      rule.limit = stripWrapping(t[i++]);
+    } else if (cmd === "condition") {
+      rule.condition = stripWrapping(t[i++]);
+    } else if (cmd === "reference") {
+      const ids = tokenizePackage(t[i++]).map(stripWrapping);
+      rule.referenceId = ids[0] ?? null;
+    } else if (cmd === "specification_reference") {
+      rule.specificationReference = stripWrapping(t[i++]);
+    } else if (cmd === "source_discrepancy") {
+      rule.sourceDiscrepancy = parseSourceDiscrepancy(unwrapBlock(t[i++]));
+    } else {
+      unwrapBlock(t[i++]);
     }
-    return true;
   }
-  if (ref.predicate === "cites") {
-    if (el.fieldReferences) {
-      el.fieldReferences.push({ urn: ref.target, role: "reference" });
-    } else if (el.formReferences) {
-      el.formReferences.push({ urn: ref.target, role: "reference" });
-    } else if (el.referenceIds) {
-      el.referenceIds.push(ref.target);
-    }
-    return true;
-  }
-  const CITATION_ROLES = [
-    "requirement",
-    "test-procedure",
-    "calculation",
-    "report-format",
-    "method"
-  ];
-  if (CITATION_ROLES.includes(ref.predicate)) {
-    const channel = el.fieldReferences ?? el.formReferences;
-    if (!channel) {
-      return false;
-    }
-    channel.push({ urn: ref.target, role: ref.predicate });
-    return true;
-  }
-  return false;
-}
-function dumpSourceRefAsRef(src, indent, escapeString2) {
-  if (src.doc && src.doc.startsWith("urn:")) {
-    const anchor = `${src.doc}${src.clause ? "#clause-" + src.clause : ""}${src.fragment ? "/" + src.fragment : ""}`;
-    return `${indent}ref derives-from "${escapeString2(anchor)}"
-`;
-  }
-  return `${indent}source { doc "${escapeString2(src.doc ?? "")}" clause "${escapeString2(String(src.clause ?? ""))}"` + (src.fragment ? ` fragment "${escapeString2(src.fragment)}"` : "") + " }\n";
-}
-
-// src/ser-des/config/correspondence.ts
-function parseCorresponds(t, i, stripWrapping2) {
-  if (t[i] === void 0) {
-    throw new Error(
-      "Parsing error: corresponds: Expecting value for corresponds (the scheme and the concept)"
-    );
-  }
-  const scheme = stripWrapping2(t[i++]);
-  if (t[i] === void 0) {
-    throw new Error(
-      "Parsing error: corresponds: Expecting value for corresponds (the concept)"
-    );
-  }
-  const corr = {
-    scheme,
-    concept: stripWrapping2(t[i++]),
-    projections: []
-  };
-  if (i < t.length && t[i].startsWith("{")) {
-    const block = unwrapBlock(t[i++]);
-    forEachEntry(
-      block,
-      (keyword, value, peek) => {
-        if (keyword === "projection") {
-          const codec = stripWrapping2(value());
-          const entries = [];
-          const next = peek();
-          if (next && next.startsWith("{")) {
-            forEachEntry(
-              unwrapBlock(value()),
-              (k, kv) => {
-                entries.push({ key: k, value: stripWrapping2(kv()) });
-                return true;
-              },
-              { construct: "corresponds.projection", id: codec }
-            );
-          }
-          corr.projections.push({ codec, entries });
-          return true;
-        }
-        return false;
-      },
-      { construct: "corresponds", id: corr.scheme }
-    );
-  }
-  return { corr, next: i };
-}
-function parseCorrespondsFromReaders(value, peek, stripWrapping2) {
-  const parts = [value(), value()];
-  const next = peek();
-  if (next && next.startsWith("{")) {
-    parts.push(value());
-  }
-  return parseCorresponds(parts, 0, stripWrapping2).corr;
-}
-function dumpCorrespondences(corrs, indent, escapeString2, dumpBareSafe2) {
-  if (!corrs || corrs.length === 0) {
-    return "";
-  }
-  let out = "";
-  for (const c of corrs) {
-    out += `${indent}corresponds ${dumpBareSafe2(c.scheme)} "${escapeString2(c.concept)}"`;
-    if (c.projections.length === 0) {
-      out += "\n";
-      continue;
-    }
-    out += " {\n";
-    for (const p of c.projections) {
-      out += `${indent}  projection ${dumpBareSafe2(p.codec)} {`;
-      for (const e of p.entries) {
-        out += ` ${dumpBareSafe2(e.key)} ${dumpBareSafe2(e.value)}`;
-      }
-      out += " }\n";
-    }
-    out += `${indent}}
-`;
-  }
-  return out;
+  return rule;
 }
-
-// src/ser-des/config/series.ts
-function parseSeriesDecl(block) {
-  const decl = { axes: [], cellSymbol: "", cellUnit: "" };
+function parseNestedFields(block) {
+  const out = [];
   const t = tokenize(block);
   let i = 0;
   while (i < t.length) {
     const cmd = t[i++];
-    if (cmd !== "axis" && cmd !== "cell") {
+    if (cmd !== "field") {
       if (i < t.length) {
         unwrapBlock(t[i - 1]);
       }
       continue;
     }
-    if (cmd === "axis") {
-      const axis = {
-        id: stripWrapping(t[i++]),
-        unit: "",
-        type: "",
-        role: ""
-      };
-      if (i < t.length && t[i].startsWith("{")) {
-        const ablock = unwrapBlock(t[i++]);
-        const at = tokenize(ablock);
-        let j = 0;
-        while (j < at.length) {
-          const ac = at[j++];
-          if (j >= at.length) {
-            break;
-          }
-          if (ac === "unit") {
-            axis.unit = stripWrapping(at[j++]);
-          } else if (ac === "type") {
-            axis.type = stripWrapping(at[j++]);
-          } else if (ac === "role") {
-            axis.role = stripWrapping(at[j++]);
-          } else {
-            unwrapBlock(at[j++]);
-          }
-        }
-      }
-      decl.axes.push(axis);
-    } else {
-      const cblock = unwrapBlock(t[i++]);
-      const ct = tokenize(cblock);
-      let j = 0;
-      while (j < ct.length) {
-        const cc = ct[j++];
-        if (j >= ct.length) {
-          break;
-        }
-        if (cc === "symbol") {
-          decl.cellSymbol = stripWrapping(ct[j++]);
-        } else if (cc === "unit") {
-          decl.cellUnit = stripWrapping(ct[j++]);
-        } else {
-          unwrapBlock(ct[j++]);
-        }
-      }
-    }
-  }
-  return decl;
-}
-function dumpSeriesDecl(decl) {
-  let out = "series { ";
-  for (const a of decl.axes) {
-    out += "axis " + a.id + " { ";
-    if (a.unit) {
-      out += 'unit "' + escapeString(a.unit) + '" ';
-    }
-    if (a.type) {
-      out += "type " + a.type + " ";
-    }
-    if (a.role) {
-      out += "role " + a.role + " ";
+    const head = readFieldHead(t, i);
+    if (!head) {
+      break;
     }
-    out += "} ";
-  }
-  out += "cell { ";
-  if (decl.cellSymbol) {
-    out += "symbol " + decl.cellSymbol + " ";
-  }
-  if (decl.cellUnit) {
-    out += 'unit "' + escapeString(decl.cellUnit) + '" ';
+    out.push(parseFormField(head.name, head.block, head.type || void 0));
+    i = head.next;
   }
-  out += "} }";
   return out;
 }
-
-// src/ser-des/config/sourceDiscrepancy.ts
-var VALID_RESOLUTIONS = ["follows_clause_x", "annotated_only"];
-function parseSourceDiscrepancy(block) {
-  const sd = {
-    summary: "",
-    sources: [],
-    resolution: "",
-    rationale: ""
-  };
+function parseApplicability(block) {
+  const entries = [];
   const t = tokenize(block);
   let i = 0;
   while (i < t.length) {
-    const cmd = t[i++];
+    const dimension = stripColon(t[i++]);
     if (i >= t.length) {
       break;
     }
-    if (cmd === "summary") {
-      sd.summary = stripWrapping(t[i++]);
-    } else if (cmd === "sources") {
-      sd.sources = tokenize(stripWrapping(t[i++])).map(stripWrapping).filter((s) => s.length > 0);
-    } else if (cmd === "resolution") {
-      const r = stripWrapping(t[i++]);
-      if (!VALID_RESOLUTIONS.includes(r)) {
-        throw new Error(
-          `Parsing error: source_discrepancy: Unknown resolution ${r} (valid: ${VALID_RESOLUTIONS.join(
-            ", "
-          )})`
-        );
-      }
-      sd.resolution = r;
-    } else if (cmd === "rationale") {
-      sd.rationale = stripWrapping(t[i++]);
-    } else {
-      unwrapBlock(t[i++]);
+    if (t[i] === ":") {
+      i++;
+    }
+    if (i < t.length) {
+      const read = readBalanced(t, i);
+      i = read.next;
+      const trimmed = read.text.trim();
+      let entry;
+      if (trimmed.startsWith("[")) {
+        const inner = trimmed.slice(1, trimmed.lastIndexOf("]"));
+        const values = inner.split(/[,\s]+/).filter((s) => s.length > 0);
+        entry = { dimension, values, mapping: null, match: null };
+      } else if (trimmed.startsWith("{")) {
+        const inner = trimmed.slice(1, -1);
+        const mapping = {};
+        for (const pair of inner.split(/[,\n]+/).map((s) => s.trim()).filter((s) => s)) {
+          const m = pair.match(/^(\w+)\s*:\s*(.+)$/);
+          if (m) {
+            mapping[m[1]] = m[2].trim();
+          }
+        }
+        entry = { dimension, values: [], mapping, match: null };
+      } else {
+        entry = {
+          dimension,
+          values: [stripWrapping(trimmed)],
+          mapping: null,
+          match: null
+        };
+      }
+      if (!entry.mapping && t[i] === "match") {
+        i++;
+        const mode = stripWrapping(t[i++] ?? "");
+        if (mode !== "any" && mode !== "all" && mode !== "exact") {
+          throw new Error(
+            `Parsing error: applicability: Unknown match ${mode} (valid: any, all, exact)`
+          );
+        }
+        entry.match = mode;
+      }
+      entries.push(entry);
     }
   }
-  return sd;
-}
-function dumpSourceDiscrepancy(sd, indent) {
-  let out = indent + "source_discrepancy { ";
-  out += 'summary "' + escapeString(sd.summary) + '" ';
-  out += "sources { " + sd.sources.map((s) => '"' + escapeString(s) + '"').join(" ") + " } ";
-  out += "resolution " + sd.resolution + " ";
-  out += 'rationale "' + escapeString(sd.rationale) + '" ';
-  out += "}";
-  return out;
-}
-
-// src/ser-des/config/field-parser.ts
-function readValueToken(t, i) {
-  const tok = t[i] ?? "";
-  if (!tok.startsWith("ocl{")) {
-    return { text: tok, next: i + 1 };
-  }
-  const delta = (s) => (s.match(/\{/g) || []).length - (s.match(/\}/g) || []).length;
-  let text = tok;
-  let depth = delta(tok);
-  let j = i + 1;
-  while (depth > 0 && j < t.length) {
-    const nt = t[j++];
-    depth += delta(nt);
-    text += " " + nt;
-  }
-  return { text, next: j };
+  return entries;
 }
-function parseValueEntries(raw) {
-  const inner = raw.trim().replace(/^[[{]/, "").replace(/[\]}]$/, "");
-  const t = tokenizePackage(inner);
-  const out = [];
-  let i = 0;
-  while (i < t.length) {
-    const entry = stripWrapping(t[i++].replace(/,$/, ""));
-    if (!entry) {
-      continue;
-    }
-    if (i < t.length && t[i].startsWith("{")) {
-      const lb = tokenizePackage(unwrapBlock(t[i++]));
-      let label = "";
-      for (let k = 0; k + 1 < lb.length; k += 2) {
-        if (lb[k] === "label") {
-          label = stripWrapping(lb[k + 1]);
+function parseSubformRef(subformId, block) {
+  const ref = {
+    subformId: stripWrapping(subformId),
+    parameters: {},
+    applicability: []
+  };
+  if (block && block.trim()) {
+    const t = tokenize(block);
+    let i = 0;
+    while (i < t.length) {
+      const cmd = t[i++];
+      if (i < t.length) {
+        if (cmd === "parameters") {
+          const pblock = unwrapBlock(t[i++]);
+          const pt = tokenize(pblock);
+          let j = 0;
+          while (j < pt.length) {
+            const key = stripColon(pt[j++]);
+            if (j < pt.length) {
+              if (pt[j] === ":") {
+                j++;
+              }
+              if (j < pt.length) {
+                ref.parameters[key] = stripWrapping(pt[j++]);
+              }
+            }
+          }
+        } else if (cmd === "applicability") {
+          ref.applicability = parseApplicability(unwrapBlock(t[i++]));
+        } else {
+          unwrapBlock(t[i++]);
         }
       }
-      out.push({ value: entry, label });
-    } else {
-      out.push(entry);
     }
   }
-  return out;
+  return ref;
 }
-function dumpValueEntry(e) {
-  if (typeof e === "string") {
-    return e;
+function dumpFormField(field, indent) {
+  let out = "";
+  if (field.subformRef && !field.name) {
+    const sr = field.subformRef;
+    out += indent + "subform_ref " + sr.subformId + " { ";
+    const pkeys = Object.keys(sr.parameters);
+    if (pkeys.length > 0) {
+      out += "parameters { ";
+      for (const k of pkeys) {
+        out += k + ": " + sr.parameters[k] + " ";
+      }
+      out += "} ";
+    }
+    if (sr.applicability.length > 0) {
+      out += "applicability { " + dumpApplicabilityEntries(sr.applicability) + "} ";
+    }
+    out += "}\n";
+    return out;
   }
-  return e.value + ' { label "' + escapeString(e.label) + '" }';
-}
-function dumpBareSafe(v) {
-  return /[\s{}"]/.test(v) || v.endsWith(":") || v.startsWith("#") || v.startsWith("//") ? '"' + escapeString(v) + '"' : v;
-}
-function stripColon(x) {
-  return x.endsWith(":") ? x.slice(0, -1) : x;
-}
-function readBalanced(t, i) {
-  const first = t[i] ?? "";
-  if (!first.startsWith("[")) {
-    return { text: first, next: i + 1 };
+  const inner = [];
+  if (field.subformRef) {
+    const sr = field.subformRef;
+    let refLine = "subform_ref " + sr.subformId + " { ";
+    const pkeys = Object.keys(sr.parameters);
+    if (pkeys.length > 0) {
+      refLine += "parameters { ";
+      for (const k of pkeys) {
+        refLine += k + ": " + sr.parameters[k] + " ";
+      }
+      refLine += "} ";
+    }
+    if (sr.applicability.length > 0) {
+      refLine += "applicability { " + dumpApplicabilityEntries(sr.applicability) + "} ";
+    }
+    inner.push(refLine + "}");
   }
-  let text = first;
-  let j = i + 1;
-  while (!text.includes("]") && j < t.length) {
-    text += " " + t[j++];
+  if (field.label) {
+    inner.push('label "' + escapeString(field.label) + '"');
   }
-  return { text, next: j };
-}
-function subBlockTokens(block) {
-  return tokenizePackage(block).map((s) => s.replace(/^;+|;+$/g, "")).filter((s) => s.length > 0);
-}
-function readEntryTokens(value) {
-  if (value.startsWith("{")) {
-    return subBlockTokens(unwrapBlock(value)).flatMap((s) => s.split(",")).map((s) => stripWrapping(s.trim())).filter((s) => s.length > 0);
+  if (field.definition) {
+    inner.push('definition "' + escapeString(field.definition) + '"');
   }
-  const single = stripWrapping(value);
-  return single === "" ? [] : [single];
-}
-function readSource(block) {
-  const src = { doc: "", clause: "" };
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const cmd = t[i++];
-    if (i >= t.length) {
-      break;
-    }
-    if (cmd === "doc") {
-      src.doc = stripWrapping(t[i++]);
-    } else if (cmd === "clause") {
-      src.clause = stripWrapping(t[i++]);
-    } else if (cmd === "fragment") {
-      src.fragment = stripWrapping(t[i++]);
-    } else {
-      unwrapBlock(t[i++]);
-    }
+  if (field.description) {
+    inner.push('description "' + escapeString(field.description) + '"');
   }
-  return src;
-}
-function readFieldHead(t, i) {
-  const name = t[i++];
-  if (name === void 0) {
-    return null;
+  if (field.unit) {
+    inner.push('unit "' + escapeString(field.unit) + '"');
   }
-  let type = "";
-  if (t[i] === ":") {
-    i++;
-    type = t[i++] ?? "";
-    if (t[i] && t[i].startsWith("[") && t[i].endsWith("]")) {
-      i++;
-    }
+  if (field.symbol) {
+    inner.push("symbol " + field.symbol);
   }
-  const blockToken = t[i++];
-  if (blockToken === void 0 || !blockToken.startsWith("{")) {
-    return null;
+  if (field.verdict) {
+    inner.push("verdict " + field.verdict);
   }
-  return { name, type, block: unwrapBlock(blockToken), next: i };
-}
-function parseFormField(name, block, type) {
-  const field = {
-    name,
-    type: type || "string",
-    typeDeclared: !!type,
-    label: "",
-    definition: "",
-    unit: "",
-    symbol: "",
-    verdict: "",
-    targets: [],
-    dimension: "",
-    enumRef: "",
-    pattern: "",
-    required: false,
-    requiredWhen: "",
-    refs: [],
-    measurementMethod: "",
-    calculationId: null,
-    calculationBindings: [],
-    derivation: "",
-    evaluation: null,
-    values: [],
-    trueLabel: "",
-    falseLabel: "",
-    enumValues: [],
-    defaultValue: "",
-    hasDefault: false,
-    referenceIds: [],
-    fieldReferences: [],
-    specificationReference: "",
-    applicability: [],
-    sourceDiscrepancy: null,
-    fields: [],
-    itemsType: "",
-    subformRef: null
-  };
-  if (!block || !block.trim()) {
-    return field;
+  if (field.dimension) {
+    inner.push("dimension " + field.dimension);
   }
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const cmd = t[i++];
-    if (i >= t.length) {
-      break;
-    }
-    if (cmd === "label") {
-      field.label = stripWrapping(t[i++]);
-    } else if (cmd === "definition") {
-      field.definition = stripWrapping(t[i++]);
-    } else if (cmd === "description") {
-      field.description = stripWrapping(t[i++]);
-    } else if (cmd === "type") {
-      field.type = stripWrapping(t[i++]);
-      field.typeDeclared = true;
-    } else if (cmd === "unit") {
-      field.unit = stripWrapping(t[i++]);
-    } else if (cmd === "symbol") {
-      field.symbol = stripWrapping(t[i++]);
-    } else if (cmd === "verdict") {
-      field.verdict = stripWrapping(t[i++]);
-    } else if (cmd === "targets") {
-      field.targets = tokenizePackage(t[i++]).map(stripWrapping);
-    } else if (cmd === "dimension") {
-      field.dimension = stripWrapping(t[i++]);
-    } else if (cmd === "enum") {
-      field.enumRef = stripWrapping(t[i++]);
-    } else if (cmd === "pattern") {
-      field.pattern = stripWrapping(t[i++]);
-    } else if (cmd === "scope") {
-      field.scope = stripWrapping(t[i++]);
-    } else if (cmd === "examples") {
-      field.examples = stripWrapping(t[i++]);
-    } else if (cmd === "bind") {
-      field.bind = stripWrapping(t[i++]);
-    } else if (cmd === "required") {
-      field.required = stripWrapping(t[i++]) === "true";
-    } else if (cmd === "required_when") {
-      const read = readValueToken(t, i);
-      field.requiredWhen = stripWrapping(read.text);
-      i = read.next;
-    } else if (cmd === "measurement_method") {
-      field.measurementMethod = stripWrapping(t[i++]);
-    } else if (cmd === "calculation") {
-      const read = readValueToken(t, i);
-      field.calculationId = stripWrapping(read.text);
-      i = read.next;
-    } else if (cmd === "calculation_bindings") {
-      field.calculationBindings = parseCalculationBindings(unwrapBlock(t[i++]));
-    } else if (cmd === "derivation") {
-      field.derivation = stripWrapping(t[i++]);
-    } else if (cmd === "evaluation") {
-      field.evaluation = parseEvaluation(unwrapBlock(t[i++]));
-    } else if (cmd === "values") {
-      const read = readBalanced(t, i);
-      field.values = parseValueEntries(read.text);
-      i = read.next;
-    } else if (cmd === "default") {
-      field.defaultValue = stripWrapping(t[i++]);
-      field.hasDefault = true;
-    } else if (cmd === "true_label") {
-      field.trueLabel = stripWrapping(t[i++]);
-    } else if (cmd === "false_label") {
-      field.falseLabel = stripWrapping(t[i++]);
-    } else if (cmd === "enum_values") {
-      field.enumValues = parseValueEntries(t[i++]);
-    } else if (cmd === "min_items") {
-      const raw = stripWrapping(t[i++]);
-      const n = parseInt(raw, 10);
-      field.minItems = isNaN(n) ? raw : n;
-    } else if (cmd === "max_items") {
-      const raw = stripWrapping(t[i++]);
-      const n = parseInt(raw, 10);
-      field.maxItems = isNaN(n) ? raw : n;
-    } else if (cmd === "items") {
-      const iblock = unwrapBlock(t[i++]);
-      const it = tokenize(iblock);
-      const typeParts = [];
-      let k = 0;
-      while (k < it.length && it[k] !== "fields") {
-        if (it[k] === "unit" && k + 1 < it.length) {
-          field.itemsUnit = stripWrapping(it[k + 1]);
-          k += 2;
-        } else {
-          typeParts.push(it[k++]);
-        }
-      }
-      field.itemsType = typeParts.join(" ");
-      if (it[k] === "fields") {
-        k++;
-        if (k < it.length) {
-          field.fields = parseNestedFields(unwrapBlock(it[k]));
-        }
+  if (field.enumRef) {
+    inner.push("enum " + field.enumRef);
+  }
+  if (field.pattern) {
+    inner.push('pattern "' + escapeString(field.pattern) + '"');
+  }
+  if (field.scope) {
+    inner.push("scope " + field.scope);
+  }
+  if (field.examples) {
+    inner.push('examples "' + escapeString(field.examples) + '"');
+  }
+  if (field.bind) {
+    inner.push("bind " + dumpBareSafe(field.bind));
+  }
+  if (field.required) {
+    inner.push("required true");
+  }
+  if (field.requiredWhen) {
+    inner.push("required_when " + dumpBareSafe(field.requiredWhen));
+  }
+  if (field.measurementMethod) {
+    inner.push("measurement_method " + field.measurementMethod);
+  }
+  if (field.calculationId) {
+    inner.push("calculation " + dumpBareSafe(field.calculationId));
+  }
+  if (field.calculationBindings.length > 0) {
+    inner.push(
+      "calculation_bindings { " + field.calculationBindings.map((b) => b.inputName + ": " + b.pathExpr).join(" ") + "}"
+    );
+  }
+  if (field.derivation) {
+    inner.push('derivation "' + escapeString(field.derivation) + '"');
+  }
+  if (field.evaluation) {
+    let ev = 'evaluation { rule "' + escapeString(field.evaluation.rule) + '"';
+    if (field.evaluation.verdict) {
+      ev += " verdict " + field.evaluation.verdict;
+    }
+    if (field.evaluation.op) {
+      ev += " op " + field.evaluation.op;
+    }
+    if (field.evaluation.limit) {
+      ev += ' limit "' + escapeString(field.evaluation.limit) + '"';
+    }
+    if (field.evaluation.condition) {
+      ev += ' condition "' + escapeString(field.evaluation.condition) + '"';
+    }
+    if (field.evaluation.referenceId) {
+      ev += " reference { " + field.evaluation.referenceId + " }";
+    }
+    if (field.evaluation.specificationReference) {
+      ev += ' specification_reference "' + escapeString(field.evaluation.specificationReference) + '"';
+    }
+    if (field.evaluation.sourceDiscrepancy) {
+      ev += " " + dumpSourceDiscrepancy(field.evaluation.sourceDiscrepancy, "");
+    }
+    inner.push(ev + " }");
+  }
+  if (field.values.length > 0) {
+    inner.push("values { " + field.values.map(dumpValueEntry).join(" ") + " }");
+  }
+  if (field.hasDefault) {
+    inner.push("default " + dumpBareSafe(field.defaultValue));
+  }
+  if (field.trueLabel) {
+    inner.push('true_label "' + escapeString(field.trueLabel) + '"');
+  }
+  if (field.falseLabel) {
+    inner.push('false_label "' + escapeString(field.falseLabel) + '"');
+  }
+  if (field.enumValues.length > 0) {
+    inner.push(
+      "enum_values { " + field.enumValues.map(dumpValueEntry).join(" ") + " }"
+    );
+  }
+  if (field.itemsType) {
+    let itemsLine = "items { " + field.itemsType;
+    if (field.itemsUnit) {
+      itemsLine += ' unit "' + escapeString(field.itemsUnit) + '"';
+    }
+    inner.push(itemsLine + " }");
+  }
+  if (field.minItems !== void 0 && field.minItems !== null) {
+    inner.push("min_items " + dumpBareSafe(String(field.minItems)));
+  }
+  if (field.maxItems !== void 0 && field.maxItems !== null) {
+    inner.push("max_items " + dumpBareSafe(String(field.maxItems)));
+  }
+  if (field.series) {
+    inner.push(dumpSeriesDecl(field.series));
+  }
+  if (field.applicability.length > 0) {
+    inner.push(
+      "applicability { " + dumpApplicabilityEntries(field.applicability) + "}"
+    );
+  }
+  if (field.targets.length > 0) {
+    inner.push("targets { " + field.targets.join(" ") + " }");
+  }
+  if (field.sourceRefs && field.sourceRefs.length > 0) {
+    for (const s of field.sourceRefs) {
+      inner.push(dumpSourceRefAsRef(s, "", escapeString).trimEnd());
+    }
+  }
+  if (field.fieldReferences.length > 0) {
+    for (const r of field.fieldReferences) {
+      inner.push(
+        "ref " + roleToPredicateForDump(r.role) + ' "' + escapeString(r.urn) + '"'
+      );
+    }
+  }
+  if (field.refs && field.refs.length > 0) {
+    for (const r of field.refs) {
+      inner.push(
+        "ref " + r.predicate + ' "' + escapeString(r.target) + '"' + (r.note ? ' { note "' + escapeString(r.note) + '" }' : "")
+      );
+    }
+  }
+  if (field.correspondences && field.correspondences.length > 0) {
+    inner.push(
+      dumpCorrespondences(
+        field.correspondences,
+        "",
+        escapeString,
+        dumpBareSafe
+      ).trimEnd()
+    );
+  }
+  if (field.specificationReference) {
+    inner.push(
+      'specification_reference "' + escapeString(field.specificationReference) + '"'
+    );
+  }
+  if (field.sourceDiscrepancy) {
+    inner.push(dumpSourceDiscrepancy(field.sourceDiscrepancy, ""));
+  }
+  if (field.fields.length > 0) {
+    inner.push(
+      "fields {\n" + field.fields.map((f) => dumpFormField(f, indent + "    ")).join("") + indent + "  }"
+    );
+  }
+  if (field.referenceIds.length > 0) {
+    inner.push("reference { " + field.referenceIds.join(" ") + " }");
+  }
+  const typeSpec = field.type && (field.type !== "string" || field.typeDeclared) ? " : " + field.type : "";
+  if (inner.length === 0) {
+    return indent + "field " + field.name + typeSpec + " { }\n";
+  }
+  if (inner.every((s) => !s.includes("\n"))) {
+    return indent + "field " + field.name + typeSpec + " { " + inner.join(" ") + " }\n";
+  }
+  return indent + "field " + field.name + typeSpec + " {\n" + inner.map((s) => indent + "  " + s + "\n").join("") + indent + "}\n";
+}
+function dumpApplicabilityEntries(entries) {
+  let out = "";
+  for (const a of entries) {
+    if (a.mapping) {
+      out += a.dimension + ": { ";
+      const pairs = [];
+      for (const [k, v] of Object.entries(a.mapping)) {
+        pairs.push(k + ": " + v);
       }
-    } else if (cmd === "series") {
-      field.series = parseSeriesDecl(unwrapBlock(t[i++]));
-    } else if (cmd === "fields") {
-      field.fields = parseNestedFields(unwrapBlock(t[i++]));
-    } else if (cmd === "subform_ref") {
-      const subformId = stripWrapping(t[i++]);
-      const refBlock = i < t.length ? unwrapBlock(t[i++]) : "";
-      field.subformRef = parseSubformRef(subformId, refBlock);
-      if (!field.type || field.type === "string") {
-        field.type = "array";
+      out += pairs.join(", ") + " ";
+      out += "} ";
+    } else {
+      out += a.dimension + ": [" + a.values.join(", ") + "] ";
+      if (a.match) {
+        out += "match " + a.match + " ";
       }
-    } else if (cmd === "reference") {
-      field.referenceIds = tokenizePackage(t[i++]).map(stripWrapping);
-    } else if (cmd === "references") {
-      field.fieldReferences = parseRoleReferences(unwrapBlock(t[i++]));
-    } else if (cmd === "ref") {
-      const r = parseRef(t, i, stripWrapping, unwrapBlock);
-      if (!foldRefIntoLegacy(field, r.ref)) {
-        field.refs.push(r.ref);
+    }
+  }
+  return out;
+}
+function parseRoleReferences(block) {
+  const out = [];
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const role = stripColon(t[i++]);
+    if (!role) {
+      break;
+    }
+    if (i < t.length && t[i] === ":") {
+      i++;
+    }
+    if (i < t.length && t[i].startsWith("{")) {
+      const urns = tokenize(unwrapBlock(t[i++])).map(stripWrapping).filter((s) => s.length > 0);
+      for (const urn of urns) {
+        out.push({ urn, role });
       }
-      i = r.next;
-    } else if (cmd === "corresponds") {
-      const cc = parseCorresponds(t, i, stripWrapping);
-      (field.correspondences ??= []).push(cc.corr);
-      i = cc.next;
-    } else if (cmd === "specification_reference") {
-      field.specificationReference = stripWrapping(t[i++]);
-    } else if (cmd === "applicability") {
-      field.applicability = parseApplicability(unwrapBlock(t[i++]));
-    } else if (cmd === "source_discrepancy") {
-      field.sourceDiscrepancy = parseSourceDiscrepancy(unwrapBlock(t[i++]));
-    } else {
-      unwrapBlock(t[i++]);
     }
   }
-  return field;
-}
-function parseCalculationBindings(block) {
-  const out = [];
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const key = stripColon(t[i++]);
-    if (i >= t.length) {
-      break;
-    }
-    if (t[i] === ":") {
-      i++;
+  return out;
+}
+function roleToPredicateForDump(role) {
+  if (role === "source") {
+    return "derives-from";
+  }
+  if (role === "reference") {
+    return "cites";
+  }
+  return role;
+}
+
+// src/ser-des/config/approval.ts
+var parseApproval = function(id, data) {
+  const result = {
+    id,
+    name: "",
+    modality: "",
+    actorRef: "",
+    approverRef: "",
+    recordRefs: [],
+    actor: null,
+    approver: null,
+    records: [],
+    ref: [],
+    source: null,
+    _relations: {
+      actor: "",
+      approver: "",
+      records: [],
+      ref: []
+    }
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "modality") {
+        result.modality = value();
+      } else if (keyword === "name") {
+        result.name = unwrapped(value);
+      } else if (keyword === "actor") {
+        result._relations.actor = value();
+      } else if (keyword === "approve_by") {
+        result._relations.approver = value();
+      } else if (keyword === "approval_record") {
+        result._relations.records = tokenizePackage(value());
+      } else if (keyword === "reference") {
+        result._relations.ref = tokenizePackage(value());
+      } else if (keyword === "source") {
+        result.source = readSource(unwrapBlock(value()));
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "approval", id }
+  );
+  return (ctx) => {
+    ctx.approvals[id] = result;
+    return ctx;
+  };
+};
+var resolveApproval = function(ctx, unresolved) {
+  const { _relations, ...rest } = unresolved;
+  const p = {
+    ...rest,
+    // The raw reference ids survive resolution even when they name no
+    // declared construct — the linter (C143) and the dumper read these.
+    actorRef: _relations.actor,
+    approverRef: _relations.approver,
+    recordRefs: [..._relations.records],
+    records: [],
+    ref: []
+  };
+  if (_relations.actor !== "") {
+    p.actor = resolveFromContext(ctx, "roles", _relations.actor) ?? null;
+  }
+  if (_relations.approver !== "") {
+    p.approver = resolveFromContext(ctx, "roles", _relations.approver) ?? null;
+  }
+  for (const id of _relations.records) {
+    const r = resolveFromContext(ctx, "regs", id);
+    if (r !== void 0) {
+      p.records.push(r);
     }
-    if (i < t.length) {
-      out.push({ inputName: key, pathExpr: stripWrapping(t[i++]) });
+  }
+  for (const id of _relations.ref) {
+    const r = resolveFromContext(ctx, "references", id);
+    if (r !== void 0) {
+      p.ref.push(r);
     }
   }
-  return out;
-}
-function parseEvaluation(block) {
-  const rule = { rule: "", condition: "", referenceId: null };
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const cmd = t[i++];
-    if (i >= t.length) {
-      break;
+  return p;
+};
+var dumpApproval = function(approval) {
+  let out = "approval " + approval.id + " {\n";
+  out += '  name "' + escapeString(approval.name) + '"\n';
+  if (approval.actorRef) {
+    out += "  actor " + approval.actorRef + "\n";
+  }
+  if (approval.modality !== "") {
+    out += "  modality " + approval.modality + "\n";
+  }
+  if (approval.approverRef) {
+    out += "  approve_by " + approval.approverRef + "\n";
+  }
+  if (approval.recordRefs.length > 0) {
+    out += "  approval_record {\n";
+    for (const id of approval.recordRefs) {
+      out += "    " + id + "\n";
     }
-    if (cmd === "rule") {
-      rule.rule = stripWrapping(t[i++]);
-    } else if (cmd === "verdict") {
-      rule.verdict = stripWrapping(t[i++]);
-    } else if (cmd === "op") {
-      rule.op = stripWrapping(t[i++]);
-    } else if (cmd === "limit") {
-      rule.limit = stripWrapping(t[i++]);
-    } else if (cmd === "condition") {
-      rule.condition = stripWrapping(t[i++]);
-    } else if (cmd === "reference") {
-      const ids = tokenizePackage(t[i++]).map(stripWrapping);
-      rule.referenceId = ids[0] ?? null;
-    } else if (cmd === "specification_reference") {
-      rule.specificationReference = stripWrapping(t[i++]);
-    } else if (cmd === "source_discrepancy") {
-      rule.sourceDiscrepancy = parseSourceDiscrepancy(unwrapBlock(t[i++]));
-    } else {
-      unwrapBlock(t[i++]);
+    out += "  }\n";
+  }
+  if (approval.ref.length > 0) {
+    out += "  reference {\n";
+    for (const r of approval.ref) {
+      out += "    " + r.id + "\n";
     }
+    out += "  }\n";
   }
-  return rule;
-}
-function parseNestedFields(block) {
-  const out = [];
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const cmd = t[i++];
-    if (cmd !== "field") {
-      if (i < t.length) {
-        unwrapBlock(t[i - 1]);
-      }
-      continue;
+  if (approval.source && (approval.source.doc || approval.source.clause)) {
+    out += "  source {\n";
+    if (approval.source.doc) {
+      out += '    doc "' + escapeString(approval.source.doc) + '"\n';
     }
-    const head = readFieldHead(t, i);
-    if (!head) {
-      break;
+    if (approval.source.clause) {
+      out += '    clause "' + escapeString(approval.source.clause) + '"\n';
     }
-    out.push(parseFormField(head.name, head.block, head.type || void 0));
-    i = head.next;
+    out += "  }\n";
   }
+  out += "}\n";
   return out;
-}
-function parseApplicability(block) {
-  const entries = [];
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const dimension = stripColon(t[i++]);
-    if (i >= t.length) {
-      break;
-    }
-    if (t[i] === ":") {
-      i++;
-    }
-    if (i < t.length) {
-      const read = readBalanced(t, i);
-      i = read.next;
-      const trimmed = read.text.trim();
-      let entry;
-      if (trimmed.startsWith("[")) {
-        const inner = trimmed.slice(1, trimmed.lastIndexOf("]"));
-        const values = inner.split(/[,\s]+/).filter((s) => s.length > 0);
-        entry = { dimension, values, mapping: null, match: null };
-      } else if (trimmed.startsWith("{")) {
-        const inner = trimmed.slice(1, -1);
-        const mapping = {};
-        for (const pair of inner.split(/[,\n]+/).map((s) => s.trim()).filter((s) => s)) {
-          const m = pair.match(/^(\w+)\s*:\s*(.+)$/);
-          if (m) {
-            mapping[m[1]] = m[2].trim();
-          }
-        }
-        entry = { dimension, values: [], mapping, match: null };
+};
+
+// src/ser-des/config/data.ts
+var parseEnum = (id, data) => {
+  const result = {
+    id,
+    values: []
+  };
+  forEachEntry(
+    data,
+    (_vid, value) => {
+      result.values.push(parseEnumValue(_vid, value()));
+      return true;
+    },
+    { construct: "enum", id }
+  );
+  return (ctx) => {
+    ctx.enums[id] = result;
+    return ctx;
+  };
+};
+var parseEnumValue = (id, data) => {
+  const ev = {
+    id,
+    value: ""
+  };
+  forEachEntry(
+    data,
+    (command, value) => {
+      if (command === "definition") {
+        ev.value = unwrapped(value);
       } else {
-        entry = {
-          dimension,
-          values: [stripWrapping(trimmed)],
-          mapping: null,
-          match: null
-        };
-      }
-      if (!entry.mapping && t[i] === "match") {
-        i++;
-        const mode = stripWrapping(t[i++] ?? "");
-        if (mode !== "any" && mode !== "all" && mode !== "exact") {
-          throw new Error(
-            `Parsing error: applicability: Unknown match ${mode} (valid: any, all, exact)`
-          );
-        }
-        entry.match = mode;
+        return false;
       }
-      entries.push(entry);
+      return true;
+    },
+    { construct: "enum value", id }
+  );
+  return ev;
+};
+var parseRegistry = function(id, data) {
+  const result = {
+    id,
+    title: "",
+    data: null,
+    _relations: {
+      data: ""
     }
-  }
-  return entries;
-}
-function parseSubformRef(subformId, block) {
-  const ref = {
-    subformId: stripWrapping(subformId),
-    parameters: {},
-    applicability: []
   };
-  if (block && block.trim()) {
-    const t = tokenize(block);
-    let i = 0;
-    while (i < t.length) {
-      const cmd = t[i++];
-      if (i < t.length) {
-        if (cmd === "parameters") {
-          const pblock = unwrapBlock(t[i++]);
-          const pt = tokenize(pblock);
-          let j = 0;
-          while (j < pt.length) {
-            const key = stripColon(pt[j++]);
-            if (j < pt.length) {
-              if (pt[j] === ":") {
-                j++;
-              }
-              if (j < pt.length) {
-                ref.parameters[key] = stripWrapping(pt[j++]);
-              }
+  forEachEntry(
+    data,
+    (command, value) => {
+      if (command === "title") {
+        result.title = unwrapped(value);
+      } else if (command === "data_class") {
+        result._relations.data = value();
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "registry", id }
+  );
+  return (ctx) => {
+    ctx.regs[id] = result;
+    return ctx;
+  };
+};
+var parseDataClass = function(id, data) {
+  const result = {
+    id,
+    attributes: []
+  };
+  forEachAttribute(
+    data,
+    (basic, details) => {
+      if (basic.startsWith("ref ")) {
+        const m = basic.match(/^ref\s+(\S+)\s+"([^"]*)"$/);
+        if (m) {
+          const ref = { predicate: m[1], target: m[2] };
+          if (details) {
+            const noteMatch = /note\s+"([^"]*)"/.exec(details) ?? /note\s+(\S+)/.exec(details);
+            if (noteMatch) {
+              ref.note = noteMatch[1];
             }
           }
-        } else if (cmd === "applicability") {
-          ref.applicability = parseApplicability(unwrapBlock(t[i++]));
-        } else {
-          unwrapBlock(t[i++]);
+          result.ref ??= [];
+          result.ref.push(ref);
+          return;
         }
       }
-    }
-  }
-  return ref;
-}
-function dumpFormField(field, indent) {
-  let out = "";
-  if (field.subformRef && !field.name) {
-    const sr = field.subformRef;
-    out += indent + "subform_ref " + sr.subformId + " { ";
-    const pkeys = Object.keys(sr.parameters);
-    if (pkeys.length > 0) {
-      out += "parameters { ";
-      for (const k of pkeys) {
-        out += k + ": " + sr.parameters[k] + " ";
+      const head = basic.trim();
+      if (head === "store") {
+        result.store = details.trim();
+        return;
       }
-      out += "} ";
-    }
-    if (sr.applicability.length > 0) {
-      out += "applicability { " + dumpApplicabilityEntries(sr.applicability) + "} ";
+      if (head === "description") {
+        result.description = stripWrapping(details.trim());
+        return;
+      }
+      if (head === "indexes") {
+        result.indexes = details.split(/\s+/).filter((x) => x.length > 0);
+        return;
+      }
+      if (head === "helper") {
+        result.helper = details.trim() === "true";
+        return;
+      }
+      if (head === "extends") {
+        result.extends = details.trim();
+        return;
+      }
+      result.attributes.push(parseDataAttribute(head, details));
+    },
+    { construct: "class", id }
+  );
+  return (ctx) => {
+    ctx.dataclasses[id] = result;
+    return ctx;
+  };
+};
+var parseDataAttribute = (basic, details) => {
+  const result = {
+    id: "",
+    type: "",
+    modality: "",
+    cardinality: "",
+    definition: "",
+    ref: [],
+    satisfy: [],
+    _relations: {
+      ref: []
     }
-    out += "}\n";
-    return out;
+  };
+  const cardMatch = basic.match(/^(.*?)\s*\[([\d*][^\]]*)\]\s*$/);
+  if (cardMatch) {
+    result.cardinality = cardMatch[2].trim();
+    basic = cardMatch[1];
   }
-  const inner = [];
-  if (field.subformRef) {
-    const sr = field.subformRef;
-    let refLine = "subform_ref " + sr.subformId + " { ";
-    const pkeys = Object.keys(sr.parameters);
-    if (pkeys.length > 0) {
-      refLine += "parameters { ";
-      for (const k of pkeys) {
-        refLine += k + ": " + sr.parameters[k] + " ";
+  const colonIndex = basic.indexOf(":");
+  if (colonIndex !== -1) {
+    result.type = basic.substr(colonIndex + 1, basic.length - colonIndex - 1).trim();
+    basic = basic.substr(0, colonIndex);
+  }
+  result.id = basic.trim();
+  forEachEntry(
+    details,
+    (keyword, value) => {
+      if (keyword === "modality") {
+        result.modality = value();
+      } else if (keyword === "definition") {
+        result.definition = unwrapped(value);
+      } else if (keyword === "reference") {
+        result._relations.ref = tokenizePackage(value());
+      } else if (keyword === "satisfy") {
+        result.satisfy = tokenizePackage(value());
+      } else if (keyword === "on_delete") {
+        result.onDelete = value();
+      } else if (keyword === "deprecated") {
+        result.deprecated = value() === "true";
+      } else if (keyword === "enum_values") {
+        result.enumValues = tokenizePackage(value());
+      } else if (keyword === "required") {
+        result.required = value() === "true";
+      } else if (keyword === "unit") {
+        result.unit = unwrapped(value);
+      } else if (keyword === "default") {
+        result.defaultValue = unwrapped(value);
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "data attribute", id: result.id }
+  );
+  return result;
+};
+var resolveDataClass = function(ctx, unresolved) {
+  const attributes = unresolved.attributes.map((attr) => {
+    const resolved = { ...attr, ref: [] };
+    for (const id of attr._relations.ref) {
+      const r = resolveFromContext(ctx, "references", id);
+      if (r !== void 0) {
+        resolved.ref.push(r);
       }
-      refLine += "} ";
     }
-    if (sr.applicability.length > 0) {
-      refLine += "applicability { " + dumpApplicabilityEntries(sr.applicability) + "} ";
+    return resolved;
+  });
+  return {
+    id: unresolved.id,
+    attributes,
+    ...unresolved.store !== void 0 ? { store: unresolved.store } : {},
+    ...unresolved.indexes !== void 0 ? { indexes: unresolved.indexes } : {},
+    ...unresolved.helper !== void 0 ? { helper: unresolved.helper } : {},
+    ...unresolved.extends !== void 0 ? { extends: unresolved.extends } : {},
+    ...unresolved.description !== void 0 ? { description: unresolved.description } : {},
+    ...unresolved.ref !== void 0 ? { ref: unresolved.ref } : {}
+  };
+};
+var resolveRegistry = function(ctx, unresolved) {
+  const { _relations, ...rest } = unresolved;
+  const p = { ...rest, data: null };
+  if (_relations.data !== "") {
+    const dc = resolveFromContext(
+      ctx,
+      "dataclasses",
+      _relations.data
+    );
+    if (dc !== void 0) {
+      p.data = dc;
     }
-    inner.push(refLine + "}");
-  }
-  if (field.label) {
-    inner.push('label "' + escapeString(field.label) + '"');
-  }
-  if (field.definition) {
-    inner.push('definition "' + escapeString(field.definition) + '"');
-  }
-  if (field.description) {
-    inner.push('description "' + escapeString(field.description) + '"');
-  }
-  if (field.unit) {
-    inner.push('unit "' + escapeString(field.unit) + '"');
   }
-  if (field.symbol) {
-    inner.push("symbol " + field.symbol);
-  }
-  if (field.verdict) {
-    inner.push("verdict " + field.verdict);
-  }
-  if (field.dimension) {
-    inner.push("dimension " + field.dimension);
-  }
-  if (field.enumRef) {
-    inner.push("enum " + field.enumRef);
-  }
-  if (field.pattern) {
-    inner.push('pattern "' + escapeString(field.pattern) + '"');
-  }
-  if (field.scope) {
-    inner.push("scope " + field.scope);
+  return p;
+};
+var dumpDataClass = function(dataclass) {
+  let out = "class " + dataclass.id + " {\n";
+  if (dataclass.store) {
+    out += "  store { " + dataclass.store + " }\n";
   }
-  if (field.examples) {
-    inner.push('examples "' + escapeString(field.examples) + '"');
+  if (dataclass.description) {
+    out += '  description { "' + escapeString(dataclass.description) + '" }\n';
   }
-  if (field.bind) {
-    inner.push("bind " + dumpBareSafe(field.bind));
+  if (dataclass.indexes && dataclass.indexes.length > 0) {
+    out += "  indexes { " + dataclass.indexes.join(" ") + " }\n";
   }
-  if (field.required) {
-    inner.push("required true");
+  if (dataclass.helper !== void 0) {
+    out += "  helper { " + dataclass.helper + " }\n";
   }
-  if (field.requiredWhen) {
-    inner.push("required_when " + dumpBareSafe(field.requiredWhen));
+  if (dataclass.extends) {
+    out += "  extends { " + dataclass.extends + " }\n";
   }
-  if (field.measurementMethod) {
-    inner.push("measurement_method " + field.measurementMethod);
+  if (dataclass.ref && dataclass.ref.length > 0) {
+    for (const r of dataclass.ref) {
+      out += "  ref " + r.predicate + ' "' + escapeString(r.target) + '"';
+      if (r.note) {
+        out += ' { note "' + escapeString(r.note) + '" }';
+      }
+      out += "\n";
+    }
   }
-  if (field.calculationId) {
-    inner.push("calculation " + dumpBareSafe(field.calculationId));
+  for (const a of dataclass.attributes) {
+    out += toDataAttributeModel(a);
   }
-  if (field.calculationBindings.length > 0) {
-    inner.push(
-      "calculation_bindings { " + field.calculationBindings.map((b) => b.inputName + ": " + b.pathExpr).join(" ") + "}"
-    );
+  out += "}\n";
+  return out;
+};
+var toDataAttributeModel = (attribute) => {
+  let out = "  " + attribute.id;
+  if (attribute.type !== "") {
+    out += ": " + attribute.type;
   }
-  if (field.derivation) {
-    inner.push('derivation "' + escapeString(field.derivation) + '"');
+  if (attribute.cardinality !== "") {
+    out += "[" + attribute.cardinality + "]";
   }
-  if (field.evaluation) {
-    let ev = 'evaluation { rule "' + escapeString(field.evaluation.rule) + '"';
-    if (field.evaluation.verdict) {
-      ev += " verdict " + field.evaluation.verdict;
-    }
-    if (field.evaluation.op) {
-      ev += " op " + field.evaluation.op;
-    }
-    if (field.evaluation.limit) {
-      ev += ' limit "' + escapeString(field.evaluation.limit) + '"';
-    }
-    if (field.evaluation.condition) {
-      ev += ' condition "' + escapeString(field.evaluation.condition) + '"';
-    }
-    if (field.evaluation.referenceId) {
-      ev += " reference { " + field.evaluation.referenceId + " }";
-    }
-    if (field.evaluation.specificationReference) {
-      ev += ' specification_reference "' + escapeString(field.evaluation.specificationReference) + '"';
-    }
-    if (field.evaluation.sourceDiscrepancy) {
-      ev += " " + dumpSourceDiscrepancy(field.evaluation.sourceDiscrepancy, "");
-    }
-    inner.push(ev + " }");
+  out += " {\n";
+  out += '    definition "' + escapeString(attribute.definition) + '"\n';
+  if (attribute.modality !== "") {
+    out += "    modality " + attribute.modality + "\n";
   }
-  if (field.values.length > 0) {
-    inner.push("values { " + field.values.map(dumpValueEntry).join(" ") + " }");
+  if (attribute.onDelete) {
+    out += "    on_delete " + attribute.onDelete + "\n";
   }
-  if (field.hasDefault) {
-    inner.push("default " + dumpBareSafe(field.defaultValue));
+  if (attribute.deprecated) {
+    out += "    deprecated true\n";
   }
-  if (field.trueLabel) {
-    inner.push('true_label "' + escapeString(field.trueLabel) + '"');
+  if (attribute.enumValues && attribute.enumValues.length > 0) {
+    out += "    enum_values { " + attribute.enumValues.join(" ") + " }\n";
   }
-  if (field.falseLabel) {
-    inner.push('false_label "' + escapeString(field.falseLabel) + '"');
+  if (attribute.required !== void 0) {
+    out += "    required " + (attribute.required ? "true" : "false") + "\n";
   }
-  if (field.enumValues.length > 0) {
-    inner.push(
-      "enum_values { " + field.enumValues.map(dumpValueEntry).join(" ") + " }"
-    );
+  if (attribute.unit) {
+    out += '    unit "' + escapeString(attribute.unit) + '"\n';
   }
-  if (field.itemsType) {
-    let itemsLine = "items { " + field.itemsType;
-    if (field.itemsUnit) {
-      itemsLine += ' unit "' + escapeString(field.itemsUnit) + '"';
+  if (attribute.defaultValue !== void 0) {
+    out += '    default "' + escapeString(attribute.defaultValue) + '"\n';
+  }
+  if (attribute.satisfy.length > 0) {
+    out += "    satisfy {\n";
+    for (const s of attribute.satisfy) {
+      out += "      " + s + "\n";
     }
-    inner.push(itemsLine + " }");
+    out += "    }\n";
   }
-  if (field.minItems !== void 0 && field.minItems !== null) {
-    inner.push("min_items " + dumpBareSafe(String(field.minItems)));
+  if (attribute.ref.length > 0) {
+    out += "    reference {\n";
+    for (const r of attribute.ref) {
+      out += "      " + r.id + "\n";
+    }
+    out += "    }\n";
   }
-  if (field.maxItems !== void 0 && field.maxItems !== null) {
-    inner.push("max_items " + dumpBareSafe(String(field.maxItems)));
+  out += "  }\n";
+  return out;
+};
+var dumpEnumValue = (ev) => {
+  let out = "  " + ev.id + " {\n";
+  out += '    definition "' + escapeString(ev.value) + '"\n';
+  out += "  }\n";
+  return out;
+};
+var dumpEnum = function(en) {
+  let out = "enum " + en.id + " {\n";
+  for (const v of en.values) {
+    out += dumpEnumValue(v);
   }
-  if (field.series) {
-    inner.push(dumpSeriesDecl(field.series));
+  out += "}\n";
+  return out;
+};
+var dumpRegistry = function(reg) {
+  let out = "data_registry " + reg.id + " {\n";
+  out += '  title "' + escapeString(reg.title) + '"\n';
+  if (reg.data !== null) {
+    out += "  data_class " + reg.data.id + "\n";
   }
-  if (field.applicability.length > 0) {
-    inner.push(
-      "applicability { " + dumpApplicabilityEntries(field.applicability) + "}"
-    );
+  out += "}\n";
+  return out;
+};
+var parseVariable = function(id, data) {
+  const result = {
+    id,
+    type: "",
+    definition: "",
+    description: ""
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "type") {
+        result.type = value();
+      } else if (keyword === "definition") {
+        result.definition = unwrapped(value);
+      } else if (keyword === "description") {
+        result.description = unwrapped(value);
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "variable", id }
+  );
+  return (ctx) => {
+    ctx.variables[id] = result;
+    return ctx;
+  };
+};
+var dumpVariable = function(v) {
+  let out = "variable " + v.id + " {\n";
+  if (v.type !== "") {
+    out += "  type " + v.type + "\n";
   }
-  if (field.targets.length > 0) {
-    inner.push("targets { " + field.targets.join(" ") + " }");
+  if (v.definition !== "") {
+    out += '  definition "' + escapeString(v.definition) + '"\n';
   }
-  if (field.sourceRefs && field.sourceRefs.length > 0) {
-    for (const s of field.sourceRefs) {
-      inner.push(dumpSourceRefAsRef(s, "", escapeString).trimEnd());
-    }
+  if (v.description !== "") {
+    out += '  description "' + escapeString(v.description) + '"\n';
   }
-  if (field.fieldReferences.length > 0) {
-    for (const r of field.fieldReferences) {
-      inner.push(
-        "ref " + roleToPredicateForDump(r.role) + ' "' + escapeString(r.urn) + '"'
+  out += "}\n";
+  return out;
+};
+
+// src/ser-des/config/event.ts
+var parseEndEvent = function(id, data) {
+  const result = {
+    id,
+    eventType: "end"
+  };
+  if (data !== "") {
+    const t = tokenizePackage(data);
+    if (t.length > 0) {
+      throw new Error(
+        `Parsing error: end_event. ID ${id}: Expecting empty body`
       );
     }
   }
-  if (field.refs && field.refs.length > 0) {
-    for (const r of field.refs) {
-      inner.push(
-        "ref " + r.predicate + ' "' + escapeString(r.target) + '"' + (r.note ? ' { note "' + escapeString(r.note) + '" }' : "")
+  return (ctx) => {
+    ctx.events[id] = result;
+    return ctx;
+  };
+};
+var parseSignalCatchEvent = function(id, data) {
+  const result = {
+    id,
+    eventType: "signalcatch",
+    signal: ""
+  };
+  if (data !== "") {
+    const t = tokenizePackage(data);
+    let i = 0;
+    while (i < t.length) {
+      const command = t[i++];
+      if (i < t.length) {
+        if (command === "catch") {
+          result.signal = unwrapBlock(t[i++]);
+        } else {
+          i++;
+        }
+      } else {
+        throw new Error(
+          `Parsing error: Signal Catch Event. ID ${id}: Expecting value for ${command}`
+        );
+      }
+    }
+  }
+  return (ctx) => {
+    ctx.events[id] = result;
+    return ctx;
+  };
+};
+var parseStartEvent = function(id, data) {
+  const result = {
+    id,
+    eventType: "start"
+  };
+  if (data !== "") {
+    const t = tokenizePackage(data);
+    if (t.length > 0) {
+      throw new Error(
+        `Parsing error: end_event. ID ${id}: Expecting empty body`
       );
     }
   }
-  if (field.correspondences && field.correspondences.length > 0) {
-    inner.push(
-      dumpCorrespondences(
-        field.correspondences,
-        "",
-        escapeString,
-        dumpBareSafe
-      ).trimEnd()
-    );
+  return (ctx) => {
+    ctx.events[id] = result;
+    return ctx;
+  };
+};
+var parseTimerEvent = function(id, data) {
+  const result = {
+    id,
+    eventType: "timer",
+    type: "",
+    para: ""
+  };
+  if (data !== "") {
+    const t = tokenizePackage(data);
+    let i = 0;
+    while (i < t.length) {
+      const command = t[i++];
+      if (i < t.length) {
+        if (command === "type") {
+          result.type = t[i++];
+        } else if (command === "para") {
+          result.para = unwrapBlock(t[i++]);
+        } else {
+          i++;
+        }
+      } else {
+        throw new Error(
+          `Parsing error: Timer Event. ID ${id}: Expecting value for ${command}`
+        );
+      }
+    }
   }
-  if (field.specificationReference) {
-    inner.push(
-      'specification_reference "' + escapeString(field.specificationReference) + '"'
-    );
+  return (ctx) => {
+    ctx.events[id] = result;
+    return ctx;
+  };
+};
+var dumpEvent = function(event) {
+  if (event.eventType === "start") {
+    return dumpStartEvent(event);
   }
-  if (field.sourceDiscrepancy) {
-    inner.push(dumpSourceDiscrepancy(field.sourceDiscrepancy, ""));
+  if (event.eventType === "end") {
+    return dumpEndEvent(event);
   }
-  if (field.fields.length > 0) {
-    inner.push(
-      "fields {\n" + field.fields.map((f) => dumpFormField(f, indent + "    ")).join("") + indent + "  }"
-    );
+  if (event.eventType === "signalcatch") {
+    return dumpSignalCatchEvent(event);
   }
-  if (field.referenceIds.length > 0) {
-    inner.push("reference { " + field.referenceIds.join(" ") + " }");
+  if (event.eventType === "timer") {
+    return dumpTimerEvent(event);
+  }
+  return "";
+};
+function dumpEndEvent(end) {
+  return "end_event " + end.id + " {\n}\n";
+}
+function dumpSignalCatchEvent(sc) {
+  let out = "signal_catch_event " + sc.id + " {\n";
+  if (sc.signal !== "") {
+    out += '  catch "' + escapeString(sc.signal) + '"\n';
   }
-  const typeSpec = field.type && (field.type !== "string" || field.typeDeclared) ? " : " + field.type : "";
-  if (inner.length === 0) {
-    return indent + "field " + field.name + typeSpec + " { }\n";
+  out += "}\n";
+  return out;
+}
+function dumpStartEvent(s) {
+  return "start_event " + s.id + " {\n}\n";
+}
+function dumpTimerEvent(te) {
+  let out = "timer_event " + te.id + " {\n";
+  if (te.type !== "") {
+    out += "  type " + te.type + "\n";
   }
-  if (inner.every((s) => !s.includes("\n"))) {
-    return indent + "field " + field.name + typeSpec + " { " + inner.join(" ") + " }\n";
+  if (te.para !== "") {
+    out += '  para "' + escapeString(te.para) + '"\n';
   }
-  return indent + "field " + field.name + typeSpec + " {\n" + inner.map((s) => indent + "  " + s + "\n").join("") + indent + "}\n";
+  out += "}\n";
+  return out;
 }
-function dumpApplicabilityEntries(entries) {
-  let out = "";
-  for (const a of entries) {
-    if (a.mapping) {
-      out += a.dimension + ": { ";
-      const pairs = [];
-      for (const [k, v] of Object.entries(a.mapping)) {
-        pairs.push(k + ": " + v);
-      }
-      out += pairs.join(", ") + " ";
-      out += "} ";
-    } else {
-      out += a.dimension + ": [" + a.values.join(", ") + "] ";
-      if (a.match) {
-        out += "match " + a.match + " ";
+
+// src/ser-des/config/gateway.ts
+var parseExclusiveGate = function(id, data) {
+  const gateway = {
+    id,
+    gatewayType: "exclusive_gateway",
+    label: "",
+    edges: []
+  };
+  forEachEntry(
+    data,
+    (command, value) => {
+      if (command === "label") {
+        gateway.label = unwrapped(value);
+      } else if (command === "edge") {
+        const edge = {
+          target: stripWrapping(value()),
+          condition: "",
+          label: ""
+        };
+        const et = tokenize(unwrapBlock(value()));
+        for (let j = 0; j + 1 < et.length; j += 2) {
+          if (et[j] === "condition") {
+            edge.condition = stripWrapping(et[j + 1]);
+          } else if (et[j] === "label") {
+            edge.label = stripWrapping(et[j + 1]);
+          }
+        }
+        gateway.edges.push(edge);
+      } else {
+        return false;
       }
-    }
+      return true;
+    },
+    { construct: "Exclusive gateway", id }
+  );
+  return (ctx) => {
+    ctx.gateways[id] = gateway;
+    return ctx;
+  };
+};
+var dumpGateway = function(gate) {
+  if (gate.gatewayType === "exclusive_gateway") {
+    return dumpEGate(gate);
   }
-  return out;
-}
-function parseRoleReferences(block) {
-  const out = [];
-  const t = tokenize(block);
-  let i = 0;
-  while (i < t.length) {
-    const role = stripColon(t[i++]);
-    if (!role) {
-      break;
-    }
-    if (i < t.length && t[i] === ":") {
-      i++;
+  return "";
+};
+function dumpEGate(egate) {
+  let out = "exclusive_gateway " + egate.id + " {\n";
+  if (egate.label !== "") {
+    out += '  label "' + escapeString(egate.label) + '"\n';
+  }
+  for (const e of egate.edges ?? []) {
+    out += "  edge " + dumpBareSafe(e.target) + " {";
+    if (e.condition === "default") {
+      out += " condition default";
+    } else if (e.condition !== "") {
+      out += ' condition "' + escapeString(e.condition) + '"';
     }
-    if (i < t.length && t[i].startsWith("{")) {
-      const urns = tokenize(unwrapBlock(t[i++])).map(stripWrapping).filter((s) => s.length > 0);
-      for (const urn of urns) {
-        out.push({ urn, role });
-      }
+    if (e.label !== "") {
+      out += ' label "' + escapeString(e.label) + '"';
     }
+    out += " }\n";
   }
+  out += "}\n";
   return out;
 }
-function roleToPredicateForDump(role) {
-  if (role === "source") {
-    return "derives-from";
-  }
-  if (role === "reference") {
-    return "cites";
+
+// src/ser-des/config/metadata.ts
+var parseMetadata = function(token) {
+  const metadata = {
+    schema: "",
+    author: "",
+    title: "",
+    edition: "",
+    namespace: "",
+    shortname: ""
+  };
+  if (token !== "") {
+    const t = tokenizePackage(token);
+    let i = 0;
+    while (i < t.length) {
+      const keyword = t[i++];
+      if (i < t.length) {
+        if (keyword === "title") {
+          metadata.title = stripWrapping(t[i++]);
+        } else if (keyword === "schema") {
+          metadata.schema = stripWrapping(t[i++]);
+        } else if (keyword === "edition") {
+          metadata.edition = stripWrapping(t[i++]);
+        } else if (keyword === "author") {
+          metadata.author = stripWrapping(t[i++]);
+        } else if (keyword === "namespace") {
+          metadata.namespace = stripWrapping(t[i++]);
+        } else if (keyword === "shortname") {
+          metadata.shortname = stripWrapping(t[i++]);
+        } else {
+          throw new Error(
+            "Parsing error: metadata. Unknown keyword " + keyword
+          );
+        }
+      } else {
+        throw new Error(
+          "Parsing error: metadata. Expecting value for " + keyword
+        );
+      }
+    }
   }
-  return role;
-}
+  return (ctx) => {
+    ctx.metadata = metadata;
+    return ctx;
+  };
+};
 
 // src/ser-des/config/quantity.ts
 var NUMERIC = /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/;
@@ -2928,6 +2985,10 @@ var parseProcess = function(id, data) {
     id,
     name: "",
     modality: "",
+    // The workflow facets (smart TODO.roadmap/40 batch 5)
+    phase: "",
+    guards: [],
+    machineSteps: [],
     actor: null,
     output: [],
     input: [],
@@ -2962,6 +3023,8 @@ var parseProcess = function(id, data) {
     windows: [],
     source: null,
     provisionRefs: [],
+    outputRefs: [],
+    inputRefs: [],
     _relations: {
       actor: "",
       output: [],
@@ -3002,6 +3065,12 @@ var parseProcess = function(id, data) {
     (keyword, value, peek) => {
       if (keyword === "modality") {
         result.modality = value();
+      } else if (keyword === "phase") {
+        result.phase = stripWrapping(value());
+      } else if (keyword === "guard") {
+        result.guards.push(unwrapped(value));
+      } else if (keyword === "machine_steps") {
+        result.machineSteps = tokenize(stripWrapping(value())).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
       } else if (keyword === "name") {
         result.name = unwrapped(value);
       } else if (keyword === "actor") {
@@ -3015,9 +3084,13 @@ var parseProcess = function(id, data) {
       } else if (keyword === "validate_measurement") {
         result.measure = tokenizePackage(value()).map((x) => unwrapBlock(x));
       } else if (keyword === "output") {
-        result._relations.output = tokenizePackage(value());
+        result._relations.output = tokenizePackage(value()).map(
+          (x) => stripWrapping(x)
+        );
       } else if (keyword === "reference_data_registry") {
-        result._relations.input = tokenizePackage(value());
+        result._relations.input = tokenizePackage(value()).map(
+          (x) => stripWrapping(x)
+        );
       } else if (keyword === "signature") {
         const sig = { inputs: [], outputs: [] };
         const st = tokenize(unwrapBlock(value()));
@@ -3125,6 +3198,12 @@ var resolveProcess = function(ctx, unresolved) {
     // name no declared `provision` construct (e.g. `/req/cs/*`
     // requirements) — the linter and the dumper read this list.
     provisionRefs: [..._relations.provision],
+    // The raw process-I/O ids survive the same way (smart
+    // TODO.roadmap/40 batch 5e): OIML SMART names entity-class STORE
+    // ids here, which the `regs` resolver cannot see — without the raw
+    // carriers the load → dump round-trip silently dropped them.
+    outputRefs: [..._relations.output],
+    inputRefs: [..._relations.input],
     actor: null,
     page: null
   };
@@ -3254,10 +3333,22 @@ var dumpProcess = function(process2, ctx) {
   if (process2.modality !== "") {
     out += "  modality " + process2.modality + "\n";
   }
-  if (process2.input.length > 0) {
+  if (process2.phase) {
+    out += "  phase " + dumpBareSafe(process2.phase) + "\n";
+  }
+  if (process2.guards && process2.guards.length > 0) {
+    for (const g of process2.guards) {
+      out += '  guard "' + escapeString(g) + '"\n';
+    }
+  }
+  if (process2.machineSteps && process2.machineSteps.length > 0) {
+    out += "  machine_steps { " + process2.machineSteps.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  const inputIds = process2.inputRefs && process2.inputRefs.length > 0 ? process2.inputRefs : process2.input.map((r) => r.id);
+  if (inputIds.length > 0) {
     out += "  reference_data_registry {\n";
-    for (const dr of process2.input) {
-      out += "    " + dr.id + "\n";
+    for (const id of inputIds) {
+      out += "    " + dumpBareSafe(id) + "\n";
     }
     out += "  }\n";
   }
@@ -3275,10 +3366,11 @@ var dumpProcess = function(process2, ctx) {
     }
     out += "  }\n";
   }
-  if (process2.output.length > 0) {
+  const outputIds = process2.outputRefs && process2.outputRefs.length > 0 ? process2.outputRefs : process2.output.map((r) => r.id);
+  if (outputIds.length > 0) {
     out += "  output {\n";
-    for (const c of process2.output) {
-      out += "    " + c.id + "\n";
+    for (const id of outputIds) {
+      out += "    " + dumpBareSafe(id) + "\n";
     }
     out += "  }\n";
   }
@@ -3697,6 +3789,75 @@ var dumpWorkflowConfig = function(c) {
   return out;
 };
 
+// src/ser-des/config/workflowStage.ts
+function readTokenList2(block) {
+  return tokenize(stripWrapping(block)).map(stripColon).map(stripWrapping).filter((s) => s.length > 0);
+}
+function dumpTokenList2(keyword, ids) {
+  if (ids.length === 0) {
+    return "";
+  }
+  return "  " + keyword + " { " + ids.map(dumpBareSafe).join(" ") + " }\n";
+}
+var parseWorkflowStage = (id, data) => {
+  const stage = {
+    id,
+    label: "",
+    description: "",
+    elements: [],
+    startEvent: "",
+    endEvents: [],
+    approvals: [],
+    gateways: []
+  };
+  forEachEntry(
+    data,
+    (keyword, value) => {
+      if (keyword === "label") {
+        stage.label = stripWrapping(value());
+      } else if (keyword === "description") {
+        stage.description = stripWrapping(value());
+      } else if (keyword === "elements") {
+        stage.elements = readTokenList2(value());
+      } else if (keyword === "start_event") {
+        stage.startEvent = stripWrapping(value());
+      } else if (keyword === "end_events") {
+        stage.endEvents = readTokenList2(value());
+      } else if (keyword === "approvals") {
+        stage.approvals = readTokenList2(value());
+      } else if (keyword === "gateways") {
+        stage.gateways = readTokenList2(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "workflow_stage", id }
+  );
+  return (ctx) => {
+    ctx.workflowStages[id] = stage;
+    return ctx;
+  };
+};
+var dumpWorkflowStage = function(s) {
+  let out = "workflow_stage " + dumpBareSafe(s.id) + " {\n";
+  if (s.label) {
+    out += '  label "' + escapeString(s.label) + '"\n';
+  }
+  if (s.description) {
+    out += '  description "' + escapeString(s.description) + '"\n';
+  }
+  out += dumpTokenList2("elements", s.elements);
+  if (s.startEvent) {
+    out += "  start_event " + dumpBareSafe(s.startEvent) + "\n";
+  }
+  out += dumpTokenList2("end_events", s.endEvents);
+  out += dumpTokenList2("approvals", s.approvals);
+  out += dumpTokenList2("gateways", s.gateways);
+  out += "}\n";
+  return out;
+};
+
 // src/ser-des/config/verificationPathway.ts
 var VERIFICATION_KINDS = [
   "initial",
@@ -18588,6 +18749,16 @@ var CONSTRUCTS = [
     parse: parseWorkflowConfig,
     dump: dumpWorkflowConfig
   }),
+  // The named pipeline stage (smart TODO.roadmap/40 batch 5) — groups
+  // the workflow constructs per stage; the members-resolve discipline
+  // is C142's.
+  defineConstruct({
+    keyword: "workflow_stage",
+    field: "workflowStages",
+    takesID: true,
+    parse: parseWorkflowStage,
+    dump: dumpWorkflowStage
+  }),
   defineConstruct({
     keyword: "approval",
     field: "approvals",
@@ -19582,6 +19753,9 @@ var MERGE_FIELDS = [
   // The certification workflow step register (smart TODO.roadmap/40
   // batch 3) — the rec-overlay deep merge (OVERLAY_DEEP_MERGE_FIELDS).
   "workflowConfigs",
+  // The named pipeline stages (smart TODO.roadmap/40 batch 5) compose
+  // with uses-no-redefine semantics.
+  "workflowStages",
   // The verification pathways (smart TODO.roadmap/40 batch 3) compose
   // with uses-no-redefine semantics.
   "verificationPathways",
@@ -20591,6 +20765,9 @@ var TIER_BY_FIELD = {
   // The certification workflow step register (smart TODO.roadmap/40
   // batch 3) — operational wiring, tertiary.
   workflowConfigs: "tertiary",
+  // The named pipeline stages (smart TODO.roadmap/40 batch 5) —
+  // operational wiring, tertiary.
+  workflowStages: "tertiary",
   // The verification pathways (smart TODO.roadmap/40 batch 3) —
   // operational wiring, tertiary.
   verificationPathways: "tertiary",
@@ -22033,6 +22210,33 @@ var CHECK_RULES = [
     "normal",
     "smart TODO.roadmap/40 batch 3 (the packages-as-SSOT epic)"
   ),
+  // C142 (smart TODO.roadmap/40 batch 5; the packages-as-SSOT epic): the
+  // gateway routing cascade — edge targets resolve to declared processes
+  // (gated), exactly one default edge per edge-carrying gateway, the
+  // default recommended last (warning). The workflow_stage members-
+  // resolve legs ride this rule (step 5d).
+  R(
+    "C142",
+    "gateway-edges-resolve",
+    "composition",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 5 (the packages-as-SSOT epic)"
+  ),
+  // C143 (smart TODO.roadmap/40 batch 5; the packages-as-SSOT epic): the
+  // first approval rule — actor/approve_by resolve to declared roles,
+  // the approval_record entries to declared entity-class stores (the
+  // dataclass `store { … }` names), per-register gated (the C58
+  // doctrine). Reads the raw reference ids so unresolvable ids are still
+  // checked — and still round-trip.
+  R(
+    "C143",
+    "approval-references-resolve",
+    "composition",
+    "error",
+    "normal",
+    "smart TODO.roadmap/40 batch 5 (the packages-as-SSOT epic)"
+  ),
   // ── quantities / time / duality (TODO.roadmap/06) ─────────────────
   R(
     "C32",
@@ -27589,6 +27793,108 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  {
+    const gwProcessIds = new Set((standard.processes ?? []).map((p) => p.id));
+    for (const g of standard.gateways ?? []) {
+      if (g.gatewayType !== "exclusive_gateway") {
+        continue;
+      }
+      const edges = g.edges ?? [];
+      const where = `exclusive_gateway ${g.id}`;
+      edges.forEach((e, i) => {
+        if (gwProcessIds.size > 0 && !gwProcessIds.has(e.target)) {
+          err(
+            "C142",
+            `${where}: edge ${i + 1} targets "${e.target}", which is not a declared process (gateway-edges-resolve)`
+          );
+        }
+      });
+      if (edges.length > 0) {
+        const defaults = edges.map((e, i) => ({ e, i })).filter((x) => x.e.condition === "default");
+        if (defaults.length === 0) {
+          err(
+            "C142",
+            `${where}: no default edge \u2014 the first-match-wins cascade needs its catch-all (gateway-edges-resolve)`
+          );
+        } else if (defaults.length > 1) {
+          err(
+            "C142",
+            `${where}: ${defaults.length} default edges \u2014 exactly one catch-all is allowed (gateway-edges-resolve)`
+          );
+        } else if (defaults[0].i !== edges.length - 1) {
+          warn(
+            "C142",
+            `${where}: the default edge is not last \u2014 it shadows the edges after it in the first-match-wins cascade (gateway-edges-resolve)`
+          );
+        }
+      }
+    }
+    const stageApprovalIds = new Set((standard.approvals ?? []).map((a) => a.id));
+    const stageGatewayIds = new Set((standard.gateways ?? []).map((g) => g.id));
+    for (const s of standard.workflowStages ?? []) {
+      const where = `workflow_stage ${s.id}`;
+      for (const el of s.elements ?? []) {
+        if (gwProcessIds.size > 0 && !gwProcessIds.has(el)) {
+          err(
+            "C142",
+            `${where}: element "${el}" is not a declared process (gateway-edges-resolve)`
+          );
+        }
+      }
+      for (const a of s.approvals ?? []) {
+        if (stageApprovalIds.size > 0 && !stageApprovalIds.has(a)) {
+          err(
+            "C142",
+            `${where}: approval "${a}" is not a declared approval (gateway-edges-resolve)`
+          );
+        }
+      }
+      for (const g of s.gateways ?? []) {
+        if (stageGatewayIds.size > 0 && !stageGatewayIds.has(g)) {
+          err(
+            "C142",
+            `${where}: gateway "${g}" is not a declared gateway (gateway-edges-resolve)`
+          );
+        }
+      }
+    }
+  }
+  {
+    const approvalRoleIds = new Set((standard.roles ?? []).map((r) => r.id));
+    const approvalStores = /* @__PURE__ */ new Set();
+    for (const c of standard.dataclasses ?? []) {
+      if (c.store) {
+        for (const s of c.store.split(/\s+/)) {
+          if (s) {
+            approvalStores.add(s);
+          }
+        }
+      }
+    }
+    for (const a of standard.approvals ?? []) {
+      const where = `approval ${a.id}`;
+      if (a.actorRef && approvalRoleIds.size > 0 && !approvalRoleIds.has(a.actorRef)) {
+        err(
+          "C143",
+          `${where}: actor "${a.actorRef}" is not a declared role (approval-references-resolve)`
+        );
+      }
+      if (a.approverRef && approvalRoleIds.size > 0 && !approvalRoleIds.has(a.approverRef)) {
+        err(
+          "C143",
+          `${where}: approver "${a.approverRef}" is not a declared role (approval-references-resolve)`
+        );
+      }
+      for (const store of a.recordRefs ?? []) {
+        if (approvalStores.size > 0 && !approvalStores.has(store)) {
+          err(
+            "C143",
+            `${where}: approval_record "${store}" is not a declared entity-class store (approval-references-resolve)`
+          );
+        }
+      }
+    }
+  }
   for (const d of standard.duals ?? []) {
     if (d.attribute && !attrIds.has(d.attribute)) {
       err(