@primmel/primmel 1.3.2 → 1.4.1

package/dist/src/ser-des/config/field-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 // ─────────────────────────────────────────────────────────────────────
-// Shared FormField parser.
+// Shared FormField parser + dumper.
 //
 // Both form.ts (for `form` construct) and subform.ts (for `subform`
 // construct) need to parse the same `field <name> { ... }` block shape.
@@ -9,35 +9,259 @@
 //
 // Extracted here so both can import without circular-dependency issues
 // (this file imports only from tokenize + types, never from form/subform).
+//
+// The module has since become the shared home for the small field-level
+// helpers every construct ser-des needs — dumpBareSafe, stripColon,
+// readBalanced, and the verbatim-identical subBlockTokens /
+// readEntryTokens / readSource copies the passport/invariant/monitor/
+// formulasUsed and source-carrying constructs each carried (the E11
+// review minor).
+//
+// v2 parser repair (W1a):
+// - Scalar values use stripWrapping (unwrapBlock mangles bare tokens:
+//   `true` → `ru`, `computed` → `ompute`, `42` → ``).
+// - Typed field heads (`field x : number { … }`) are parsed, not lost.
+// - calculation_bindings / evaluation / items / nested fields /
+//   min_items / max_items are POPULATED (previously parsed-then-skipped).
+// - Nested `subform_ref` inside a field block is captured.
+// - dumpFormField emits the full field fidelity (lossless round-trip).
 // ─────────────────────────────────────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readValueToken = readValueToken;
+exports.parseValueEntries = parseValueEntries;
+exports.dumpBareSafe = dumpBareSafe;
+exports.stripColon = stripColon;
+exports.readBalanced = readBalanced;
+exports.subBlockTokens = subBlockTokens;
+exports.readEntryTokens = readEntryTokens;
+exports.readSource = readSource;
+exports.readFieldHead = readFieldHead;
 exports.parseFormField = parseFormField;
+exports.parseApplicability = parseApplicability;
+exports.parseSubformRef = parseSubformRef;
+exports.dumpFormField = dumpFormField;
+exports.dumpApplicabilityEntries = dumpApplicabilityEntries;
+exports.parseRoleReferences = parseRoleReferences;
+exports.dumpRoleReferences = dumpRoleReferences;
 const tokenize_1 = require("../tokenize");
