@primmel/primmel 1.3.2 → 1.4.1

package/dist/src/ser-des/config/conformanceTest.js

@@ -0,0 +1,929 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dumpConformanceTest = exports.parseConformanceTest = void 0;
+exports.parseTestSubject = parseTestSubject;
+const tokenize_1 = require("../tokenize");
+const tokenize_2 = require("../tokenize");
+const field_parser_1 = require("./field-parser");
+const series_1 = require("./series");
+const sourceDiscrepancy_1 = require("./sourceDiscrepancy");
+const acceptance_1 = require("./acceptance");
+const design_1 = require("./design");
+const competenceKind_1 = require("./competenceKind");
+const parse_block_1 = require("../parse-block");
+function readStringList(block) {
+    return (0, tokenize_1.default)((0, tokenize_2.stripWrapping)(block))
+        .map(field_parser_1.stripColon)
+        .map(tokenize_2.stripWrapping)
+        .filter(x => x.length > 0);
+}
+/** Numeric-looking values parse as numbers, everything else stays a string. */
+function numOrString(s) {
+    if (s.trim() !== '' && !isNaN(Number(s))) {
+        return Number(s);
+    }
+    return s;
+}
+function parseTestVariables(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'variable') {
+            if (i < t.length) {
+                (0, tokenize_2.unwrapBlock)(t[i - 1]);
+            }
+            continue;
+        }
+        const name = (0, tokenize_2.stripWrapping)(t[i++]);
+        const v = {
+            name,
+            type: '',
+            unit: '',
+            source: '',
+            derivation: '',
+            description: '',
+            itemType: '',
+            series: null,
+            provenance: null,
+        };
+        if (i < t.length && t[i].startsWith('{')) {
+            const vb = (0, tokenize_2.unwrapBlock)(t[i++]);
+            const vt = (0, tokenize_1.default)(vb);
+            let j = 0;
+            while (j < vt.length) {
+                const vc = vt[j++];
+                if (j >= vt.length) {
+                    break;
+                }
+                if (vc === 'type') {
+                    v.type = (0, tokenize_2.stripWrapping)(vt[j++]);
+                }
+                else if (vc === 'unit') {
+                    v.unit = (0, tokenize_2.stripWrapping)(vt[j++]);
+                }
+                else if (vc === 'source') {
+                    v.source = (0, tokenize_2.stripWrapping)(vt[j++]);
+                }
+                else if (vc === 'derivation') {
+                    v.derivation = (0, tokenize_2.stripWrapping)(vt[j++]);
+                }
+                else if (vc === 'description') {
+                    v.description = (0, tokenize_2.stripWrapping)(vt[j++]);
+                }
+                else if (vc === 'item_type') {
+                    v.itemType = (0, tokenize_2.stripWrapping)(vt[j++]);
+                }
+                else if (vc === 'series') {
+                    v.series = (0, series_1.parseSeriesDecl)((0, tokenize_2.unwrapBlock)(vt[j++]));
+                }
+                else if (vc === 'provenance') {
+                    // Probe-channel provenance (TCD-2): provenance { channel … ref …
+                    // observed_at … limitation "…" } — the three-source physical
+                    // channel vocabulary is C99's to police, not the parser's.
+                    const pb = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(vt[j++]));
+                    const p = { channel: '', ref: '', observedAt: '', limitation: '' };
+                    for (let k = 0; k + 1 < pb.length; k += 2) {
+                        if (pb[k] === 'channel') {
+                            p.channel = (0, tokenize_2.stripWrapping)(pb[k + 1]);
+                        }
+                        else if (pb[k] === 'ref') {
+                            p.ref = (0, tokenize_2.stripWrapping)(pb[k + 1]);
+                        }
+                        else if (pb[k] === 'observed_at') {
+                            p.observedAt = (0, tokenize_2.stripWrapping)(pb[k + 1]);
+                        }
+                        else if (pb[k] === 'limitation') {
+                            p.limitation = (0, tokenize_2.stripWrapping)(pb[k + 1]);
+                        }
+                    }
+                    v.provenance = p;
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(vt[j++]);
+                }
+            }
+        }
+        out.push(v);
+    }
+    return out;
+}
+function parsePreconditions(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'precondition') {
+            if (i < t.length) {
+                (0, tokenize_2.unwrapBlock)(t[i - 1]);
+            }
+            continue;
+        }
+        const pid = (0, tokenize_2.stripWrapping)(t[i++]);
+        const p = {
+            id: pid,
+            check: '',
+            description: '',
+            onViolation: 'invalid',
+        };
+        if (i < t.length && t[i].startsWith('{')) {
+            const pb = (0, tokenize_2.unwrapBlock)(t[i++]);
+            const pt = (0, tokenize_1.default)(pb);
+            let j = 0;
+            while (j < pt.length) {
+                const pc = pt[j++];
+                if (j >= pt.length) {
+                    break;
+                }
+                if (pc === 'check') {
+                    p.check = (0, tokenize_2.stripWrapping)(pt[j++]);
+                }
+                else if (pc === 'description') {
+                    p.description = (0, tokenize_2.stripWrapping)(pt[j++]);
+                }
+                else if (pc === 'on_violation') {
+                    p.onViolation = (0, tokenize_2.stripWrapping)(pt[j++]);
+                }
+                else if (pc === 'on_unresolvable') {
+                    p.onUnresolvable = (0, tokenize_2.stripWrapping)(pt[j++]);
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(pt[j++]);
+                }
+            }
+        }
+        out.push(p);
+    }
+    return out;
+}
+function parseObservables(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'observable') {
+            if (i < t.length) {
+                (0, tokenize_2.unwrapBlock)(t[i - 1]);
+            }
+            continue;
+        }
+        const name = (0, tokenize_2.stripWrapping)(t[i++]);
+        const o = { name, quantityKind: '', unit: '', as: '' };
+        if (i < t.length && t[i].startsWith('{')) {
+            const ob = (0, tokenize_2.unwrapBlock)(t[i++]);
+            const ot = (0, tokenize_1.default)(ob);
+            let j = 0;
+            while (j < ot.length) {
+                const oc = ot[j++];
+                if (j >= ot.length) {
+                    break;
+                }
+                if (oc === 'quantity_kind' || oc === 'quantityKind') {
+                    o.quantityKind = (0, tokenize_2.stripWrapping)(ot[j++]);
+                }
+                else if (oc === 'unit') {
+                    o.unit = (0, tokenize_2.stripWrapping)(ot[j++]);
+                }
+                else if (oc === 'as') {
+                    o.as = (0, tokenize_2.stripWrapping)(ot[j++]);
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(ot[j++]);
+                }
+            }
+        }
+        out.push(o);
+    }
+    return out;
+}
+function parseAcceptanceCriteria(block, result) {
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd === 'type') {
+            result.acceptanceCriteriaType = (0, tokenize_2.stripWrapping)(t[i++]);
+            continue;
+        }
+        if (cmd === 'description') {
+            result.acceptanceCriteriaDescription = (0, tokenize_2.stripWrapping)(t[i++]);
+            continue;
+        }
+        if (cmd === 'pass_if') {
+            result.acceptancePassIf = (0, tokenize_2.stripWrapping)(t[i++]);
+            continue;
+        }
+        if (cmd !== 'criterion' && cmd !== 'item') {
+            if (i < t.length) {
+                (0, tokenize_2.unwrapBlock)(t[i - 1]);
+            }
+            continue;
+        }
+        // The criterion name is optional — documentary criteria (description +
+        // reference only) arrive as `criterion { ... }` or `criterion "" { ... }`.
+        let item = '';
+        if (i < t.length && !t[i].startsWith('{')) {
+            item = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        const c = {
+            item,
+            passIf: '',
+            requirementId: '',
+            criterion: '',
+            optional: false,
+            description: '',
+            reference: '',
+            sourceDiscrepancy: null,
+        };
+        if (i < t.length && t[i].startsWith('{')) {
+            const cb = (0, tokenize_2.unwrapBlock)(t[i++]);
+            const ct = (0, tokenize_1.default)(cb);
+            let j = 0;
+            while (j < ct.length) {
+                const cc = ct[j++];
+                if (j >= ct.length) {
+                    break;
+                }
+                if (cc === 'pass_if') {
+                    c.passIf = (0, tokenize_2.stripWrapping)(ct[j++]);
+                }
+                else if (cc === 'requirement' || cc === 'target') {
+                    // `target /req/x` is the cc.yaml alias of `requirement /req/x`.
+                    c.requirementId = (0, tokenize_2.stripWrapping)(ct[j++]);
+                }
+                else if (cc === 'criterion') {
+                    c.criterion = (0, tokenize_2.stripWrapping)(ct[j++]);
+                }
+                else if (cc === 'optional') {
+                    c.optional = (0, tokenize_2.stripWrapping)(ct[j++]) === 'true';
+                }
+                else if (cc === 'description') {
+                    c.description = (0, tokenize_2.stripWrapping)(ct[j++]);
+                }
+                else if (cc === 'reference') {
+                    c.reference = (0, tokenize_2.stripWrapping)(ct[j++]);
+                }
+                else if (cc === 'accepts') {
+                    const ab = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(ct[j++]));
+                    const accepts = { verdict: '', op: '', limit: '' };
+                    for (let k = 0; k + 1 < ab.length; k += 2) {
+                        if (ab[k] === 'verdict') {
+                            accepts.verdict = (0, tokenize_2.stripWrapping)(ab[k + 1]);
+                        }
+                        else if (ab[k] === 'op') {
+                            accepts.op = (0, tokenize_2.stripWrapping)(ab[k + 1]);
+                        }
+                        else if (ab[k] === 'limit') {
+                            accepts.limit = (0, tokenize_2.stripWrapping)(ab[k + 1]);
+                        }
+                    }
+                    c.accepts = accepts;
+                }
+                else if (cc === 'source_discrepancy') {
+                    c.sourceDiscrepancy = (0, sourceDiscrepancy_1.parseSourceDiscrepancy)((0, tokenize_2.unwrapBlock)(ct[j++]));
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(ct[j++]);
+                }
+            }
+        }
+        result.acceptanceCriteria.push(c);
+    }
+}
+function parseDerivedValues(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'value') {
+            if (i < t.length) {
+                (0, tokenize_2.unwrapBlock)(t[i - 1]);
+            }
+            continue;
+        }
+        const name = (0, tokenize_2.stripWrapping)(t[i++]);
+        let expression = '';
+        if (i < t.length && t[i].startsWith('{')) {
+            const vb = (0, tokenize_2.unwrapBlock)(t[i++]);
+            const vt = (0, tokenize_1.default)(vb);
+            let j = 0;
+            while (j < vt.length) {
+                const vc = vt[j++];
+                if (j >= vt.length) {
+                    break;
+                }
+                if (vc === 'expression') {
+                    expression = (0, tokenize_2.stripWrapping)(vt[j++]);
+                }
+                else {
+                    (0, tokenize_2.unwrapBlock)(vt[j++]);
+                }
+            }
+        }
+        out.push({ name, expression });
+    }
+    return out;
+}
+function parseTestSubject(block) {
+    const out = {};
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const key = (0, field_parser_1.stripColon)(t[i++]);
+        if (i >= t.length) {
+            break;
+        }
+        if (t[i] === ':') {
+            i++;
+        }
+        if (i < t.length) {
+            out[key] = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+    }
+    return out;
+}
+function parseInstances(block) {
+    const out = { by: '', values: {} };
+    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 === 'by') {
+            out.by = (0, tokenize_2.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'values') {
+            const vt = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < vt.length) {
+                const key = (0, field_parser_1.stripColon)(vt[j++]);
+                if (j >= vt.length) {
+                    break;
+                }
+                if (vt[j] === ':') {
+                    j++;
+                }
+                if (j < vt.length && vt[j].startsWith('{')) {
+                    const pt = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(vt[j++]));
+                    const params = {};
+                    let k = 0;
+                    while (k < pt.length) {
+                        const pkey = (0, field_parser_1.stripColon)(pt[k++]);
+                        if (k >= pt.length) {
+                            break;
+                        }
+                        if (pt[k] === ':') {
+                            k++;
+                        }
+                        if (k < pt.length) {
+                            params[pkey] = numOrString((0, tokenize_2.stripWrapping)(pt[k++]));
+                        }
+                    }
+                    out.values[key] = params;
+                }
+            }
+        }
+        else {
+            (0, tokenize_2.unwrapBlock)(t[i++]);
+        }
+    }
+    return out;
+}
+const parseConformanceTest = function (id, data) {
+    const result = {
+        id,
+        name: '',
+        type: '',
+        guidance: '',
+        reference: '',
+        targets: [],
+        bindsTo: [],
+        applicability: [],
+        procedure: [],
+        measurements: [],
+        kind: '',
+        obligation: '',
+        obligationNote: '',
+        testSubject: {},
+        variables: [],
+        observables: [],
+        conditionsToEnforce: [],
+        preconditions: [],
+        referenceMaterials: [],
+        requiredCompetence: [],
+        acceptanceCriteria: [],
+        acceptanceCriteriaType: '',
+        acceptanceCriteriaDescription: '',
+        acceptancePassIf: '',
+        design: null,
+        acceptance: null,
+        dependencies: [],
+        instances: null,
+        inheritsFrom: '',
+        resultForms: [],
+        derivedValues: [],
+        sourceDiscrepancy: null,
+    };
+    (0, parse_block_1.forEachEntry)(data, (keyword, value) => {
+        if (keyword === 'name') {
+            result.name = (0, parse_block_1.unwrapped)(value);
+        }
+        else if (keyword === 'purpose') {
+            result.purpose = (0, parse_block_1.unwrapped)(value);
+        }
+        else if (keyword === 'method') {
+            result.method = (0, parse_block_1.unwrapped)(value);
+        }
+        else if (keyword === 'method_ref') {
+            result.methodRef = (0, tokenize_2.stripWrapping)(value());
+        }
+        else if (keyword === 'guidance') {
+            result.guidance = (0, parse_block_1.unwrapped)(value);
+        }
+        else if (keyword === 'type') {
+            result.type = value();
+        }
+        else if (keyword === 'reference') {
+            const refValue = value();
+            if (refValue.startsWith('{')) {
+                const inner = (0, tokenize_1.default)((0, tokenize_2.unwrapBlock)(refValue));
+                if (inner.includes('doc') || inner.includes('clause')) {
+                    // Structured block: reference { doc "urn:…" clause "2.5" } (v2).
+                    // The optional third field `fragment` is the sentence sub-address
+                    // (TODO.roadmap/26) — the dumper emits it, so the parser must
+                    // keep it (codec symmetry, TODO.refactor/16).
+                    const src = {
+                        doc: '',
+                        clause: '',
+                    };
+                    for (let k = 0; k + 1 < inner.length; k += 2) {
+                        if (inner[k] === 'doc') {
+                            src.doc = (0, tokenize_2.stripWrapping)(inner[k + 1]);
+                        }
+                        else if (inner[k] === 'clause') {
+                            src.clause = (0, tokenize_2.stripWrapping)(inner[k + 1]);
+                        }
+                        else if (inner[k] === 'fragment') {
+                            src.fragment = (0, tokenize_2.stripWrapping)(inner[k + 1]);
+                        }
+                    }
+                    if (!result.sourceRef) {
+                        result.sourceRef = src;
+                    }
+                    (result.sourceRefs ??= []).push(src);
+                    if (!result.reference) {
+                        result.reference = src.doc;
+                    }
+                }
+                else {
+                    // Legacy block: reference { R60doc#2.10.1 } — scalar inside braces.
+                    // Clear sourceRefs as well as sourceRef: a mixed construct
+                    // (structured blocks then a legacy scalar) must not dump
+                    // structured blocks its scalar fields deny.
+                    result.sourceRef = null;
+                    result.sourceRefs = undefined;
+                    result.reference = (0, tokenize_2.unwrapBlock)(refValue).trim();
+                }
+            }
+            else {
+                result.sourceRef = null;
+                result.sourceRefs = undefined;
+                result.reference = refValue;
+            }
+        }
+        else if (keyword === 'targets') {
+            result.targets = (0, tokenize_2.tokenizePackage)(value());
+        }
+        else if (keyword === 'binds_to') {
+            result.bindsTo = (0, tokenize_2.tokenizePackage)(value());
+        }
+        else if (keyword === 'applicability') {
+            result.applicability = (0, field_parser_1.parseApplicability)((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'procedure') {
+            const block = value();
+            const tokens = (0, tokenize_2.tokenizePackage)(block);
+            let i = 0;
+            while (i < tokens.length) {
+                const order = parseInt(tokens[i], 10);
+                if (!isNaN(order) && i + 1 < tokens.length) {
+                    const action = (0, parse_block_1.unwrapped)(() => tokens[i + 1]);
+                    const step = {
+                        order,
+                        action,
+                        outputs: [],
+                    };
+                    i += 2;
+                    if (tokens[i] === 'inputs' && i + 1 < tokens.length) {
+                        step.inputs = readStringList(tokens[i + 1]);
+                        i += 2;
+                    }
+                    if (tokens[i] === 'outputs' && i + 1 < tokens.length) {
+                        step.outputs = readStringList(tokens[i + 1]);
+                        i += 2;
+                    }
+                    result.procedure.push(step);
+                }
+                else {
+                    i++;
+                }
+            }
+        }
+        else if (keyword === 'procedure_steps') {
+            result.procedureSteps = readStringList(value());
+        }
+        else if (keyword === 'kind') {
+            result.kind = (0, tokenize_2.stripWrapping)(value());
+        }
+        else if (keyword === 'obligation') {
+            result.obligation = (0, tokenize_2.stripWrapping)(value());
+        }
+        else if (keyword === 'obligation_note') {
+            result.obligationNote = (0, parse_block_1.unwrapped)(value);
+        }
+        else if (keyword === 'test_subject') {
+            result.testSubject = parseTestSubject((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'variables') {
+            result.variables = parseTestVariables((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'observables') {
+            result.observables = parseObservables((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'conditions_to_enforce' ||
+            keyword === 'conditionsToEnforce') {
+            result.conditionsToEnforce = readStringList(value());
+        }
+        else if (keyword === 'preconditions') {
+            result.preconditions = parsePreconditions((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'reference_materials') {
+            result.referenceMaterials = readStringList(value());
+        }
+        else if (keyword === 'required_competence') {
+            result.requiredCompetence = (0, competenceKind_1.parseRequiredCompetence)((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'acceptance_criteria') {
+            parseAcceptanceCriteria((0, tokenize_2.unwrapBlock)(value()), result);
+        }
+        else if (keyword === 'design') {
+            result.design = (0, design_1.parseDesign)((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'acceptance') {
+            result.acceptance = (0, acceptance_1.parseAcceptance)((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'dependencies') {
+            result.dependencies = readStringList(value());
+        }
+        else if (keyword === 'instances') {
+            result.instances = parseInstances((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'inherits_from') {
+            result.inheritsFrom = (0, tokenize_2.stripWrapping)(value());
+        }
+        else if (keyword === 'result_forms') {
+            result.resultForms = readStringList(value());
+        }
+        else if (keyword === 'produces_artifacts') {
+            result.producesArtifacts = readStringList(value());
+        }
+        else if (keyword === 'report_rows') {
+            result.reportRows = readStringList(value());
+        }
+        else if (keyword === 'derived_values') {
+            result.derivedValues = parseDerivedValues((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else if (keyword === 'validate_measurement') {
+            const block = value();
+            const tokens = (0, tokenize_2.tokenizePackage)(block);
+            for (const t of tokens) {
+                if (t.startsWith('"')) {
+                    result.measurements.push((0, tokenize_2.unwrapBlock)(t));
+                }
+            }
+        }
+        else if (keyword === 'source_discrepancy') {
+            result.sourceDiscrepancy = (0, sourceDiscrepancy_1.parseSourceDiscrepancy)((0, tokenize_2.unwrapBlock)(value()));
+        }
+        else {
+            return false;
+        }
+        return true;
+    }, { construct: 'conformance_test', id });
+    return ctx => {
+        ctx.conformanceTests[id] = result;
+        return ctx;
+    };
+};
+exports.parseConformanceTest = parseConformanceTest;
+const dumpConformanceTest = function (ct) {
+    let out = 'conformance_test ' + ct.id + ' {\n';
+    if (ct.name) {
+        out += '  name "' + (0, tokenize_2.escapeString)(ct.name) + '"\n';
+    }
+    if (ct.type) {
+        out += '  type ' + ct.type + '\n';
+    }
+    if (ct.purpose) {
+        out += '  purpose "' + (0, tokenize_2.escapeString)(ct.purpose) + '"\n';
+    }
+    if (ct.method) {
+        out += '  method "' + (0, tokenize_2.escapeString)(ct.method) + '"\n';
+    }
+    if (ct.methodRef) {
+        out += '  method_ref ' + ct.methodRef + '\n';
+    }
+    if (ct.guidance) {
+        out += '  guidance "' + (0, tokenize_2.escapeString)(ct.guidance) + '"\n';
+    }
+    if (ct.sourceRefs && ct.sourceRefs.length > 0) {
+        for (const src of ct.sourceRefs) {
+            out +=
+                '  reference { doc "' +
+                    (0, tokenize_2.escapeString)(src.doc) +
+                    '" clause "' +
+                    (0, tokenize_2.escapeString)(src.clause) +
+                    '"' +
+                    (src.fragment ? ' fragment "' + (0, tokenize_2.escapeString)(src.fragment) + '"' : '') +
+                    ' }\n';
+        }
+    }
+    else if (ct.sourceRef && ct.sourceRef.doc) {
+        out +=
+            '  reference { doc "' +
+                (0, tokenize_2.escapeString)(ct.sourceRef.doc) +
+                '" clause "' +
+                (0, tokenize_2.escapeString)(ct.sourceRef.clause) +
+                '"' +
+                (ct.sourceRef.fragment
+                    ? ' fragment "' + (0, tokenize_2.escapeString)(ct.sourceRef.fragment) + '"'
+                    : '') +
+                ' }\n';
+    }
+    else if (ct.reference) {
+        out += '  reference ' + ct.reference + '\n';
+    }
+    if (ct.targets.length > 0) {
+        out += '  targets {\n';
+        for (const t of ct.targets) {
+            out += '    ' + t + '\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.bindsTo && ct.bindsTo.length > 0) {
+        out += '  binds_to {\n';
+        for (const b of ct.bindsTo) {
+            out += '    ' + b + '\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.applicability.length > 0) {
+        out +=
+            '  applicability {\n    ' +
+                (0, field_parser_1.dumpApplicabilityEntries)(ct.applicability).trim() +
+                '\n  }\n';
+    }
+    if (ct.procedure.length > 0) {
+        out += '  procedure {\n';
+        for (const step of ct.procedure) {
+            let line = '    ' + step.order + ' "' + (0, tokenize_2.escapeString)(step.action) + '"';
+            if (step.inputs && step.inputs.length > 0) {
+                line += ' inputs { ' + step.inputs.join(' ') + ' }';
+            }
+            if (step.outputs.length > 0) {
+                line += ' outputs { ' + step.outputs.join(' ') + ' }';
+            }
+            out += line + '\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.procedureSteps && ct.procedureSteps.length > 0) {
+        out += '  procedure_steps { ' + ct.procedureSteps.join(' ') + ' }\n';
+    }
+    if (ct.measurements.length > 0) {
+        out += '  validate_measurement {\n';
+        for (const m of ct.measurements) {
+            out += '    "' + (0, tokenize_2.escapeString)(m) + '"\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.kind) {
+        out += '  kind ' + ct.kind + '\n';
+    }
+    if (ct.obligation) {
+        out += '  obligation ' + ct.obligation + '\n';
+    }
+    if (ct.obligationNote) {
+        out += '  obligation_note "' + (0, tokenize_2.escapeString)(ct.obligationNote) + '"\n';
+    }
+    if (Object.keys(ct.testSubject).length > 0) {
+        out += '  test_subject {\n';
+        for (const [k, v] of Object.entries(ct.testSubject)) {
+            out += '    ' + k + ': "' + (0, tokenize_2.escapeString)(v) + '"\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.variables.length > 0) {
+        out += '  variables {\n';
+        for (const v of ct.variables) {
+            let line = '    variable ' + v.name + ' { ';
+            if (v.type) {
+                line += 'type ' + v.type + ' ';
+            }
+            if (v.unit) {
+                line += 'unit "' + (0, tokenize_2.escapeString)(v.unit) + '" ';
+            }
+            if (v.source) {
+                line += 'source ' + v.source + ' ';
+            }
+            if (v.derivation) {
+                line += 'derivation "' + (0, tokenize_2.escapeString)(v.derivation) + '" ';
+            }
+            if (v.description) {
+                line += 'description "' + (0, tokenize_2.escapeString)(v.description) + '" ';
+            }
+            if (v.itemType) {
+                line += 'item_type "' + (0, tokenize_2.escapeString)(v.itemType) + '" ';
+            }
+            if (v.series) {
+                line += (0, series_1.dumpSeriesDecl)(v.series) + ' ';
+            }
+            if (v.provenance) {
+                let pv = 'provenance { ';
+                if (v.provenance.channel) {
+                    pv += 'channel ' + v.provenance.channel + ' ';
+                }
+                if (v.provenance.ref) {
+                    pv += 'ref "' + (0, tokenize_2.escapeString)(v.provenance.ref) + '" ';
+                }
+                if (v.provenance.observedAt) {
+                    pv += 'observed_at ' + v.provenance.observedAt + ' ';
+                }
+                if (v.provenance.limitation) {
+                    pv += 'limitation "' + (0, tokenize_2.escapeString)(v.provenance.limitation) + '" ';
+                }
+                line += pv + '} ';
+            }
+            out += line + '}\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.observables.length > 0) {
+        out += '  observables {\n';
+        for (const o of ct.observables) {
+            let line = '    observable ' + o.name + ' { ';
+            if (o.quantityKind) {
+                line += 'quantity_kind ' + o.quantityKind + ' ';
+            }
+            if (o.unit) {
+                line += 'unit "' + (0, tokenize_2.escapeString)(o.unit) + '" ';
+            }
+            if (o.as) {
+                line += 'as "' + (0, tokenize_2.escapeString)(o.as) + '" ';
+            }
+            out += line + '}\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.conditionsToEnforce.length > 0) {
+        out +=
+            '  conditions_to_enforce { ' + ct.conditionsToEnforce.join(' ') + ' }\n';
+    }
+    if (ct.preconditions.length > 0) {
+        out += '  preconditions {\n';
+        for (const p of ct.preconditions) {
+            let line = '    precondition ' + p.id + ' { ';
+            if (p.check) {
+                line += 'check "' + (0, tokenize_2.escapeString)(p.check) + '" ';
+            }
+            if (p.description) {
+                line += 'description "' + (0, tokenize_2.escapeString)(p.description) + '" ';
+            }
+            line += 'on_violation ' + p.onViolation + ' ';
+            if (p.onUnresolvable) {
+                line += 'on_unresolvable ' + p.onUnresolvable + ' ';
+            }
+            out += line + '}\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.referenceMaterials.length > 0) {
+        out +=
+            '  reference_materials { ' + ct.referenceMaterials.join(' ') + ' }\n';
+    }
+    if (ct.requiredCompetence.length > 0) {
+        out += (0, competenceKind_1.dumpRequiredCompetence)(ct.requiredCompetence);
+    }
+    if (ct.acceptanceCriteria.length > 0 ||
+        ct.acceptanceCriteriaType ||
+        ct.acceptancePassIf) {
+        out += '  acceptance_criteria {\n';
+        if (ct.acceptanceCriteriaType) {
+            out += '    type ' + ct.acceptanceCriteriaType + '\n';
+        }
+        if (ct.acceptanceCriteriaDescription) {
+            out +=
+                '    description "' +
+                    (0, tokenize_2.escapeString)(ct.acceptanceCriteriaDescription) +
+                    '"\n';
+        }
+        if (ct.acceptancePassIf) {
+            out += '    pass_if "' + (0, tokenize_2.escapeString)(ct.acceptancePassIf) + '"\n';
+        }
+        for (const c of ct.acceptanceCriteria) {
+            // Documentary criteria carry no name — emit `criterion "" { ... }`
+            // so the re-parse doesn't swallow the block as the name.
+            let line = '    criterion ' + (c.item || '""') + ' { ';
+            if (c.passIf) {
+                line += 'pass_if "' + (0, tokenize_2.escapeString)(c.passIf) + '" ';
+            }
+            if (c.requirementId) {
+                line += 'requirement ' + c.requirementId + ' ';
+            }
+            if (c.criterion) {
+                line += 'criterion ' + c.criterion + ' ';
+            }
+            if (c.optional) {
+                line += 'optional true ';
+            }
+            if (c.description) {
+                line += 'description "' + (0, tokenize_2.escapeString)(c.description) + '" ';
+            }
+            if (c.reference) {
+                line += 'reference "' + (0, tokenize_2.escapeString)(c.reference) + '" ';
+            }
+            if (c.accepts) {
+                line +=
+                    'accepts { verdict ' +
+                        c.accepts.verdict +
+                        ' op ' +
+                        c.accepts.op +
+                        ' limit "' +
+                        (0, tokenize_2.escapeString)(c.accepts.limit) +
+                        '" } ';
+            }
+            if (c.sourceDiscrepancy) {
+                line += (0, sourceDiscrepancy_1.dumpSourceDiscrepancy)(c.sourceDiscrepancy, '') + ' ';
+            }
+            out += line + '}\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.design) {
+        out += (0, design_1.dumpDesign)(ct.design, '  ');
+    }
+    if (ct.acceptance) {
+        out += (0, acceptance_1.dumpAcceptance)(ct.acceptance, '  ') + '\n';
+    }
+    if (ct.dependencies.length > 0) {
+        out += '  dependencies { ' + ct.dependencies.join(' ') + ' }\n';
+    }
+    if (ct.instances) {
+        let line = '  instances { by ' + ct.instances.by + ' values { ';
+        for (const [key, params] of Object.entries(ct.instances.values)) {
+            line += key + ' { ';
+            for (const [pk, pv] of Object.entries(params)) {
+                line += pk + ': ' + pv + ' ';
+            }
+            line += '} ';
+        }
+        out += line + '} }\n';
+    }
+    if (ct.inheritsFrom) {
+        out += '  inherits_from ' + ct.inheritsFrom + '\n';
+    }
+    if (ct.resultForms.length > 0) {
+        out += '  result_forms { ' + ct.resultForms.join(' ') + ' }\n';
+    }
+    if (ct.producesArtifacts && ct.producesArtifacts.length > 0) {
+        out += '  produces_artifacts { ' + ct.producesArtifacts.join(' ') + ' }\n';
+    }
+    if (ct.reportRows && ct.reportRows.length > 0) {
+        out += '  report_rows { ' + ct.reportRows.join(' ') + ' }\n';
+    }
+    if (ct.derivedValues.length > 0) {
+        out += '  derived_values {\n';
+        for (const d of ct.derivedValues) {
+            out +=
+                '    value ' +
+                    d.name +
+                    ' { expression "' +
+                    (0, tokenize_2.escapeString)(d.expression) +
+                    '" }\n';
+        }
+        out += '  }\n';
+    }
+    if (ct.sourceDiscrepancy) {
+        out += (0, sourceDiscrepancy_1.dumpSourceDiscrepancy)(ct.sourceDiscrepancy, '  ') + '\n';
+    }
+    out += '}\n';
+    return out;
+};
+exports.dumpConformanceTest = dumpConformanceTest;
+//# sourceMappingURL=conformanceTest.js.map