@primmel/primmel 1.3.2 → 1.4.0

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

@@ -1,10 +1,619 @@
 "use strict";
+// ─────────────────────────────────────────────────────────────────────
+// `process` construct — v2 MMEL process + v3 process-model extensions
+// (TODO.roadmap/02).
+//
+// The v2 shape is untouched: name/actor/modality, registry I/O
+// (reference_data_registry / output), validate_provision /
+// validate_measurement, canvas page, nested child processes.
+//
+// The v3 additions make the process a recursive subject with two
+// definition forms (concept doc §4):
+//
+//   process creep_test {
+//     name "Creep test method (R 60-2, 2.7.3)"
+//     # IS — signature, invariants, preconditions, executor
+//     signature {
+//       in  { applied_load : mass duration : time }
+//       out { indication_series : mass_series }
+//     }
+//     invariants { "ocl{self.applied_load <= self.e_max}" }
+//     preconditions {
+//       precondition warmed-up {
+//         check "ocl{self.state = #ready and self.warmed_up}"
+//         description "An unwarmed run is invalid, never a fail."
+//         on_violation invalid
+//       }
+//     }
+//     executor lab
+//     # HAS — registers, state
+//     registers { conditions_log : text indication_series : mass_series }
+//     state OperationalStates
+//     # per-classification instances (R 60: n_runs A/B=5, C/D=3)
+//     instances {
+//       by accuracy_class
+//       values { A { n_runs: 5 } B { n_runs: 5 } C { n_runs: 3 } D { n_runs: 3 } }
+//     }
+//     # DOES — the executable body (absent = abstract form, always valid)
+//     does {
+//       start_event s
+//       action stabilize  { executor actor role lab_technician capture stab_form write { conditions_log } }
+//       action apply_load { executor actor role lab_technician read { applied_load } }
+//       action hold       { executor machine wait duration }
+//       action record     { executor machine read { applied_load } write { indication_series } }
+//       end_event e
+//       flow {
+//         s -> stabilize -> apply_load -> hold -> record -> e
+//       }
+//     }
+//   }
+//
+// A step may declare `fires <transition>` (TODO.roadmap/07): when the step
+// completes, the process's bound state machine (`state <machineRef>`) takes
+// the named transition — e.g. `action warm_up { executor machine fires warm }`
+// drives an operational machine off → ready.
+//
+// A step may declare `calls <process>` (TODO.roadmap/38): the step invokes
+// a sub-process, binding its declared signature —
+// `calls creep_method { with { in { applied_load : test_load } out { indication_series : raw } } }`
+// maps every callee IN parameter to a caller register (read) and every
+// callee OUT parameter back to a caller register (write). The linter
+// (C76 subprocess-signature-bound) checks resolution, completeness and
+// kind compatibility; the caller-side names count as step I/O for
+// C12/C13/C75.
+//
+// Step kinds: action, approval, gateway, parallel_gateway, start_event,
+// end_event, timer_event (period for recurrence), signal_event. Flow
+// edges chain (`a -> b -> c`); an optional `{ when "ocl{...}" }` body
+// conditions the LAST hop of a chain (first match in document order wins
+// at a gateway; the unconditioned edge is the default).
+//
+// `child_composition gateway` (default `all`) declares how the process's
+// CHILDREN combine for the coverage calculus (TODO.roadmap/04): `all` =
+// every child required; `gateway` = the children are exclusive branches
+// and at least one suffices for minimal cover.
+//
+// `activity_kind { <id>+ }` (TODO.roadmap/39) classifies the process
+// against the ISO/IEC 17000 functional-approach activity taxonomy —
+// multi-kind is deliberate (ISO/IEC 17065 §7.4 "evaluation" = selection +
+// determination). Classification, not inheritance; the ids resolve against
+// a declared activity_archetype register when one is in scope (C58).
+//
+// `segregation { constraint <id> { … } }` (TODO.roadmap/39b) declares the
+// ISO/IEC 17065 role-segregation constraints as first-class structure —
+// review/decision personnel disjoint from evaluation personnel (7.5.1 /
+// 7.6.2), complaint-resolution independence (7.13.5, the reserved
+// `case_personnel` pair member), and the consultancy bars (4.2.10
+// body-specified period; 7.13.6 fixed P2Y):
+//
+//   segregation {
+//     constraint review_not_evaluation {
+//       kind case_personnel_disjoint
+//       clause "7.5.1"
+//       pair { review evaluation }
+//       statement "The review shall be carried out by person(s) who have
+//         not been involved in the evaluation process."
+//     }
+//     constraint complaint_two_year_bar {
+//       kind consultancy_bar
+//       clause "7.13.6"
+//       period P2Y
+//       barred { consultancy employment }
+//       statement "…"
+//     }
+//   }
+//
+// Pair members are PROCESS ids (a process's personnel set for the case at
+// hand), never roles — a scheme may bind one role to evaluation, review
+// AND decision, so the norms quantify over process involvement. C59
+// (segregation-members-resolve) checks declaration well-formedness.
+// ─────────────────────────────────────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dumpProcess = exports.resolveProcess = exports.parseProcess = void 0;
 exports.dumpProcessTree = dumpProcessTree;
 const resolve_1 = require("../resolve");
 const tokenize_1 = require("../tokenize");
 const parse_block_1 = require("../parse-block");
