@primmel/primmel 1.21.12 → 1.21.14

package/dist-cli/primmel.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // scripts/check.mts
-import { existsSync as existsSync8, readdirSync as readdirSync7, statSync as statSync4, writeFileSync } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync8, statSync as statSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join10 } from "node:path";
 
 // src/check.ts
 import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
@@ -200,16 +200,44 @@ function parse(mmelString, parsers, options = {}) {
       continue;
     }
     if (cfg.takesID) {
-      if (i + 1 > tokens.length) {
+      let formatTok;
+      if (cfg.takesFormat) {
+        const f = tokens[i++];
+        if (!["xml", "yaml", "json", "toml", "csv"].includes(f.value)) {
+          throw new Error(
+            `Parsing error: mapping. Unknown format "${f.value}" at line ${f.start.line} col ${f.start.col} (xml, yaml, json, toml, csv)`
+          );
+        }
+        formatTok = f;
+      }
+      if (i + 1 >= tokens.length) {
         throw new Error(
           `Keyword "${tok.value}" at line ${tok.start.line} col ${tok.start.col} expects an ID and payload, but only ${tokens.length - i + 1} token(s) remain.`
         );
       }
       const idTok = tokens[i++];
+      if (cfg.optionalTypedId && tokens[i]?.value === ":") {
+        const typeTok = tokens[i + 1];
+        const blockTok = tokens[i + 2];
+        if (!typeTok || !blockTok) {
+          throw new Error(
+            `Keyword "${tok.value}" at line ${tok.start.line} col ${tok.start.col} expects a type and payload, but too few token(s) remain.`
+          );
+        }
+        i += 3;
+        declarations.push({
+          keyword: tok.value,
+          id: idTok.value,
+          payload: `: ${typeTok.value} ${blockTok.value}`,
+          start: tok.start,
+          end: blockTok.end
+        });
+        continue;
+      }
       const payloadTok = tokens[i++];
       declarations.push({
         keyword: tok.value,
-        id: idTok.value,
+        id: formatTok ? `${formatTok.value}:${idTok.value}` : idTok.value,
         payload: payloadTok.value,
         start: tok.start,
         end: payloadTok.end
@@ -269,6 +297,11 @@ function parseDeclarations(declarations, parsers, options = {}) {
     calculations: {},
     verdicts: {},
     referenceMaterials: {},
+    wireMappings: {},
+    stringFormats: {},
+    namespaces: {},
+    datums: {},
+    checks: {},
     testPointSets: {},
     commonTestConditions: {},
     competenceKinds: {},
@@ -277,6 +310,7 @@ function parseDeclarations(declarations, parsers, options = {}) {
     schemeTypes: {},
     predicates: {},
     constraints: {},
+    uncertaintyBudgets: {},
     discrepancyRecords: {},
     stateMachines: {},
     conformanceTests: {},
@@ -2495,6 +2529,403 @@ var parseMetadata = function(token) {
     return ctx;
   };
 };
+var dumpMetadata = function(meta) {
+  let out = "metadata {\n";
+  out += '  title "' + escapeString(meta.title) + '"\n';
+  out += '  schema "' + escapeString(meta.schema) + '"\n';
+  out += '  edition "' + escapeString(meta.edition) + '"\n';
+  out += '  author "' + escapeString(meta.author) + '"\n';
+  out += '  namespace "' + escapeString(meta.namespace) + '"\n';
+  out += '  shortname "' + escapeString(meta.shortname ?? "") + '"\n';
+  out += "}\n";
+  return out;
+};
+
+// src/expressions/index.ts
+var OPERATORS = [
+  "->",
+  "<=",
+  ">=",
+  "!=",
+  "\u2260",
+  "<",
+  ">",
+  "=",
+  "+",
+  "-",
+  "*",
+  "/",
+  "(",
+  ")",
+  ",",
+  ".",
+  "|"
+];
+var NAV_OPS = /* @__PURE__ */ new Set(["forAll", "exists", "select", "collect"]);
+function lex(src) {
+  const tokens = [];
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (/\s/.test(c)) {
+      i += 1;
+      continue;
+    }
+    if (c === "'") {
+      let j = i + 1;
+      while (j < src.length && src[j] !== "'") {
+        j += 1;
+      }
+      if (j >= src.length) {
+        throw new Error(`expression: unterminated string at offset ${i}`);
+      }
+      tokens.push({ kind: "str", value: src.slice(i + 1, j) });
+      i = j + 1;
+      continue;
+    }
+    if (/[0-9]/.test(c)) {
+      let j = i;
+      while (j < src.length && /[0-9.]/.test(src[j])) {
+        j += 1;
+      }
+      tokens.push({ kind: "num", value: Number(src.slice(i, j)) });
+      i = j;
+      continue;
+    }
+    if (/[A-Za-z_]/.test(c)) {
+      let j = i;
+      while (j < src.length && /[A-Za-z0-9_.]/.test(src[j])) {
+        j += 1;
+      }
+      tokens.push({ kind: "name", value: src.slice(i, j) });
+      i = j;
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (OPERATORS.includes(two)) {
+      tokens.push({ kind: "op", value: two });
+      i += 2;
+      continue;
+    }
+    if (OPERATORS.includes(c)) {
+      tokens.push({ kind: "op", value: c });
+      i += 1;
+      continue;
+    }
+    throw new Error(`expression: unexpected character "${c}" at offset ${i}`);
+  }
+  return tokens;
+}
+var BINARY_LEVELS = [
+  ["implies"],
+  ["or"],
+  ["xor"],
+  ["and"],
+  ["<=", ">=", "<", ">", "=", "!=", "\u2260"],
+  ["+", "-"],
+  ["*", "/"]
+];
+var WORD_BINOPS = /* @__PURE__ */ new Set(["implies", "or", "xor", "and"]);
+var ExprParser = class {
+  tokens;
+  pos = 0;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  take() {
+    const tok = this.tokens[this.pos];
+    if (tok === void 0) {
+      throw new Error("expression: unexpected end");
+    }
+    this.pos += 1;
+    return tok;
+  }
+  parse() {
+    const ast = this.parseLevel(0);
+    if (this.pos !== this.tokens.length) {
+      throw new Error(`expression: trailing tokens at position ${this.pos}`);
+    }
+    return ast;
+  }
+  parseLevel(level) {
+    if (level >= BINARY_LEVELS.length) {
+      return this.parseUnary();
+    }
+    let left = this.parseLevel(level + 1);
+    for (; ; ) {
+      const tok = this.peek();
+      const op = tok?.kind === "op" ? tok.value : tok?.kind === "name" && WORD_BINOPS.has(tok.value) ? tok.value : void 0;
+      if (op === void 0 || !BINARY_LEVELS[level].includes(op)) {
+        return left;
+      }
+      this.take();
+      const right = this.parseLevel(level + 1);
+      left = { type: "binop", op, left, right };
+    }
+  }
+  parseUnary() {
+    const tok = this.peek();
+    if (tok?.kind === "name" && (tok.value === "not" || tok.value === "-")) {
+      this.take();
+      return { type: "unop", op: tok.value, operand: this.parseUnary() };
+    }
+    if (tok?.kind === "op" && tok.value === "-") {
+      this.take();
+      return { type: "unop", op: "-", operand: this.parseUnary() };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const tok = this.take();
+    if (tok.kind === "num") {
+      return { type: "num", value: tok.value };
+    }
+    if (tok.kind === "str") {
+      return { type: "str", value: tok.value };
+    }
+    if (tok.kind === "op" && tok.value === "(") {
+      const inner = this.parseLevel(0);
+      const close = this.take();
+      if (close.kind !== "op" || close.value !== ")") {
+        throw new Error("expression: expected closing parenthesis");
+      }
+      return inner;
+    }
+    if (tok.kind === "name") {
+      if (tok.value === "true" || tok.value === "false") {
+        return { type: "bool", value: tok.value === "true" };
+      }
+      if (tok.value === "if") {
+        const cond = this.parseLevel(0);
+        const thenTok = this.take();
+        if (thenTok.kind !== "name" || thenTok.value !== "then") {
+          throw new Error('expression: expected "then" in the conditional');
+        }
+        const whenTrue = this.parseLevel(0);
+        const elseTok = this.take();
+        if (elseTok.kind !== "name" || elseTok.value !== "else") {
+          throw new Error('expression: expected "else" in the conditional');
+        }
+        const whenFalse = this.parseLevel(0);
+        const endTok = this.take();
+        if (endTok.kind !== "name" || endTok.value !== "endif") {
+          throw new Error(
+            'expression: expected "endif" to close the conditional'
+          );
+        }
+        return { type: "ifelse", cond, then: whenTrue, else: whenFalse };
+      }
+      const segs = [tok.value];
+      while (this.peek()?.kind === "op" && this.peek().value === ".") {
+        this.take();
+        const seg = this.take();
+        if (seg.kind !== "name") {
+          throw new Error('expression: expected a path segment after "."');
+        }
+        segs.push(seg.value);
+      }
+      const next = this.peek();
+      if (next?.kind === "op" && next.value === "(" && !WORD_BINOPS.has(segs[0])) {
+        this.take();
+        const args2 = [];
+        const closing = this.peek();
+        if (closing?.kind === "op" && closing.value === ")") {
+          this.take();
+          return { type: "call", callee: segs.join("."), args: args2 };
+        }
+        for (; ; ) {
+          args2.push(this.parseLevel(0));
+          const sep = this.peek();
+          if (sep?.kind === "op" && sep.value === ",") {
+            this.take();
+            continue;
+          }
+          break;
+        }
+        const close = this.take();
+        if (close.kind !== "op" || close.value !== ")") {
+          throw new Error("expression: expected closing parenthesis");
+        }
+        return { type: "call", callee: segs.join("."), args: args2 };
+      }
+      const arrow = this.peek();
+      if (arrow?.kind === "op" && arrow.value === "->") {
+        this.take();
+        const opTok = this.take();
+        if (opTok.kind !== "name" || !NAV_OPS.has(opTok.value)) {
+          throw new Error(
+            "expression: expected a collection iterator (forAll | exists | select | collect)"
+          );
+        }
+        if (this.peek()?.kind !== "op" || this.peek().value !== "(") {
+          throw new Error("expression: expected ( after the iterator");
+        }
+        this.take();
+        const varTok = this.take();
+        if (varTok.kind !== "name") {
+          throw new Error("expression: expected the lambda parameter");
+        }
+        if (this.peek()?.kind !== "op" || this.peek().value !== "|") {
+          throw new Error("expression: expected | after the parameter");
+        }
+        this.take();
+        const body = this.parseLevel(0);
+        const close = this.take();
+        if (close.kind !== "op" || close.value !== ")") {
+          throw new Error("expression: expected closing parenthesis");
+        }
+        return {
+          type: "nav",
+          source: segs.join("."),
+          op: opTok.value,
+          var: varTok.value,
+          body
+        };
+      }
+      return { type: "name", path: segs };
+    }
+    throw new Error(`expression: unexpected token "${String(tok.value)}"`);
+  }
+};
+function parseExpression(src) {
+  return new ExprParser(lex(src)).parse();
+}
+function canonicalizeExpression(raw) {
+  const body = raw.trim();
+  if (body.length === 0) {
+    throw new Error("expression: the block is empty");
+  }
+  return renderExpression(parseExpression(body));
+}
+function freeIdentifiers(ast) {
+  const out = { names: [], calls: [] };
+  const walk = (node, bound) => {
+    switch (node.type) {
+      case "num":
+        return;
+      case "str":
+        return;
+      case "bool":
+        return;
+      case "ifelse":
+        walk(node.cond, bound);
+        walk(node.then, bound);
+        walk(node.else, bound);
+        return;
+      case "name": {
+        if (bound.has(node.path[0].split(".")[0])) {
+          return;
+        }
+        out.names.push(node.path.join("."));
+        return;
+      }
+      case "call":
+        out.calls.push(node.callee);
+        for (const a of node.args) {
+          walk(a, bound);
+        }
+        return;
+      case "unop":
+        walk(node.operand, bound);
+        return;
+      case "binop":
+        walk(node.left, bound);
+        walk(node.right, bound);
+        return;
+      case "nav": {
+        const inner = new Set(bound);
+        inner.add(node["var"]);
+        walk({ type: "name", path: [node.source] }, bound);
+        walk(node.body, inner);
+        return;
+      }
+    }
+  };
+  walk(ast, /* @__PURE__ */ new Set());
+  return out;
+}
+function renderExpression(ast) {
+  switch (ast.type) {
+    case "num":
+      return String(ast.value);
+    case "str":
+      return "'" + ast.value + "'";
+    case "bool":
+      return ast.value ? "true" : "false";
+    case "ifelse":
+      return "if " + renderExpression(ast.cond) + " then " + renderExpression(ast.then) + " else " + renderExpression(ast.else) + " endif";
+    case "name":
+      return ast.path.join(".");
+    case "call":
+      return ast.callee + "(" + ast.args.map(renderExpression).join(", ") + ")";
+    case "unop": {
+      const inner = renderExpression(ast.operand);
+      return ast.op + (ast.operand.type === "binop" ? " (" + inner + ")" : " " + inner);
+    }
+    case "nav":
+      return ast.source + " -> " + ast.op + "(" + ast["var"] + " | " + renderExpression(ast.body) + ")";
+    case "binop":
+      return renderExpression(ast.left) + " " + ast.op + " " + renderExpression(ast.right);
+  }
+}
+
+// src/ser-des/expression-carrier.ts
+function readExpressionCarrier(token, what) {
+  if (token.startsWith("{")) {
+    try {
+      return {
+        source: canonicalizeExpression(unwrapBlock(token)),
+        inline: true
+      };
+    } catch (e) {
+      throw new Error(
+        `Parsing error: ${what}: ${e.message ?? String(e)}`
+      );
+    }
+  }
+  if (token.length >= 2 && token.charAt(0) === '"') {
+    return {
+      source: unescapeString(token.substr(1, token.length - 2)),
+      inline: false
+    };
+  }
+  return { source: token, inline: false };
+}
+function dumpExpressionBlock(keyword, source, indent) {
+  const body = source.split("\n").map((l) => indent + "  " + l).join("\n");
+  return indent + keyword + " {\n" + body + "\n" + indent + "}\n";
+}
+function readArgsBlock(token) {
+  const at = tokenize(token);
+  const args2 = [];
+  let k = 0;
+  while (k < at.length) {
+    const name = unescapeStringOrBare(at[k++]);
+    if (k >= at.length) {
+      throw new Error(`limit args: "${name}" binds to nothing`);
+    }
+    if (at[k] !== "<-") {
+      throw new Error(
+        `limit args: expected "<-" after "${name}" (name <- source)`
+      );
+    }
+    k += 1;
+    if (k >= at.length) {
+      throw new Error(`limit args: "${name}" binds to nothing`);
+    }
+    args2.push({ name, source: unescapeStringOrBare(at[k++]) });
+  }
+  return args2;
+}
+function unescapeStringOrBare(t) {
+  if (t.length >= 2 && t.charAt(0) === '"' && t.charAt(t.length - 1) === '"') {
+    return unescapeString(t.substr(1, t.length - 2));
+  }
+  return t;
+}
 
 // src/ser-des/config/quantity.ts
 var NUMERIC = /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/;
@@ -2987,10 +3418,20 @@ var STEP_KINDS = /* @__PURE__ */ new Set([
   "timer_event",
   "signal_event"
 ]);
+function parseCallBindings(block) {
+  return parseParamList(unwrapBlock(block)).map((pr) => ({
+    param: pr.name,
+    bind: pr.type
+  }));
+}
 function parseStepBody(id, kind, block) {
   const step = {
     id,
     kind,
+    signatureBlock: "",
+    sigInputs: [],
+    sigOutputs: [],
+    completion: "",
     executor: "",
     role: "",
     capture: "",
@@ -3260,6 +3701,112 @@ var parseProcess = function(id, data) {
         result._relations.page = value();
       } else if (keyword === "validate_provision") {
         result._relations.provision = tokenizePackage(value());
+      } else if (keyword === "step" || keyword === "binding") {
+        const sid = stripWrapping(value());
+        const blockTok = value();
+        if (keyword === "step") {
+          const raw = blockTok !== void 0 && blockTok.startsWith("{") ? unwrapBlock(blockTok) : blockTok ?? "";
+          const st = {
+            id: sid,
+            kind: "action",
+            executor: "",
+            role: "",
+            capture: "",
+            reads: [],
+            writes: [],
+            fires: "",
+            calls: "",
+            callIn: [],
+            callOut: [],
+            wait: "",
+            period: "",
+            signal: "",
+            signatureBlock: raw,
+            sigInputs: [],
+            sigOutputs: [],
+            completion: "",
+            description: ""
+          };
+          const tt = tokenizePackage(raw);
+          let ti = 0;
+          while (ti < tt.length) {
+            const tc = tt[ti++];
+            if (ti >= tt.length) {
+              break;
+            }
+            if (tc === "inputs" || tc === "outputs") {
+              const pairs = parseParamList(unwrapBlock(tt[ti++]));
+              const names = pairs.map((pr) => pr.name);
+              if (tc === "inputs") {
+                st.sigInputs = names;
+              } else {
+                st.sigOutputs = names;
+              }
+            } else if (tc === "requires") {
+              const ids = tokenizePackage(unwrapBlock(tt[ti++])).map(stripWrapping).filter((x) => x.length > 0);
+              (result.stepRequires ??= []).push(...ids);
+            } else if (tc === "completion") {
+              if (tt[ti] === "check") {
+                ti += 1;
+                st.completionGate = stripWrapping(tt[ti++]);
+                const bt = tokenizePackage(unwrapBlock(tt[ti++]));
+                let bi = 0;
+                while (bi < bt.length) {
+                  const bc = bt[bi++];
+                  if (bi >= bt.length) {
+                    break;
+                  }
+                  if (bc === "expression") {
+                    const c = readExpressionCarrier(
+                      bt[bi++],
+                      "step completion"
+                    );
+                    st.completion = c.source;
+                    st.completionBound = c.inline || void 0;
+                  } else {
+                    bi = skipUnknownEntry(bt, bi);
+                  }
+                }
+              } else {
+                const c = readExpressionCarrier(tt[ti++], "step completion");
+                st.completion = c.source;
+                st.completionBound = c.inline || void 0;
+              }
+            } else if (tc === "calls") {
+              st.calls = stripWrapping(tt[ti++]);
+              if (ti < tt.length && tt[ti] === "with") {
+                const wt = tokenize(unwrapBlock(tt[ti++]));
+                let wk = 0;
+                while (wk < wt.length) {
+                  const wc = wt[wk++];
+                  if (wk >= wt.length) {
+                    break;
+                  }
+                  if (wc === "in") {
+                    st.callIn.push(...parseCallBindings(wt[wk++]));
+                  } else if (wc === "out") {
+                    st.callOut.push(...parseCallBindings(wt[wk++]));
+                  } else {
+                    unwrapBlock(wt[wk++]);
+                  }
+                }
+              }
+            } else if (tc === "description") {
+              st.description = stripWrapping(tt[ti++]);
+            } else {
+              ti = skipUnknownEntry(tt, ti);
+            }
+          }
+          (result.steps ??= []).push(st);
+        } else {
+          (result.bindings ??= []).push({
+            id: sid,
+            block: blockTok !== void 0 && blockTok.startsWith("{") ? unwrapBlock(blockTok) : blockTok ?? ""
+          });
+        }
+      } else if (keyword === "requires") {
+        const inner = tokenizePackage(unwrapBlock(value()));
+        (result.stepRequires ??= []).push(...inner.map(stripWrapping));
       } else if (keyword === "validate_measurement") {
         result.measure = tokenizePackage(value()).map((x) => unwrapBlock(x));
       } else if (keyword === "output") {
@@ -3417,6 +3964,25 @@ var resolveProcess = function(ctx, unresolved) {
   }
   return p;
 };
+function indentBlock(block) {
+  return block.split("\n").map((line) => line ? "  " + line : line).join("\n");
+}
+function dumpProcessTree(process2, lookup, nested = false) {
+  let out = dumpProcess(process2, { nested });
+  if (process2.children.length > 0) {
+    const childBlocks = [];
+    for (const childId of process2.children) {
+      const child = lookup.get(childId);
+      if (child) {
+        childBlocks.push(indentBlock(dumpProcessTree(child, lookup, true)));
+      }
+    }
+    if (childBlocks.length > 0) {
+      out = out.replace(/\n}\n$/, "\n" + childBlocks.join("\n") + "}\n");
+    }
+  }
+  return out;
+}
 function dumpParamList(params) {
   return params.map(
     (p) => p.name + (p.type ? " : " + p.type : "") + (p.initial !== void 0 ? " = " + dumpQuantityValue(p.initial) : "")
@@ -3531,6 +4097,26 @@ var dumpProcess = function(process2, ctx) {
   if (process2.machineSteps && process2.machineSteps.length > 0) {
     out += "  machine_steps { " + process2.machineSteps.map(dumpBareSafe).join(" ") + " }\n";
   }
+  for (const st of process2.steps ?? []) {
+    if (st.signatureBlock) {
+      const lines = st.signatureBlock.split("\n").map((l) => l.trim()).filter((l) => l !== "");
+      out += "  step " + st.id + " {\n";
+      for (const line of lines) {
+        out += "   " + line + "\n";
+      }
+      out += "  }\n";
+    }
+  }
+  for (const b of process2.bindings ?? []) {
+    out += "  binding " + b.id + " {\n";
+    for (const line of b.block.split("\n")) {
+      out += line === "" ? "\n" : "  " + line + "\n";
+    }
+    out += "  }\n";
+  }
+  for (const req of process2.stepRequires ?? []) {
+    out += "  requires { " + req + " }\n";
+  }
   const inputIds = process2.inputRefs && process2.inputRefs.length > 0 ? process2.inputRefs : process2.input.map((r) => r.id);
   if (inputIds.length > 0) {
     out += "  reference_data_registry {\n";
@@ -5270,6 +5856,11 @@ function parseColumnDefs(block) {
     if (!name) {
       break;
     }
+    if (i < t.length && t[i] === "{") {
+      throw new Error(
+        `Parsing error: table. Column "${name}": the old columns dialect (colN { name ... type ... }) is retired \u2014 write the canonical form: ${name === "" ? "name" : name}: type "unit"`
+      );
+    }
     if (i < t.length && t[i] === ":") {
       i++;
     }
@@ -6695,6 +7286,7 @@ var parseSymbol = function(id, data) {
     type: "number",
     unit: "1",
     latex: "",
+    renders: [],
     values: [],
     series: null,
     kind: "",
@@ -6746,6 +7338,20 @@ var parseSymbol = function(id, data) {
         result.unit = unwrapped(value);
       } else if (command === "latex") {
         result.latex = unwrapped(value);
+      } else if (command === "render") {
+        const notation = stripWrapping(value());
+        const text = peek() !== void 0 ? stripWrapping(value()) : "";
+        if (!result.renders) {
+          result.renders = [];
+        }
+        if (["asciimath", "latex", "unicodemath", "mathml", "omml"].includes(
+          notation
+        )) {
+          result.renders.push({ notation, text });
+          if (notation === "latex" && !result.latex) {
+            result.latex = text;
+          }
+        }
       } else if (command === "values") {
         const v = value();
         result.values = v.startsWith("{") ? tokenizePackage(v).map(stripWrapping) : [stripWrapping(v)];
@@ -6826,6 +7432,9 @@ var dumpSymbol = function(s) {
   if (s.latex) {
     out += '  latex "' + escapeString(s.latex) + '"\n';
   }
+  for (const r of s.renders ?? []) {
+    out += "  render " + r.notation + ' "' + escapeString(r.text) + '"\n';
+  }
   if (s.values.length > 0) {
     out += "  values { " + s.values.map(dumpBareSafe).join(" ") + " }\n";
   }
@@ -6971,6 +7580,23 @@ var parseCalculation = function(id, data) {
           result.description = unwrapBlock(t[i++]);
         } else if (command === "expression") {
           result.expression = unwrapBlock(t[i++]);
+        } else if (command === "math") {
+          const inner = tokenizePackage(unwrapBlock(t[i++]));
+          let notation = "";
+          let formula = "";
+          let j = 0;
+          while (j < inner.length) {
+            const k = inner[j++];
+            if (j >= inner.length) {
+              break;
+            }
+            if (k === "notation") {
+              notation = stripWrapping(inner[j++]);
+            } else if (k === "formula") {
+              formula = stripWrapping(inner[j++]);
+            }
+          }
+          result.math = { notation, formula };
         } else if (command === "reference") {
           result._relations.ref = tokenizePackage(t[i++]);
         } else if (command === "ref") {
@@ -7287,6 +7913,23 @@ function parseVariant(vid, block, calcId) {
       variant.params = tokenize(stripWrapping(t[i++])).map(stripWrapping).filter((s) => s.length > 0);
     } else if (cmd === "expression") {
       variant.expression = stripWrapping(t[i++]);
+    } else if (cmd === "math") {
+      const inner = tokenizePackage(unwrapBlock(t[i++]));
+      let notation = "";
+      let formula = "";
+      let j = 0;
+      while (j < inner.length) {
+        const k = inner[j++];
+        if (j >= inner.length) {
+          break;
+        }
+        if (k === "notation") {
+          notation = stripWrapping(inner[j++]);
+        } else if (k === "formula") {
+          formula = stripWrapping(inner[j++]);
+        }
+      }
+      variant.math = { notation, formula };
     } else if (cmd === "lookup") {
       variant.lookup = parseLookup(unwrapBlock(t[i++]));
     } else if (cmd === "profile") {
@@ -7427,6 +8070,12 @@ var dumpCalculation = function(c) {
   if (c.expression) {
     out += '  expression "' + escapeString(c.expression) + '"\n';
   }
+  if (c.math) {
+    out += "  math {\n";
+    out += "    notation " + c.math.notation + "\n";
+    out += '    formula "' + escapeString(c.math.formula) + '"\n';
+    out += "  }\n";
+  }
   if (c.params && c.params.length > 0) {
     out += "  params { " + c.params.join(" ") + " }\n";
   }
@@ -8605,7 +9254,7 @@ function parseRequiredCompetence(block) {
     const entry = {
       kind: stripWrapping(t[i++]),
       range: null,
-      methodStandard: "",
+      methodRef: "",
       resolution: null,
       stability: null,
       description: ""
@@ -8638,8 +9287,8 @@ function parseRequiredCompetence(block) {
             }
           }
           entry.range = range;
-        } else if (cc === "method_standard") {
-          entry.methodStandard = stripWrapping(ct[j++]);
+        } else if (cc === "method_ref") {
+          entry.methodRef = stripWrapping(ct[j++]);
         } else if (cc === "resolution") {
           entry.resolution = readQuantity(unwrapBlock(ct[j++]));
         } else if (cc === "stability") {
@@ -8682,8 +9331,8 @@ function dumpRequiredCompetence(entries) {
       line += ' unit "' + escapeString(e.range.unit) + '" }\n';
       out += line;
     }
-    if (e.methodStandard) {
-      out += '      method_standard "' + escapeString(e.methodStandard) + '"\n';
+    if (e.methodRef) {
+      out += "      method_ref " + e.methodRef + "\n";
     }
     out += dumpQuantity("resolution", e.resolution);
     out += dumpQuantity("stability", e.stability);
@@ -8706,8 +9355,7 @@ var parseCompetenceKind = function(id, data) {
     id,
     label: "",
     definition: "",
-    source: null,
-    methodStandards: []
+    source: null
   };
   const t = tokenizePackage(data);
   let i = 0;
@@ -8724,14 +9372,6 @@ var parseCompetenceKind = function(id, data) {
       result.definition = readValue(t[i++]);
     } else if (keyword === "source") {
       result.source = readSource(unwrapBlock(t[i++]));
-    } else if (keyword === "method_standard") {
-      const stdId = stripWrapping(t[i++]);
-      if (i >= t.length) {
-        throw new Error(
-          `Parsing error: competence_kind. ID ${id}: Expecting title for method_standard ${stdId}`
-        );
-      }
-      result.methodStandards.push({ id: stdId, title: readValue(t[i++]) });
     } else if (keyword === "ref") {
       const rr = parseRef(t, i, stripWrapping, unwrapBlock);
       if (!foldRefIntoLegacy(result, rr.ref)) {
@@ -8762,9 +9402,6 @@ var dumpCompetenceKind = function(k) {
   if (k.source && (k.source.doc || k.source.clause)) {
     out += '  source { doc "' + escapeString(k.source.doc) + '" clause "' + escapeString(k.source.clause) + '"' + (k.source.fragment ? ' fragment "' + escapeString(k.source.fragment) + '"' : "") + " }\n";
   }
-  for (const ms of k.methodStandards) {
-    out += "  method_standard " + ms.id + ' "' + escapeString(ms.title) + '"\n';
-  }
   out += dumpCorrespondences(
     k.correspondences,
     "  ",
@@ -8825,7 +9462,9 @@ function parseTestVariables(block) {
         } else if (vc === "source") {
           v.source = stripWrapping(vt[j++]);
         } else if (vc === "derivation") {
-          v.derivation = stripWrapping(vt[j++]);
+          const c = readExpressionCarrier(vt[j++], "test variable derivation");
+          v.derivation = c.source;
+          v.derivationBound = c.inline || void 0;
         } else if (vc === "description") {
           v.description = stripWrapping(vt[j++]);
         } else if (vc === "item_type") {
@@ -8885,7 +9524,9 @@ function parsePreconditions(block) {
           break;
         }
         if (pc === "check") {
-          p.check = stripWrapping(pt[j++]);
+          const c = readExpressionCarrier(pt[j++], "precondition check");
+          p.check = c.source;
+          p.checkBound = c.inline || void 0;
         } else if (pc === "description") {
           p.description = stripWrapping(pt[j++]);
         } else if (pc === "on_violation") {
@@ -9651,8 +10292,17 @@ var dumpConformanceTest = function(ct) {
       if (v.source) {
         line += "source " + v.source + " ";
       }
+      let derivationBlock = "";
       if (v.derivation) {
-        line += 'derivation "' + escapeString(v.derivation) + '" ';
+        if (v.derivationBound) {
+          derivationBlock = dumpExpressionBlock(
+            "derivation",
+            v.derivation,
+            "      "
+          );
+        } else {
+          line += 'derivation "' + escapeString(v.derivation) + '" ';
+        }
       }
       if (v.description) {
         line += 'description "' + escapeString(v.description) + '" ';
@@ -9679,7 +10329,11 @@ var dumpConformanceTest = function(ct) {
         }
         line += pv + "} ";
       }
-      out += line + "}\n";
+      if (derivationBlock) {
+        out += line + "\n" + derivationBlock + "    }\n";
+      } else {
+        out += line + "}\n";
+      }
     }
     out += "  }\n";
   }
@@ -9707,8 +10361,13 @@ var dumpConformanceTest = function(ct) {
     out += "  preconditions {\n";
     for (const p of ct.preconditions) {
       let line = "    precondition " + p.id + " { ";
+      let checkBlock = "";
       if (p.check) {
-        line += 'check "' + escapeString(p.check) + '" ';
+        if (p.checkBound) {
+          checkBlock = dumpExpressionBlock("check", p.check, "      ");
+        } else {
+          line += 'check "' + escapeString(p.check) + '" ';
+        }
       }
       if (p.description) {
         line += 'description "' + escapeString(p.description) + '" ';
@@ -9717,7 +10376,11 @@ var dumpConformanceTest = function(ct) {
       if (p.onUnresolvable) {
         line += "on_unresolvable " + p.onUnresolvable + " ";
       }
-      out += line + "}\n";
+      if (checkBlock) {
+        out += line + "\n" + checkBlock + "    }\n";
+      } else {
+        out += line + "}\n";
+      }
     }
     out += "  }\n";
   }
@@ -10082,7 +10745,9 @@ var parseVerdict = function(id, data) {
       } else if (keyword === "behavior") {
         result.behavior = value();
       } else if (keyword === "derive" || keyword === "expression") {
-        result.derive = unwrapped(value);
+        const c = readExpressionCarrier(value(), "verdict derive");
+        result.derive = c.source;
+        result.deriveBound = c.inline || void 0;
       } else if (keyword === "inputs" || keyword === "uses") {
         result.inputs = readIdList3(value());
       } else if (keyword === "series_reduction") {
@@ -10140,7 +10805,11 @@ var dumpVerdict = function(v) {
     out += " }\n";
   }
   if (v.derive) {
-    out += '  derive "' + escapeString(v.derive) + '"\n';
+    if (v.deriveBound) {
+      out += dumpExpressionBlock("derive", v.derive, "  ");
+    } else {
+      out += '  derive "' + escapeString(v.derive) + '"\n';
+    }
   }
   if (v.inputs.length > 0) {
     out += "  inputs { " + v.inputs.join(" ") + " }\n";
@@ -10743,8 +11412,15 @@ var parseConstraint = function(id, data) {
       result.stereotype = stripWrapping(t[i++]);
     } else if (keyword === "name") {
       result.name = readValue2(t[i++]);
+    } else if (keyword === "args") {
+      if (!result.args) {
+        result.args = [];
+      }
+      result.args.push(...readArgsBlock(unwrapBlock(t[i++])));
     } else if (keyword === "check") {
-      result.check = readValue2(t[i++]);
+      const c = readExpressionCarrier(t[i++], "constraint check");
+      result.check = c.source;
+      result.checkBound = c.inline || void 0;
     } else if (keyword === "violation_meaning") {
       result.violationMeaning = readValue2(t[i++]);
     } else if (keyword === "on_violation") {
@@ -10778,8 +11454,19 @@ var dumpConstraint = function(c) {
   if (c.name) {
     out += '  name "' + escapeString(c.name) + '"\n';
   }
+  if ((c.args ?? []).length > 0) {
+    out += "  args {\n";
+    for (const a of c.args ?? []) {
+      out += "    " + a.name + " <- " + a.source + "\n";
+    }
+    out += "  }\n";
+  }
   if (c.check) {
-    out += '  check "' + escapeString(c.check) + '"\n';
+    if (c.checkBound) {
+      out += dumpExpressionBlock("check", c.check, "  ");
+    } else {
+      out += '  check "' + escapeString(c.check) + '"\n';
+    }
   }
   if (c.violationMeaning) {
     out += '  violation_meaning "' + escapeString(c.violationMeaning) + '"\n';
@@ -10798,6 +11485,169 @@ var dumpConstraint = function(c) {
   return out;
 };
 
+// src/ser-des/config/uncertaintyBudget.ts
+var DISTRIBUTIONS = /* @__PURE__ */ new Set([
+  "rectangular",
+  "triangular",
+  "normal",
+  "ushape"
+]);
+function readComponent(block) {
+  const c = {
+    id: "",
+    type: "B",
+    series: "",
+    distribution: "",
+    halfWidth: "",
+    unit: "",
+    source: null,
+    description: ""
+  };
+  const t = tokenizePackage(block);
+  let i = 0;
+  while (i < t.length) {
+    const kw = t[i++];
+    if (i >= t.length) {
+      throw new Error(
+        `Parsing error: uncertainty_budget component. ID ${c.id}: Expecting value for ${kw}`
+      );
+    }
+    if (kw === "type") {
+      const v = stripWrapping(t[i++]);
+      if (v !== "A" && v !== "B") {
+        throw new Error(
+          `Parsing error: uncertainty_budget component. ID ${c.id}: unknown type "${v}" (A evaluates the statistics of a series; B states a distribution)`
+        );
+      }
+      c.type = v;
+    } else if (kw === "series") {
+      c.series = stripWrapping(t[i++]);
+    } else if (kw === "distribution") {
+      const v = stripWrapping(t[i++]);
+      if (!DISTRIBUTIONS.has(v)) {
+        throw new Error(
+          `Parsing error: uncertainty_budget component. ID ${c.id}: unknown distribution "${v}" (rectangular | triangular | normal | ushape)`
+        );
+      }
+      c.distribution = v;
+    } else if (kw === "half_width") {
+      c.halfWidth = stripWrapping(t[i++]);
+    } else if (kw === "unit") {
+      c.unit = stripWrapping(t[i++]);
+    } else if (kw === "description") {
+      c.description = stripWrapping(t[i++]);
+    } else if (kw === "source") {
+      c.source = readSource(unwrapBlock(t[i++]));
+    } else {
+      i = skipUnknownValue(t, i, kw);
+    }
+  }
+  return c;
+}
+var parseUncertaintyBudget = function(id, data) {
+  const result = {
+    id,
+    target: "",
+    coverageK: "",
+    components: [],
+    source: null
+  };
+  const t = tokenizePackage(data);
+  let i = 0;
+  while (i < t.length) {
+    const kw = t[i++];
+    if (i >= t.length) {
+      throw new Error(
+        `Parsing error: uncertainty_budget. ID ${id}: Expecting value for ${kw}`
+      );
+    }
+    if (kw === "target") {
+      result.target = stripWrapping(t[i++]);
+    } else if (kw === "coverage") {
+      const head = stripWrapping(t[i++]);
+      if (head !== "k") {
+        throw new Error(
+          `Parsing error: uncertainty_budget. ID ${id}: coverage states its factor \u2014 coverage k <number>`
+        );
+      }
+      result.coverageK = stripWrapping(t[i++]);
+    } else if (kw === "component") {
+      if (t[i].startsWith("{")) {
+        throw new Error(
+          `Parsing error: uncertainty_budget. ID ${id}: a component carries an id \u2014 component <id> { \u2026 }`
+        );
+      }
+      const cid = stripWrapping(t[i++]);
+      const c = readComponent(unwrapBlock(t[i++]));
+      c.id = cid;
+      result.components.push(c);
+    } else if (kw === "source") {
+      result.source = readSource(unwrapBlock(t[i++]));
+    } else if (kw === "ref") {
+      const rr = parseRef(t, i, stripWrapping, unwrapBlock);
+      if (!foldRefIntoLegacy(result, rr.ref)) {
+        (result.refs ??= []).push(rr.ref);
+      }
+      i = rr.next;
+    } else if (kw === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
+    } else {
+      i = skipUnknownValue(t, i, kw);
+    }
+  }
+  return (ctx) => {
+    ctx.uncertaintyBudgets[id] = result;
+    return ctx;
+  };
+};
+var dumpUncertaintyBudget = function(b) {
+  let out = "uncertainty_budget " + b.id + " {\n";
+  if (b.target) {
+    out += "  target " + b.target + "\n";
+  }
+  if (b.coverageK) {
+    out += "  coverage k " + b.coverageK + "\n";
+  }
+  for (const c of b.components) {
+    out += "  component " + c.id + " {\n";
+    out += "    type " + c.type + "\n";
+    if (c.type === "A" && c.series) {
+      out += "    series " + c.series + "\n";
+    }
+    if (c.type === "B") {
+      if (c.distribution) {
+        out += "    distribution " + c.distribution + "\n";
+      }
+      if (c.halfWidth) {
+        out += "    half_width " + c.halfWidth + "\n";
+      }
+      if (c.unit) {
+        out += '    unit "' + escapeString(c.unit) + '"\n';
+      }
+    }
+    if (c.description) {
+      out += '    description "' + escapeString(c.description) + '"\n';
+    }
+    if (c.source && (c.source.doc || c.source.clause)) {
+      out += '    source { doc "' + escapeString(c.source.doc) + '" clause "' + escapeString(c.source.clause) + '"' + (c.source.fragment ? ' fragment "' + escapeString(c.source.fragment) + '"' : "") + " }\n";
+    }
+    out += "  }\n";
+  }
+  if (b.source && (b.source.doc || b.source.clause)) {
+    out += '  source { doc "' + escapeString(b.source.doc) + '" clause "' + escapeString(b.source.clause) + '"' + (b.source.fragment ? ' fragment "' + escapeString(b.source.fragment) + '"' : "") + " }\n";
+  }
+  out += dumpCorrespondences(
+    b.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
+  out += "}\n";
+  return out;
+};
+
 // src/ser-des/config/discrepancyRecord.ts
 var VALID_STATUSES = ["open", "resolved"];
 var parseDiscrepancyRecord = function(id, data) {
@@ -11146,8 +11996,8 @@ function readAccepts(block) {
   }
   return accepts;
 }
-function readLimit(block) {
-  const limit = {
+function blankLimit() {
+  return {
     expression: "",
     uses: [],
     modality: "",
@@ -11158,15 +12008,51 @@ function readLimit(block) {
     acceptance: null,
     sourceDiscrepancy: null
   };
-  const t = tokenize(block);
-  let i = 0;
+}
+function readLimit(block) {
+  const limit = blankLimit();
+  readLegacyLimitFields(tokenize(block), limit, 0);
+  return limit;
+}
+function readExpressionBlock(raw) {
+  return canonicalizeExpression(raw);
+}
+function readLegacyLimitFields(t, limit, start) {
+  let i = start;
   while (i < t.length) {
     const cmd = t[i++];
     if (i >= t.length) {
       break;
     }
-    if (cmd === "expression") {
-      limit.expression = stripWrapping(t[i++]);
+    if (cmd === "args") {
+      if (!limit.args) {
+        limit.args = [];
+      }
+      const at = tokenize(unwrapBlock(t[i++]));
+      let k = 0;
+      while (k < at.length) {
+        const name = stripWrapping(at[k++]);
+        const arrow = at[k];
+        if (arrow !== "<-") {
+          throw new Error(
+            `limit args: expected "<-" after "${name}" (name <- source)`
+          );
+        }
+        k += 1;
+        if (k >= at.length) {
+          throw new Error(`limit args: "${name}" binds to nothing`);
+        }
+        const source = stripWrapping(at[k++]);
+        limit.args.push({ name, source });
+      }
+    } else if (cmd === "expression") {
+      const value = t[i++];
+      if (value.startsWith("{")) {
+        limit.argsBound = true;
+        limit.expression = readExpressionBlock(unwrapBlock(value));
+      } else {
+        limit.expression = stripWrapping(value);
+      }
     } else if (cmd === "uses") {
       limit.uses = readIdList4(t[i++]);
     } else if (cmd === "modality") {
@@ -11203,7 +12089,6 @@ function readLimit(block) {
       i = skipUnknownValue(t, i, cmd);
     }
   }
-  return limit;
 }
 function readSubjects(block) {
   const out = [];
@@ -11415,6 +12300,52 @@ var parseRequirement = function(id, data) {
   };
 };
 function dumpLimit(limit) {
+  if (limit.argsBound) {
+    let out2 = "  limit {\n";
+    if ((limit.args ?? []).length > 0) {
+      out2 += "    args {\n";
+      for (const a of limit.args ?? []) {
+        out2 += "      " + a.name + " <- " + a.source + "\n";
+      }
+      out2 += "    }\n";
+    }
+    out2 += "    expression {\n";
+    for (const line of limit.expression.split("\n")) {
+      out2 += "      " + line + "\n";
+    }
+    out2 += "    }\n";
+    if (limit.modality) {
+      out2 += "    modality " + limit.modality + "\n";
+    }
+    if (limit.relativeTo) {
+      out2 += "    relative_to " + limit.relativeTo + "\n";
+    }
+    if (limit.notes) {
+      out2 += '    notes "' + escapeString(limit.notes) + '"\n';
+    }
+    if (limit.accepts) {
+      const a = limit.accepts;
+      let line = "    accepts { verdict " + a.verdict;
+      if (a.op) {
+        line += " op " + a.op;
+      }
+      if (a.limit) {
+        line += ' limit "' + escapeString(a.limit) + '"';
+      }
+      if (a.sourceDiscrepancy) {
+        line += " " + dumpSourceDiscrepancy(a.sourceDiscrepancy, "");
+      }
+      out2 += line + " }\n";
+    }
+    if (limit.acceptance) {
+      out2 += dumpAcceptance(limit.acceptance, "    ") + "\n";
+    }
+    if (limit.sourceDiscrepancy) {
+      out2 += dumpSourceDiscrepancy(limit.sourceDiscrepancy, "    ") + "\n";
+    }
+    out2 += "  }\n";
+    return out2;
+  }
   let out = "  limit {\n";
   if (limit.expression) {
     out += '    expression "' + escapeString(limit.expression) + '"\n';
@@ -11578,8 +12509,12 @@ var parseRequirementClass = function(id, data) {
     subject: "",
     guidance: "",
     dependencies: [],
-    referenceIds: []
+    referenceIds: [],
+    limit: null,
+    members: []
   };
+  const nestedParsers = [];
+  const members = [];
   const t = tokenizePackage(data);
   let i = 0;
   while (i < t.length) {
@@ -11603,11 +12538,24 @@ var parseRequirementClass = function(id, data) {
       result.dependencies = readIdList4(t[i++]);
     } else if (cmd === "reference") {
       result.referenceIds = readIdList4(t[i++]);
+    } else if (cmd === "limit") {
+      result.limit = readLimit(unwrapBlock(t[i++]));
+    } else if (cmd === "requirement") {
+      const childId = stripWrapping(t[i++]);
+      const childBlock = t[i++];
+      const childParse = parseRequirement(childId, unwrapBlock(childBlock));
+      nestedParsers.push(childParse);
+      members.push(childId);
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
   }
   return (ctx) => {
+    const c = ctx;
+    for (const parse2 of nestedParsers) {
+      parse2(c);
+    }
+    result.members = members;
     ctx.requirementClasses[id] = result;
     return ctx;
   };
@@ -11632,6 +12580,9 @@ var dumpRequirementClass = function(rc) {
   if (rc.referenceIds.length > 0) {
     out += "  reference { " + rc.referenceIds.join(" ") + " }\n";
   }
+  if (rc.limit) {
+    out += dumpLimit(rc.limit);
+  }
   out += "}\n";
   return out;
 };
@@ -11700,6 +12651,8 @@ var parsePackage = function(data) {
       manifest.title = stripWrapping(t[i++]);
     } else if (cmd === "version") {
       manifest.version = stripWrapping(t[i++]);
+    } else if (cmd === "language") {
+      manifest.language = stripWrapping(t[i++]);
     } else if (cmd === "editions") {
       manifest.editions = readList(t[i++]);
     } else if (cmd === "baseUrn" || cmd === "base_urn") {
@@ -18912,6 +19865,298 @@ var dumpPartAnnex = function(a) {
   return out;
 };
 
+// src/ser-des/config/lmlAligned.ts
+var MATH_NOTATIONS = ["asciimath", "latex", "unicodemath", "mathml", "omml"];
+var MAPPING_FORMATS = ["xml", "yaml", "json", "toml", "csv"];
+function splitMappingId(id) {
+  const at = id.indexOf(":");
+  const format = at === -1 ? "xml" : id.slice(0, at);
+  return { format, target: at === -1 ? id : id.slice(at + 1) };
+}
+var parseWireMapping = function(id, data) {
+  const { format, target } = splitMappingId(id);
+  const out = {
+    id,
+    format,
+    target,
+    element: "",
+    namespaceRef: "",
+    content: "",
+    mixed: false,
+    renderNil: null,
+    entries: [],
+    source: null
+  };
+  forEachEntry(
+    data,
+    (command, value, peek) => {
+      if (command === "element") {
+        out.element = stripWrapping(value());
+      } else if (command === "namespace") {
+        out.namespaceRef = stripWrapping(value());
+      } else if (command === "mixed_content") {
+        value();
+        out.mixed = true;
+      } else if (command === "render_nil") {
+        out.renderNil = stripWrapping(value()) === "true";
+      } else if (command === "map_content") {
+        out.content = stripWrapping(value());
+      } else if (command === "map_element" || command === "map_attribute" || command === "map") {
+        const wire = stripWrapping(value());
+        const name = peek() !== void 0 ? stripWrapping(value()) : "";
+        const kind = command === "map_element" ? "element" : command === "map_attribute" ? "attribute" : "map";
+        out.entries.push({ kind, wire, name, modifier: "" });
+      } else if (command === "map_key" || command === "map_value") {
+        const modifier = stripWrapping(value());
+        const name = peek() !== void 0 ? stripWrapping(value()) : "";
+        out.entries.push({ kind: "map", wire: command, name, modifier });
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "mapping", id }
+  );
+  return (ctx) => {
+    ctx.wireMappings[id] = out;
+    return ctx;
+  };
+};
+var dumpWireMapping = function(w) {
+  const lines = [`mapping ${w.format} ${w.target} {`];
+  if (w.element) {
+    lines.push(`  element "${escapeString(w.element)}"`);
+  }
+  if (w.namespaceRef) {
+    lines.push(`  namespace ${w.namespaceRef}`);
+  }
+  for (const e of w.entries) {
+    if (e.kind === "map" && e.modifier) {
+      lines.push(`  ${e.wire} ${e.modifier} ${e.name}`);
+    } else {
+      const kw = e.kind === "element" ? "map_element" : e.kind === "attribute" ? "map_attribute" : "map";
+      lines.push(`  ${kw} "${escapeString(e.wire)}" ${e.name}`);
+    }
+  }
+  if (w.content) {
+    lines.push(`  map_content ${w.content}`);
+  }
+  if (w.mixed) {
+    lines.push(`  mixed_content`);
+  }
+  if (w.renderNil !== null) {
+    lines.push(`  render_nil ${w.renderNil}`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+};
+var parseStringFormat = function(rawId, data) {
+  if (!rawId.startsWith(":")) {
+    throw new Error(
+      `Parsing error: string_format. ID ${rawId}: the registered format name carries the colon sigil (string_format :${rawId})`
+    );
+  }
+  const id = rawId.slice(1);
+  const out = { id, artifact: "", root: "", source: null };
+  forEachEntry(
+    data,
+    (command, value) => {
+      if (command === "artifact") {
+        out.artifact = stripWrapping(value());
+      } else if (command === "root") {
+        out.root = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "string_format", id }
+  );
+  return (ctx) => {
+    ctx.stringFormats[id] = out;
+    return ctx;
+  };
+};
+var dumpStringFormat = function(f) {
+  return [
+    `string_format :${f.id} {`,
+    `  artifact "${escapeString(f.artifact)}"`,
+    `  root "${escapeString(f.root)}"`,
+    "}"
+  ].join("\n");
+};
+var parseNamespace = function(id, data) {
+  const out = {
+    id,
+    uri: "",
+    prefix: "",
+    isDefault: false,
+    source: null
+  };
+  forEachEntry(
+    data,
+    (command, value) => {
+      if (command === "uri") {
+        out.uri = stripWrapping(value());
+      } else if (command === "prefix") {
+        out.prefix = stripWrapping(value());
+      } else if (command === "default") {
+        value();
+        out.isDefault = true;
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "namespace", id }
+  );
+  return (ctx) => {
+    ctx.namespaces[id] = out;
+    return ctx;
+  };
+};
+var dumpNamespace = function(d) {
+  const lines = [`namespace ${d.id} {`, `  uri "${escapeString(d.uri)}"`];
+  if (d.prefix) {
+    lines.push(`  prefix "${escapeString(d.prefix)}"`);
+  }
+  if (d.isDefault) {
+    lines.push(`  default`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+};
+var parseDatum = function(id, raw) {
+  const data = raw.replace(/^\s*:\s*\S+\s*/, "");
+  const out = {
+    id,
+    type: "",
+    unit: "",
+    quantityKind: "",
+    origin: "declared",
+    scope: "",
+    renders: [],
+    label: "",
+    description: "",
+    source: null
+  };
+  forEachEntry(
+    data,
+    (command, value, peek) => {
+      if (command === "render") {
+        const notation = stripWrapping(value());
+        const text = peek() !== void 0 ? stripWrapping(value()) : "";
+        if (MATH_NOTATIONS.includes(notation)) {
+          out.renders.push({ notation, text });
+        }
+      } else if (command === "label") {
+        out.label = stripWrapping(value());
+      } else if (command === "description") {
+        const v = value();
+        out.description = v.startsWith("{") ? unwrapBlock(v) : stripWrapping(v);
+      } else if (command === "unit") {
+        out.unit = stripWrapping(value());
+      } else if (command === "quantity_kind") {
+        out.quantityKind = stripWrapping(value());
+      } else if (command === "origin") {
+        const o = stripWrapping(value());
+        if (["declared", "design-fixed", "observed", "computed"].includes(o)) {
+          out.origin = o;
+        }
+      } else if (command === "scope") {
+        out.scope = stripWrapping(value());
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "datum", id }
+  );
+  return (ctx) => {
+    ctx.datums[id] = out;
+    return ctx;
+  };
+};
+var dumpDatum = function(x) {
+  const lines = [`datum ${x.id}${x.type ? ` : ${x.type}` : ""} {`];
+  if (x.quantityKind) {
+    lines.push(`  quantity_kind ${x.quantityKind}`);
+  }
+  if (x.unit) {
+    lines.push(`  unit ${x.unit}`);
+  }
+  if (x.origin !== "declared") {
+    lines.push(`  origin ${x.origin}`);
+  }
+  if (x.scope) {
+    lines.push(`  scope ${x.scope}`);
+  }
+  for (const r of x.renders) {
+    lines.push(`  render ${r.notation} "${escapeString(r.text)}"`);
+  }
+  if (x.label) {
+    lines.push(`  label "${escapeString(x.label)}"`);
+  }
+  if (x.description) {
+    lines.push(`  description { ${x.description} }`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+};
+var parseCheck = function(id, data) {
+  const out = {
+    id,
+    inputs: [],
+    expression: "",
+    operator: "",
+    threshold: "",
+    source: null
+  };
+  forEachEntry(
+    data,
+    (command, value, peek) => {
+      if (command === "inputs") {
+        const block = value();
+        const inner = block.startsWith("{") ? tokenizePackage(unwrapBlock(block)) : [];
+        out.inputs = inner.map((x) => stripWrapping(x));
+      } else if (command === "expression") {
+        out.expression = stripWrapping(value());
+      } else if (command === "operator") {
+        out.operator = stripWrapping(value());
+      } else if (command === "threshold") {
+        const v = value();
+        out.threshold = v.startsWith("{") ? unwrapBlock(v) : stripWrapping(v);
+      } else {
+        return false;
+      }
+      void peek;
+      return true;
+    },
+    { construct: "check", id }
+  );
+  return (ctx) => {
+    ctx.checks[id] = out;
+    return ctx;
+  };
+};
+var dumpCheck = function(x) {
+  const lines = [`check ${x.id} {`];
+  if (x.inputs.length) {
+    lines.push(`  inputs { ${x.inputs.join(" ")} }`);
+  }
+  if (x.expression) {
+    lines.push(`  expression "${escapeString(x.expression)}"`);
+  }
+  if (x.operator) {
+    lines.push(`  operator ${x.operator}`);
+  }
+  if (x.threshold) {
+    lines.push(`  threshold ${x.threshold}`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+};
+
 // src/ser-des/config/index.ts
 function defineConstruct(def) {
   return def;
@@ -19287,6 +20532,14 @@ var CONSTRUCTS = [
     parse: parseConstraint,
     dump: dumpConstraint
   }),
+  // The uncertainty budgets (register W5 — the GUM plane's language side)
+  defineConstruct({
+    keyword: "uncertainty_budget",
+    field: "uncertaintyBudgets",
+    takesID: true,
+    parse: parseUncertaintyBudget,
+    dump: dumpUncertaintyBudget
+  }),
   // Corpus-level source-discrepancy records (TODO.roadmap/54 — gap 13's
   // corpus-level extension of the source_discrepancy facet)
   defineConstruct({
@@ -19575,7 +20828,45 @@ var CONSTRUCTS = [
   // Primmel v3.2 consumption constructs (TODO.primmel/11; MN 114 clause
   // 10.6): the top-level applicability dimension (one grammar with the
   // instrument's inline dimension blocks, two placements).
-  dimensionConstruct
+  dimensionConstruct,
+  // ── the LML-aligned substrate (TODO.lang-gaps; Annex F) ─────────
+  defineConstruct({
+    keyword: "mapping",
+    field: "wireMappings",
+    takesID: true,
+    takesFormat: true,
+    parse: parseWireMapping,
+    dump: dumpWireMapping
+  }),
+  defineConstruct({
+    keyword: "string_format",
+    field: "stringFormats",
+    takesID: true,
+    parse: parseStringFormat,
+    dump: dumpStringFormat
+  }),
+  defineConstruct({
+    keyword: "namespace",
+    field: "namespaces",
+    takesID: true,
+    parse: parseNamespace,
+    dump: dumpNamespace
+  }),
+  defineConstruct({
+    keyword: "datum",
+    field: "datums",
+    takesID: true,
+    optionalTypedId: true,
+    parse: parseDatum,
+    dump: dumpDatum
+  }),
+  defineConstruct({
+    keyword: "check",
+    field: "checks",
+    takesID: true,
+    parse: parseCheck,
+    dump: dumpCheck
+  })
 ];
 function buildParserConfig(constructs) {
   const out = {};
@@ -19585,6 +20876,8 @@ function buildParserConfig(constructs) {
     }
     const entry = {
       takesID: c.takesID,
+      takesFormat: c.takesFormat,
+      optionalTypedId: c.optionalTypedId,
       parse: c.parse,
       field: c.field,
       ...c.deprecated ? { deprecated: c.deprecated } : {}
@@ -19811,6 +21104,9 @@ function loadPackageInternal(dir, options = {}, withProvenance = false) {
     return composePackage(dir, options, manifest, withProvenance);
   }
   const parseOptions = withProvenance ? { ...options, withProvenance: true } : options;
+  if (manifest?.language) {
+    parseOptions.strict = true;
+  }
   const ctx = parse(joinChunks(chunks), PARSER_CONFIG, parseOptions);
   if (manifest) {
     ctx.packageManifest = manifest;
@@ -19894,6 +21190,11 @@ var MERGE_FIELDS = [
   "calculations",
   "verdicts",
   "referenceMaterials",
+  "wireMappings",
+  "stringFormats",
+  "namespaces",
+  "datums",
+  "checks",
   "testPointSets",
   "commonTestConditions",
   "competenceKinds",
@@ -19903,6 +21204,7 @@ var MERGE_FIELDS = [
   "schemeActivityKinds",
   "schemeTypes",
   "constraints",
+  "uncertaintyBudgets",
   "discrepancyRecords",
   "stateMachines",
   "conformanceTests",
@@ -20134,7 +21436,12 @@ function composePackage(rootDir, options, rootManifest, withProvenance = false)
   const ctxs = /* @__PURE__ */ new Map();
   const pkgChunks = /* @__PURE__ */ new Map();
   for (const id of order) {
-    const parsed = parsePackageContent(dirs.get(id), parseOptions);
+    const pkgOptions = { ...parseOptions };
+    const pkgManifest = manifests.get(id);
+    if (pkgManifest?.language) {
+      pkgOptions.strict = true;
+    }
+    const parsed = parsePackageContent(dirs.get(id), pkgOptions);
     ctxs.set(id, parsed.ctx);
     pkgChunks.set(id, parsed.chunks);
   }
@@ -20233,7 +21540,21 @@ function composePackage(rootDir, options, rootManifest, withProvenance = false)
   for (const id of order) {
     const m = manifests.get(id);
     for (const req of m.requires ?? []) {
-      const satisfied = order.some(
+      const at = req.indexOf(":");
+      const scoped = at > 0 ? { pkg: req.slice(0, at), token: req.slice(at + 1) } : null;
+      let scopedProvides = null;
+      if (scoped && !order.includes(scoped.pkg)) {
+        try {
+          const dir = locate(scoped.pkg);
+          if (dir) {
+            const rm = readPackageManifest(dir);
+            scopedProvides = rm.provides ?? [];
+            manifests.set(scoped.pkg, rm);
+          }
+        } catch {
+        }
+      }
+      const satisfied = scoped ? order.includes(scoped.pkg) ? (manifests.get(scoped.pkg).provides ?? []).includes(scoped.token) : (scopedProvides ?? []).includes(scoped.token) : order.some(
         (other) => other !== id && (other === req || (manifests.get(other).provides ?? []).includes(req))
       );
       if (!satisfied) {
@@ -22042,6 +23363,176 @@ var CHECK_RULES = [
     "normal",
     "the MMEL v2 validation parity (the rename contract \u2014 TODO.editor/41)"
   ),
+  // ── the LML-aligned substrate (TODO.lang-gaps; the spec's validation
+  // contract, language-v3 §16) ── The five constructs (mapping /
+  // string_format / namespace / datum / check) carry their declared
+  // data; the checker does the discipline. C163 is the release
+  // classification contract — it runs over `primmel diff --exit-code`
+  // (the existing diff classifier, src/model-diff.ts), so its catalog
+  // entry documents the contract the CLI already enforces; no second
+  // implementation lives here. C165/C166 are RESERVED for the
+  // calculation math plane (the formula identifier bindings and the
+  // Plurimath-conformant parse) — catalogued, not faked.
+  R(
+    "C158",
+    "prose-quarantine",
+    "base",
+    "error",
+    "normal",
+    "the LML-aligned validation contract (language-v3 \xA716; TODO.lang-gaps)"
+  ),
+  R(
+    "C159",
+    "urn-only-refs",
+    "base",
+    "error",
+    "normal",
+    "the LML-aligned validation contract (language-v3 \xA716; TODO.lang-gaps)"
+  ),
+  R(
+    "C160",
+    "signature-closure",
+    "base",
+    "error",
+    "normal",
+    "the LML-aligned validation contract (language-v3 \xA716; TODO.lang-gaps)"
+  ),
+  R(
+    "C161",
+    "check-surface",
+    "base",
+    "error",
+    "normal",
+    "the LML-aligned validation contract (language-v3 \xA716; TODO.lang-gaps)"
+  ),
+  R(
+    "C162",
+    "namespace-coherence",
+    "base",
+    "error",
+    "normal",
+    "the LML-aligned validation contract (language-v3 \xA716; TODO.lang-gaps)"
+  ),
+  R(
+    "C163",
+    "change-levels",
+    "base",
+    "error",
+    "normal",
+    "the LML-aligned validation contract (language-v3 \xA716) \u2014 runs over `primmel diff --exit-code` (src/model-diff.ts, the diff classifier)"
+  ),
+  R(
+    "C164",
+    "wire-mapping-coverage",
+    "base",
+    "error",
+    "normal",
+    "the LML-aligned validation contract (language-v3 \xA716; TODO.lang-gaps)"
+  ),
+  R(
+    "C165",
+    "math-symbols-declared",
+    "quantities",
+    "warning",
+    "normal",
+    "RESERVED for the calculation math plane (language-v3 \xA716) \u2014 the formula identifier bindings"
+  ),
+  R(
+    "C166",
+    "math-parses",
+    "quantities",
+    "warning",
+    "normal",
+    "RESERVED for the calculation math plane (language-v3 \xA716) \u2014 the Plurimath-conformant parse (plurimath-ts)"
+  ),
+  R(
+    "C167",
+    "qualified-unit-reference",
+    "quantities",
+    "error",
+    "normal",
+    "the LML-aligned validation contract (language-v3 \xA716; TODO.lang-gaps)"
+  ),
+  R(
+    "C168",
+    "method-ref-resolves",
+    "process",
+    "error",
+    "normal",
+    "a conformance test method_ref names a process to be realized \u2014 bare in-package, or scoped <package>:<id> resolved read-only through the locator; never a bibliographic standard id"
+  ),
+  R(
+    "C169",
+    "provenance-clause-resolves",
+    "base",
+    "error",
+    "normal",
+    "a provenance binding citing a shipped document lands on a real fragment or sentence of that document \u2014 nothing linked to air"
+  ),
+  R(
+    "C170",
+    "edition-lineage-declared",
+    "base",
+    "error",
+    "normal",
+    "a package declaring more than one edition carries edition-mapping.json (primmel-edition-mapping/1) naming both edition states \u2014 the cross-edition linkage is an artifact, never implicit"
+  ),
+  R(
+    "C171",
+    "expression-identifiers-resolve",
+    "base",
+    "error",
+    "normal",
+    "every identifier inside a limit expression, derivation, or derive resolves to a declared name in scope \u2014 the formula is the executable core, nothing in it is air"
+  ),
+  R(
+    "C172",
+    "requirement-algebra-resolves",
+    "base",
+    "error",
+    "normal",
+    "containment is conjunction; a requirement class limit (the law) names its contained members with the OCL booleans \u2014 and/or/xor/implies \u2014 and every member appears in the law"
+  ),
+  R(
+    "C176",
+    "language-declared-wellformed",
+    "base",
+    "error",
+    "normal",
+    "a declared language generation is well-formed (v<major>[.<minor>]); the declaration makes the package parse strictly \u2014 unknown keywords are errors"
+  ),
+  R(
+    "C179",
+    "uncertainty-budget-resolves",
+    "base",
+    "error",
+    "normal",
+    "an uncertainty budget targets a declared verdict; a Type A component names a declared captured series, a Type B component states its distribution and half-width; the coverage factor is a positive number"
+  ),
+  R(
+    "C173",
+    "step-plane-refs-resolve",
+    "process",
+    "error",
+    "normal",
+    "a signature step's completion is one expression over the step's own declared ios; the calls bindings resolve the callee's declared signature; the dot-descent process:step.io resolves to a declared io"
+  ),
+  R(
+    "C177",
+    "kind-coherence",
+    "base",
+    "error",
+    "normal",
+    "a comparison in an inline expression sets operands of the same declared quantity kind \u2014 the kinds from the args' declared sources; unknown-kind and bare-number operands never conflict"
+  ),
+  R(
+    "C178",
+    "legacy-carrier-deprecated",
+    "base",
+    "warning",
+    "normal",
+    "a package declaring the deprecation generation carries quoted ocl{\u2026} expression carriers \u2014 the inline blocks (expression { \u2026 }, derive { \u2026 }, derivation { \u2026 }, check { \u2026 }) are the only forward form"
+  ),
   // ── mapping (TODO.roadmap/04) ─────────────────────────────────────
   R(
     "C21",
@@ -23525,6 +25016,22 @@ var EMPTY = {
   textCoverageBudgetReason: null,
   entries: []
 };
+function issueElementId(message) {
+  const m = message.match(/^[a-z_]+ ([^:\s][^:]*):/);
+  return m ? m[1] : "";
+}
+function entryMatches(entry, issue) {
+  if (issue.check !== entry.rule) {
+    return false;
+  }
+  if (!globMatch(entry.match, issue.message)) {
+    return false;
+  }
+  if (entry.id !== void 0) {
+    return globMatch(entry.id, issueElementId(issue.message));
+  }
+  return true;
+}
 function globMatch(glob, text) {
   const re = new RegExp(
     "^" + glob.split("*").map(escapeRegExp).join("[\\s\\S]*") + "$"
@@ -23624,6 +25131,8 @@ function parseEntry2(block) {
       entry.rule = value;
     } else if (key === "match") {
       entry.match = value;
+    } else if (key === "id") {
+      entry.id = value;
     } else if (key === "reason") {
       entry.reason = value;
     } else if (key === "audit_ref") {
@@ -23642,6 +25151,13 @@ function validateEntry(entry) {
       message: `${ALLOWLIST_FILENAME}: entry${label} names ${entry.rule ? `unknown rule "${entry.rule}"` : "no rule"} \u2014 every allowlist entry names a real rule id (allowlist-malformed)`
     });
   }
+  if (entry.id !== void 0 && entry.id === "") {
+    issues.push({
+      check: "C56",
+      severity: "error",
+      message: `${ALLOWLIST_FILENAME}: entry for rule "${entry.rule}" has an empty id glob \u2014 the structured key pins the element identity or is absent (allowlist-malformed)`
+    });
+  }
   if (!entry.match) {
     issues.push({
       check: "C56",
@@ -23677,7 +25193,7 @@ function applyAllowlist(issues, allowlist, activeRules) {
     }
     let matched = false;
     for (const issue of out) {
-      if (issue.check === entry.rule && globMatch(entry.match, issue.message)) {
+      if (entryMatches(entry, issue)) {
         issue.known = true;
         matched = true;
       }
@@ -23742,7 +25258,7 @@ function applyProviderAllowlists(issues, providers, activeRules) {
       }
       let matched = false;
       for (const issue of out) {
-        if (!issue.known && issue.check === entry.rule && globMatch(entry.match, issue.message)) {
+        if (!issue.known && entryMatches(entry, issue)) {
           issue.known = true;
           matched = true;
         }
@@ -24081,6 +25597,40 @@ function computeTextCoverage(standard, manifests, config) {
   }
   const documents = [];
   const matchedAllowanceSentences = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    const urn = manifest.document.urn;
+    const fragments = /* @__PURE__ */ new Set();
+    const addresses = /* @__PURE__ */ new Set();
+    for (const s of manifest.sentences) {
+      fragments.add(s.fragment);
+      addresses.add(s.address);
+    }
+    for (const b of bindings) {
+      if (b.doc !== urn) {
+        continue;
+      }
+      if (fragments.has(b.fragmentPath) || addresses.has(b.fragmentPath)) {
+        continue;
+      }
+      const prefix = b.fragmentPath + ".";
+      let resolved = false;
+      for (const f of fragments) {
+        if (f.startsWith(prefix) || b.fragmentPath.startsWith(f + "/")) {
+          resolved = true;
+          break;
+        }
+      }
+      if (resolved) {
+        continue;
+      }
+      const subpart = /^(table|figure|annex)-/.test(b.fragmentPath);
+      configIssues.push({
+        check: "C169",
+        severity: subpart ? "warning" : "error",
+        message: `provenance binding ${b.doc}#${b.fragmentPath} (${b.element}, ${b.kind}) names no fragment or sentence of the shipped document \u2014 ${subpart ? "a bare subpart citation the clause-only harvest cannot verify" : "linked to air"} (provenance-clause-resolves)`
+      });
+    }
+  }
   for (const manifest of manifests) {
     const urn = manifest.document.urn;
     const sentences = manifest.sentences;
@@ -24479,6 +26029,7 @@ function checkPackage(dir, options = {}) {
   issues.push(...checkDimensions(standard));
   issues.push(...checkReferences(standard));
   issues.push(...checkVerdictChains(standard));
+  issues.push(...checkLmlAligned(standard));
   issues.push(...checkClosedDerivations(standard));
   issues.push(...checkAttestations(standard));
   issues.push(...checkTypedPayloads(standard));
@@ -24563,9 +26114,12 @@ function checkPackage(dir, options = {}) {
     };
     (form.fields ?? []).forEach(checkField);
   }
+  const classIds = new Set(
+    (standard.requirementClasses ?? []).map((rc) => rc.id)
+  );
   for (const t of standard.conformanceTests ?? []) {
     for (const target of t.targets ?? []) {
-      if (!reqIds.has(target)) {
+      if (!reqIds.has(target) && !classIds.has(target)) {
         err(
           "C2",
           `conformance test ${t.id}: target "${target}" is not a declared requirement`
@@ -24722,9 +26276,19 @@ function checkPackage(dir, options = {}) {
     }
   }
   const covered = /* @__PURE__ */ new Set();
+  const classMembers = /* @__PURE__ */ new Map();
+  for (const rc of standard.requirementClasses ?? []) {
+    classMembers.set(rc.id, rc.members ?? []);
+  }
+  const coverWithMembers = (id) => {
+    covered.add(id);
+    for (const m of classMembers.get(id) ?? []) {
+      covered.add(m);
+    }
+  };
   for (const t of standard.conformanceTests ?? []) {
     for (const target of t.targets ?? []) {
-      covered.add(target);
+      coverWithMembers(target);
     }
   }
   const provisioned = /* @__PURE__ */ new Set();
@@ -24763,6 +26327,1003 @@ function checkPackage(dir, options = {}) {
       warn("C5", `conformance test ${t.id}: targets no requirement`);
     }
   }
+  const OCL_WORDS = /* @__PURE__ */ new Set([
+    "and",
+    "or",
+    "not",
+    "xor",
+    "implies",
+    "if",
+    "then",
+    "else",
+    "endif",
+    "true",
+    "false",
+    "null",
+    "invalid",
+    "abs",
+    "max",
+    "min",
+    "floor",
+    "ceil",
+    "mod",
+    "div",
+    "round",
+    "sqrt",
+    "exp",
+    "ln",
+    "log",
+    "sum",
+    "count",
+    "exists",
+    "forall",
+    "oclIsUndefined",
+    "oclIsKindOf",
+    "oclIsTypeOf",
+    "String",
+    "Integer",
+    "Real",
+    "Boolean",
+    "Set",
+    "Bag",
+    "Sequence",
+    "Collection",
+    // the subject-chain roots: every expression reads the dispatch
+    // context through them — context, never air
+    "sample",
+    "family",
+    "group",
+    "model",
+    "instrument",
+    "specimen",
+    "max_of",
+    "min_of",
+    "mean_of",
+    "stddev_of",
+    "count_of"
+  ]);
+  const globalExprNames = new Set(
+    [
+      ...(standard.symbols ?? []).map((s) => s.id),
+      ...(standard.symbols ?? []).map((s) => s.id.split("/").pop() ?? ""),
+      ...(standard.datums ?? []).map((d) => d.id),
+      ...(standard.verdicts ?? []).map((v) => v.id),
+      // the lookup tables: a dotted helper call's OBJECT is declared here —
+      // the method name rides the declared object
+      ...(standard.tables ?? []).map((v) => v.id),
+      // the subject anatomy: a declared attribute is a declaration
+      ...(standard.attributeDefinitions ?? []).map((a) => a.id),
+      ...(standard.attributeDefinitions ?? []).map(
+        (a) => a.id.split("/").pop() ?? ""
+      ),
+      // the calculations: a derivation may call a declared calculation
+      // (twin-cert's lookupMPE) — the callable registry
+      ...(standard.calculations ?? []).map((c) => c.id),
+      ...(standard.calculations ?? []).map((c) => c.id.split("/").pop() ?? "")
+    ].filter((x) => x !== "")
+  );
+  const symbolKinds = /* @__PURE__ */ new Map();
+  for (const s of standard.symbols ?? []) {
+    if (s.quantityKind) {
+      symbolKinds.set(s.id, s.quantityKind);
+      symbolKinds.set(s.id.split("/").pop() ?? "", s.quantityKind);
+    }
+  }
+  const attributeKinds = /* @__PURE__ */ new Map();
+  for (const a of standard.attributeDefinitions ?? []) {
+    if (a.quantityKind) {
+      attributeKinds.set(a.id, a.quantityKind);
+      attributeKinds.set(
+        a.id.split("/").pop() ?? "",
+        a.quantityKind
+      );
+    }
+  }
+  const verdictKinds = /* @__PURE__ */ new Map();
+  for (const v of standard.verdicts ?? []) {
+    if (v.quantityKind) {
+      verdictKinds.set(v.id, v.quantityKind);
+    }
+  }
+  const tableColumnTypes = /* @__PURE__ */ new Map();
+  for (const t of standard.tables ?? []) {
+    const cols = /* @__PURE__ */ new Map();
+    for (const c of t.columnDefs ?? []) {
+      cols.set(c.name, (c.type || "").toLowerCase());
+    }
+    if (cols.size > 0) {
+      tableColumnTypes.set(t.id, cols);
+    }
+  }
+  const bare = (q) => q.split(":").pop() ?? q;
+  const usesCovers = (uses, id) => uses.some((u) => {
+    const tail = bare(u.replace(/\./g, ":"));
+    return u === id || tail === id || u.endsWith("." + id);
+  });
+  const exprIds = (expr) => {
+    const paths = expr.match(/[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*/g) ?? [];
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of paths) {
+      if (p.includes(".")) {
+        const segs = p.split(".");
+        if (globalExprNames.has(segs[0])) {
+          continue;
+        }
+        const finalSeg = segs[segs.length - 1];
+        if (!seen.has(p)) {
+          seen.add(p);
+          if (!OCL_WORDS.has(finalSeg)) {
+            out.push(finalSeg);
+          }
+        }
+        continue;
+      }
+      if (!OCL_WORDS.has(p) && !seen.has(p)) {
+        seen.add(p);
+        out.push(p);
+      }
+    }
+    return out;
+  };
+  const unresolvedIn = (expr, scope, uses) => {
+    const scopeSet = /* @__PURE__ */ new Set([...scope, ...globalExprNames]);
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const id of exprIds(expr)) {
+      if (seen.has(id)) {
+        continue;
+      }
+      seen.add(id);
+      if (OCL_WORDS.has(id) || scopeSet.has(id) || usesCovers(uses, id)) {
+        continue;
+      }
+      out.push(id);
+    }
+    return out;
+  };
+  const mappedCalcIds = /* @__PURE__ */ new Set();
+  {
+    const mapsTo = standard.packageManifest?.mapsTo ?? [];
+    for (const target of mapsTo) {
+      if (!options.resolvePackage) {
+        continue;
+      }
+      try {
+        const depDir = options.resolvePackage(target);
+        if (!depDir) {
+          continue;
+        }
+        const dep = loadPackageWithIssues(depDir);
+        for (const c of dep.standard?.calculations ?? []) {
+          mappedCalcIds.add(c.id);
+          mappedCalcIds.add(c.id.split("/").pop() ?? "");
+        }
+      } catch {
+      }
+    }
+    for (const x of mappedCalcIds) {
+      if (x !== "") {
+        globalExprNames.add(x);
+      }
+    }
+  }
+  const INLINE_FUNCTION_WORDS = /* @__PURE__ */ new Set([
+    "abs",
+    "max",
+    "min",
+    "floor",
+    "ceil",
+    "round",
+    "sqrt",
+    "exp",
+    "ln",
+    "log",
+    "mod",
+    "sum",
+    "count",
+    "exists",
+    "forall",
+    // the series aggregations (register W4): the GUM type A vocabulary —
+    // the statistics of a captured series; the evaluation is plurimath's
+    "max_of",
+    "min_of",
+    "mean_of",
+    "stddev_of",
+    "count_of"
+  ]);
+  const DECLARATION_KINDS = /* @__PURE__ */ new Set([
+    "symbol",
+    "table",
+    "datum",
+    "verdict",
+    "attribute",
+    "process"
+  ]);
+  const CONTEXT_ROOTS = /* @__PURE__ */ new Set([
+    "sample",
+    "family",
+    "group",
+    "model",
+    "instrument",
+    "specimen"
+  ]);
+  const checkInlineLimit = (ownerKind, ownerId, limit, memberScope) => {
+    let ast;
+    try {
+      ast = parseExpression(limit.expression);
+    } catch (e) {
+      err(
+        "C171",
+        `${ownerKind} ${ownerId}: the inline limit expression does not parse \u2014 ${String(e.message ?? e)} (expression-identifiers-resolve)`
+      );
+      return;
+    }
+    const ids = freeIdentifiers(ast);
+    const args2 = limit.args ?? [];
+    const argNames = new Set(args2.map((a) => a.name));
+    if (memberScope === null && args2.length === 0 && ids.names.some((n) => !n.includes("."))) {
+      err(
+        "C171",
+        `${ownerKind} ${ownerId}: the inline limit declares no arguments \u2014 every identifier must bind explicitly, args { name <- <declaration> } (expression-identifiers-resolve)`
+      );
+    }
+    for (const call of new Set(ids.calls)) {
+      if (INLINE_FUNCTION_WORDS.has(call)) {
+        continue;
+      }
+      if (globalExprNames.has(call)) {
+        continue;
+      }
+      if (call.includes(".")) {
+        const root = call.split(".")[0];
+        if (argNames.has(root) || globalExprNames.has(root) || root === "self" || CONTEXT_ROOTS.has(root)) {
+          continue;
+        }
+      }
+      if (argNames.has(call)) {
+        continue;
+      }
+      err(
+        "C171",
+        `${ownerKind} ${ownerId}: the limit calls "${call}(\u2026)", which no argument binds and which is not in the expression function vocabulary (abs max min floor ceil round sqrt exp ln log mod sum count exists forall) \u2014 air inside the formula (expression-identifiers-resolve)`
+      );
+    }
+    for (const id of new Set(ids.names)) {
+      const root = id.split(".")[0];
+      if (id.includes(".") && (root === "self" || argNames.has(root) || CONTEXT_ROOTS.has(root))) {
+        continue;
+      }
+      if (argNames.has(id)) {
+        continue;
+      }
+      if (memberScope !== null && memberScope.has(id)) {
+        continue;
+      }
+      const lawScoped = memberScope !== null;
+      const fix = lawScoped ? "the law composes the containment only \u2014 its identifiers are the members" : "add args { " + id + " <- <declaration> } or remove it";
+      err(
+        lawScoped ? "C172" : "C171",
+        `${ownerKind} ${ownerId}: the limit expression names "${id}", which no argument binds \u2014 ${fix} (${lawScoped ? "requirement-algebra-resolves" : "expression-identifiers-resolve"})`
+      );
+    }
+    for (const a of args2) {
+      if (a.source.includes(":")) {
+        const segs = a.source.split(":");
+        if (segs.some((s) => s.length === 0)) {
+          err(
+            "C171",
+            `${ownerKind} ${ownerId}: argument "${a.name}" binds to "${a.source}" \u2014 a binding is <kind>:<id> in this package or <package>:<kind>:<id> across a uses edge (expression-identifiers-resolve)`
+          );
+          continue;
+        }
+        if (segs.length === 2) {
+          const [kind, id] = segs;
+          if (kind === "process") {
+            const segs2 = id.split(".");
+            const proc = (standard.processes ?? []).find(
+              (pp) => pp.id === segs2[0]
+            );
+            if (!proc) {
+              err(
+                "C171",
+                `${ownerKind} ${ownerId}: argument "${a.name}" binds to "${a.source}", which no declared process names \u2014 air inside the formula (expression-identifiers-resolve)`
+              );
+            } else if (segs2.length >= 2) {
+              const stp = (proc.steps ?? []).find((ss) => ss.id === segs2[1]);
+              if (!stp) {
+                err(
+                  "C171",
+                  `${ownerKind} ${ownerId}: argument "${a.name}" binds to "${a.source}" \u2014 the process declares no step "${segs2[1]}" (expression-identifiers-resolve)`
+                );
+              } else if (segs2.length >= 3) {
+                const io = segs2.slice(2).join(".");
+                if (!(stp.sigInputs ?? []).includes(io) && !(stp.sigOutputs ?? []).includes(io)) {
+                  err(
+                    "C171",
+                    `${ownerKind} ${ownerId}: argument "${a.name}" binds to "${a.source}" \u2014 the step declares no io "${io}" (expression-identifiers-resolve)`
+                  );
+                }
+              }
+            }
+            continue;
+          }
+          if (kind !== "observable") {
+            if (!DECLARATION_KINDS.has(kind)) {
+              err(
+                "C171",
+                `${ownerKind} ${ownerId}: argument "${a.name}" binds to "${a.source}" \u2014 "${kind}" is not a declaration kind (symbol table datum verdict attribute observable) (expression-identifiers-resolve)`
+              );
+              continue;
+            }
+            const idRoot = id.split(".")[0];
+            const idTail = id.split(".").pop() ?? id;
+            if (!globalExprNames.has(id) && !globalExprNames.has(idRoot) && !globalExprNames.has(idTail)) {
+              err(
+                "C171",
+                `${ownerKind} ${ownerId}: argument "${a.name}" binds to "${a.source}", which no declared ${kind} names \u2014 air inside the formula (expression-identifiers-resolve)`
+              );
+            }
+          }
+          continue;
+        }
+        continue;
+      }
+      if (a.source === "self" || a.source.startsWith("self.")) {
+        continue;
+      }
+      const bare2 = (q) => q.split(":").pop() ?? q;
+      const sourceBare = bare2(a.source.replace(/\./g, ":"));
+      if (memberScope !== null) {
+        if (!memberScope.has(a.source) && !memberScope.has(sourceBare)) {
+          err(
+            "C172",
+            `requirement class ${ownerId}: the law binds "${a.name}" to "${a.source}", which is not a contained member (requirement-algebra-resolves)`
+          );
+        }
+        continue;
+      }
+      if (!globalExprNames.has(a.source) && !globalExprNames.has(sourceBare) && !usesCovers(limit.uses, sourceBare)) {
+        err(
+          "C171",
+          `${ownerKind} ${ownerId}: argument "${a.name}" binds to "${a.source}", which no symbol, datum, verdict, attribute, or uses entry declares \u2014 air inside the formula (expression-identifiers-resolve)`
+        );
+      }
+    }
+    const kindLabel = (k) => k === void 0 ? "an operand of unknown kind" : k === "TEXT" ? "text" : k === null ? "a bare number" : `the "${k}" quantity`;
+    const argKindOf = (source) => {
+      if (source.includes(":")) {
+        const segs = source.split(":");
+        if (segs.length !== 2) {
+          return void 0;
+        }
+        const [kind, id] = segs;
+        if (kind === "symbol") {
+          return symbolKinds.get(id.split(".").pop() ?? id);
+        }
+        if (kind === "attribute") {
+          return attributeKinds.get(id.split(".").pop() ?? id);
+        }
+        if (kind === "verdict") {
+          return verdictKinds.get(id.split(".")[0]);
+        }
+        if (kind === "table") {
+          const segs2 = id.split(".");
+          const colType = segs2.length === 2 ? tableColumnTypes.get(segs2[0])?.get(segs2[1]) : void 0;
+          return colType === "string" ? "TEXT" : void 0;
+        }
+        return void 0;
+      }
+      if (source === "self" || source.startsWith("self.")) {
+        return void 0;
+      }
+      return symbolKinds.get(source) ?? attributeKinds.get(source) ?? void 0;
+    };
+    const kindConflicts = /* @__PURE__ */ new Set();
+    const kindMixErr = (node, l, r) => {
+      const key = renderExpression(node);
+      if (kindConflicts.has(key)) {
+        return;
+      }
+      kindConflicts.add(key);
+      err(
+        "C177",
+        `${ownerKind} ${ownerId}: ${kindLabel(l)} is set against ${kindLabel(r)} in "${renderExpression(node)}" \u2014 the operands must share the quantity kind (kind-coherence)`
+      );
+    };
+    const kindOf = (node) => {
+      switch (node.type) {
+        case "num":
+          return null;
+        case "str":
+          return null;
+        case "bool":
+          return null;
+        case "ifelse": {
+          kindOf(node.cond);
+          const l = kindOf(node.then);
+          const r = kindOf(node.else);
+          if (l !== void 0 && r !== void 0 && l !== null && r !== null && l !== r) {
+            kindMixErr(node, l, r);
+          }
+          return l !== void 0 && l !== null ? l : r;
+        }
+        case "name": {
+          const root = node.path[0];
+          if (node.path.length > 1 && (root === "self" || CONTEXT_ROOTS.has(root))) {
+            return void 0;
+          }
+          const arg = args2.find((a) => a.name === root);
+          return arg ? argKindOf(arg.source) : void 0;
+        }
+        case "call": {
+          if (node.callee.includes(".")) {
+            return void 0;
+          }
+          const kinded = [
+            "abs",
+            "max",
+            "min",
+            "floor",
+            "ceil",
+            "round",
+            "sqrt",
+            "exp",
+            "ln",
+            "log",
+            "mod"
+          ];
+          if (!kinded.includes(node.callee)) {
+            return null;
+          }
+          let acc = void 0;
+          for (const a of node.args) {
+            const k = kindOf(a);
+            if (k === void 0) {
+              continue;
+            }
+            if (acc === void 0 || acc === null) {
+              acc = k;
+              continue;
+            }
+            if (k !== void 0 && k !== null && k !== acc) {
+              kindMixErr(node, acc, k);
+            }
+          }
+          return acc;
+        }
+        case "unop":
+          return node.op === "not" ? null : kindOf(node.operand);
+        case "nav":
+          return node.op === "select" ? void 0 : node.op === "collect" ? kindOf(node.body) : null;
+        case "binop": {
+          if (["<=", ">=", "<", ">", "=", "!=", "\u2260"].includes(node.op)) {
+            const l2 = kindOf(node.left);
+            const r2 = kindOf(node.right);
+            if (l2 !== void 0 && r2 !== void 0 && l2 !== null && r2 !== null && l2 !== r2) {
+              kindMixErr(node, l2, r2);
+            }
+            return null;
+          }
+          if (["and", "or", "xor", "implies"].includes(node.op)) {
+            kindOf(node.left);
+            kindOf(node.right);
+            return null;
+          }
+          const l = kindOf(node.left);
+          const r = kindOf(node.right);
+          if (l !== void 0 && r !== void 0 && l !== null && r !== null && l !== r) {
+            kindMixErr(node, l, r);
+          }
+          return l !== void 0 && l !== null ? l : r;
+        }
+      }
+    };
+    kindOf(ast);
+  };
+  for (const r of standard.requirements ?? []) {
+    if (r.limit?.argsBound) {
+      checkInlineLimit("requirement", r.id, r.limit, null);
+      continue;
+    }
+    const expr = r.limit?.expression;
+    if (!expr) {
+      continue;
+    }
+    const ocl = expr.replace(/^ocl\{/, "").replace(/\}$/, "");
+    const uses = r.limit?.uses ?? [];
+    for (const id of unresolvedIn(ocl, [], uses)) {
+      err(
+        "C171",
+        `requirement ${r.id}: the limit expression names "${id}", which no uses entry, symbol, datum, or verdict declares \u2014 air inside the formula (expression-identifiers-resolve)`
+      );
+    }
+  }
+  const resolveInlineCarrier = (ownerKind, ownerId, what, src, scope) => {
+    let ast;
+    try {
+      ast = parseExpression(src);
+    } catch (e) {
+      err(
+        "C171",
+        `${ownerKind} ${ownerId}: the ${what} does not parse \u2014 ${String(e.message ?? e)} (expression-identifiers-resolve)`
+      );
+      return;
+    }
+    const ids = freeIdentifiers(ast);
+    for (const call of new Set(ids.calls)) {
+      if (INLINE_FUNCTION_WORDS.has(call)) {
+        continue;
+      }
+      if (call.includes(".")) {
+        const root = call.split(".")[0];
+        if (scope.has(root) || globalExprNames.has(root) || root === "self" || CONTEXT_ROOTS.has(root)) {
+          continue;
+        }
+      }
+      if (scope.has(call) || globalExprNames.has(call)) {
+        continue;
+      }
+      err(
+        "C171",
+        `${ownerKind} ${ownerId}: the ${what} calls "${call}(\u2026)", which nothing declares and which is not in the expression function vocabulary \u2014 air inside the formula (expression-identifiers-resolve)`
+      );
+    }
+    for (const id of new Set(ids.names)) {
+      const root = id.split(".")[0];
+      if (id.includes(".") && (scope.has(root) || root === "self" || CONTEXT_ROOTS.has(root))) {
+        continue;
+      }
+      if (scope.has(id)) {
+        continue;
+      }
+      if (globalExprNames.has(id) || globalExprNames.has(id.split(".").pop() ?? id)) {
+        continue;
+      }
+      err(
+        "C171",
+        `${ownerKind} ${ownerId}: the ${what} names "${id}", which nothing in scope declares \u2014 air inside the formula (expression-identifiers-resolve)`
+      );
+    }
+  };
+  for (const v of standard.verdicts ?? []) {
+    const expr = v.derive;
+    if (!expr) {
+      continue;
+    }
+    const inputs = v.inputs ?? [];
+    if (v.deriveBound) {
+      resolveInlineCarrier("verdict", v.id, "derive", expr, new Set(inputs));
+      continue;
+    }
+    const ocl = expr.replace(/^ocl\{/, "").replace(/\}$/, "");
+    for (const id of unresolvedIn(ocl, inputs, [])) {
+      err(
+        "C171",
+        `verdict ${v.id}: the derive expression names "${id}", which no input declares \u2014 air inside the formula (expression-identifiers-resolve)`
+      );
+    }
+  }
+  for (const t of standard.conformanceTests ?? []) {
+    const scope = (t.variables ?? []).map((v) => v.name);
+    for (const v of t.variables ?? []) {
+      if (!v.derivation) {
+        continue;
+      }
+      if (v.derivationBound) {
+        resolveInlineCarrier(
+          "conformance test",
+          t.id,
+          `variable ${v.name}'s derivation`,
+          v.derivation,
+          new Set(scope)
+        );
+        continue;
+      }
+      const ocl = v.derivation.replace(/^ocl\{/, "").replace(/\}$/, "");
+      for (const id of unresolvedIn(ocl, scope, [])) {
+        err(
+          "C171",
+          `conformance test ${t.id}: variable ${v.name}'s derivation names "${id}", which no sibling variable, symbol, datum, or verdict declares \u2014 air inside the formula (expression-identifiers-resolve)`
+        );
+      }
+    }
+  }
+  for (const c of standard.constraints ?? []) {
+    if (!c.checkBound || !c.check) {
+      continue;
+    }
+    const cArgs = c.args ?? [];
+    const cScope = new Set(cArgs.map((a) => a.name));
+    for (const a of cArgs) {
+      if (a.source.includes(":")) {
+        const segs = a.source.split(":");
+        if (segs.length === 2 && segs[0] !== "observable") {
+          const [kind, id] = segs;
+          if (!DECLARATION_KINDS.has(kind)) {
+            err(
+              "C171",
+              `constraint ${c.id}: argument "${a.name}" binds to "${a.source}" \u2014 "${kind}" is not a declaration kind (expression-identifiers-resolve)`
+            );
+          } else {
+            const idRoot = id.split(".")[0];
+            const idTail = id.split(".").pop() ?? id;
+            if (!globalExprNames.has(id) && !globalExprNames.has(idRoot) && !globalExprNames.has(idTail)) {
+              err(
+                "C171",
+                `constraint ${c.id}: argument "${a.name}" binds to "${a.source}", which no declared ${kind} names \u2014 air inside the formula (expression-identifiers-resolve)`
+              );
+            }
+          }
+        }
+        continue;
+      }
+      if (a.source === "self" || a.source.startsWith("self.")) {
+        continue;
+      }
+      const bare2 = a.source.split(":").pop() ?? a.source;
+      if (!globalExprNames.has(a.source) && !globalExprNames.has(bare2)) {
+        err(
+          "C171",
+          `constraint ${c.id}: argument "${a.name}" binds to "${a.source}", which nothing declares \u2014 air inside the formula (expression-identifiers-resolve)`
+        );
+      }
+    }
+    resolveInlineCarrier("constraint", c.id, "check", c.check, cScope);
+    try {
+      const ast = parseExpression(c.check);
+      const booleanTop = ast.type === "binop" && [
+        "<=",
+        ">=",
+        "<",
+        ">",
+        "=",
+        "!=",
+        "\u2260",
+        "and",
+        "or",
+        "xor",
+        "implies"
+      ].includes(ast.op) || ast.type === "nav" && ["forAll", "exists"].includes(ast.op);
+      if (!booleanTop) {
+        err(
+          "C84",
+          `constraint ${c.id}: the check does not evaluate to a boolean \u2014 an invariant is one comparison or logical composition (constraint-shape)`
+        );
+      }
+    } catch {
+    }
+  }
+  const memberSet = /* @__PURE__ */ new Map();
+  for (const rc of standard.requirementClasses ?? []) {
+    memberSet.set(rc.id, new Set((rc.members ?? []).map(String)));
+  }
+  for (const rc of standard.requirementClasses ?? []) {
+    const law = rc.limit?.expression;
+    const members = memberSet.get(rc.id) ?? /* @__PURE__ */ new Set();
+    if (!law) {
+      continue;
+    }
+    if (rc.limit?.argsBound) {
+      checkInlineLimit("requirement class", rc.id, rc.limit, members);
+      const covered2 = /* @__PURE__ */ new Set();
+      try {
+        for (const n of freeIdentifiers(parseExpression(law)).names) {
+          covered2.add(n);
+        }
+      } catch {
+      }
+      for (const a of rc.limit.args ?? []) {
+        covered2.add(a.name);
+        covered2.add(a.source);
+      }
+      for (const m of members) {
+        if (!covered2.has(m)) {
+          warn(
+            "C172",
+            `requirement class ${rc.id}: member ${m} does not appear in the law \u2014 either it is always-required (add it with \`and\`) or it is orphaned (requirement-algebra-resolves)`
+          );
+        }
+      }
+      continue;
+    }
+    const ocl = law.replace(/^ocl\{/, "").replace(/\}$/, "");
+    const ids = (ocl.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []).filter(
+      (x) => !OCL_WORDS.has(x)
+    );
+    const lawIds = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      lawIds.add(id);
+      if (!members.has(id)) {
+        err(
+          "C172",
+          `requirement class ${rc.id}: the law names "${id}", which is not a contained member \u2014 the algebra composes the containment only (requirement-algebra-resolves)`
+        );
+      }
+    }
+    for (const m of members) {
+      if (!lawIds.has(m)) {
+        warn(
+          "C172",
+          `requirement class ${rc.id}: member ${m} does not appear in the law \u2014 either it is always-required (add it with \`and\`) or it is orphaned (requirement-algebra-resolves)`
+        );
+      }
+    }
+  }
+  const DEPRECATION_GENERATION = "v3.4";
+  const generationRank = (g) => {
+    const m = g.match(/^v(\d+)(?:\.(\d+))?$/);
+    if (!m) {
+      return -1;
+    }
+    return Number(m[1]) * 1e3 + Number(m[2] ?? "0");
+  };
+  try {
+    const mf = readPackageManifest(dir);
+    if (mf.language !== void 0) {
+      if (!/^v\d+(\.\d+)?$/.test(mf.language)) {
+        err(
+          "C176",
+          `the declared language "${mf.language}" is not a generation (v<major>[.<minor>]) (language-declared-wellformed)`
+        );
+      } else if (generationRank(mf.language) >= generationRank(DEPRECATION_GENERATION)) {
+        let legacy = 0;
+        for (const r of standard.requirements ?? []) {
+          if (r.limit && !r.limit.argsBound && r.limit.expression) {
+            legacy += 1;
+          }
+        }
+        for (const v of standard.verdicts ?? []) {
+          if (v.derive && !v.deriveBound) {
+            legacy += 1;
+          }
+        }
+        for (const t of standard.conformanceTests ?? []) {
+          for (const v of t.variables ?? []) {
+            if (v.derivation && !v.derivationBound) {
+              legacy += 1;
+            }
+          }
+          for (const p of t.preconditions ?? []) {
+            if (p.check && !p.checkBound) {
+              legacy += 1;
+            }
+          }
+        }
+        for (const c of standard.constraints ?? []) {
+          if (c.check && !c.checkBound) {
+            legacy += 1;
+          }
+        }
+        if (legacy > 0) {
+          warn(
+            "C178",
+            `${legacy} quoted expression carrier${legacy === 1 ? "" : "s"} \u2014 the ocl{\u2026} string form is deprecated as of ${DEPRECATION_GENERATION}; migrate to the inline blocks (expression { \u2026 }, derive { \u2026 }, derivation { \u2026 }, check { \u2026 }) (legacy-carrier-deprecated)`
+          );
+        }
+      }
+    }
+  } catch {
+  }
+  {
+    const seriesVariables = /* @__PURE__ */ new Map();
+    for (const t of standard.conformanceTests ?? []) {
+      for (const v of t.variables ?? []) {
+        seriesVariables.set(v.name, v.series !== null);
+      }
+    }
+    for (const b of standard.uncertaintyBudgets ?? []) {
+      if (!b.target) {
+        err(
+          "C179",
+          `uncertainty_budget ${b.id}: declares no target \u2014 the budget backs a declared verdict's measured quantity (uncertainty-budget-resolves)`
+        );
+      } else if (!(standard.verdicts ?? []).some((v) => v.id === b.target)) {
+        err(
+          "C179",
+          `uncertainty_budget ${b.id}: target "${b.target}" is not a declared verdict \u2014 the budget backs a measured quantity the verdicts own (uncertainty-budget-resolves)`
+        );
+      }
+      if (b.components.length === 0) {
+        warn(
+          "C179",
+          `uncertainty_budget ${b.id}: declares no components \u2014 an empty budget states no uncertainty (uncertainty-budget-resolves)`
+        );
+      }
+      if (b.coverageK && !(Number(b.coverageK) > 0)) {
+        err(
+          "C179",
+          `uncertainty_budget ${b.id}: coverage k "${b.coverageK}" is not a positive number (uncertainty-budget-resolves)`
+        );
+      }
+      for (const c of b.components) {
+        if (c.type === "A") {
+          if (!c.series) {
+            err(
+              "C179",
+              `uncertainty_budget ${b.id}: component ${c.id} is Type A but names no series \u2014 the statistics compute from a declared captured series (uncertainty-budget-resolves)`
+            );
+          } else if (!seriesVariables.has(c.series)) {
+            err(
+              "C179",
+              `uncertainty_budget ${b.id}: component ${c.id}'s series "${c.series}" is not a declared test variable (uncertainty-budget-resolves)`
+            );
+          } else if (!seriesVariables.get(c.series)) {
+            err(
+              "C179",
+              `uncertainty_budget ${b.id}: component ${c.id}'s series "${c.series}" declares no series shape \u2014 a Type A evaluation needs the captured series' axes and cell (uncertainty-budget-resolves)`
+            );
+          }
+        } else {
+          if (!c.distribution) {
+            err(
+              "C179",
+              `uncertainty_budget ${b.id}: component ${c.id} is Type B but states no distribution (uncertainty-budget-resolves)`
+            );
+          }
+          if (!c.halfWidth) {
+            err(
+              "C179",
+              `uncertainty_budget ${b.id}: component ${c.id} is Type B but states no half_width \u2014 the distribution spans a half-width (uncertainty-budget-resolves)`
+            );
+          }
+        }
+      }
+    }
+  }
+  for (const p of standard.processes ?? []) {
+    for (const st of p.steps ?? []) {
+      if (!st.completion) {
+        continue;
+      }
+      const ios = /* @__PURE__ */ new Set([...st.sigInputs, ...st.sigOutputs]);
+      let ids;
+      try {
+        ids = freeIdentifiers(
+          parseExpression(
+            st.completion.replace(/^ocl\{/, "").replace(/\}$/, "")
+          )
+        );
+      } catch (e) {
+        err(
+          "C173",
+          `process ${p.id}: step "${st.id}" completion does not parse \u2014 ${String(e.message ?? e)} \u2014 the completion is one expression over the step's ios (step-plane-refs-resolve)`
+        );
+        continue;
+      }
+      for (const call of new Set(ids.calls)) {
+        if (!INLINE_FUNCTION_WORDS.has(call)) {
+          err(
+            "C173",
+            `process ${p.id}: step "${st.id}" completion calls "${call}(\u2026)", which is not in the expression function vocabulary (step-plane-refs-resolve)`
+          );
+        }
+      }
+      for (const id of new Set(ids.names)) {
+        const root = id.split(".")[0];
+        if (id.includes(".") && (root === "self" || CONTEXT_ROOTS.has(root))) {
+          continue;
+        }
+        if (ios.has(id) || ios.has(root)) {
+          continue;
+        }
+        err(
+          "C173",
+          `process ${p.id}: step "${st.id}" completion names "${id}", which is not a declared io of the step \u2014 the completion reads the step's own inputs and outputs (step-plane-refs-resolve)`
+        );
+      }
+    }
+  }
+  try {
+    const mf = readPackageManifest(dir);
+    const eds = (mf.editions ?? []).map(String);
+    if (eds.length > 1) {
+      const map = JSON.parse(
+        readFileSync5(join4(dir, "edition-mapping.json"), "utf8")
+      );
+      if (map.kind !== "primmel-edition-mapping/1") {
+        err(
+          "C170",
+          `edition-mapping.json: kind "${String(map.kind)}" is not primmel-edition-mapping/1 (edition-lineage-declared)`
+        );
+      } else {
+        const fromEd = map.from?.edition === void 0 ? void 0 : String(map.from.edition);
+        const toEd = map.to?.edition === void 0 ? void 0 : String(map.to.edition);
+        for (const [side, ed] of [
+          ["from", fromEd],
+          ["to", toEd]
+        ]) {
+          if (!ed || !eds.includes(ed)) {
+            err(
+              "C170",
+              `edition-mapping.json: the ${side} edition ${String(ed)} is not among the manifest's declared editions [${eds.join(", ")}] (edition-lineage-declared)`
+            );
+          }
+        }
+      }
+    }
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT") {
+      const eds = (() => {
+        try {
+          return (readPackageManifest(dir).editions ?? []).map(
+            String
+          );
+        } catch {
+          return [];
+        }
+      })();
+      if (eds.length > 1) {
+        err(
+          "C170",
+          `the package declares ${eds.length} editions [${eds.join(", ")}] but ships no edition-mapping.json \u2014 the cross-edition linkage is an artifact, never implicit (edition-lineage-declared)`
+        );
+      }
+    } else if (e instanceof SyntaxError) {
+      err(
+        "C170",
+        `edition-mapping.json is not valid JSON: ${e.message} (edition-lineage-declared)`
+      );
+    }
+  }
+  const methodTargetIds = (s) => /* @__PURE__ */ new Set([
+    ...(s.processes ?? []).map((p) => p.id),
+    ...(s.conformanceTests ?? []).map((x) => x.id)
+  ]);
+  const localMethodIds = methodTargetIds(standard);
+  const scopedMethodIds = /* @__PURE__ */ new Map();
+  const resolveCitation = (elemId, ref) => {
+    const colon = ref.indexOf(":");
+    if (colon <= 0) {
+      if (!localMethodIds.has(ref)) {
+        err(
+          "C168",
+          `${elemId}: the reference "${ref}" names no process or conformance test declared in this package (method-ref-resolves)`
+        );
+      }
+      return;
+    }
+    if (!options.resolvePackage) {
+      return;
+    }
+    const pkgId = ref.slice(0, colon);
+    const localId = ref.slice(colon + 1);
+    let ids = scopedMethodIds.get(pkgId);
+    if (!ids) {
+      ids = /* @__PURE__ */ new Set();
+      try {
+        const depDir = options.resolvePackage(pkgId);
+        if (depDir) {
+          const dep = loadPackageWithIssues(depDir);
+          ids = methodTargetIds(dep.standard);
+        }
+      } catch {
+      }
+      scopedMethodIds.set(pkgId, ids);
+    }
+    if (!ids.has(localId)) {
+      err(
+        "C168",
+        `${elemId}: the reference "${ref}" names no process or conformance test declared in package "${pkgId}" (method-ref-resolves)`
+      );
+    }
+  };
+  for (const t of standard.conformanceTests ?? []) {
+    const ref = t.methodRef;
+    if (ref) {
+      resolveCitation(t.id, ref);
+    }
+  }
+  for (const pr of standard.processes ?? []) {
+    const raw = pr;
+    for (const st of raw.steps ?? []) {
+      const call = st.calls || st.signatureBlock?.match(/\bcalls +([\w:/.-]+)/)?.[1];
+      if (call) {
+        resolveCitation(`${pr.id}/step/${st.id ?? ""}`, call);
+      }
+    }
+  }
   const ASPECT_FAMILY = {
     metadata: "is",
     provenance: "is",
@@ -25650,7 +28211,7 @@ function checkPackage(dir, options = {}) {
           `constraint ${c.id}: stereotype "${c.stereotype || "(none)"}" \u2014 a constraint is always \xABinv\xBB, the subject's declaration-level invariant (constraint-shape)`
         );
       }
-      if (!OCL_CHECK.test(c.check)) {
+      if (!c.checkBound && !OCL_CHECK.test(c.check)) {
         err(
           "C84",
           `constraint ${c.id}: check is not one OCL boolean expression ocl{\u2026} over the subject's declared anatomy (constraint-shape)`
@@ -28745,9 +31306,9 @@ function checkPackage(dir, options = {}) {
       if (!dataclassByEntity.has(c.id)) {
         dataclassByEntity.set(c.id, c);
       }
-      const bare = c.id.includes("#") ? c.id.slice(0, c.id.indexOf("#")) : c.id;
-      if (!dataclassByEntity.has(bare)) {
-        dataclassByEntity.set(bare, c);
+      const bare2 = c.id.includes("#") ? c.id.slice(0, c.id.indexOf("#")) : c.id;
+      if (!dataclassByEntity.has(bare2)) {
+        dataclassByEntity.set(bare2, c);
       }
     }
     const whereFields = (where) => {
@@ -30345,6 +32906,101 @@ function checkVerdictChains(standard) {
   }
   return issues;
 }
+function checkLmlAligned(standard) {
+  const issues = [];
+  const err = (check, message) => issues.push({ check, severity: "error", message });
+  const warn = (check, message) => issues.push({ check, severity: "warning", message });
+  const namespaceIds = new Set((standard.namespaces ?? []).map((n) => n.id));
+  const dataclassIds = /* @__PURE__ */ new Set();
+  for (const c of standard.dataclasses ?? []) {
+    dataclassIds.add(c.id);
+    dataclassIds.add(c.id.replace(/#data$/, ""));
+  }
+  const symbolIds = new Set((standard.symbols ?? []).map((s) => s.id));
+  const datumIds = new Set((standard.datums ?? []).map((d) => d.id));
+  const CLAUSE_CITATION = /clause-\d|§\d/i;
+  for (const d of standard.datums ?? []) {
+    if (!d.description) {
+      continue;
+    }
+    if (CLAUSE_CITATION.test(d.description)) {
+      err(
+        "C158",
+        `datum ${d.id}: the description cites a clause \u2014 a reference in prose belongs in a urn reference, not the quarantined free text (prose-quarantine)`
+      );
+    } else if (d.description.includes("TODO.roadmap")) {
+      warn(
+        "C158",
+        `datum ${d.id}: the description carries the unfinished-prose marker TODO.roadmap (prose-quarantine)`
+      );
+    }
+  }
+  for (const w of standard.wireMappings ?? []) {
+    if (w.namespaceRef && !namespaceIds.has(w.namespaceRef)) {
+      err(
+        "C159",
+        `mapping ${w.id}: namespace "${w.namespaceRef}" names no declared namespace block (urn-only-refs)`
+      );
+    }
+  }
+  for (const c of standard.checks ?? []) {
+    for (const inp of c.inputs ?? []) {
+      if (!(datumIds.has(inp) || symbolIds.has(inp))) {
+        err(
+          "C160",
+          `check ${c.id}: input "${inp}" resolves to no declared datum or symbol \u2014 the check consumes an undeclared name (signature-closure)`
+        );
+      }
+    }
+  }
+  for (const d of standard.datums ?? []) {
+    for (const r of d.renders ?? []) {
+      if (!MATH_NOTATIONS.includes(r.notation)) {
+        err(
+          "C161",
+          `datum ${d.id}: render notation "${r.notation}" is outside the closed vocabulary (${MATH_NOTATIONS.join("|")}) (check-surface)`
+        );
+      }
+    }
+  }
+  const metaNamespace = standard.meta?.namespace ?? "";
+  if (metaNamespace && namespaceIds.size > 0 && !namespaceIds.has(metaNamespace)) {
+    err(
+      "C162",
+      `metadata namespace "${metaNamespace}" names no declared namespace block (namespace-coherence)`
+    );
+  }
+  for (const w of standard.wireMappings ?? []) {
+    if (!MAPPING_FORMATS.includes(w.format)) {
+      err(
+        "C164",
+        `mapping ${w.id}: format "${w.format}" is outside the wire vocabulary (${MAPPING_FORMATS.join("|")}) (wire-mapping-coverage)`
+      );
+    }
+    if (dataclassIds.size > 0 && !dataclassIds.has(w.target)) {
+      err(
+        "C164",
+        `mapping ${w.id}: the class "${w.target}" is no declared dataclass \u2014 a class serialized to a format carries the declared mapping (wire-mapping-coverage)`
+      );
+    }
+  }
+  const QUALIFIED_REF = /^[a-z]+:[A-Za-z0-9_-]+$/;
+  for (const d of standard.datums ?? []) {
+    if (d.unit && !QUALIFIED_REF.test(d.unit)) {
+      err(
+        "C167",
+        `datum ${d.id}: unit "${d.unit}" is bare \u2014 a unit reference uses the qualified <namespace>:<id> form (si:\u2026, unitsdb:\u2026) (qualified-unit-reference)`
+      );
+    }
+    if (d.quantityKind && !QUALIFIED_REF.test(d.quantityKind)) {
+      err(
+        "C167",
+        `datum ${d.id}: quantity_kind "${d.quantityKind}" is bare \u2014 a quantity-kind reference uses the qualified <namespace>:<id> form (si:\u2026, unitsdb:\u2026) (qualified-unit-reference)`
+      );
+    }
+  }
+  return issues;
+}
 function checkEditionLifecycle(dir, standard) {
   const issues = [];
   const err = (check, message) => issues.push({ check, severity: "error", message });
@@ -30546,6 +33202,143 @@ function findCycle(adj) {
   return cycle;
 }
 
+// src/fmt.ts
+import { readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync3, writeFileSync } from "node:fs";
+import { join as join5 } from "node:path";
+
+// src/ser-des/dump.ts
+function dump(model, dumpers) {
+  let out = "";
+  if (model.root !== null) {
+    out += "root " + model.root.id + "\n\n";
+  }
+  out += dumpMetadata(model.meta) + "\n";
+  const childIds = /* @__PURE__ */ new Set();
+  for (const p of model.processes) {
+    for (const c of p.children) {
+      childIds.add(c);
+    }
+  }
+  const processMap = new Map(model.processes.map((p) => [p.id, p]));
+  const memberIds = /* @__PURE__ */ new Set();
+  for (const rc of model.requirementClasses ?? []) {
+    for (const m of rc.members ?? []) {
+      memberIds.add(m);
+    }
+  }
+  const requirementMap = new Map(
+    (model.requirements ?? []).map((r) => [r.id, r])
+  );
+  const classMap = new Map(
+    (model.requirementClasses ?? []).map((rc) => [rc.id, rc])
+  );
+  const dumpersRef = dumpers;
+  const dumpClassTree = (rcId) => {
+    const rc = classMap.get(rcId);
+    if (!rc) {
+      return "";
+    }
+    const base = dumpersRef.requirementClasses(rc);
+    if (!rc.members || rc.members.length === 0) {
+      return base;
+    }
+    const inner = rc.members.map((m) => {
+      const body = dumpersRef.requirements(requirementMap.get(m));
+      return body.split("\n").filter((l) => l !== "").map((l) => "  " + l).join("\n");
+    }).join("\n");
+    return base.slice(0, base.lastIndexOf("}")) + inner + "\n}\n";
+  };
+  Object.keys(dumpers).forEach((field) => {
+    if (field === "processes") {
+      for (const p of model.processes) {
+        if (!childIds.has(p.id)) {
+          out += dumpProcessTree(p, processMap);
+        }
+      }
+      return;
+    }
+    if (field === "requirements") {
+      for (const r of model.requirements ?? []) {
+        if (!memberIds.has(r.id)) {
+          out += dumpersRef.requirements(r);
+        }
+      }
+      return;
+    }
+    if (field === "requirementClasses") {
+      for (const rc of model.requirementClasses ?? []) {
+        out += dumpClassTree(rc.id);
+      }
+      return;
+    }
+    const items = model[field];
+    const dumper = dumpers[field];
+    for (const item of items) {
+      out += dumper(item);
+    }
+  });
+  return out;
+}
+
+// src/ser-des/index.ts
+function load(mmelString, options = {}) {
+  const context = parse(mmelString, PARSER_CONFIG, options);
+  return resolve(context, RESOLVER_CONFIG);
+}
+function loadFile(filePath, options = {}) {
+  const content = preprocessIncludes(filePath);
+  return load(content, options);
+}
+function dump2(standard) {
+  return dump(standard, DUMPER_CONFIG);
+}
+
+// src/fmt.ts
+var ALLOWLIST = ".primmel-allowlist.prl";
+function walkPrl(dir, out = []) {
+  for (const e of readdirSync4(dir).sort()) {
+    const p = join5(dir, e);
+    if (statSync3(p).isDirectory()) {
+      walkPrl(p, out);
+    } else if (e.endsWith(".prl") && e !== ALLOWLIST) {
+      out.push(p);
+    }
+  }
+  return out;
+}
+function fmtPackage(dir, check = false) {
+  const result = { dir, files: [], written: 0 };
+  for (const file of walkPrl(dir)) {
+    const src = readFileSync6(file, "utf8");
+    if (/^\s*include\s+"/m.test(src)) {
+      result.files.push({ file, status: "skipped-includes" });
+      continue;
+    }
+    let canonical2;
+    try {
+      const raw = dump2(loadFile(file));
+      if (dump2(load(raw)) !== raw) {
+        result.files.push({ file, status: "unstable" });
+        continue;
+      }
+      canonical2 = /^\s*metadata\s*\{/.test(src) ? raw : raw.replace(/^metadata \{\n(?: {2}\w+ ""\n)*\}\n+/, "");
+    } catch {
+      result.files.push({ file, status: "unstable" });
+      continue;
+    }
+    if (canonical2 === src) {
+      result.files.push({ file, status: "unchanged" });
+      continue;
+    }
+    if (!check) {
+      writeFileSync(file, canonical2);
+      result.written += 1;
+    }
+    result.files.push({ file, status: "formatted" });
+  }
+  return result;
+}
+
 // src/export/reqif.ts
 var REQIF_NAMESPACE = "http://www.omg.org/spec/ReqIF/20110401/reqif.xsd";
 var REQIF_VERSION = "1.0";
@@ -31819,23 +34612,23 @@ function renderJsonLd(prefixes, triples) {
 
 // src/export/retrieval.ts
 import { createHash } from "node:crypto";
-import { readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
-import { join as join6, relative } from "node:path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
+import { join as join7, relative } from "node:path";
 
 // src/export/unitsdb.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "node:fs";
+import { join as join6 } from "node:path";
 function loadUnitsDb(dir) {
   if (!dir) {
     return null;
   }
   try {
     const entries = [];
-    const jsonPath = join5(dir, "units.json");
+    const jsonPath = join6(dir, "units.json");
     if (!existsSync6(jsonPath)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync6(jsonPath, "utf8")).units;
+    const parsed = JSON.parse(readFileSync7(jsonPath, "utf8")).units;
     if (!Array.isArray(parsed)) {
       return null;
     }
@@ -32066,12 +34859,12 @@ function retrievalDigest(value) {
   return createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
 }
 function* walkPackage(dir) {
-  for (const entry of readdirSync4(dir).sort()) {
+  for (const entry of readdirSync5(dir).sort()) {
     if (entry === ".DS_Store") {
       continue;
     }
-    const p = join6(dir, entry);
-    if (statSync3(p).isDirectory()) {
+    const p = join7(dir, entry);
+    if (statSync4(p).isDirectory()) {
       yield* walkPackage(p);
     } else {
       yield p;
@@ -32083,7 +34876,7 @@ function packageSourceHash(dir) {
   for (const file of walkPackage(dir)) {
     h.update(relative(dir, file));
     h.update("\0");
-    h.update(createHash("sha256").update(readFileSync7(file)).digest());
+    h.update(createHash("sha256").update(readFileSync8(file)).digest());
     h.update("\n");
   }
   return h.digest("hex");
@@ -32339,6 +35132,9 @@ function retrievalFacet(unit, pkg) {
       facet[`app_${dim}_match`] = match;
     }
   }
+  if ((unit.method_refs ?? []).length > 0) {
+    facet.method_refs = unit.method_refs.join("|");
+  }
   return facet;
 }
 function resolveTextAddress(address, elementIds) {
@@ -32483,11 +35279,34 @@ function requirementUnit(r) {
     collectClauses(r)
   );
 }
+function processUnit(pr) {
+  const steps = pr.steps ?? [];
+  const calls = steps.map((s) => {
+    const st = s;
+    const call = st.calls || st.signatureBlock?.match(/\bcalls +([\w:/.-]+)/)?.[1] || "";
+    return call ? { id: st.id ?? "", calls: call } : null;
+  }).filter((s) => s !== null);
+  return assemble(
+    {
+      id: pr.id,
+      kind: "process",
+      ...present(pr.name) ? { name: pr.name } : {},
+      ...present(pr.summary) ? { statement: pr.summary } : {},
+      ...calls.length > 0 ? { calls } : {}
+    },
+    collectClauses(pr)
+  );
+}
 function conformanceTestUnit(t) {
   const payload = {
     ...present(t.kind) ? { test_kind: t.kind } : {},
     ...present(t.methodRef) ? { method_ref: t.methodRef } : {}
   };
+  const methodRefs = [
+    ...new Set(
+      [t.methodRef, ...(t.requiredCompetence ?? []).map((rc) => rc.methodRef)].filter((m) => present(m)).map((m) => m)
+    )
+  ].sort();
   const decision = acceptanceDecisionOf(t.acceptance);
   const criteria = testAcceptanceCriteriaOf(t);
   return assemble(
@@ -32515,6 +35334,7 @@ function conformanceTestUnit(t) {
         }))
       } : {},
       ...presentList(t.dependencies) ? { dependencies: t.dependencies } : {},
+      ...methodRefs.length > 0 ? { method_refs: methodRefs } : {},
       ...Object.keys(payload).length > 0 ? { payload } : {}
     },
     collectClauses(t)
@@ -32946,6 +35766,9 @@ function exportStandardRetrieval(standard, options = {}) {
   for (const t of standard.conformanceTests ?? []) {
     push(conformanceTestUnit(t), t.id);
   }
+  for (const pr of standard.processes ?? []) {
+    push(processUnit(pr), pr.id);
+  }
   for (const t of standard.terms ?? []) {
     push(termUnit(t, pkg.base_urn), t.id);
   }
@@ -33256,8 +36079,8 @@ function exportPackageImpact(dir) {
 }
 
 // src/export/cddal.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync5 } from "node:fs";
-import { basename, join as join7, resolve as resolve5 } from "node:path";
+import { readFileSync as readFileSync9, readdirSync as readdirSync6 } from "node:fs";
+import { basename, join as join8, resolve as resolve5 } from "node:path";
 var CDDAL_PROJECTION_VERSION = "primmel-cddal/1";
 function escapeCddalString(s) {
   return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
@@ -33403,23 +36226,23 @@ function projectCddal(model, packageId, l10n = /* @__PURE__ */ new Map()) {
 }
 function exportPackageCddal(dir) {
   const model = loadPackage(dir);
-  const l10nFiles = readdirSync5(dir).filter((e) => /^l10n\.[^/]+\.prl$/.test(e)).map((e) => join7(dir, e));
-  const l10n = readL10n(l10nFiles, (p) => readFileSync8(p, "utf8"));
+  const l10nFiles = readdirSync6(dir).filter((e) => /^l10n\.[^/]+\.prl$/.test(e)).map((e) => join8(dir, e));
+  const l10n = readL10n(l10nFiles, (p) => readFileSync9(p, "utf8"));
   return projectCddal(model, basename(resolve5(dir)), l10n);
 }
 
 // src/package-diff.ts
-import { existsSync as existsSync7, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync7, readFileSync as readFileSync10 } from "fs";
+import { join as join9 } from "path";
 function packageMappings(dir, standard) {
   const profiles = [...standard.mapProfiles ?? []];
   if (existsSync7(dir)) {
-    for (const entry of readdirSync6(dir).sort()) {
+    for (const entry of readdirSync7(dir).sort()) {
       if (!entry.endsWith(".prm")) {
         continue;
       }
       profiles.push(
-        ...prmToMapProfiles(loadPrm(readFileSync9(join8(dir, entry), "utf8")))
+        ...prmToMapProfiles(loadPrm(readFileSync10(join9(dir, entry), "utf8")))
       );
     }
   }
@@ -33428,17 +36251,17 @@ function packageMappings(dir, standard) {
 }
 function packageClauseTexts(dir) {
   const out = /* @__PURE__ */ new Map();
-  const prdDir = join8(dir, "sources-prd");
+  const prdDir = join9(dir, "sources-prd");
   if (!existsSync7(prdDir)) {
     return out;
   }
-  for (const entry of readdirSync6(prdDir).sort()) {
+  for (const entry of readdirSync7(prdDir).sort()) {
     if (!entry.endsWith(".sentences.json")) {
       continue;
     }
     let payload;
     try {
-      payload = JSON.parse(readFileSync9(join8(prdDir, entry), "utf8"));
+      payload = JSON.parse(readFileSync10(join9(prdDir, entry), "utf8"));
     } catch {
       continue;
     }
@@ -33491,15 +36314,15 @@ var DIFF_USAGE = "Usage: primmel diff [--json] [--exit-code] [--compare-texts] [
 var EXPORT_USAGE = "Usage: primmel export reqif|rdf|retrieval|impact|cddal <package-dir> [--out <file>] [--format turtle|jsonld]";
 function readablePackageDirProblem(target, needsManifest) {
   try {
-    if (!statSync4(target).isDirectory()) {
+    if (!statSync5(target).isDirectory()) {
       return "not a directory";
     }
-    readdirSync7(target);
+    readdirSync8(target);
   } catch (e) {
     const err = e;
     return err.code === "ENOENT" ? "no such directory" : err.message;
   }
-  if (needsManifest && !existsSync8(join9(target, "package.primmel"))) {
+  if (needsManifest && !existsSync8(join10(target, "package.primmel"))) {
     return "no package.primmel found";
   }
   return null;
@@ -33725,7 +36548,7 @@ function exportCli(args2) {
   const out = values.get("--out");
   if (out !== void 0) {
     try {
-      writeFileSync(out, document);
+      writeFileSync2(out, document);
     } catch (e) {
       console.error(`cannot write ${out}: ${e.message}`);
       process.exit(1);
@@ -33736,6 +36559,32 @@ function exportCli(args2) {
   }
   process.exit(0);
 }
+function fmtCli(argv) {
+  const check = argv.includes("--check");
+  const rest = argv.filter((a) => a !== "--check");
+  const dir = rest[rest.length - 1];
+  if (!dir || !existsSync8(dir)) {
+    console.error(`cannot read package at ${dir || "(none)"}: no such directory`);
+    process.exit(2);
+  }
+  let result;
+  try {
+    result = fmtPackage(dir, check);
+  } catch (e) {
+    console.error(`cannot format package at ${dir}: ${e.message}`);
+    process.exit(2);
+  }
+  for (const f of result.files) {
+    const label = f.file.startsWith(dir + "/") ? f.file.slice(dir.length + 1) : f.file;
+    const note = f.status === "formatted" ? check ? "would reformat" : "formatted" : f.status === "unchanged" ? "ok" : f.status === "unstable" ? "UNSTABLE \u2014 does not round-trip; left as-is" : "skipped (includes)";
+    console.log(`  ${label}: ${note}`);
+  }
+  const unstable = result.files.filter((f) => f.status === "unstable").length;
+  console.log(
+    `fmt: ${result.files.length} files, ${check ? result.files.filter((f) => f.status === "formatted").length + " would reformat" : result.written + " written"}, ${unstable} unstable`
+  );
+  process.exit(unstable > 0 ? 2 : check && result.files.some((f) => f.status === "formatted") ? 1 : 0);
+}
 var args = process.argv.slice(2);
 if (args[0] === "diff") {
   diffCli(args.slice(1));
@@ -33743,6 +36592,12 @@ if (args[0] === "diff") {
   checkCli(args.slice(1));
 } else if (args[0] === "export") {
   exportCli(args.slice(1));
+} else if (args[0] === "fmt") {
+  fmtCli(args.slice(1));
 } else {
   checkCli(args);
 }
+//! The Primmel expression language: the lexer, the precedence parser, and
+//! the AST. The machine-executable core — first-class syntax, never a
+//! quoted string. The identifiers resolve against the caller's scope (the
+//! argument bindings); the unbound names surface at parse time.