+const tokenize_2 = require("../tokenize");
+const series_1 = require("./series");
+const sourceDiscrepancy_1 = require("./sourceDiscrepancy");
+/**
+ * Read a value token, accumulating inline `ocl{…}` expressions that the
+ * whitespace tokenizer splits (braces are only block delimiters at token
+ * start, so `ocl{(a - b) / c}` arrives as several tokens).
+ */
+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 };
+}
 /**
- * Parse a `field <name> { ... }` block into a FormField.
+ * Parse a values / enum_values block: bare entries, optionally with a
+ * display-label block — `{ kg { label "Kg" } g }` or `[A, B]`.
+ */
+function parseValueEntries(raw) {
+    const inner = raw
+        .trim()
+        .replace(/^[[{]/, '')
+        .replace(/[\]}]$/, '');
+    const t = (0, tokenize_2.tokenizePackage)(inner);
+    const out = [];
+    let i = 0;
+    while (i < t.length) {
+        const entry = (0, tokenize_2.stripWrapping)(t[i++].replace(/,$/, ''));
+        if (!entry) {
+            continue;
+        }
+        if (i < t.length && t[i].startsWith('{')) {
+            const lb = (0, tokenize_2.tokenizePackage)((0, tokenize_2.unwrapBlock)(t[i++]));
+            let label = '';
+            for (let k = 0; k + 1 < lb.length; k += 2) {
+                if (lb[k] === 'label') {
+                    label = (0, tokenize_2.stripWrapping)(lb[k + 1]);
+                }
+            }
+            out.push({ value: entry, label });
+        }
+        else {
+            out.push(entry);
+        }
+    }
+    return out;
+}
+/** Dump one values / enum_values entry (label block when present). */
+function dumpValueEntry(e) {
+    if (typeof e === 'string') {
+        return e;
+    }
+    return e.value + ' { label "' + (0, tokenize_2.escapeString)(e.label) + '" }';
+}
+/**
+ * Emit a bare value safely: quote it when it contains spaces/braces/quotes
+ * OR ends in a colon OR STARTS with a comment opener (`#` or `//`).
+ * A bare trailing-colon token re-parses as a KEY head (`note : ref:` reads
+ * back as two entries — see isKeyHead in the instance ser-des), so any
+ * value ending in `:` must be quoted on dump. The tokenizer only treats
+ * `#`/`//` as a comment BETWEEN tokens — a mid-token `#` or `//` is
+ * literal (`StdS#Process5` round-trips bare; the v2 map_profile form
+ * depends on it) — but a LEADING `#` or `//` starts a to-end-of-line
+ * comment on re-parse (tokenize.ts's two comment openers) and the value
+ * vanishes, so a value starting with either must never dump bare (the
+ * E10 vocabulary-value exposure; the `//` half is TODO.v2/13 item 1).
+ */
+function dumpBareSafe(v) {
+    return /[\s{}"]/.test(v) ||
+        v.endsWith(':') ||
+        v.startsWith('#') ||
+        v.startsWith('//')
+        ? '"' + (0, tokenize_2.escapeString)(v) + '"'
+        : v;
+}
+/** Strip one trailing colon: `status:` → `status` (tokenizer keeps colons attached). */
+function stripColon(x) {
+    return x.endsWith(':') ? x.slice(0, -1) : x;
+}
+/**
+ * Read a balanced `[...]` or `{...}` value that may span whitespace.
+ * The tokenizer is brace-aware only for `{...}`; `[A, C]` lists split
+ * across tokens. `t[i]` is the token to start from; returns the joined
+ * text and the next unconsumed index.
+ */
+function readBalanced(t, i) {
+    const first = t[i] ?? '';
+    if (!first.startsWith('[')) {
+        return { text: first, next: i + 1 };
+    }
+    let text = first;
+    let j = i + 1;
+    while (!text.includes(']') && j < t.length) {
+        text += ' ' + t[j++];
+    }
+    return { text, next: j };
+}
+/** Strip the sketch's optional `;` separators from a sub-block stream. */
+function subBlockTokens(block) {
+    return (0, tokenize_2.tokenizePackage)(block)
+        .map(s => s.replace(/^;+|;+$/g, ''))
+        .filter(s => s.length > 0);
+}
+/** Read a content-entry token stream: `{ a b }` block, or a single bare
+ *  entry. Commas are optional noise (the §15.8 sketch spelling). */
+function readEntryTokens(value) {
+    if (value.startsWith('{')) {
+        return subBlockTokens((0, tokenize_2.unwrapBlock)(value))
+            .flatMap(s => s.split(','))
+            .map(s => (0, tokenize_2.stripWrapping)(s.trim()))
+            .filter(s => s.length > 0);
+    }
+    const single = (0, tokenize_2.stripWrapping)(value);
+    return single === '' ? [] : [single];
+}
+/** Read one `source { doc "…" clause "…" [fragment "…"] }` block — the
+ *  requirement/test_point_set provenance idiom. Unknown keys are skipped
+ *  (forward compatibility); last wins on a repeated key. */
+function readSource(block) {
+    const src = { doc: '', clause: '' };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'doc') {
+            src.doc = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'clause') {
+            src.clause = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'fragment') {
+            src.fragment = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return src;
+}
+/**
+ * Read a field head: `name [: type] { ...block... }`.
+ * `t[i]` must be the token AFTER the `field` keyword. Returns null when
+ * the shape is not a field head (caller may treat it as something else,
+ * e.g. a bare `subform_ref`).
+ */
+function readFieldHead(t, i) {
+    const name = t[i++];
+    if (name === undefined) {
+        return null;
+    }
+    let type = '';
+    if (t[i] === ':') {
+        i++;
+        type = t[i++] ?? '';
+        // Optional cardinality after the type, e.g. `: string [0..*]`
+        if (t[i] && t[i].startsWith('[') && t[i].endsWith(']')) {
+            i++;
+        }
+    }
+    const blockToken = t[i++];
+    if (blockToken === undefined || !blockToken.startsWith('{')) {
+        return null;
+    }
+    return { name, type, block: (0, tokenize_2.unwrapBlock)(blockToken), next: i };
+}
+/**
+ * Parse a `field <name> [: <type>] { ... }` block into a FormField.
  *
- * Caller passes the field name (the token consumed before the brace)
- * and the raw block content (inside the braces). Returns a fully
- * populated FormField with all known sub-keywords processed and
- * unknown ones skipped (forward-compatible).
+ * Caller passes the field name (the token consumed before the brace),
+ * the raw block content (inside the braces), and optionally the declared
+ * type from the field head. Returns a fully populated FormField with all
+ * known sub-keywords processed and unknown ones skipped (forward-compatible).
  */
-function parseFormField(name, block) {
+function parseFormField(name, block, type) {
     const field = {
         name,
-        type: 'string',
+        type: type || 'string',
+        typeDeclared: !!type,
         label: '',
         definition: '',
         unit: '',
+        symbol: '',
+        verdict: '',
+        targets: [],
+        dimension: '',
+        enumRef: '',
+        pattern: '',
         required: false,
+        requiredWhen: '',
         measurementMethod: '',
         calculationId: null,
         calculationBindings: [],
         derivation: '',
         evaluation: null,
         values: [],
+        trueLabel: '',
+        falseLabel: '',
+        enumValues: [],
         defaultValue: '',
         hasDefault: false,
         referenceIds: [],
+        fieldReferences: [],
+        specificationReference: '',
+        applicability: [],
+        sourceDiscrepancy: null,
         fields: [],
         itemsType: '',
         subformRef: null,
@@ -45,7 +269,9 @@ function parseFormField(name, block) {
     if (!block || !block.trim()) {
         return field;
     }
-    const t = (0, tokenize_1.tokenizePackage)(block);
+    // `block` is already-unwrapped CONTENT — use plain tokenize. (tokenizePackage
+    // would unwrap AGAIN and eat real characters: `d_max}` → `d_ma`.)
+    const t = (0, tokenize_1.default)(block);
     let i = 0;
     while (i < t.length) {
         const cmd = t[i++];
@@ -53,56 +279,645 @@ function parseFormField(name, block) {
             break;
         }
         if (cmd === 'label') {
-            field.label = (0, tokenize_1.unwrapBlock)(t[i++]);
+            field.label = (0, tokenize_2.stripWrapping)(t[i++]);
         }
         else if (cmd === 'definition') {
-            field.definition = (0, tokenize_1.unwrapBlock)(t[i++]);
+            field.definition = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'description') {
+            field.description = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'type') {
+            // Type may also be declared inside the block.
+            field.type = (0, tokenize_2.stripWrapping)(t[i++]);
+            field.typeDeclared = true;
         }
         else if (cmd === 'unit') {
-            field.unit = (0, tokenize_1.unwrapBlock)(t[i++]);
+            field.unit = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'symbol') {
+            field.symbol = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'verdict') {
+            field.verdict = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'targets') {
+            field.targets = (0, tokenize_2.tokenizePackage)(t[i++]).map(tokenize_2.stripWrapping);
+        }
+        else if (cmd === 'dimension') {
+            field.dimension = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'enum') {
+            field.enumRef = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'pattern') {
+            field.pattern = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'scope') {
+            field.scope = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'examples') {
+            field.examples = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'bind') {
+            // Binding path into the subject chain (G5):
+            // model.parameters.e_max · sample.test_context.d_min · model.classification.accuracy_class
+            field.bind = (0, tokenize_2.stripWrapping)(t[i++]);
         }
         else if (cmd === 'required') {
-            field.required = (0, tokenize_1.unwrapBlock)(t[i++]) === 'true';
+            field.required = (0, tokenize_2.stripWrapping)(t[i++]) === 'true';
+        }
+        else if (cmd === 'required_when') {
+            // The conditional-requiredness expression — quoted or inline ocl{…}
+            // (the whitespace tokenizer SPLITS the braces — accumulate until
+            // brace-balanced, same as `calculation`).
+            const read = readValueToken(t, i);
+            field.requiredWhen = (0, tokenize_2.stripWrapping)(read.text);
+            i = read.next;
         }
         else if (cmd === 'measurement_method') {
-            field.measurementMethod = (0, tokenize_1.unwrapBlock)(t[i++]);
+            field.measurementMethod = (0, tokenize_2.stripWrapping)(t[i++]);
         }
         else if (cmd === 'calculation') {
-            // Bare ID — use stripWrapping to avoid mangling unquoted values.
-            field.calculationId = (0, tokenize_1.stripWrapping)(t[i++]);
+            // Bare ID, quoted string, or inline `ocl{…}` expression (which the
+            // whitespace tokenizer SPLITS — accumulate until brace-balanced, or the
+            // value truncates at the first space and becomes a dump-time hazard).
+            const read = readValueToken(t, i);
+            field.calculationId = (0, tokenize_2.stripWrapping)(read.text);
+            i = read.next;
         }
         else if (cmd === 'calculation_bindings') {
-            // Skip the binding block (raw preservation not yet implemented).
-            (0, tokenize_1.unwrapBlock)(t[i++]);
+            field.calculationBindings = parseCalculationBindings((0, tokenize_2.unwrapBlock)(t[i++]));
         }
         else if (cmd === 'derivation') {
-            field.derivation = (0, tokenize_1.unwrapBlock)(t[i++]);
+            field.derivation = (0, tokenize_2.stripWrapping)(t[i++]);
         }
         else if (cmd === 'evaluation') {
-            // Skip evaluation block.
-            (0, tokenize_1.unwrapBlock)(t[i++]);
+            field.evaluation = parseEvaluation((0, tokenize_2.unwrapBlock)(t[i++]));
         }
         else if (cmd === 'values') {
-            field.values = (0, tokenize_1.tokenizePackage)(t[i++]);
+            // values { A B } / values [A, B] — entries may carry a label:
+            // values { kg { label "Kg" } g }
+            const read = readBalanced(t, i);
+            field.values = parseValueEntries(read.text);
+            i = read.next;
         }
         else if (cmd === 'default') {
-            field.defaultValue = (0, tokenize_1.unwrapBlock)(t[i++]);
+            field.defaultValue = (0, tokenize_2.stripWrapping)(t[i++]);
             field.hasDefault = true;
         }
-        else if (cmd === 'min_items' || cmd === 'max_items') {
-            (0, tokenize_1.unwrapBlock)(t[i++]);
+        else if (cmd === 'true_label') {
+            field.trueLabel = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'false_label') {
+            field.falseLabel = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'enum_values') {
+            field.enumValues = parseValueEntries(t[i++]);
+        }
+        else if (cmd === 'min_items') {
+            const raw = (0, tokenize_2.stripWrapping)(t[i++]);
+            const n = parseInt(raw, 10);
+            field.minItems = isNaN(n) ? raw : n;
+        }
+        else if (cmd === 'max_items') {
+            const raw = (0, tokenize_2.stripWrapping)(t[i++]);
+            const n = parseInt(raw, 10);
+            field.maxItems = isNaN(n) ? raw : n;
         }
-        else if (cmd === 'items' || cmd === 'fields') {
-            (0, tokenize_1.unwrapBlock)(t[i++]);
+        else if (cmd === 'items') {
+            // items { <type> [unit "…"] [fields { … }] } — element type, optional
+            // unit, optional nested fields.
+            const iblock = (0, tokenize_2.unwrapBlock)(t[i++]);
+            const it = (0, tokenize_1.default)(iblock);
+            const typeParts = [];
+            let k = 0;
+            while (k < it.length && it[k] !== 'fields') {
+                if (it[k] === 'unit' && k + 1 < it.length) {
+                    field.itemsUnit = (0, tokenize_2.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((0, tokenize_2.unwrapBlock)(it[k]));
+                }
+            }
+        }
+        else if (cmd === 'series') {
+            // series { axis <id> { … } … cell { symbol … unit "…" } } — typed
+            // series shape for datalist (array) evidence.
+            field.series = (0, series_1.parseSeriesDecl)((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'fields') {
+            field.fields = parseNestedFields((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'subform_ref') {
+            // Nested: field … { subform_ref SubformID { parameters { … } applicability { … } } }
+            const subformId = (0, tokenize_2.stripWrapping)(t[i++]);
+            const refBlock = i < t.length ? (0, tokenize_2.unwrapBlock)(t[i++]) : '';
+            field.subformRef = parseSubformRef(subformId, refBlock);
+            if (!field.type || field.type === 'string') {
+                field.type = 'array';
+            }
         }
         else if (cmd === 'reference') {
-            field.referenceIds = (0, tokenize_1.tokenizePackage)(t[i++]);
+            field.referenceIds = (0, tokenize_2.tokenizePackage)(t[i++]).map(tokenize_2.stripWrapping);
+        }
+        else if (cmd === 'references') {
+            field.fieldReferences = parseRoleReferences((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'specification_reference') {
+            field.specificationReference = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'applicability') {
+            field.applicability = parseApplicability((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else if (cmd === 'source_discrepancy') {
+            field.sourceDiscrepancy = (0, sourceDiscrepancy_1.parseSourceDiscrepancy)((0, tokenize_2.unwrapBlock)(t[i++]));
         }
         else {
             // Forward-compatible: skip unknown keyword value
-            (0, tokenize_1.unwrapBlock)(t[i++]);
+            (0, tokenize_2.unwrapBlock)(t[i++]);
         }
     }
     return field;
 }
+/** `calculation_bindings { inputName: pathExpr … }` */
+function parseCalculationBindings(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const key = stripColon(t[i++]);
+        if (i >= t.length) {
+            break;
+        }
+        if (t[i] === ':') {
+            i++;
+        }
+        if (i < t.length) {
+            out.push({ inputName: key, pathExpr: (0, tokenize_2.stripWrapping)(t[i++]) });
+        }
+    }
+    return out;
+}
+/** `evaluation { rule "…" verdict <id> op <op> limit "…" condition "…" reference { … } source_discrepancy { … } }` */
+function parseEvaluation(block) {
+    const rule = { rule: '', condition: '', referenceId: null };
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (i >= t.length) {
+            break;
+        }
+        if (cmd === 'rule') {
+            rule.rule = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'verdict') {
+            rule.verdict = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'op') {
+            rule.op = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'limit') {
+            rule.limit = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'condition') {
+            rule.condition = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'reference') {
+            const ids = (0, tokenize_2.tokenizePackage)(t[i++]).map(tokenize_2.stripWrapping);
+            rule.referenceId = ids[0] ?? null;
+        }
+        else if (cmd === 'specification_reference') {
+            rule.specificationReference = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'source_discrepancy') {
+            rule.sourceDiscrepancy = (0, sourceDiscrepancy_1.parseSourceDiscrepancy)((0, tokenize_2.unwrapBlock)(t[i++]));
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return rule;
+}
+/** `fields { field a { … } field b : number { … } … }` (recursive) */
+function parseNestedFields(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'field') {
+            if (i < t.length) {
+                (0, tokenize_2.unwrapBlock)(t[i - 1]);
+            }
+            continue;
+        }
+        const head = readFieldHead(t, i);
+        if (!head) {
+            break;
+        }
+        out.push(parseFormField(head.name, head.block, head.type || undefined));
+        i = head.next;
+    }
+    return out;
+}
+/** Parse `applicability { dim: [A, B] dim2: { A: 5, B: 3 } }` entries. */
+function parseApplicability(block) {
+    const entries = [];
+    const t = (0, tokenize_1.default)(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;
+            // text is `[A, B]`, `{ A: 5, B: 5 }`, or a bare value
+            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('{')) {
+                // Mapping form
+                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 {
+                // Single value
+                entry = {
+                    dimension,
+                    values: [(0, tokenize_2.stripWrapping)(trimmed)],
+                    mapping: null,
+                    match: null,
+                };
+            }
+            // Declared-condition match mode (rc.yaml $defs/applicability):
+            // `match any|all|exact` follows the values — universal/exact matching
+            // for set-cardinality dimensions (default 'any', existential).
+            if (!entry.mapping && t[i] === 'match') {
+                i++;
+                const mode = (0, tokenize_2.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 entries;
+}
+/** Parse `SubformID { parameters { … } applicability { … } }` */
+function parseSubformRef(subformId, block) {
+    const ref = {
+        subformId: (0, tokenize_2.stripWrapping)(subformId),
+        parameters: {},
+        applicability: [],
+    };
+    if (block && block.trim()) {
+        const t = (0, tokenize_1.default)(block);
+        let i = 0;
+        while (i < t.length) {
+            const cmd = t[i++];
+            if (i < t.length) {
+                if (cmd === 'parameters') {
+                    const pblock = (0, tokenize_2.unwrapBlock)(t[i++]);
+                    const pt = (0, tokenize_1.default)(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] = (0, tokenize_2.stripWrapping)(pt[j++]);
+                            }
+                        }
+                    }
+                }
+                else if (cmd === 'applicability') {
+                    ref.applicability = parseApplicability((0, tokenize_2.unwrapBlock)(t[i++]));
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(t[i++]);
+                }
+            }
+        }
+    }
+    return ref;
+}
+/** Dump one field with full fidelity (recursive for nested fields). */
+function dumpFormField(field, indent) {
+    let out = '';
+    // A NAMELESS subform reference (form-level `subform_ref X { ... }`)
+    // dumps in its bare form. A named field that composes a subform keeps
+    // its other properties — the subform_ref becomes one entry of the
+    // field body (converter emits `field x { … subform_ref X { } }`).
+    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;
+    }
+    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 + '}');
+    }
+    if (field.label) {
+        inner.push('label "' + (0, tokenize_2.escapeString)(field.label) + '"');
+    }
+    if (field.definition) {
+        inner.push('definition "' + (0, tokenize_2.escapeString)(field.definition) + '"');
+    }
+    if (field.description) {
+        inner.push('description "' + (0, tokenize_2.escapeString)(field.description) + '"');
+    }
+    if (field.unit) {
+        inner.push('unit "' + (0, tokenize_2.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 "' + (0, tokenize_2.escapeString)(field.pattern) + '"');
+    }
+    if (field.scope) {
+        inner.push('scope ' + field.scope);
+    }
+    if (field.examples) {
+        inner.push('examples "' + (0, tokenize_2.escapeString)(field.examples) + '"');
+    }
+    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 "' + (0, tokenize_2.escapeString)(field.derivation) + '"');
+    }
+    if (field.evaluation) {
+        let ev = 'evaluation { rule "' + (0, tokenize_2.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 "' + (0, tokenize_2.escapeString)(field.evaluation.limit) + '"';
+        }
+        if (field.evaluation.condition) {
+            ev += ' condition "' + (0, tokenize_2.escapeString)(field.evaluation.condition) + '"';
+        }
+        if (field.evaluation.referenceId) {
+            ev += ' reference { ' + field.evaluation.referenceId + ' }';
+        }
+        if (field.evaluation.specificationReference) {
+            ev +=
+                ' specification_reference "' +
+                    (0, tokenize_2.escapeString)(field.evaluation.specificationReference) +
+                    '"';
+        }
+        if (field.evaluation.sourceDiscrepancy) {
+            ev += ' ' + (0, sourceDiscrepancy_1.dumpSourceDiscrepancy)(field.evaluation.sourceDiscrepancy, '');
+        }
+        inner.push(ev + ' }');
+    }
+    if (field.values.length > 0) {
+        inner.push('values { ' + field.values.map(dumpValueEntry).join(' ') + ' }');
+    }
+    if (field.hasDefault) {
+        // Defaults may be free text ("26 MHz – 3 GHz") or JSON-encoded
+        // structures — quote whenever the value isn't a single safe token.
+        inner.push('default ' + dumpBareSafe(field.defaultValue));
+    }
+    if (field.trueLabel) {
+        inner.push('true_label "' + (0, tokenize_2.escapeString)(field.trueLabel) + '"');
+    }
+    if (field.falseLabel) {
+        inner.push('false_label "' + (0, tokenize_2.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 "' + (0, tokenize_2.escapeString)(field.itemsUnit) + '"';
+        }
+        inner.push(itemsLine + ' }');
+    }
+    if (field.minItems !== undefined && field.minItems !== null) {
+        inner.push('min_items ' + dumpBareSafe(String(field.minItems)));
+    }
+    if (field.maxItems !== undefined && field.maxItems !== null) {
+        inner.push('max_items ' + dumpBareSafe(String(field.maxItems)));
+    }
+    if (field.series) {
+        inner.push((0, series_1.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.fieldReferences.length > 0) {
+        inner.push('references { ' + dumpRoleReferences(field.fieldReferences) + ' }');
+    }
+    if (field.specificationReference) {
+        inner.push('specification_reference "' +
+            (0, tokenize_2.escapeString)(field.specificationReference) +
+            '"');
+    }
+    if (field.sourceDiscrepancy) {
+        inner.push((0, sourceDiscrepancy_1.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');
+}
+/** Dump applicability entries inside an `applicability { … }` block. */
+function dumpApplicabilityEntries(entries) {
+    let out = '';
+    for (const a of entries) {
+        if (a.mapping) {
+            out += a.dimension + ': { ';
+            // Pairs are comma-separated: the mapping parser splits on [,\n], so
+            // space-separated pairs would re-parse as one merged pair.
+            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 + ' ';
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Parse role-grouped reference URNs:
+ * `references { requirement { "urn:…" "urn:…" } test-procedure { "urn:…" } }`
+ * → flattened [{ urn, role }] in document order.
+ */
+function parseRoleReferences(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(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 = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]))
+                .map(tokenize_2.stripWrapping)
+                .filter(s => s.length > 0);
+            for (const urn of urns) {
+                out.push({ urn, role });
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Dump flattened role references re-grouped by role (first-seen role
+ * order, urn order preserved within a role) — the inner content of a
+ * `references { … }` block.
+ */
+function dumpRoleReferences(refs) {
+    const roles = [];
+    const byRole = new Map();
+    for (const r of refs) {
+        if (!byRole.has(r.role)) {
+            byRole.set(r.role, []);
+            roles.push(r.role);
+        }
+        byRole.get(r.role).push(r.urn);
+    }
+    return roles
+        .map(role => role +
+        ' { ' +
+        byRole
+            .get(role)
+            .map(u => '"' + (0, tokenize_2.escapeString)(u) + '"')
+            .join(' ') +
+        ' }')
+        .join(' ');
+}
 //# sourceMappingURL=field-parser.js.map