+const field_parser_1 = require("./field-parser");
+const quantity_1 = require("./quantity");
+/** 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;
+}
+/** A token that heads a `key :` entry: unquoted, trailing colon. */
+function isKeyHead(tok) {
+    return !tok.startsWith('"') && tok.endsWith(':') && tok.length > 1;
+}
+// ── v3 block sub-parsers ─────────────────────────────────────────────
+/**
+ * Read `name [: type]` entries (signature params, registers, call
+ * bindings). When `allowInitial` is set (registers only — TODO.roadmap/50),
+ * an entry may carry an INITIAL value: `name : type = <value> [unit]`.
+ * The value shape follows the instance `key : value [unit]` contract
+ * (ser-des/config/instance.ts readValueMap): the value is one token
+ * (quoted strings stay one token), the optional unit a second, and a
+ * single brace-block token is the QuantityValue block form
+ * (`= { value 2.2 unit t }`); anything more is a parse error — multi-word
+ * values must be quoted so the unit position stays unambiguous. Entry
+ * boundaries: the next entry head is a bare `name` token followed by a
+ * `:` token, or an attached-colon `name:` token.
+ */
+function parseParamList(block, allowInitial = false) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const name = (0, field_parser_1.stripColon)(t[i++]);
+        if (!name) {
+            break;
+        }
+        let type = '';
+        if (i < t.length && t[i] === ':') {
+            i++;
+        }
+        if (i < t.length) {
+            type = (0, tokenize_1.stripWrapping)(t[i++]);
+        }
+        const param = { name, type };
+        if (i < t.length && t[i] === '=') {
+            if (!allowInitial) {
+                throw new Error(`Parsing error: parameter "${name}" declares an initial value — initial values are a registers facet (signature parameters and call bindings take their values at the call)`);
+            }
+            i++;
+            const parts = [];
+            while (i < t.length && t[i + 1] !== ':' && !isKeyHead(t[i])) {
+                parts.push(t[i++]);
+            }
+            if (parts.length === 0) {
+                throw new Error(`Parsing error: register "${name}" declares "=" with no value (shape: name : type = value [unit])`);
+            }
+            if (parts.length > 2) {
+                throw new Error(`Parsing error: register "${name}" initial value has ${parts.length} tokens ` +
+                    `(shape: name : type = value [unit]) — quote multi-word values`);
+            }
+            // QuantityValue block form: `= { value … unit … }`.
+            if (parts.length === 1 && parts[0].startsWith('{')) {
+                param.initial = (0, quantity_1.readQuantityBlock)((0, tokenize_1.unwrapBlock)(parts[0]));
+            }
+            else {
+                const [rawValue, rawUnit] = parts;
+                const value = (0, quantity_1.coerceValueToken)(rawValue);
+                const initial = rawUnit === undefined
+                    ? { value }
+                    : { value, unit: (0, tokenize_1.stripWrapping)(rawUnit) };
+                param.initial = initial;
+            }
+        }
+        out.push(param);
+    }
+    return out;
+}
+/** Read OCL entries — quoted strings or bare `ocl{…}` (reassembled). */
+function parseOclList(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const read = (0, field_parser_1.readValueToken)(t, i);
+        const text = (0, tokenize_1.stripWrapping)(read.text);
+        i = read.next;
+        if (text) {
+            out.push(text);
+        }
+    }
+    return out;
+}
+/**
+ * Forward-compatible skip of an unknown keyword entry. `i` is the index
+ * AFTER the unknown keyword; consumes the optional value and, when a
+ * `{ … }` block follows, the balanced block — so `kw value`,
+ * `kw { block }`, and `kw value { block }` all stay aligned with the
+ * token walk (the tokenizer keeps a `{…}` group as ONE balanced token).
+ */
+function skipUnknownEntry(t, i) {
+    if (i >= t.length) {
+        return i;
+    }
+    if (t[i].startsWith('{')) {
+        return i + 1; // `kw { block }`
+    }
+    i++; // the value
+    if (i < t.length && t[i].startsWith('{')) {
+        i++; // `kw value { block }`
+    }
+    return i;
+}
+/**
+ * Preconditions — same shape as conformance-test preconditions (an OCL
+ * Boolean check, a description, and the violation outcome). The outcome
+ * is always `invalid` (a violated entry guard voids the run, never fails
+ * it); the keyword is carried for parallelism with cc.yaml.
+ */
+function parseProcessPreconditions(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'precondition') {
+            i = skipUnknownEntry(t, i);
+            continue;
+        }
+        const pid = (0, tokenize_1.stripWrapping)(t[i++]);
+        const p = {
+            id: pid,
+            check: '',
+            description: '',
+            onViolation: 'invalid',
+        };
+        if (i < t.length && t[i].startsWith('{')) {
+            const pt = (0, tokenize_1.default)((0, tokenize_1.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < pt.length) {
+                const pc = pt[j++];
+                if (j >= pt.length) {
+                    break;
+                }
+                if (pc === 'check') {
+                    const read = (0, field_parser_1.readValueToken)(pt, j);
+                    p.check = (0, tokenize_1.stripWrapping)(read.text);
+                    j = read.next;
+                }
+                else if (pc === 'description') {
+                    p.description = (0, tokenize_1.stripWrapping)(pt[j++]);
+                }
+                else if (pc === 'on_violation') {
+                    p.onViolation = (0, tokenize_1.stripWrapping)(pt[j++]);
+                }
+                else {
+                    (0, tokenize_1.unwrapBlock)(pt[j++]);
+                }
+            }
+        }
+        out.push(p);
+    }
+    return out;
+}
+/**
+ * Segregation constraints (TODO.roadmap/39b): `constraint <id> { … }`
+ * entries of a `segregation { … }` block — the ISO/IEC 17065
+ * non-involvement rules as first-class structure (kind, clause, pair /
+ * period / barred, statement).
+ */
+function parseSegregation(block) {
+    const out = [];
+    const t = (0, tokenize_1.default)(block);
+    let i = 0;
+    while (i < t.length) {
+        const cmd = t[i++];
+        if (cmd !== 'constraint') {
+            i = skipUnknownEntry(t, i);
+            continue;
+        }
+        const sid = (0, tokenize_1.stripWrapping)(t[i++]);
+        const entry = {
+            id: sid,
+            kind: '',
+            clause: '',
+            pair: [],
+            period: '',
+            barred: [],
+            statement: '',
+        };
+        if (i < t.length && t[i].startsWith('{')) {
+            const et = (0, tokenize_1.default)((0, tokenize_1.unwrapBlock)(t[i++]));
+            let j = 0;
+            while (j < et.length) {
+                const ec = et[j++];
+                if (j >= et.length) {
+                    break;
+                }
+                if (ec === 'kind') {
+                    entry.kind = (0, tokenize_1.stripWrapping)(et[j++]);
+                }
+                else if (ec === 'clause') {
+                    entry.clause = (0, tokenize_1.stripWrapping)(et[j++]);
+                }
+                else if (ec === 'pair') {
+                    entry.pair.push(...(0, tokenize_1.default)((0, tokenize_1.stripWrapping)(et[j++]))
+                        .map(field_parser_1.stripColon)
+                        .map(tokenize_1.stripWrapping)
+                        .filter(s => s.length > 0));
+                }
+                else if (ec === 'period') {
+                    entry.period = (0, tokenize_1.stripWrapping)(et[j++]);
+                }
+                else if (ec === 'barred') {
+                    entry.barred.push(...(0, tokenize_1.default)((0, tokenize_1.stripWrapping)(et[j++]))
+                        .map(field_parser_1.stripColon)
+                        .map(tokenize_1.stripWrapping)
+                        .filter(s => s.length > 0));
+                }
+                else if (ec === 'statement') {
+                    entry.statement = (0, tokenize_1.stripWrapping)(et[j++]);
+                }
+                else {
+                    (0, tokenize_1.unwrapBlock)(et[j++]);
+                }
+            }
+        }
+        out.push(entry);
+    }
+    return out;
+}
+/** Per-classification instances: `by <dimension> values { V { k: n } … }`. */ function parseProcessInstances(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_1.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'values') {
+            const vt = (0, tokenize_1.default)((0, tokenize_1.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_1.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_1.stripWrapping)(pt[k++]));
+                        }
+                    }
+                    out.values[key] = params;
+                }
+            }
+        }
+        else {
+            (0, tokenize_1.unwrapBlock)(t[i++]);
+        }
+    }
+    return out;
+}
+const STEP_KINDS = new Set([
+    'action',
+    'approval',
+    'gateway',
+    'parallel_gateway',
+    'start_event',
+    'end_event',
+    'timer_event',
+    'signal_event',
+]);
+/** Read one step body (the `{ … }` after `<kind> <id>`). */
+function parseStepBody(id, kind, block) {
+    const step = {
+        id,
+        kind,
+        executor: '',
+        role: '',
+        capture: '',
+        reads: [],
+        writes: [],
+        wait: '',
+        period: '',
+        signal: '',
+        fires: '',
+        calls: '',
+        callIn: [],
+        callOut: [],
+        description: '',
+    };
+    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 === 'executor') {
+            const ex = (0, tokenize_1.stripWrapping)(t[i++]);
+            if (ex !== 'machine' && ex !== 'actor') {
+                throw new Error(`Parsing error: process step. ID ${id}: Unknown executor ${ex} (valid: machine, actor)`);
+            }
+            step.executor = ex;
+        }
+        else if (cmd === 'role') {
+            step.role = (0, tokenize_1.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'capture') {
+            step.capture = (0, tokenize_1.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'read') {
+            step.reads.push(...(0, tokenize_1.default)((0, tokenize_1.stripWrapping)(t[i++]))
+                .map(field_parser_1.stripColon)
+                .map(tokenize_1.stripWrapping)
+                .filter(s => s.length > 0));
+        }
+        else if (cmd === 'write') {
+            step.writes.push(...(0, tokenize_1.default)((0, tokenize_1.stripWrapping)(t[i++]))
+                .map(field_parser_1.stripColon)
+                .map(tokenize_1.stripWrapping)
+                .filter(s => s.length > 0));
+        }
+        else if (cmd === 'wait') {
+            step.wait = (0, tokenize_1.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'period') {
+            step.period = (0, tokenize_1.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'signal') {
+            step.signal = (0, tokenize_1.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'fires') {
+            step.fires = (0, tokenize_1.stripWrapping)(t[i++]);
+        }
+        else if (cmd === 'calls') {
+            // calls <process> — optionally followed by a `with { in {…} out {…} }`
+            // signature-binding block (TODO.roadmap/38). The binding lists reuse
+            // the `name : name` param-list shape: callee param : caller name.
+            step.calls = (0, tokenize_1.stripWrapping)(t[i++]);
+            if (i < t.length && t[i].startsWith('{')) {
+                const bind = (b) => parseParamList((0, tokenize_1.unwrapBlock)(b)).map(p => ({
+                    param: p.name,
+                    bind: p.type,
+                }));
+                const ct = (0, tokenize_1.default)((0, tokenize_1.unwrapBlock)(t[i++]));
+                let j = 0;
+                while (j < ct.length) {
+                    const cc = ct[j++];
+                    if (j >= ct.length) {
+                        break;
+                    }
+                    if (cc === 'with') {
+                        const wt = (0, tokenize_1.default)((0, tokenize_1.unwrapBlock)(ct[j++]));
+                        let k = 0;
+                        while (k < wt.length) {
+                            const wc = wt[k++];
+                            if (k >= wt.length) {
+                                break;
+                            }
+                            if (wc === 'in') {
+                                step.callIn.push(...bind(wt[k++]));
+                            }
+                            else if (wc === 'out') {
+                                step.callOut.push(...bind(wt[k++]));
+                            }
+                            else {
+                                (0, tokenize_1.unwrapBlock)(wt[k++]);
+                            }
+                        }
+                    }
+                    else {
+                        j = skipUnknownEntry(ct, j);
+                    }
+                }
+            }
+        }
+        else if (cmd === 'description') {
+            step.description = (0, tokenize_1.stripWrapping)(t[i++]);
+        }
+        else {
+            i = skipUnknownEntry(t, i);
+        }
+    }
+    return step;
+}
+/**
+ * Read the flow block: chained edges `a -> b -> c`, each hop optionally
+ * followed by `{ when "ocl{…}" }` (the condition binds to the LAST hop
+ * of the chain). `condition` is accepted as an alias of `when` for
+ * symmetry with canvas edges.
+ *
+ * A FUSED arrow (`s->a->e`, `s→a→e` — no whitespace around the arrow)
+ * tokenizes as ONE token and would otherwise yield zero edges, surfacing
+ * later as misleading C11 errors. Reject it at parse time with a clear
+ * message instead of silently dropping the chain or attempting to split
+ * it. Block (`{…}`) and quoted tokens are exempt — an OCL `->` inside a
+ * `when` condition is not a flow arrow.
+ */
+function parseFlowEdges(block) {
+    const edges = [];
+    const t = (0, tokenize_1.default)(block);
+    for (const tok of t) {
+        if (!tok.startsWith('{') &&
+            !tok.startsWith('"') &&
+            tok !== '->' &&
+            tok !== '→' &&
+            (tok.includes('->') || tok.includes('→'))) {
+            throw new Error(`Parsing error: process flow edge "${tok}" contains a fused arrow — separate steps and "->" with whitespace`);
+        }
+    }
+    let i = 0;
+    while (i < t.length) {
+        let current = (0, tokenize_1.stripWrapping)(t[i++]);
+        if (!current) {
+            break;
+        }
+        while (i < t.length && (t[i] === '->' || t[i] === '→')) {
+            i++;
+            if (i >= t.length) {
+                break;
+            }
+            const to = (0, tokenize_1.stripWrapping)(t[i++]);
+            let condition = '';
+            if (i < t.length && t[i].startsWith('{')) {
+                const bt = (0, tokenize_1.default)((0, tokenize_1.unwrapBlock)(t[i++]));
+                let j = 0;
+                while (j < bt.length) {
+                    const cmd = bt[j++];
+                    if (j >= bt.length) {
+                        break;
+                    }
+                    if (cmd === 'when' || cmd === 'condition') {
+                        const read = (0, field_parser_1.readValueToken)(bt, j);
+                        condition = (0, tokenize_1.stripWrapping)(read.text);
+                        j = read.next;
+                    }
+                    else {
+                        (0, tokenize_1.unwrapBlock)(bt[j++]);
+                    }
+                }
+            }
+            edges.push({ from: current, to, condition });
+            current = to;
+        }
+    }
+    return edges;
+}
+/** Read the `does { … }` executable body: step declarations + one flow block. */
+function parseDoes(block) {
+    const flow = { steps: [], edges: [] };
+    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 === 'flow') {
+            flow.edges.push(...parseFlowEdges((0, tokenize_1.unwrapBlock)(t[i++])));
+        }
+        else if (STEP_KINDS.has(cmd)) {
+            const stepId = (0, tokenize_1.stripWrapping)(t[i++]);
+            let body = '';
+            if (i < t.length && t[i].startsWith('{')) {
+                body = (0, tokenize_1.unwrapBlock)(t[i++]);
+            }
+            flow.steps.push(parseStepBody(stepId, cmd, body));
+        }
+        else {
+            // Forward-compatible: skip `kw value` and `kw id { body }` shapes.
+            const v = t[i++];
+            if (v !== undefined &&
+                !v.startsWith('{') &&
+                i < t.length &&
+                t[i].startsWith('{')) {
+                i++;
+            }
+        }
+    }
+    return flow;
+}
+// ── process parser ───────────────────────────────────────────────────
 const parseProcess = function (id, data) {
     const result = {
         id: id,
@@ -18,6 +627,20 @@ const parseProcess = function (id, data) {
         measure: [],
         parent: '',
         children: [],
+        // v3 process model — defaults keep a plain v2 process exactly as before
+        signature: null,
+        invariants: [],
+        activityKinds: [],
+        segregation: [],
+        preconditions: [],
+        executor: '',
+        registers: [],
+        state: '',
+        instances: null,
+        childComposition: 'all',
+        does: null,
+        source: null,
+        provisionRefs: [],
         _relations: {
             actor: '',
             output: [],
@@ -84,6 +707,84 @@ const parseProcess = function (id, data) {
         else if (keyword === 'reference_data_registry') {
             result._relations.input = (0, tokenize_1.tokenizePackage)(value());
         }
+        else if (keyword === 'signature') {
+            // signature { in { … } out { … } }
+            const sig = { inputs: [], outputs: [] };
+            const st = (0, tokenize_1.default)((0, tokenize_1.unwrapBlock)(value()));
+            let j = 0;
+            while (j < st.length) {
+                const sc = st[j++];
+                if (j >= st.length) {
+                    break;
+                }
+                if (sc === 'in') {
+                    sig.inputs.push(...parseParamList((0, tokenize_1.unwrapBlock)(st[j++])));
+                }
+                else if (sc === 'out') {
+                    sig.outputs.push(...parseParamList((0, tokenize_1.unwrapBlock)(st[j++])));
+                }
+                else {
+                    (0, tokenize_1.unwrapBlock)(st[j++]);
+                }
+            }
+            result.signature = sig;
+        }
+        else if (keyword === 'invariants') {
+            result.invariants = parseOclList((0, tokenize_1.unwrapBlock)(value()));
+        }
+        else if (keyword === 'activity_kind') {
+            // activity_kind { testing verification … } — ISO/IEC 17000
+            // functional-approach classification (TODO.roadmap/39; C58).
+            result.activityKinds = (0, tokenize_1.default)((0, tokenize_1.stripWrapping)(value()))
+                .map(field_parser_1.stripColon)
+                .map(tokenize_1.stripWrapping)
+                .filter(s => s.length > 0);
+        }
+        else if (keyword === 'segregation') {
+            // segregation { constraint <id> { … } … } — ISO/IEC 17065 role
+            // segregation (TODO.roadmap/39b; C59).
+            result.segregation = parseSegregation((0, tokenize_1.unwrapBlock)(value()));
+        }
+        else if (keyword === 'preconditions') {
+            result.preconditions = parseProcessPreconditions((0, tokenize_1.unwrapBlock)(value()));
+        }
+        else if (keyword === 'executor') {
+            result.executor = (0, tokenize_1.stripWrapping)(value());
+        }
+        else if (keyword === 'registers') {
+            // registers { name : type [= value [unit]] … } — HAS state slots;
+            // the optional initial value is the register's starting content
+            // (TODO.roadmap/50).
+            result.registers = parseParamList((0, tokenize_1.unwrapBlock)(value()), true);
+        }
+        else if (keyword === 'state') {
+            result.state = (0, tokenize_1.stripWrapping)(value());
+        }
+        else if (keyword === 'instances') {
+            result.instances = parseProcessInstances((0, tokenize_1.unwrapBlock)(value()));
+        }
+        else if (keyword === 'child_composition') {
+            const comp = (0, tokenize_1.stripWrapping)(value());
+            if (comp !== 'all' && comp !== 'gateway') {
+                throw new Error(`Parsing error: process. ID ${id}: Unknown child_composition "${comp}" (valid: all, gateway)`);
+            }
+            result.childComposition = comp;
+        }
+        else if (keyword === 'does') {
+            // The presence of the body marks the process EXECUTABLE — even an
+            // empty `does { }` (the linter then reports the missing start event).
+            result.does = parseDoes((0, tokenize_1.unwrapBlock)(value()));
+        }
+        else if (keyword === 'source') {
+            // Clause-URN provenance — the same facet requirement carries.
+            // Repeated source blocks collect into sourceRefs (TODO.roadmap/24);
+            // source stays the first entry for back-compatibility.
+            const src = (0, field_parser_1.readSource)((0, tokenize_1.unwrapBlock)(value()));
+            if (!result.source) {
+                result.source = src;
+            }
+            (result.sourceRefs ??= []).push(src);
+        }
         else {
             return false;
         }
@@ -105,6 +806,10 @@ const resolveProcess = function (ctx, unresolved) {
         output: [],
         input: [],
         provision: [],
+        // The raw validate_provision ids survive resolution even when they
+        // name no declared `provision` construct (e.g. `/req/cs/*`
+        // requirements) — the linter and the dumper read this list.
+        provisionRefs: [..._relations.provision],
         actor: null,
         page: null,
     };
@@ -142,14 +847,14 @@ function indentBlock(block) {
         .map(line => (line ? '  ' + line : line))
         .join('\n');
 }
-function dumpProcessTree(process, lookup) {
-    let out = (0, exports.dumpProcess)(process);
+function dumpProcessTree(process, lookup, nested = false) {
+    let out = (0, exports.dumpProcess)(process, { nested });
     if (process.children.length > 0) {
         const childBlocks = [];
         for (const childId of process.children) {
             const child = lookup.get(childId);
             if (child) {
-                childBlocks.push(indentBlock(dumpProcessTree(child, lookup)));
+                childBlocks.push(indentBlock(dumpProcessTree(child, lookup, true)));
             }
         }
         if (childBlocks.length > 0) {
@@ -158,7 +863,102 @@ function dumpProcessTree(process, lookup) {
     }
     return out;
 }
-const dumpProcess = function (process) {
+// ── v3 block dumpers ─────────────────────────────────────────────────
+function dumpParamList(params) {
+    return params
+        .map(p => p.name +
+        (p.type ? ' : ' + p.type : '') +
+        (p.initial !== undefined ? ' = ' + (0, quantity_1.dumpQuantityValue)(p.initial) : ''))
+        .join(' ');
+}
+function dumpSignature(sig) {
+    let out = '  signature {\n';
+    if (sig.inputs.length > 0) {
+        out += '    in { ' + dumpParamList(sig.inputs) + ' }\n';
+    }
+    if (sig.outputs.length > 0) {
+        out += '    out { ' + dumpParamList(sig.outputs) + ' }\n';
+    }
+    out += '  }\n';
+    return out;
+}
+function dumpStep(step) {
+    const inner = [];
+    if (step.executor) {
+        inner.push('executor ' + step.executor);
+    }
+    if (step.role) {
+        inner.push('role ' + (0, field_parser_1.dumpBareSafe)(step.role));
+    }
+    if (step.capture) {
+        inner.push('capture ' + (0, field_parser_1.dumpBareSafe)(step.capture));
+    }
+    if (step.reads.length > 0) {
+        inner.push('read { ' + step.reads.map(field_parser_1.dumpBareSafe).join(' ') + ' }');
+    }
+    if (step.writes.length > 0) {
+        inner.push('write { ' + step.writes.map(field_parser_1.dumpBareSafe).join(' ') + ' }');
+    }
+    if (step.wait) {
+        inner.push('wait ' + (0, field_parser_1.dumpBareSafe)(step.wait));
+    }
+    if (step.period) {
+        inner.push('period ' + (0, field_parser_1.dumpBareSafe)(step.period));
+    }
+    if (step.signal) {
+        inner.push('signal ' + (0, field_parser_1.dumpBareSafe)(step.signal));
+    }
+    if (step.fires) {
+        inner.push('fires ' + (0, field_parser_1.dumpBareSafe)(step.fires));
+    }
+    if (step.calls) {
+        let c = 'calls ' + (0, field_parser_1.dumpBareSafe)(step.calls);
+        if (step.callIn.length > 0 || step.callOut.length > 0) {
+            const bind = (bs) => bs
+                .map(b => (0, field_parser_1.dumpBareSafe)(b.param) + ' : ' + (0, field_parser_1.dumpBareSafe)(b.bind))
+                .join(' ');
+            c += ' { with {';
+            if (step.callIn.length > 0) {
+                c += ' in { ' + bind(step.callIn) + ' }';
+            }
+            if (step.callOut.length > 0) {
+                c += ' out { ' + bind(step.callOut) + ' }';
+            }
+            c += ' } }';
+        }
+        inner.push(c);
+    }
+    if (step.description) {
+        inner.push('description "' + (0, tokenize_1.escapeString)(step.description) + '"');
+    }
+    if (inner.length === 0) {
+        return '    ' + step.kind + ' ' + step.id + '\n';
+    }
+    return '    ' + step.kind + ' ' + step.id + ' { ' + inner.join(' ') + ' }\n';
+}
+function dumpDoes(flow) {
+    let out = '  does {\n';
+    for (const s of flow.steps) {
+        out += dumpStep(s);
+    }
+    if (flow.edges.length > 0) {
+        out += '    flow {\n';
+        for (const e of flow.edges) {
+            out += '      ' + e.from + ' -> ' + e.to;
+            if (e.condition) {
+                out += ' { when "' + (0, tokenize_1.escapeString)(e.condition) + '" }';
+            }
+            out += '\n';
+        }
+        out += '    }\n';
+    }
+    out += '  }\n';
+    return out;
+}
+// Wider than Dumper<Process> by one OPTIONAL context arg (still
+// assignable to Dumper<Process>): `nested` marks emission inside the
+// parent's block, where the nesting itself expresses the parent link.
+const dumpProcess = function (process, ctx) {
     let out = 'process ' + process.id + ' {\n';
     out += '  name "' + (0, tokenize_1.escapeString)(process.name) + '"\n';
     if (process.actor !== null) {
@@ -174,10 +974,10 @@ const dumpProcess = function (process) {
         }
         out += '  }\n';
     }
-    if (process.provision.length > 0) {
+    if (process.provisionRefs.length > 0) {
         out += '  validate_provision {\n';
-        for (const r of process.provision) {
-            out += '    ' + r.id + '\n';
+        for (const id of process.provisionRefs) {
+            out += '    ' + id + '\n';
         }
         out += '  }\n';
     }
@@ -198,7 +998,114 @@ const dumpProcess = function (process) {
     if (process.page !== null) {
         out += '  canvas ' + process.page.id + '\n';
     }
-    if (process.parent && process.children.length === 0) {
+    // ── v3 blocks (emitted only when declared) ──
+    if (process.signature !== null && process.signature !== undefined) {
+        out += dumpSignature(process.signature);
+    }
+    if (process.invariants && process.invariants.length > 0) {
+        out += '  invariants {\n';
+        for (const inv of process.invariants) {
+            out += '    "' + (0, tokenize_1.escapeString)(inv) + '"\n';
+        }
+        out += '  }\n';
+    }
+    if (process.activityKinds && process.activityKinds.length > 0) {
+        out +=
+            '  activity_kind { ' +
+                process.activityKinds.map(field_parser_1.dumpBareSafe).join(' ') +
+                ' }\n';
+    }
+    if (process.segregation && process.segregation.length > 0) {
+        out += '  segregation {\n';
+        for (const s of process.segregation) {
+            out += '    constraint ' + s.id + ' {\n';
+            if (s.kind) {
+                out += '      kind ' + (0, field_parser_1.dumpBareSafe)(s.kind) + '\n';
+            }
+            if (s.clause) {
+                out += '      clause "' + (0, tokenize_1.escapeString)(s.clause) + '"\n';
+            }
+            if (s.pair.length > 0) {
+                out += '      pair { ' + s.pair.map(field_parser_1.dumpBareSafe).join(' ') + ' }\n';
+            }
+            if (s.period) {
+                out += '      period ' + (0, field_parser_1.dumpBareSafe)(s.period) + '\n';
+            }
+            if (s.barred.length > 0) {
+                out +=
+                    '      barred { ' + s.barred.map(field_parser_1.dumpBareSafe).join(' ') + ' }\n';
+            }
+            if (s.statement) {
+                out += '      statement "' + (0, tokenize_1.escapeString)(s.statement) + '"\n';
+            }
+            out += '    }\n';
+        }
+        out += '  }\n';
+    }
+    if (process.preconditions && process.preconditions.length > 0) {
+        out += '  preconditions {\n';
+        for (const p of process.preconditions) {
+            let line = '    precondition ' + p.id + ' { ';
+            if (p.check) {
+                line += 'check "' + (0, tokenize_1.escapeString)(p.check) + '" ';
+            }
+            if (p.description) {
+                line += 'description "' + (0, tokenize_1.escapeString)(p.description) + '" ';
+            }
+            line += 'on_violation ' + p.onViolation + ' ';
+            out += line + '}\n';
+        }
+        out += '  }\n';
+    }
+    if (process.executor) {
+        out += '  executor ' + (0, field_parser_1.dumpBareSafe)(process.executor) + '\n';
+    }
+    if (process.registers && process.registers.length > 0) {
+        out += '  registers { ' + dumpParamList(process.registers) + ' }\n';
+    }
+    if (process.state) {
+        out += '  state ' + (0, field_parser_1.dumpBareSafe)(process.state) + '\n';
+    }
+    if (process.instances) {
+        let line = '  instances { by ' + process.instances.by + ' values { ';
+        for (const [key, params] of Object.entries(process.instances.values)) {
+            line += key + ' { ';
+            for (const [pk, pv] of Object.entries(params)) {
+                line += pk + ': ' + (0, field_parser_1.dumpBareSafe)(String(pv)) + ' ';
+            }
+            line += '} ';
+        }
+        out += line + '} }\n';
+    }
+    if (process.childComposition === 'gateway') {
+        out += '  child_composition gateway\n';
+    }
+    if (process.does) {
+        out += dumpDoes(process.does);
+    }
+    // Clause-URN provenance (the requirement facet shape) — repeated blocks
+    // from sourceRefs, single-block fallback.
+    for (const src of process.sourceRefs ??
+        (process.source && (process.source.doc || process.source.clause)
+            ? [process.source]
+            : [])) {
+        out +=
+            '  source { doc "' +
+                (0, tokenize_1.escapeString)(src.doc) +
+                '" clause "' +
+                (0, tokenize_1.escapeString)(src.clause) +
+                '"' +
+                (src.fragment ? ' fragment "' + (0, tokenize_1.escapeString)(src.fragment) + '"' : '') +
+                ' }\n';
+    }
+    // A `parent` link is emitted explicitly whenever nesting does not
+    // already express it: leaf processes keep the historical flat form,
+    // and a non-leaf process dumped at TOP LEVEL (a flat `parent X`
+    // declaration that itself has children) must emit it too — dropping it
+    // would silently re-root the subtree across a dump/load cycle, which
+    // the coverage calculus aggregates over. A non-leaf process dumped
+    // NESTED inside its parent needs no line (the nesting expresses it).
+    if (process.parent && (process.children.length === 0 || !ctx?.nested)) {
         out += '  parent ' + process.parent + '\n';
     }
     out += '}\n';