@primmel/primmel 1.8.2 → 1.9.0

package/dist-cli/primmel.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // scripts/check.mts
-import { existsSync as existsSync7, readdirSync as readdirSync5, statSync as statSync3, writeFileSync } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync6, statSync as statSync4, writeFileSync } from "node:fs";
+import { join as join7 } from "node:path";
 
 // src/check.ts
 import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
@@ -266,6 +266,8 @@ function parse(mmelString, parsers, options = {}) {
     // Primmel v3.1 dataspace + trust (TODO.primmel/10)
     dataspaces: {},
     policies: {},
+    // Primmel v3.2 consumption constructs (TODO.primmel/11)
+    dimensions: {},
     // Issue collection (duplicate IDs, etc.)
     issues: []
   };
@@ -401,6 +403,16 @@ function resolve(ctx, resolvers) {
 }
 
 // src/ser-des/parse-block.ts
+var ALIAS_FAMILY_KEYWORDS = /* @__PURE__ */ new Set([
+  "aliases",
+  "alt",
+  "colloquial",
+  "abbreviations",
+  "deprecated"
+]);
+function isAliasFamilyKeyword(keyword) {
+  return ALIAS_FAMILY_KEYWORDS.has(keyword);
+}
 function forEachEntry(data, visitor, errCtx) {
   if (data === "") {
     return;
@@ -432,6 +444,11 @@ function forEachEntry(data, visitor, errCtx) {
           i++;
           i++;
         }
+      } else if (isAliasFamilyKeyword(keyword)) {
+        i++;
+        if (!t[i - 1].startsWith("{") && t[i]?.startsWith("{")) {
+          i++;
+        }
       } else {
         i++;
       }
@@ -461,6 +478,15 @@ function skipUnknownValue(t, i, keyword) {
     }
     return i;
   }
+  if (isAliasFamilyKeyword(keyword)) {
+    if (i < t.length) {
+      i++;
+    }
+    if (!t[i - 1]?.startsWith("{") && t[i]?.startsWith("{")) {
+      i++;
+    }
+    return i;
+  }
   if (i < t.length) {
     i++;
   }
@@ -3224,6 +3250,12 @@ var parseReference = (id, data) => {
           ref.clause = unwrapBlock(t[i++]);
         } else if (keyword === "title") {
           ref.title = unwrapBlock(t[i++]);
+        } else if (keyword === "org") {
+          ref.org = unwrapBlock(t[i++]);
+        } else if (keyword === "edition") {
+          ref.edition = unwrapBlock(t[i++]);
+        } else if (keyword === "urn") {
+          ref.urn = unwrapBlock(t[i++]);
         } else {
           i++;
         }
@@ -3246,6 +3278,15 @@ var dumpReference = function(ref) {
   if (ref.title) {
     out += '  title "' + escapeString(ref.title) + '"\n';
   }
+  if (ref.org) {
+    out += '  org "' + escapeString(ref.org) + '"\n';
+  }
+  if (ref.edition) {
+    out += '  edition "' + escapeString(ref.edition) + '"\n';
+  }
+  if (ref.urn) {
+    out += '  urn "' + escapeString(ref.urn) + '"\n';
+  }
   out += "}\n";
   return out;
 };
@@ -5352,6 +5393,10 @@ function parseInputs(block) {
     let defaultValue = "";
     let hasDefault = false;
     let enumValues;
+    let quantityKind;
+    let rangeMin;
+    let rangeMax;
+    let hasRange = false;
     if (i < t.length && t[i].startsWith("{")) {
       const propBlock = unwrapBlock(t[i++]);
       const pt = tokenizePackage(propBlock);
@@ -5360,7 +5405,27 @@ function parseInputs(block) {
         const cmd = pt[j++];
         if (j < pt.length) {
           if (cmd === "unit") {
-            unit = unwrapBlock(pt[j++]);
+            unit = stripWrapping(pt[j++]);
+          } else if (cmd === "quantity_kind") {
+            quantityKind = stripWrapping(pt[j++]);
+          } else if (cmd === "range") {
+            const rt = tokenizePackage(unwrapBlock(pt[j++]));
+            let k = 0;
+            while (k < rt.length) {
+              const rc = rt[k++];
+              if (k >= rt.length) {
+                break;
+              }
+              if (rc === "min") {
+                rangeMin = stripWrapping(rt[k++]);
+                hasRange = true;
+              } else if (rc === "max") {
+                rangeMax = stripWrapping(rt[k++]);
+                hasRange = true;
+              } else {
+                unwrapBlock(rt[k++]);
+              }
+            }
           } else if (cmd === "description") {
             description = unwrapBlock(pt[j++]);
           } else if (cmd === "default") {
@@ -5374,7 +5439,7 @@ function parseInputs(block) {
         }
       }
     }
-    inputs.push({
+    const inp = {
       name,
       type,
       unit,
@@ -5382,7 +5447,20 @@ function parseInputs(block) {
       defaultValue,
       hasDefault,
       enumValues
-    });
+    };
+    if (quantityKind !== void 0) {
+      inp.quantityKind = quantityKind;
+    }
+    if (hasRange) {
+      inp.hasRange = true;
+      if (rangeMin !== void 0) {
+        inp.rangeMin = rangeMin;
+      }
+      if (rangeMax !== void 0) {
+        inp.rangeMax = rangeMax;
+      }
+    }
+    inputs.push(inp);
   }
   return inputs;
 }
@@ -5393,6 +5471,10 @@ function parseOutput(block) {
   let unit = "1";
   let name = "";
   let description = "";
+  let quantityKind;
+  let rangeMin;
+  let rangeMax;
+  let hasRange = false;
   if (t[i] === ":") {
     i++;
   }
@@ -5407,7 +5489,27 @@ function parseOutput(block) {
       const cmd = pt[j++];
       if (j < pt.length) {
         if (cmd === "unit") {
-          unit = unwrapBlock(pt[j++]);
+          unit = stripWrapping(pt[j++]);
+        } else if (cmd === "quantity_kind") {
+          quantityKind = stripWrapping(pt[j++]);
+        } else if (cmd === "range") {
+          const rt = tokenizePackage(unwrapBlock(pt[j++]));
+          let k = 0;
+          while (k < rt.length) {
+            const rc = rt[k++];
+            if (k >= rt.length) {
+              break;
+            }
+            if (rc === "min") {
+              rangeMin = stripWrapping(rt[k++]);
+              hasRange = true;
+            } else if (rc === "max") {
+              rangeMax = stripWrapping(rt[k++]);
+              hasRange = true;
+            } else {
+              unwrapBlock(rt[k++]);
+            }
+          }
         } else if (cmd === "name") {
           name = stripWrapping(pt[j++]);
         } else if (cmd === "description") {
@@ -5425,6 +5527,18 @@ function parseOutput(block) {
   if (description) {
     out.description = description;
   }
+  if (quantityKind !== void 0) {
+    out.quantityKind = quantityKind;
+  }
+  if (hasRange) {
+    out.hasRange = true;
+    if (rangeMin !== void 0) {
+      out.rangeMin = rangeMin;
+    }
+    if (rangeMax !== void 0) {
+      out.rangeMax = rangeMax;
+    }
+  }
   return out;
 }
 function parseLookup(block) {
@@ -5494,6 +5608,9 @@ var dumpCalculation = function(c) {
     for (const inp of c.inputs) {
       let line = "    " + inp.name + " : " + inp.type + " { ";
       line += 'unit "' + escapeString(inp.unit) + '"';
+      if (inp.quantityKind) {
+        line += " quantity_kind " + inp.quantityKind;
+      }
       if (inp.description) {
         line += ' description "' + escapeString(inp.description) + '"';
       }
@@ -5503,18 +5620,41 @@ var dumpCalculation = function(c) {
       if (inp.enumValues && inp.enumValues.length > 0) {
         line += " enum_values { " + inp.enumValues.join(" ") + " }";
       }
+      if (inp.hasRange) {
+        line += " range {";
+        if (inp.rangeMin) {
+          line += " min " + dumpBareSafe(inp.rangeMin);
+        }
+        if (inp.rangeMax) {
+          line += " max " + dumpBareSafe(inp.rangeMax);
+        }
+        line += " }";
+      }
       line += " }\n";
       out += line;
     }
     out += "  }\n";
   }
   let outputLine = "  output : " + c.output.type + ' { unit "' + escapeString(c.output.unit) + '"';
+  if (c.output.quantityKind) {
+    outputLine += " quantity_kind " + c.output.quantityKind;
+  }
   if (c.output.name) {
     outputLine += ' name "' + escapeString(c.output.name) + '"';
   }
   if (c.output.description) {
     outputLine += ' description "' + escapeString(c.output.description) + '"';
   }
+  if (c.output.hasRange) {
+    outputLine += " range {";
+    if (c.output.rangeMin) {
+      outputLine += " min " + dumpBareSafe(c.output.rangeMin);
+    }
+    if (c.output.rangeMax) {
+      outputLine += " max " + dumpBareSafe(c.output.rangeMax);
+    }
+    outputLine += " }";
+  }
   out += outputLine + " }\n";
   if (c.expression) {
     out += '  expression "' + escapeString(c.expression) + '"\n';
@@ -7694,6 +7834,25 @@ var dumpConformanceTest = function(ct) {
 };
 
 // src/ser-des/config/term.ts
+var ALIAS_KEYWORDS = {
+  aliases: "aliases",
+  alt: "aliases",
+  colloquial: "colloquial",
+  abbreviations: "abbreviations",
+  deprecated: "deprecated"
+};
+function isAliasKeyword(command) {
+  return command in ALIAS_KEYWORDS;
+}
+function appendAliasEntries(term, facet, entries) {
+  if (facet === "aliases") {
+    const merged = [...term.aliases ?? [], ...entries];
+    term.aliases = merged;
+    term.alt = merged;
+  } else {
+    (term[facet] ??= []).push(...entries);
+  }
+}
 var parseTerm = function(id, data) {
   const result = {
     id,
@@ -7764,12 +7923,28 @@ var parseTerm = function(id, data) {
         result.formType = unwrapped(value);
       } else if (command === "part_of_speech") {
         result.partOfSpeech = unwrapped(value);
-      } else if (command === "alt") {
-        result.alt = tokenizePackage(value()).map(stripWrapping);
-      } else if (command === "deprecated") {
-        result.deprecated = tokenizePackage(value()).map(stripWrapping);
-      } else if (command === "abbreviations") {
-        result.abbreviations = tokenizePackage(value()).map(stripWrapping);
+      } else if (isAliasKeyword(command)) {
+        const first = value();
+        let spelling;
+        let listToken = first;
+        if (!first.startsWith("{")) {
+          spelling = first;
+          const next = peek();
+          if (next === void 0 || !next.startsWith("{")) {
+            throw new Error(
+              `Parsing error: term. ID ${id}: alias-family facet "${command}" with spelling code "${spelling}" expects a list block`
+            );
+          }
+          listToken = value();
+        }
+        const entries = tokenizePackage(listToken).map(stripWrapping);
+        const facet = ALIAS_KEYWORDS[command];
+        if (spelling === void 0) {
+          appendAliasEntries(result, facet, entries);
+        } else {
+          const variant = (result.aliasSpellings ??= {})[spelling] ??= {};
+          (variant[facet] ??= []).push(...entries);
+        }
       } else if (command === "see_also") {
         result.seeAlso = tokenizePackage(value()).map(stripWrapping);
       } else {
@@ -7826,14 +8001,33 @@ var dumpTerm = function(term) {
     out += '  part_of_speech "' + escapeString(term.partOfSpeech) + '"\n';
   }
   const listEntry = (s) => /\s/.test(s) ? '"' + escapeString(s) + '"' : s;
-  if (term.alt && term.alt.length > 0) {
-    out += "  alt { " + term.alt.map(listEntry).join(" ") + " }\n";
+  const aliasLine = (facet, list, tag) => "  " + facet + (tag ? " " + tag : "") + " { " + list.map(listEntry).join(" ") + " }\n";
+  const aliases = term.aliases ?? term.alt;
+  if (aliases && aliases.length > 0) {
+    out += aliasLine("aliases", aliases);
   }
-  if (term.deprecated && term.deprecated.length > 0) {
-    out += "  deprecated { " + term.deprecated.map(listEntry).join(" ") + " }\n";
+  if (term.colloquial && term.colloquial.length > 0) {
+    out += aliasLine("colloquial", term.colloquial);
   }
   if (term.abbreviations && term.abbreviations.length > 0) {
-    out += "  abbreviations { " + term.abbreviations.map(listEntry).join(" ") + " }\n";
+    out += aliasLine("abbreviations", term.abbreviations);
+  }
+  if (term.deprecated && term.deprecated.length > 0) {
+    out += aliasLine("deprecated", term.deprecated);
+  }
+  for (const code of Object.keys(term.aliasSpellings ?? {}).sort()) {
+    const variant = term.aliasSpellings[code];
+    for (const facet of [
+      "aliases",
+      "colloquial",
+      "abbreviations",
+      "deprecated"
+    ]) {
+      const list = variant[facet];
+      if (list && list.length > 0) {
+        out += aliasLine(facet, list, code);
+      }
+    }
   }
   if (term.seeAlso && term.seeAlso.length > 0) {
     out += "  see_also { " + term.seeAlso.map(listEntry).join(" ") + " }\n";
@@ -8720,6 +8914,7 @@ function readLimit(block) {
     relativeTo: "",
     notes: "",
     accepts: null,
+    quantity: null,
     acceptance: null,
     sourceDiscrepancy: null
   };
@@ -8740,6 +8935,24 @@ function readLimit(block) {
       limit.relativeTo = stripWrapping(t[i++]);
     } else if (cmd === "notes") {
       limit.notes = stripWrapping(t[i++]);
+    } else if (cmd === "quantity") {
+      const quantity = { kind: "", unit: "" };
+      const qt = tokenize(unwrapBlock(t[i++]));
+      let k = 0;
+      while (k < qt.length) {
+        const qc = qt[k++];
+        if (k >= qt.length) {
+          break;
+        }
+        if (qc === "kind") {
+          quantity.kind = stripWrapping(qt[k++]);
+        } else if (qc === "unit") {
+          quantity.unit = stripWrapping(qt[k++]);
+        } else {
+          unwrapBlock(qt[k++]);
+        }
+      }
+      limit.quantity = quantity;
     } else if (cmd === "accepts") {
       limit.accepts = readAccepts(unwrapBlock(t[i++]));
     } else if (cmd === "acceptance") {
@@ -8812,7 +9025,8 @@ function readParameters(block) {
       rangeMin: "",
       rangeMax: "",
       hasRange: false,
-      enumValues: []
+      enumValues: [],
+      bind: ""
     };
     if (i < t.length && !t[i].startsWith("{")) {
       param.type = stripWrapping(t[i++]);
@@ -8829,6 +9043,8 @@ function readParameters(block) {
           param.description = stripWrapping(pt[j++]);
         } else if (pc === "unit") {
           param.unit = stripWrapping(pt[j++]);
+        } else if (pc === "bind") {
+          param.bind = stripWrapping(pt[j++]);
         } else if (pc === "default") {
           param.defaultValue = stripWrapping(pt[j++]);
           param.hasDefault = true;
@@ -8975,6 +9191,16 @@ function dumpLimit(limit) {
   if (limit.notes) {
     out += '    notes "' + escapeString(limit.notes) + '"\n';
   }
+  if (limit.quantity) {
+    let line = "    quantity {";
+    if (limit.quantity.kind) {
+      line += " kind " + limit.quantity.kind;
+    }
+    if (limit.quantity.unit) {
+      line += " unit " + limit.quantity.unit;
+    }
+    out += line + " }\n";
+  }
   if (limit.accepts) {
     const a = limit.accepts;
     let line = "    accepts { verdict " + a.verdict;
@@ -9036,6 +9262,9 @@ var dumpRequirement = function(r) {
       if (p.unit) {
         line += 'unit "' + escapeString(p.unit) + '" ';
       }
+      if (p.bind) {
+        line += 'bind "' + escapeString(p.bind) + '" ';
+      }
       if (p.hasDefault) {
         line += "default " + dumpBareSafe(p.defaultValue) + " ";
       }
@@ -9298,6 +9527,8 @@ var parsePackage = function(data) {
       manifest.supersedes = readUrnList(t[i++]);
     } else if (cmd === "replaces") {
       manifest.replaces = readUrnList(t[i++]);
+    } else if (cmd === "superseded_by") {
+      manifest.supersededBy = readUrnList(t[i++]);
     } else if (cmd === "validity") {
       const vblock = unwrapBlock(t[i++]);
       const vt = tokenize(vblock);
@@ -10155,6 +10386,14 @@ function parseDimension(id, block) {
       dim.source = readSource(unwrapBlock(t[i++]));
     } else if (cmd === "values") {
       dim.values = parseDimensionValues(unwrapBlock(t[i++]));
+    } else if (cmd === "values_of") {
+      dim.valuesOf = stripWrapping(t[i++]);
+    } else if (cmd === "ref") {
+      const r = parseRef(t, i, stripWrapping, unwrapBlock);
+      if (!foldRefIntoLegacy(dim, r.ref)) {
+        (dim.refs ??= []).push(r.ref);
+      }
+      i = r.next;
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
@@ -10236,6 +10475,73 @@ function parseDimensionValues(block) {
   }
   return out;
 }
+function dumpDimension(d, indent) {
+  const inner = indent + "  ";
+  const valueIndent = indent + "    ";
+  let out = indent + "dimension " + d.id + " {\n";
+  if (d.label) {
+    out += inner + 'label "' + escapeString(d.label) + '"\n';
+  }
+  if (d.scope) {
+    out += inner + "scope " + d.scope + "\n";
+  }
+  if (d.cardinality) {
+    out += inner + "cardinality " + d.cardinality + "\n";
+  }
+  if (d.labelSeparator) {
+    out += inner + 'label_separator "' + escapeString(d.labelSeparator) + '"\n';
+  }
+  if (d.description) {
+    out += inner + 'description "' + escapeString(d.description) + '"\n';
+  }
+  out += dumpSource("reference", d.source, inner);
+  if (d.valuesOf) {
+    out += inner + "values_of " + d.valuesOf + "\n";
+  }
+  if (d.values.length > 0) {
+    out += inner + "values {\n";
+    for (const v of d.values) {
+      let line = valueIndent + v.id;
+      const hasProps = v.label || v.description || v.termRef || Object.keys(v.payload).length > 0 || v.implies.length > 0;
+      if (hasProps) {
+        line += " { ";
+        if (v.label) {
+          line += 'label "' + escapeString(v.label) + '" ';
+        }
+        if (v.description) {
+          line += 'description "' + escapeString(v.description) + '" ';
+        }
+        if (v.termRef) {
+          line += "term_ref " + v.termRef + " ";
+        }
+        if (v.implies.length > 0) {
+          line += "implies { " + v.implies.join(" ") + " } ";
+        }
+        if (Object.keys(v.payload).length > 0) {
+          line += "payload { ";
+          for (const [k, val] of Object.entries(v.payload)) {
+            if (typeof val === "object" && val !== null) {
+              line += k + " { ";
+              for (const [nk, nv] of Object.entries(val)) {
+                line += nk + ': "' + escapeString(String(nv)) + '" ';
+              }
+              line += "} ";
+            } else {
+              line += k + ': "' + escapeString(String(val)) + '" ';
+            }
+          }
+          line += "} ";
+        }
+        line += "}";
+      }
+      out += line + "\n";
+    }
+    out += inner + "}\n";
+  }
+  out += dumpRefs(d.refs, inner, escapeString);
+  out += indent + "}\n";
+  return out;
+}
 function parseModelGroup(block) {
   const mg = {
     definition: "",
@@ -10374,64 +10680,7 @@ var dumpInstrument = function(inst) {
     out += line + "}\n";
   }
   for (const d of inst.dimensions) {
-    out += "  dimension " + d.id + " {\n";
-    if (d.label) {
-      out += '    label "' + escapeString(d.label) + '"\n';
-    }
-    if (d.scope) {
-      out += "    scope " + d.scope + "\n";
-    }
-    if (d.cardinality) {
-      out += "    cardinality " + d.cardinality + "\n";
-    }
-    if (d.labelSeparator) {
-      out += '    label_separator "' + escapeString(d.labelSeparator) + '"\n';
-    }
-    if (d.description) {
-      out += '    description "' + escapeString(d.description) + '"\n';
-    }
-    out += dumpSource("reference", d.source, "    ");
-    if (d.values.length > 0) {
-      out += "    values {\n";
-      for (const v of d.values) {
-        let line = "      " + v.id;
-        const hasProps = v.label || v.description || v.termRef || Object.keys(v.payload).length > 0 || v.implies.length > 0;
-        if (hasProps) {
-          line += " { ";
-          if (v.label) {
-            line += 'label "' + escapeString(v.label) + '" ';
-          }
-          if (v.description) {
-            line += 'description "' + escapeString(v.description) + '" ';
-          }
-          if (v.termRef) {
-            line += "term_ref " + v.termRef + " ";
-          }
-          if (v.implies.length > 0) {
-            line += "implies { " + v.implies.join(" ") + " } ";
-          }
-          if (Object.keys(v.payload).length > 0) {
-            line += "payload { ";
-            for (const [k, val] of Object.entries(v.payload)) {
-              if (typeof val === "object" && val !== null) {
-                line += k + " { ";
-                for (const [nk, nv] of Object.entries(val)) {
-                  line += nk + ': "' + escapeString(String(nv)) + '" ';
-                }
-                line += "} ";
-              } else {
-                line += k + ': "' + escapeString(String(val)) + '" ';
-              }
-            }
-            line += "} ";
-          }
-          line += "}";
-        }
-        out += line + "\n";
-      }
-      out += "    }\n";
-    }
-    out += "  }\n";
+    out += dumpDimension(d, "  ");
   }
   if (inst.familyMetamodelClass || inst.familyDefinition || inst.familyNote || inst.familySource && (inst.familySource.doc || inst.familySource.clause)) {
     out += "  family {\n";
@@ -12875,6 +13124,10 @@ function parseKind(id, block) {
       out.siUnit = stripWrapping(t[i++]);
     } else if (cmd === "description") {
       out.description = stripWrapping(t[i++]);
+    } else if (cmd === "corresponds") {
+      const { corr, next } = parseCorresponds(t, i, stripWrapping);
+      (out.correspondences ??= []).push(corr);
+      i = next;
     } else {
       unwrapBlock(t[i++]);
     }
@@ -12910,6 +13163,10 @@ function parseUnit(id, block) {
       out.offsetToSI = readNumber(t[i++], 0);
     } else if (cmd === "definition") {
       out.definition = stripWrapping(t[i++]);
+    } else if (cmd === "corresponds") {
+      const { corr, next } = parseCorresponds(t, i, stripWrapping);
+      (out.correspondences ??= []).push(corr);
+      i = next;
     } else {
       unwrapBlock(t[i++]);
     }
@@ -12945,6 +13202,24 @@ var parseQuantityRegister = function(id, data) {
     return ctx;
   };
 };
+function dumpCorrespondencesInline(corrs) {
+  let out = "";
+  for (const c of corrs ?? []) {
+    out += " corresponds " + dumpBareSafe(c.scheme) + ' "' + escapeString(c.concept) + '"';
+    if (c.projections.length > 0) {
+      out += " {";
+      for (const p of c.projections) {
+        out += " projection " + dumpBareSafe(p.codec) + " {";
+        for (const e of p.entries) {
+          out += " " + dumpBareSafe(e.key) + " " + dumpBareSafe(e.value);
+        }
+        out += " }";
+      }
+      out += " }";
+    }
+  }
+  return out;
+}
 function dumpDimensions(dimensions) {
   const keys = Object.keys(dimensions);
   if (keys.length === 0) {
@@ -12962,6 +13237,7 @@ var dumpQuantityRegister = function(reg) {
     if (k.description) {
       line += ' description "' + escapeString(k.description) + '"';
     }
+    line += dumpCorrespondencesInline(k.correspondences);
     out += line + " }\n";
   }
   for (const u of reg.units) {
@@ -12984,6 +13260,7 @@ var dumpQuantityRegister = function(reg) {
     if (u.definition) {
       line += ' definition "' + escapeString(u.definition) + '"';
     }
+    line += dumpCorrespondencesInline(u.correspondences);
     out += line + " }\n";
   }
   if (reg.referenceIds.length > 0) {
@@ -13442,6 +13719,25 @@ var policyConstruct = {
   dump: dumpPolicy
 };
 
+// src/ser-des/config/dimension.ts
+var parseTopLevelDimension = function(id, data) {
+  const dim = parseDimension(id, unwrapBlock(data));
+  return (ctx) => {
+    ctx.dimensions[id] = dim;
+    return ctx;
+  };
+};
+var dumpTopLevelDimension = function(d) {
+  return dumpDimension(d, "");
+};
+var dimensionConstruct = {
+  keyword: "dimension",
+  field: "dimensions",
+  takesID: true,
+  parse: parseTopLevelDimension,
+  dump: dumpTopLevelDimension
+};
+
 // src/ser-des/config/activityArchetype.ts
 var parseActivityArchetype = (id, data) => {
   const archetype = {
@@ -13859,7 +14155,11 @@ var CONSTRUCTS = [
   // sub-structures (config/trustRef.ts, config/correspondence.ts), not
   // top-level constructs.
   dataspaceConstruct,
-  policyConstruct
+  policyConstruct,
+  // 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
 ];
 function buildParserConfig(constructs) {
   const out = {};
@@ -14005,6 +14305,9 @@ function packageFiles(dir) {
   }
   return files;
 }
+function loadPackage(dir, options = {}) {
+  return loadPackageInternal(dir, options).standard;
+}
 function countNewlines(text) {
   let n = 0;
   for (let i = 0; i < text.length; i++) {
@@ -15160,30 +15463,38 @@ var GENERIC_ANCHOR = [
   "conformanceProcessIds"
 ];
 function provenanceOf(el) {
-  const out = [];
-  const push = (r) => {
+  const channels = {};
+  const push = (channel, r) => {
     if (r && typeof r === "object" && (r.doc || r.clause)) {
-      out.push(normalizeSourceRef(r.doc ?? "", r.clause ?? "", r.fragment));
+      (channels[channel] ??= []).push(
+        normalizeSourceRef(r.doc ?? "", r.clause ?? "", r.fragment)
+      );
     }
   };
-  push(el.source);
-  push(el.sourceRef);
+  push("source", el.source);
+  push("sourceRef", el.sourceRef);
   for (const r of el.sourceRefs ?? []) {
-    push(r);
+    push("sourceRefs", r);
   }
   const refString = el.reference;
   if (typeof refString === "string" && refString.startsWith("urn:")) {
-    push({ doc: refString, clause: "" });
+    push("reference", { doc: refString, clause: "" });
   }
-  const seen = /* @__PURE__ */ new Set();
-  return out.filter((r) => {
-    const k = provenanceEdgeKey(r);
-    if (seen.has(k)) {
-      return false;
-    }
-    seen.add(k);
-    return true;
-  });
+  const dedup = (rs) => {
+    const seen = /* @__PURE__ */ new Set();
+    return rs.filter((r) => {
+      const k = provenanceEdgeKey(r);
+      if (seen.has(k)) {
+        return false;
+      }
+      seen.add(k);
+      return true;
+    });
+  };
+  for (const [channel, rs] of Object.entries(channels)) {
+    channels[channel] = dedup(rs);
+  }
+  return { edges: dedup(Object.values(channels).flat()), channels };
 }
 function provenanceEdgeKey(r) {
   return canonical({ basis: r.basis, clause: r.clause, fragment: r.fragment });
@@ -15191,26 +15502,28 @@ function provenanceEdgeKey(r) {
 function elementOf(field, el) {
   const id = String(el.id ?? el.entityName ?? "");
   const tier = TIER_BY_FIELD[field] ?? "cross-cutting";
-  const provenance = provenanceOf(el);
+  const { edges: provenance, channels: provenanceChannels } = provenanceOf(el);
   const consumed = new Set(PROVENANCE_FIELDS);
   if (typeof el.reference === "string" && el.reference.startsWith("urn:")) {
     consumed.add("reference");
   }
+  const fields = {};
   const aspects = {};
   const spec = ASPECT_SPECS[field];
-  const pick = (fields) => {
+  const pick = (names) => {
     const out = {};
-    for (const f of fields) {
+    for (const f of names) {
       if (el[f] !== void 0) {
         out[f] = el[f];
         consumed.add(f);
+        fields[f] = el[f];
       }
     }
     return out;
   };
   if (spec) {
-    for (const [aspect, fields] of Object.entries(spec)) {
-      const picked = pick(fields ?? []);
+    for (const [aspect, names] of Object.entries(spec)) {
+      const picked = pick(names ?? []);
       if (Object.keys(picked).length > 0) {
         aspects[aspect] = canonical(picked);
       }
@@ -15220,10 +15533,9 @@ function elementOf(field, el) {
     const entries = el.entries ?? [];
     for (const e of entries) {
       if (e && typeof e.spelling === "string") {
-        aspects[`spelling:${e.spelling}`] = canonical({
-          value: e.value,
-          via: e.via
-        });
+        const entry = { value: e.value, via: e.via };
+        aspects[`spelling:${e.spelling}`] = canonical(entry);
+        fields[`spelling:${e.spelling}`] = entry;
       }
     }
   } else {
@@ -15244,15 +15556,31 @@ function elementOf(field, el) {
         fragment: r.fragment
       }))
     );
+    for (const [channel, edges] of Object.entries(provenanceChannels)) {
+      fields[channel] = edges.map((r) => ({
+        basis: r.basis,
+        clause: r.clause,
+        fragment: r.fragment
+      }));
+    }
   }
   const rest = {};
   for (const [k, v] of Object.entries(el)) {
     if (!consumed.has(k) && k !== "id") {
       rest[k] = v;
+      fields[k] = v;
     }
   }
   aspects.structure = canonical(rest);
-  return { key: `${field}:${id}`, id, kind: field, tier, aspects, provenance };
+  return {
+    key: `${field}:${id}`,
+    id,
+    kind: field,
+    tier,
+    aspects,
+    fields,
+    provenance
+  };
 }
 function elementIndex(standard, duplicates) {
   const out = /* @__PURE__ */ new Map();
@@ -15490,6 +15818,46 @@ function labelAspect(elA, elB, name) {
   }
   return `${name} (changed)`;
 }
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function fieldDiffPaths(prefix, a, b, out) {
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].sort();
+    for (const k of keys) {
+      fieldDiffPaths(`${prefix}.${k}`, a[k], b[k], out);
+    }
+    return;
+  }
+  if (canonical(a) !== canonical(b)) {
+    out.push(prefix);
+  }
+}
+function changedFields(elA, elB) {
+  const names = [
+    .../* @__PURE__ */ new Set([...Object.keys(elA.fields), ...Object.keys(elB.fields)])
+  ].sort();
+  const out = [];
+  for (const name of names) {
+    fieldDiffPaths(name, elA.fields[name], elB.fields[name], out);
+  }
+  const PROVENANCE_CHANNELS = [
+    "source",
+    "sourceRef",
+    "sourceRefs",
+    "reference"
+  ];
+  const seenMoves = /* @__PURE__ */ new Set();
+  return out.filter((path) => {
+    if (!PROVENANCE_CHANNELS.includes(path)) {
+      return true;
+    }
+    const move = canonical(elA.fields[path]) + " \u2192 " + canonical(elB.fields[path]);
+    if (seenMoves.has(move)) {
+      return false;
+    }
+    seenMoves.add(move);
+    return true;
+  });
+}
 function diffStandards(a, b, options = {}) {
   const duplicatesA = [];
   const duplicatesB = [];
@@ -15547,7 +15915,8 @@ function diffStandards(a, b, options = {}) {
         id: elA.id,
         kind: elA.kind,
         tier: elA.tier,
-        aspects: differing.map((name) => labelAspect(elA, elB, name)).sort()
+        aspects: differing.map((name) => labelAspect(elA, elB, name)).sort(),
+        fields: changedFields(elA, elB)
       });
       tally[elA.tier].changed++;
     }
@@ -15630,7 +15999,9 @@ function formatDiffReport(diff) {
   if (diff.changed.length > 0) {
     lines.push("", "changed:");
     for (const e of diff.changed) {
-      lines.push(`  ~ ${fmtEntry(e)} \u2014 ${e.aspects.join(", ")}`);
+      lines.push(
+        `  ~ ${fmtEntry(e)} \u2014 ${e.aspects.join(", ")} (fields: ${e.fields.join(", ")})`
+      );
     }
   }
   if (diff.moved.length > 0) {
@@ -16371,6 +16742,22 @@ var CHECK_RULES = [
     "normal",
     "TODO.roadmap/28, INV-8, doctrine \xA713.5"
   ),
+  // ── the v3.2 lineage edge (TODO.primmel/11; MN 114 v3.2 clause 9.3.1,
+  // primmel/spec#18) ──
+  // C113: the lineage graph is the union of the backward edges
+  // (supersedes/replaces) and the forward edge (superseded_by); when two
+  // composed packages declare opposite edges between the same pair the
+  // declarations must agree — A supersedes { B } while B declares
+  // superseded_by { C } without A is an error. A missing forward edge is
+  // NOT an error: the backward edges remain the authored minimum.
+  R(
+    "C113",
+    "edition-lineage-coherent",
+    "edition",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 9.3.1 (primmel/spec#18 ask 3)"
+  ),
   // ── the model supply chain (TODO.roadmap/36, doctrine ch. 15) ───────
   // Three publishers — standard (reference), manufacturer (product
   // reference), user (implementation) — with mapping as the only
@@ -16710,6 +17097,108 @@ var CHECK_RULES = [
     "normal",
     "docs/primmel/18 \xA718.6 (the unified reference/relation construct)"
   ),
+  // ── the v3.2 consumption constructs (TODO.primmel/11; MN 114 v3.2,
+  // primmel/spec#18) ──
+  // C110: the term alias family's shape (clause 13.10.1) — duplicate
+  // entries within one list are errors; the same string in two family
+  // fields of one term and the label echo are warning legs during the
+  // v3.2 rollout (the v2 `alt` semantics allowed the overlap; the
+  // cross-field leg tightens to the spec's error when the consumer wave
+  // re-authors the estate's terms — TODO.primmel/11d).
+  R(
+    "C110",
+    "term-alias-shape",
+    "base",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 13.10.1 (primmel/spec#18 ask 1)"
+  ),
+  // C111: the dimension declaration's shape (clause 10.6) — value ids
+  // unique within a dimension, implies targets resolving inside their
+  // own dimension and acyclic, values vs values_of never combined, an
+  // undocumented values_of register warned, and one dimension identifier
+  // once per applicability namespace (the is_dimension-attribute/inline
+  // mirror pattern tolerated — R 144's power_supply precedent).
+  R(
+    "C111",
+    "dimension-shape",
+    "base",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 10.6 (primmel/spec#18 ask 2)"
+  ),
+  // C112: the structured reference identity (clause 14.7) — a malformed
+  // urn is an error (the same well-formedness class as C85); a reference
+  // carrying neither urn nor the org+document pair is a warning (a
+  // display-string citation is visible debt, never silently citable).
+  R(
+    "C112",
+    "reference-identity",
+    "base",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 14.7 (primmel/spec#18 ask 3)"
+  ),
+  // C114: the limit's quantity typing agrees with the verdict it binds
+  // (clause 11.1.2) — a limit and its acceptance chain can never drift
+  // apart in units. C115: the calculation signature (clause 13.7.1) —
+  // units and quantity kinds resolve against the merged quantity register
+  // and agree in kind, a range's min never exceeds its max, and an
+  // enum-typed input declares its values. The unit-resolution leg ships
+  // as a WARNING during the v3.2 rollout (the C33 doctrine §6.8
+  // precedent: unmapped units are warnings — the estate's R 60 declares
+  // counts/v on inputs no register carries; the leg tightens to the
+  // spec's error when the register catches up — TODO.primmel/11d).
+  R(
+    "C114",
+    "limit-quantity-coherence",
+    "quantities",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 11.1.2 (primmel/spec#18 ask 4)"
+  ),
+  R(
+    "C115",
+    "calculation-signature-shape",
+    "quantities",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 13.7.1 (primmel/spec#18 ask 4)"
+  ),
+  // C116/C117: the verdict chain (clause 11.3) — a verdict's inputs may
+  // name another verdict, making the acceptance chain an explicit graph.
+  // Every input resolves to a declared symbol, a test variable or
+  // observable, or another verdict; the verdict→verdict graph never
+  // cycles. C118: the instance-parameter schema (clause 11.1.3) — a
+  // parameter's bind path resolves against the subject's aspect catalog
+  // (the binds_to path discipline), its unit resolves against the merged
+  // quantity register (the rollout WARNING leg, the C33 §6.8 precedent —
+  // tightens with C115's leg, TODO.primmel/11d), and a range's min never
+  // exceeds its max.
+  R(
+    "C116",
+    "verdict-inputs-resolve",
+    "characteristics",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 11.3 (primmel/spec#18 ask 5)"
+  ),
+  R(
+    "C117",
+    "verdict-chain-acyclic",
+    "characteristics",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 11.3 (primmel/spec#18 ask 5)"
+  ),
+  R(
+    "C118",
+    "requirement-parameter-shape",
+    "base",
+    "error",
+    "normal",
+    "TODO.primmel/11, MN 114 clause 11.1.3 (primmel/spec#18 ask 5)"
+  ),
   // ── the dataspace family (TODO.primmel/10; MN 114 v3.1 clause 19) ──
   // The v3.1 extension set: the dataspace definition, the policy
   // construct (Primmel's own policy grammar; ODRL is a codec output),
@@ -17500,12 +17989,12 @@ function uncoveredSentenceMessage(urn, s) {
   const text = s.text.length > 100 ? `${s.text.slice(0, 97)}\u2026` : s.text;
   return `sentence ${urn}#${s.address} (normative, ${s.kind}): bound by no model element and excluded by no allowance \u2014 "${text}" (text-coverage-sentence-uncovered)`;
 }
-function packageTextCoverageReport(dir, loadPackage) {
+function packageTextCoverageReport(dir, loadPackage2) {
   const { manifests, config, issues } = loadTextCoverageData(dir);
   if (manifests.length === 0) {
     return null;
   }
-  const { standard } = loadPackage(dir);
+  const { standard } = loadPackage2(dir);
   const report = computeTextCoverage(standard, manifests, config);
   report.configIssues.unshift(...issues);
   return report;
@@ -17720,6 +18209,10 @@ function checkPackage(dir, options = {}) {
   issues.push(...checkEditionLifecycle(dir, standard));
   issues.push(...checkSpellingCodes(standard));
   issues.push(...checkDeclaredPredicates(standard));
+  issues.push(...checkTermAliases(standard));
+  issues.push(...checkDimensions(standard));
+  issues.push(...checkReferences(standard));
+  issues.push(...checkVerdictChains(standard));
   const reqIds = new Set(
     (standard.requirements ?? []).map((r) => r.id)
   );
@@ -17738,6 +18231,7 @@ function checkPackage(dir, options = {}) {
   const symbolIds = new Set((standard.symbols ?? []).map((s) => s.id));
   const dimIds = /* @__PURE__ */ new Map();
   const dimCardinality = /* @__PURE__ */ new Map();
+  const dimCardinalityOpen = /* @__PURE__ */ new Set();
   for (const inst of standard.instruments ?? []) {
     for (const d of inst.dimensions ?? []) {
       dimIds.set(d.id, new Set(d.values.map((v) => v.id)));
@@ -17746,6 +18240,31 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  for (const a of standard.attributeDefinitions ?? []) {
+    if (a.isDimension !== true || dimIds.has(a.id)) {
+      continue;
+    }
+    const enumDef = (standard.enums ?? []).find((e) => e.id === a.enumRef);
+    const domain = enumDef ? new Set(enumDef.values.map((v) => v.id)) : a.enumValues && a.enumValues.length > 0 ? new Set(a.enumValues) : null;
+    dimIds.set(a.id, domain);
+    dimCardinalityOpen.add(a.id);
+  }
+  for (const d of standard.dimensions ?? []) {
+    if (dimIds.has(d.id)) {
+      continue;
+    }
+    if (d.valuesOf) {
+      dimIds.set(
+        d.id,
+        d.valuesOf === "capabilities" ? new Set((standard.capabilities ?? []).map((c) => c.id)) : null
+      );
+    } else {
+      dimIds.set(d.id, new Set(d.values.map((v) => v.id)));
+    }
+    if (d.cardinality) {
+      dimCardinality.set(d.id, d.cardinality);
+    }
+  }
   for (const form of standard.forms ?? []) {
     const checkField = (f) => {
       if (f.bind) {
@@ -17876,7 +18395,7 @@ function checkPackage(dir, options = {}) {
           "C3",
           `conformance test ${t.id}: test_subject dimension "${dim}" not declared`
         );
-      } else if (!dimIds.get(dim).has(String(value))) {
+      } else if (dimIds.get(dim) !== null && !dimIds.get(dim).has(String(value))) {
         err(
           "C3",
           `conformance test ${t.id}: test_subject ${dim}="${value}" not in the dimension's values`
@@ -17895,15 +18414,24 @@ function checkPackage(dir, options = {}) {
           `requirement ${r.id}: applicability dimension "${a.dimension}" not declared`
         );
       } else {
+        const domain = dimIds.get(a.dimension) ?? null;
         for (const v of a.values ?? []) {
-          if (!dimIds.get(a.dimension).has(v)) {
+          if (domain !== null && !domain.has(v)) {
             err(
               "C3",
               `requirement ${r.id}: applicability ${a.dimension}="${v}" not in the dimension's values`
             );
           }
         }
-        if ((a.match === "all" || a.match === "exact") && dimCardinality.get(a.dimension) !== "set") {
+        for (const k of Object.keys(a.mapping ?? {})) {
+          if (domain !== null && !domain.has(k)) {
+            err(
+              "C3",
+              `requirement ${r.id}: applicability ${a.dimension} mapping key "${k}" not in the dimension's values`
+            );
+          }
+        }
+        if ((a.match === "all" || a.match === "exact") && dimCardinality.get(a.dimension) !== "set" && !dimCardinalityOpen.has(a.dimension)) {
           warn(
             "C3",
             `requirement ${r.id}: applicability ${a.dimension} match ${a.match} on a single-cardinality dimension \u2014 only meaningful on set dimensions ('all' reduces to 'any'; a multi-value 'exact' is unsatisfiable on one value)`
@@ -20080,11 +20608,148 @@ function checkPackage(dir, options = {}) {
       );
     }
   }
-  for (const d of standard.duals ?? []) {
-    if (d.attribute && !attrIds.has(d.attribute)) {
+  for (const r of standard.requirements ?? []) {
+    const q = r.limit?.quantity;
+    const accepts = r.limit?.accepts;
+    if (!q || !accepts) {
+      continue;
+    }
+    const verdict = (standard.verdicts ?? []).find(
+      (v) => v.id === accepts.verdict
+    );
+    if (!verdict) {
+      continue;
+    }
+    if (q.kind && verdict.quantityKind && q.kind !== verdict.quantityKind) {
       err(
-        "C34",
-        `dual ${d.id}: attribute "${d.attribute}" is not a declared attribute_definition (duality-coherence)`
+        "C114",
+        `requirement ${r.id}: limit declares quantity kind "${q.kind}" but accepts verdict ${verdict.id} derives kind "${verdict.quantityKind}" \u2014 a limit and its acceptance chain never drift apart in units (limit-quantity-coherence)`
+      );
+    }
+    if (q.unit && verdict.unit && q.unit !== verdict.unit) {
+      err(
+        "C114",
+        `requirement ${r.id}: limit declares quantity unit "${q.unit}" but accepts verdict ${verdict.id} derives unit "${verdict.unit}" (limit-quantity-coherence)`
+      );
+    }
+  }
+  for (const c of standard.calculations ?? []) {
+    const entries = [
+      ...(c.inputs ?? []).map((inp) => ({
+        owner: `calculation ${c.id}: input ${inp.name}`,
+        type: inp.type,
+        unit: inp.unit,
+        isInput: true,
+        quantityKind: inp.quantityKind,
+        rangeMin: inp.rangeMin,
+        rangeMax: inp.rangeMax,
+        hasRange: inp.hasRange,
+        enumValues: inp.enumValues
+      })),
+      {
+        owner: `calculation ${c.id}: output`,
+        type: c.output.type,
+        unit: c.output.unit,
+        isInput: false,
+        quantityKind: c.output.quantityKind,
+        rangeMin: c.output.rangeMin,
+        rangeMax: c.output.rangeMax,
+        hasRange: c.output.hasRange
+      }
+    ];
+    for (const e of entries) {
+      const declaredUnit = e.unit && e.unit !== "1" ? e.unit : "";
+      const unitKind = declaredUnit ? kindOfUnit(declaredUnit) : void 0;
+      if (declaredUnit && registersExist && unitKind === void 0) {
+        warn(
+          "C115",
+          `${e.owner}: unit "${declaredUnit}" resolves to no registered unit of the merged quantity register (calculation-signature-shape)`
+        );
+      }
+      if (e.quantityKind) {
+        if (!kindDecl.has(e.quantityKind)) {
+          err(
+            "C115",
+            `${e.owner}: quantity_kind "${e.quantityKind}" resolves to no registered kind of the merged quantity register (calculation-signature-shape)`
+          );
+        } else if (unitKind !== void 0 && unitKind !== e.quantityKind) {
+          err(
+            "C115",
+            `${e.owner}: declared quantity_kind "${e.quantityKind}" but unit "${declaredUnit}" measures kind ${unitKind} \u2014 the typed-unit pair must agree in kind (calculation-signature-shape)`
+          );
+        }
+      }
+      if (e.hasRange && e.rangeMin && e.rangeMax) {
+        const lo = Number(e.rangeMin);
+        const hi = Number(e.rangeMax);
+        if (!Number.isNaN(lo) && !Number.isNaN(hi) && lo > hi) {
+          err(
+            "C115",
+            `${e.owner}: range min ${e.rangeMin} exceeds max ${e.rangeMax} (calculation-signature-shape)`
+          );
+        }
+      }
+      if (e.isInput && e.type === "enum" && (e.enumValues === void 0 || e.enumValues.length === 0)) {
+        err(
+          "C115",
+          `${e.owner}: an enum-typed input declares its values \u2014 enum_values is absent or empty (calculation-signature-shape)`
+        );
+      }
+    }
+  }
+  for (const r of standard.requirements ?? []) {
+    for (const p of r.parameters ?? []) {
+      const where = `requirement ${r.id}: param ${p.name}`;
+      if (p.bind) {
+        const parts = String(p.bind).split(".");
+        const id = parts[2];
+        if (id) {
+          if (parts[1] === "classification") {
+            const dim = DIM_ALIASES[id] ?? id;
+            if (!dimIds.has(dim) && !attrIds.has(id) && !attrIds.has(dim)) {
+              err(
+                "C118",
+                `${where}: bind "${p.bind}" \u2014 dimension "${id}" not declared (requirement-parameter-shape)`
+              );
+            }
+          } else if (parts[1] === "behaviors") {
+            if (!behaviorIds.has(id)) {
+              err(
+                "C118",
+                `${where}: bind "${p.bind}" \u2014 behavior "${id}" not declared (requirement-parameter-shape)`
+              );
+            }
+          } else if (!isIdentityPath(String(p.bind)) && !attrIds.has(id) && !symbolIds.has(id)) {
+            err(
+              "C118",
+              `${where}: bind "${p.bind}" \u2014 attribute "${id}" not defined (requirement-parameter-shape)`
+            );
+          }
+        }
+      }
+      if (p.unit && registersExist && kindOfUnit(p.unit) === void 0) {
+        warn(
+          "C118",
+          `${where}: unit "${p.unit}" resolves to no registered unit of the merged quantity register (requirement-parameter-shape)`
+        );
+      }
+      if (p.hasRange && p.rangeMin && p.rangeMax) {
+        const lo = Number(p.rangeMin);
+        const hi = Number(p.rangeMax);
+        if (!Number.isNaN(lo) && !Number.isNaN(hi) && lo > hi) {
+          err(
+            "C118",
+            `${where}: range min ${p.rangeMin} exceeds max ${p.rangeMax} (requirement-parameter-shape)`
+          );
+        }
+      }
+    }
+  }
+  for (const d of standard.duals ?? []) {
+    if (d.attribute && !attrIds.has(d.attribute)) {
+      err(
+        "C34",
+        `dual ${d.id}: attribute "${d.attribute}" is not a declared attribute_definition (duality-coherence)`
       );
     }
     if (!d.designed && !d.exhibited) {
@@ -21486,6 +22151,216 @@ function checkDeclaredPredicates(standard) {
   }
   return issues;
 }
+function checkTermAliases(standard) {
+  const issues = [];
+  const err = (message) => issues.push({ check: "C110", severity: "error", message });
+  const warn = (message) => issues.push({ check: "C110", severity: "warning", message });
+  const FACETS = ["aliases", "colloquial", "abbreviations", "deprecated"];
+  for (const t of standard.terms ?? []) {
+    const scopes = [
+      [
+        "",
+        {
+          aliases: t.aliases ?? t.alt,
+          colloquial: t.colloquial,
+          abbreviations: t.abbreviations,
+          deprecated: t.deprecated
+        }
+      ],
+      ...Object.entries(t.aliasSpellings ?? {}).map(
+        ([code, v]) => [
+          ` ${code}`,
+          { ...v }
+        ]
+      )
+    ];
+    for (const [tag, scope] of scopes) {
+      const where = (facet) => `term ${t.id}: ${facet}${tag ? ` ${tag}` : ""}`;
+      for (const facet of FACETS) {
+        const seen = /* @__PURE__ */ new Set();
+        for (const entry of scope[facet] ?? []) {
+          if (seen.has(entry)) {
+            err(
+              `${where(facet)}: duplicate entry "${entry}" \u2014 one entry has one home (term-alias-shape)`
+            );
+          }
+          seen.add(entry);
+        }
+      }
+      const home = /* @__PURE__ */ new Map();
+      for (const facet of FACETS) {
+        for (const entry of scope[facet] ?? []) {
+          const prior = home.get(entry);
+          if (prior !== void 0 && prior !== facet) {
+            warn(
+              `${where(facet)}: "${entry}" already appears in ${prior} \u2014 one entry has one home (term-alias-shape)`
+            );
+          } else {
+            home.set(entry, facet);
+          }
+        }
+      }
+    }
+    if (t.label) {
+      for (const [tag, scope] of scopes) {
+        for (const facet of FACETS) {
+          if ((scope[facet] ?? []).includes(t.label)) {
+            warn(
+              `term ${t.id}: ${facet}${tag ? ` ${tag}` : ""} entry "${t.label}" merely echoes the term's label \u2014 an alias adds a bridge or it does not belong (term-alias-shape)`
+            );
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}
+function checkDimensions(standard) {
+  const issues = [];
+  const err = (message) => issues.push({ check: "C111", severity: "error", message });
+  const warn = (message) => issues.push({ check: "C111", severity: "warning", message });
+  const checkShape = (owner, d) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (const v of d.values) {
+      if (seen.has(v.id)) {
+        err(
+          `${owner} dimension ${d.id}: duplicate value id "${v.id}" (dimension-shape)`
+        );
+      }
+      seen.add(v.id);
+    }
+    const valueIds = new Set(d.values.map((v) => v.id));
+    const adj = /* @__PURE__ */ new Map();
+    for (const v of d.values) {
+      for (const target of v.implies ?? []) {
+        if (!valueIds.has(target)) {
+          err(
+            `${owner} dimension ${d.id}: value ${v.id} implies "${target}", which is not a value of this dimension \u2014 implies targets resolve inside their own dimension (dimension-shape)`
+          );
+        }
+      }
+      adj.set(
+        v.id,
+        (v.implies ?? []).filter((t) => valueIds.has(t))
+      );
+    }
+    const cycle = findCycle(adj);
+    if (cycle) {
+      err(
+        `${owner} dimension ${d.id}: implies cycle ${cycle.join(" \u2192 ")} \u2014 the applicability engine walks the implication closure, so the graph must be acyclic (dimension-shape)`
+      );
+    }
+    if (d.valuesOf && d.values.length > 0) {
+      err(
+        `${owner} dimension ${d.id}: declares both values and values_of \u2014 a dimension carries one value domain (dimension-shape)`
+      );
+    }
+    if (d.valuesOf && d.valuesOf !== "capabilities") {
+      warn(
+        `${owner} dimension ${d.id}: values_of "${d.valuesOf}" names a register the kernel does not document (the documented register is capabilities) \u2014 the value domain stays open (dimension-shape)`
+      );
+    }
+  };
+  for (const inst of standard.instruments ?? []) {
+    for (const d of inst.dimensions ?? []) {
+      checkShape(`instrument ${inst.id}:`, d);
+    }
+  }
+  for (const d of standard.dimensions ?? []) {
+    checkShape("top-level", d);
+  }
+  const inlineHome = /* @__PURE__ */ new Map();
+  for (const inst of standard.instruments ?? []) {
+    for (const d of inst.dimensions ?? []) {
+      const prior = inlineHome.get(d.id);
+      if (prior !== void 0 && prior !== inst.id) {
+        err(
+          `dimension ${d.id}: declared inline on both instrument ${prior} and instrument ${inst.id} \u2014 one dimension identifier once per applicability namespace (dimension-shape)`
+        );
+      } else {
+        inlineHome.set(d.id, inst.id);
+      }
+    }
+  }
+  const attrDims = new Set(
+    (standard.attributeDefinitions ?? []).filter((a) => a.isDimension === true).map((a) => a.id)
+  );
+  for (const d of standard.dimensions ?? []) {
+    if (inlineHome.has(d.id)) {
+      err(
+        `dimension ${d.id}: declared both top-level and inline on instrument ${inlineHome.get(d.id)} \u2014 one dimension identifier once per applicability namespace (dimension-shape)`
+      );
+    }
+    if (attrDims.has(d.id)) {
+      err(
+        `dimension ${d.id}: declared both top-level and as the is_dimension attribute definition of the same id \u2014 one dimension identifier once per applicability namespace (dimension-shape)`
+      );
+    }
+  }
+  return issues;
+}
+function checkReferences(standard) {
+  const issues = [];
+  for (const r of standard.references ?? []) {
+    if (r.urn !== void 0) {
+      if (!/^[A-Za-z][A-Za-z0-9+.-]*:[^\s<>"{}|^`\\]*$/.test(r.urn)) {
+        issues.push({
+          check: "C112",
+          severity: "error",
+          message: `reference ${r.id}: urn "${r.urn}" is not a well-formed IRI (a scheme followed by no whitespace or IRI delimiters) (reference-identity)`
+        });
+      }
+    } else if (!(r.org && r.document)) {
+      issues.push({
+        check: "C112",
+        severity: "warning",
+        message: `reference ${r.id}: carries neither urn nor the org-and-document pair \u2014 a display-string citation is not machine-traversable (reference-identity)`
+      });
+    }
+  }
+  return issues;
+}
+function checkVerdictChains(standard) {
+  const issues = [];
+  const symbolIds = new Set((standard.symbols ?? []).map((s) => s.id));
+  const testNames = /* @__PURE__ */ new Set();
+  for (const t of standard.conformanceTests ?? []) {
+    for (const v of t.variables ?? []) {
+      testNames.add(v.name);
+    }
+    for (const o of t.observables ?? []) {
+      testNames.add(o.name);
+    }
+  }
+  const verdictIds = new Set((standard.verdicts ?? []).map((v) => v.id));
+  for (const v of standard.verdicts ?? []) {
+    for (const inp of v.inputs ?? []) {
+      if (!symbolIds.has(inp) && !testNames.has(inp) && !verdictIds.has(inp)) {
+        issues.push({
+          check: "C116",
+          severity: "error",
+          message: `verdict ${v.id}: input "${inp}" resolves to no declared symbol, test variable or observable, or verdict (verdict-inputs-resolve)`
+        });
+      }
+    }
+  }
+  const adj = /* @__PURE__ */ new Map();
+  for (const v of standard.verdicts ?? []) {
+    adj.set(
+      v.id,
+      (v.inputs ?? []).filter((i) => verdictIds.has(i))
+    );
+  }
+  const cycle = findCycle(adj);
+  if (cycle) {
+    issues.push({
+      check: "C117",
+      severity: "error",
+      message: `verdict chain cycle: ${cycle.join(" \u2192 ")} \u2014 the acceptance chain is a graph a consumer traverses, so it must be acyclic (verdict-chain-acyclic)`
+    });
+  }
+  return issues;
+}
 function checkEditionLifecycle(dir, standard) {
   const issues = [];
   const err = (check, message) => issues.push({ check, severity: "error", message });
@@ -21541,7 +22416,10 @@ function checkEditionLifecycle(dir, standard) {
   }
   const relations = [
     ...(m.supersedes ?? []).map((t) => ["supersedes", t]),
-    ...(m.replaces ?? []).map((t) => ["replaces", t])
+    ...(m.replaces ?? []).map((t) => ["replaces", t]),
+    ...(m.supersededBy ?? []).map(
+      (t) => ["superseded_by", t]
+    )
   ];
   const ownBasis = normalizeSourceRef(m.baseUrn ?? "", "").basis;
   for (const [rel, target] of relations) {
@@ -21560,7 +22438,7 @@ function checkEditionLifecycle(dir, standard) {
       continue;
     }
     const tNorm = normalizeSourceRef(target, "");
-    if (tNorm.basis === ownBasis && tNorm.edition) {
+    if (rel !== "superseded_by" && tNorm.basis === ownBasis && tNorm.edition) {
       if (!register.has(tNorm.edition)) {
         warn(
           "C79",
@@ -21571,6 +22449,7 @@ function checkEditionLifecycle(dir, standard) {
   }
   if (relations.length > 0) {
     const nodes = /* @__PURE__ */ new Map();
+    const forwardByNode = /* @__PURE__ */ new Map();
     const parent = dirname2(resolve4(dir));
     for (const entry of readdirSync3(parent).sort()) {
       const full = join4(parent, entry);
@@ -21586,6 +22465,7 @@ function checkEditionLifecycle(dir, standard) {
           ),
           ...(sib.replaces ?? []).map((t) => ["replaces", t])
         ]);
+        forwardByNode.set(key, new Set(sib.supersededBy ?? []));
       } catch {
       }
     }
@@ -21603,6 +22483,29 @@ function checkEditionLifecycle(dir, standard) {
         `supersedes cycle: ${cycle.join(" \u2192 ")} \u2014 the supersedes graph must be acyclic; a package cannot supersede itself through a chain (edition-supersedes-resolves)`
       );
     }
+    const ownKey = m.baseUrn || m.id;
+    for (const target of [...m.supersedes ?? [], ...m.replaces ?? []]) {
+      const fwd = forwardByNode.get(target);
+      if (fwd !== void 0 && fwd.size > 0 && !fwd.has(ownKey)) {
+        err(
+          "C113",
+          `package "${m.id}": supersedes/replaces ${target}, but that package declares superseded_by { ${[...fwd].join(" ")} } without ${ownKey} \u2014 opposite lineage edges between the same pair must agree (edition-lineage-coherent)`
+        );
+      }
+    }
+    for (const target of m.supersededBy ?? []) {
+      const bwdRels = nodes.get(target);
+      if (bwdRels === void 0) {
+        continue;
+      }
+      const bwd = new Set(bwdRels.map(([, t]) => t));
+      if (bwd.size > 0 && !bwd.has(ownKey)) {
+        err(
+          "C113",
+          `package "${m.id}": superseded_by ${target}, but that package declares supersedes/replaces { ${[...bwd].join(" ")} } without ${ownKey} \u2014 opposite lineage edges between the same pair must agree (edition-lineage-coherent)`
+        );
+      }
+    }
   }
   if (register.size > 0) {
     for (const inst of standard.instances ?? []) {
@@ -22715,7 +23618,7 @@ function exportStandardRdf(standard) {
       );
     }
     t(eIri, SKOSXL_PREF_LABEL, iri(prefIri));
-    (term.alt ?? []).forEach((a, i) => {
+    (term.aliases ?? term.alt ?? []).forEach((a, i) => {
       const form = (term.abbreviations ?? []).includes(a) ? "abbreviation" : "";
       t(eIri, SKOSXL_ALT_LABEL, iri(labelNode(`alt-${i + 1}`, form, a)));
     });
@@ -22930,61 +23833,1100 @@ function renderJsonLd(prefixes, triples) {
 `;
 }
 
-// src/package-diff.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
-import { join as join5 } from "path";
-function packageMappings(dir, standard) {
-  const profiles = [...standard.mapProfiles ?? []];
-  if (existsSync6(dir)) {
-    for (const entry of readdirSync4(dir).sort()) {
-      if (!entry.endsWith(".prm")) {
-        continue;
+// src/export/retrieval.ts
+import { createHash } from "node:crypto";
+import { readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
+import { join as join5, relative } from "node:path";
+var RETRIEVAL_PROJECTION = "primmel-retrieval/1";
+var RETRIEVAL_FACET_VERSION = "retrieval-facet/1";
+function sortDeep(v) {
+  if (Array.isArray(v)) {
+    return v.map(sortDeep);
+  }
+  if (v && typeof v === "object") {
+    const out = {};
+    for (const k of Object.keys(v).sort()) {
+      const val = sortDeep(v[k]);
+      if (val !== void 0) {
+        out[k] = val;
       }
-      profiles.push(
-        ...prmToMapProfiles(loadPrm(readFileSync6(join5(dir, entry), "utf8")))
-      );
     }
-  }
-  const modelId = standard.packageManifest?.id ?? standard.meta?.namespace ?? "";
-  return profiles.flatMap((p) => mappingsFromProfile(p, modelId));
-}
-function packageClauseTexts(dir) {
-  const out = /* @__PURE__ */ new Map();
-  const prdDir = join5(dir, "sources-prd");
-  if (!existsSync6(prdDir)) {
     return out;
   }
-  for (const entry of readdirSync4(prdDir).sort()) {
-    if (!entry.endsWith(".sentences.json")) {
-      continue;
-    }
-    let payload;
-    try {
-      payload = JSON.parse(readFileSync6(join5(prdDir, entry), "utf8"));
-    } catch {
+  return v;
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortDeep(value));
+}
+function retrievalDigest(value) {
+  return createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+}
+function* walkPackage(dir) {
+  for (const entry of readdirSync4(dir).sort()) {
+    if (entry === ".DS_Store") {
       continue;
     }
-    const urn = payload.document?.urn ?? "";
-    if (!urn) {
-      continue;
+    const p = join5(dir, entry);
+    if (statSync3(p).isDirectory()) {
+      yield* walkPackage(p);
+    } else {
+      yield p;
     }
-    const basis = normalizeSourceRef(urn, "").basis;
-    const byClause = /* @__PURE__ */ new Map();
-    for (const s of payload.sentences ?? []) {
-      if (!s.clause || s.text === void 0) {
-        continue;
+  }
+}
+function packageSourceHash(dir) {
+  const h = createHash("sha256");
+  for (const file of walkPackage(dir)) {
+    h.update(relative(dir, file));
+    h.update("\0");
+    h.update(createHash("sha256").update(readFileSync6(file)).digest());
+    h.update("\n");
+  }
+  return h.digest("hex");
+}
+var UUID_ANCHOR = /^_?[0-9a-f]{8}-[0-9a-f]{4}-/i;
+var DOC_FRAGMENT2 = /#([^#]*)$/;
+function normalizeClause(doc, clause, fragment = "") {
+  let rest = doc ?? "";
+  let clauseOut = clause ?? "";
+  let frag = fragment ?? "";
+  let anchor;
+  const hash = DOC_FRAGMENT2.exec(rest);
+  if (hash) {
+    rest = rest.slice(0, hash.index);
+    const embedded = hash[1] ?? "";
+    if (!clauseOut && embedded.startsWith("clause-")) {
+      const tail = embedded.slice("clause-".length);
+      const slash = tail.indexOf("/");
+      if (slash >= 0) {
+        clauseOut = tail.slice(0, slash);
+        if (!frag) {
+          frag = tail.slice(slash + 1);
+        }
+      } else {
+        clauseOut = tail;
       }
-      (byClause.get(s.clause) ?? byClause.set(s.clause, []).get(s.clause)).push(s.text);
+    } else if (embedded && !frag) {
+      anchor = embedded;
+    } else if (embedded) {
+      anchor = embedded;
     }
-    for (const [clause, texts] of byClause) {
-      out.set(clauseTextKey(basis, clause), texts.join("\n"));
+  }
+  if (clauseOut && UUID_ANCHOR.test(clauseOut)) {
+    anchor = anchor ?? clauseOut;
+    clauseOut = "";
+  }
+  const urn = rest + (clauseOut ? `#clause-${clauseOut}${frag ? `/${frag}` : ""}` : anchor && !UUID_ANCHOR.test(anchor) ? `#${anchor}` : "");
+  const out = { doc: rest, clause: clauseOut, urn };
+  if (anchor !== void 0) {
+    out.anchor = anchor;
+  }
+  if (frag) {
+    out.fragment = frag;
+  }
+  return out;
+}
+function refTargetClause(target) {
+  const m = /^(urn:[^#]+)(?:#(.+))?$/.exec(target);
+  if (!m) {
+    return null;
+  }
+  return { doc: m[1], clause: "", fragment: m[2] ?? "" };
+}
+function collectClauses(el) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (r) => {
+    if (!r || !r.doc && !r.clause) {
+      return;
+    }
+    const c = normalizeClause(r.doc ?? "", r.clause ?? "", r.fragment);
+    if (!seen.has(c.urn)) {
+      seen.add(c.urn);
+      out.push(c);
+    }
+  };
+  push(el.source);
+  push(el.sourceRef);
+  for (const r of el.sourceRefs ?? []) {
+    push(r);
+  }
+  const reference = (el.reference ?? "").replace(/^"|"$/g, "");
+  if (reference.startsWith("urn:")) {
+    push(refTargetClause(reference));
+  }
+  for (const r of el.refs ?? []) {
+    if (r && typeof r.target === "string" && r.target.startsWith("urn:")) {
+      push(refTargetClause(r.target));
     }
   }
   return out;
 }
-function diffPackageDirs(dirA, dirB, options = {}) {
-  const loadedA = loadPackageWithIssues(dirA, {
-    resolvePackage: options.resolvePackage
+function termClauses(term, baseUrn) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (c) => {
+    if (c && !seen.has(c.urn)) {
+      seen.add(c.urn);
+      out.push(c);
+    }
+  };
+  for (const token of (term.source ?? "").split(/\s+/).filter((t) => t)) {
+    push(token.startsWith("urn:") ? normalizeClause(token, "") : null);
+  }
+  if (term.section && !out.some((c) => c.clause)) {
+    push(normalizeClause(baseUrn, term.section));
+  }
+  return out;
+}
+function applicabilitySummary(entries) {
+  return (entries ?? []).map((e) => {
+    const mode = e.match && e.match !== "any" ? `(${e.match})` : "";
+    return `${e.dimension}${mode}=${[...e.values].sort().join("|")}`;
+  }).sort().join(";");
+}
+function passportOf(unit) {
+  return {
+    v: 1,
+    kind: unit.kind,
+    id: unit.id,
+    text: unit.statement ?? unit.definition ?? unit.name ?? "",
+    expression: unit.expression ?? "",
+    units: unit.units ?? [],
+    applicability: applicabilitySummary(unit.applicability),
+    acceptance: unit.acceptance ?? "",
+    provenance: (unit.clauses ?? []).map((c) => c.urn),
+    content_hash: unit.content_hash
+  };
+}
+var BASE_URN_PARTS = /^urn:oiml:pub:([rdbge]):(\d[\d-]*)(?::(\d{4}))?$/i;
+function retrievalDocParts(baseUrn) {
+  const m = BASE_URN_PARTS.exec(baseUrn);
+  if (!m) {
+    return { doctype: "", doc_number: "", year: "", label: "" };
+  }
+  const doctype = (m[1] ?? "").toLowerCase();
+  const docNumber = m[2] ?? "";
+  const year = m[3] ?? "";
+  return {
+    doctype,
+    doc_number: docNumber,
+    year,
+    label: `OIML ${doctype.toUpperCase()} ${docNumber}${year ? `:${year}` : ""}`
+  };
+}
+function retrievalFacet(unit, pkg) {
+  const parts = retrievalDocParts(pkg.base_urn);
+  const facet = {
+    unit_id: unit.id,
+    unit_hash: unit.content_hash,
+    block: unit.kind,
+    doc_id: pkg.id,
+    docidentifier: parts.label || pkg.title,
+    doctype: parts.doctype,
+    doc_number: parts.doc_number,
+    edition: pkg.edition,
+    model_version: pkg.model_version,
+    language: pkg.default_spelling,
+    clause_anchor: unit.clause?.clause ?? "",
+    clause_title: unit.name ?? unit.id,
+    ...present(pkg.status) ? { status: pkg.status } : {}
+  };
+  const valuesByDim = /* @__PURE__ */ new Map();
+  const matchByDim = /* @__PURE__ */ new Map();
+  for (const entry of unit.applicability ?? []) {
+    const values = entry.values.length > 0 ? entry.values : Object.keys(entry.mapping ?? {});
+    const set = valuesByDim.get(entry.dimension) ?? /* @__PURE__ */ new Set();
+    for (const v of values) {
+      set.add(v);
+    }
+    valuesByDim.set(entry.dimension, set);
+    if (entry.match && entry.match !== "any" && !matchByDim.has(entry.dimension)) {
+      matchByDim.set(entry.dimension, entry.match);
+    }
+  }
+  for (const dim of [...valuesByDim.keys()].sort()) {
+    facet[`app_${dim}`] = [...valuesByDim.get(dim)].sort().join("|");
+    const match = matchByDim.get(dim);
+    if (match) {
+      facet[`app_${dim}_match`] = match;
+    }
+  }
+  return facet;
+}
+function resolveTextAddress(address, elementIds) {
+  const segments = address.split(".");
+  if (segments.length < 2 || segments.some((s) => s === "")) {
+    return null;
+  }
+  for (let i = segments.length - 1; i >= 1; i--) {
+    const candidate = segments.slice(0, i).join(".");
+    if (elementIds.has(candidate)) {
+      return { elementId: candidate, path: segments.slice(i).join(".") };
+    }
+  }
+  return null;
+}
+var TEXT_ADDRESS_COLLECTIONS = [
+  "requirements",
+  "requirementClasses",
+  "conformanceTests",
+  "conformanceClasses",
+  "terms",
+  "forms",
+  "subforms",
+  "symbols",
+  "tables",
+  "calculations",
+  "notes",
+  "provisions",
+  "processes",
+  "instruments",
+  "attributeDefinitions",
+  "capabilities",
+  "behaviors",
+  "conditionSets",
+  "subjects",
+  "referenceMaterials",
+  "artifactDefinitions",
+  "monitors",
+  "passports",
+  "invariants",
+  "testSequences",
+  "formulasUsed",
+  "stateMachines",
+  "figures",
+  "links"
+];
+function attachVariants(built, standard, pkg) {
+  if (present(pkg.default_spelling)) {
+    for (const b of built) {
+      b.content.language = pkg.default_spelling;
+    }
+  }
+  const texts = standard.texts ?? [];
+  if (texts.length === 0) {
+    return 0;
+  }
+  const registry = /* @__PURE__ */ new Set();
+  for (const field of TEXT_ADDRESS_COLLECTIONS) {
+    for (const item of standard[field] ?? []) {
+      if (item?.id) {
+        registry.add(item.id);
+      }
+    }
+  }
+  const unitByElement = new Map(built.map((b) => [b.elementId, b.content]));
+  let dropped = 0;
+  for (const t of texts) {
+    const resolved = resolveTextAddress(t.id, registry);
+    const content = resolved ? unitByElement.get(resolved.elementId) : void 0;
+    if (!resolved || !content) {
+      dropped++;
+      continue;
+    }
+    const variants = content.variants ??= {};
+    variants[resolved.path] = [
+      ...variants[resolved.path] ?? [],
+      ...t.entries
+    ];
+  }
+  return dropped;
+}
+function assemble(content, clauses) {
+  if (clauses.length > 0) {
+    content.clause = clauses[0];
+    content.clauses = clauses;
+  }
+  return content;
+}
+function completeUnit(content, pkg) {
+  const hash = retrievalDigest(content);
+  const unit = {
+    ...content,
+    content_hash: hash
+  };
+  unit.passport = passportOf(unit);
+  unit.facet = retrievalFacet(unit, pkg);
+  return unit;
+}
+function scopeOf(id) {
+  const slash = id.lastIndexOf("/");
+  return slash > 0 ? id.slice(0, slash) : void 0;
+}
+var present = (s) => typeof s === "string" && s.length > 0;
+var presentList = (xs) => xs && xs.length > 0 ? xs : void 0;
+function requirementUnit(r) {
+  return assemble(
+    {
+      id: r.id,
+      kind: "requirement",
+      ...scopeOf(r.id) ? { class: scopeOf(r.id) } : {},
+      ...present(r.name) ? { name: r.name } : {},
+      ...present(r.statement) ? { statement: r.statement } : {},
+      ...present(r.guidance) ? { guidance: r.guidance } : {},
+      ...present(r.obligation) ? { obligation: r.obligation } : {},
+      modality: r.limit?.modality || "shall",
+      ...r.limit?.expression ? {
+        expression: r.limit.expression,
+        ...presentList(r.limit.uses) ? { expression_inputs: r.limit.uses } : {}
+      } : {},
+      ...presentList(r.applicability) ? { applicability: r.applicability } : {},
+      ...presentList(r.bindsTo) ? { binds_to: r.bindsTo } : {},
+      ...r.limit?.accepts ? {
+        acceptance: `${r.limit.accepts.verdict} ${r.limit.accepts.op} ${r.limit.accepts.limit}`
+      } : {},
+      ...present(r.acceptanceCriteria) ? { acceptance_criteria: r.acceptanceCriteria } : {},
+      ...present(r.verificationMethod) ? {
+        verification: {
+          method: r.verificationMethod,
+          description: r.verificationDescription ?? ""
+        }
+      } : {},
+      ...present(r.channel) ? { channel: r.channel } : {},
+      ...presentList(r.dependencies) ? { dependencies: r.dependencies } : {}
+    },
+    collectClauses(r)
+  );
+}
+function conformanceTestUnit(t) {
+  const payload = {
+    ...present(t.kind) ? { test_kind: t.kind } : {},
+    ...present(t.methodRef) ? { method_ref: t.methodRef } : {},
+    ...presentList(t.preconditions) ? {
+      preconditions: t.preconditions.map((p) => ({
+        id: p.id,
+        check: p.check,
+        description: p.description,
+        on_violation: p.onViolation
+      }))
+    } : {}
+  };
+  return assemble(
+    {
+      id: t.id,
+      kind: "conformance_test",
+      ...scopeOf(t.id) ? { class: scopeOf(t.id) } : {},
+      ...present(t.name) ? { name: t.name } : {},
+      ...present(t.purpose) ? { statement: t.purpose } : {},
+      ...present(t.method) ? { definition: t.method } : {},
+      ...present(t.guidance) ? { guidance: t.guidance } : {},
+      ...present(t.obligation) ? { obligation: t.obligation } : {},
+      ...presentList(t.applicability) ? { applicability: t.applicability } : {},
+      ...presentList(t.targets) ? { targets: t.targets } : {},
+      ...presentList(t.bindsTo) ? { binds_to: t.bindsTo } : {},
+      ...present(t.acceptancePassIf) ? { acceptance: t.acceptancePassIf } : present(t.acceptanceCriteriaDescription) ? { acceptance: t.acceptanceCriteriaDescription } : {},
+      ...presentList(t.dependencies) ? { dependencies: t.dependencies } : {},
+      ...Object.keys(payload).length > 0 ? { payload } : {}
+    },
+    collectClauses(t)
+  );
+}
+function termUnit(t, baseUrn) {
+  const payload = {
+    ...present(t.section) ? { section: t.section } : {},
+    ...present(t.language) ? { language: t.language } : {},
+    ...t.vocabRef ? { vocab_ref: t.vocabRef } : {},
+    // The alias family (MN 114 v3.2, clause 13.10.1): the parser folds
+    // the v2 `alt` spelling into the canonical aliases channel; the
+    // payload keeps the deployed `alt` key (contract stability) and adds
+    // the v3.2 facets.
+    ...presentList(t.aliases ?? t.alt) ? { alt: t.aliases ?? t.alt } : {},
+    ...presentList(t.colloquial) ? { colloquial: t.colloquial } : {},
+    ...t.aliasSpellings && Object.keys(t.aliasSpellings).length > 0 ? { alias_spellings: t.aliasSpellings } : {},
+    ...presentList(t.abbreviations) ? { abbreviations: t.abbreviations } : {},
+    ...presentList(t.seeAlso) ? { see_also: t.seeAlso } : {}
+  };
+  return assemble(
+    {
+      id: `/term/${t.id}`,
+      kind: "term",
+      ...present(t.label) ? { name: t.label } : {},
+      ...present(t.definition) ? { definition: t.definition } : {},
+      ...Object.keys(payload).length > 0 ? { payload } : {}
+    },
+    termClauses(t, baseUrn)
+  );
+}
+function attributeUnit(a) {
+  const payload = {
+    ...present(a.symbol) ? { symbol: a.symbol } : {},
+    ...present(a.quantityKind) ? { quantity_kind: a.quantityKind } : {},
+    ...present(a.valueType) ? { value_type: a.valueType } : {},
+    ...present(a.origin) ? { origin: a.origin } : {},
+    ...present(a.scope) ? { scope: a.scope } : {},
+    ...present(a.category) ? { category: a.category } : {},
+    ...present(a.irdi) ? { irdi: a.irdi } : {},
+    ...presentList(a.enumValues) ? { enum_values: a.enumValues } : {}
+  };
+  return assemble(
+    {
+      id: `/attribute/${a.id}`,
+      kind: "attribute",
+      ...present(a.name) ? { name: a.name } : {},
+      ...present(a.definition) ? { definition: a.definition } : {},
+      ...present(a.unit) && a.unit !== "1" ? { units: [a.unit] } : {},
+      ...Object.keys(payload).length > 0 ? { payload } : {}
+    },
+    collectClauses(a)
+  );
+}
+function behaviorUnit(b) {
+  const payload = {
+    ...present(b.kind) ? { behavior_kind: b.kind } : {},
+    ...present(b.stimulus) ? { stimulus: b.stimulus } : {}
+  };
+  return assemble(
+    {
+      id: `/behavior/${b.id}`,
+      kind: "behavior",
+      name: b.id,
+      ...present(b.response) ? { statement: b.response } : {},
+      ...Object.keys(payload).length > 0 ? { payload } : {}
+    },
+    collectClauses(b)
+  );
+}
+function calculationUnits(c) {
+  const out = /* @__PURE__ */ new Set();
+  for (const i of c.inputs ?? []) {
+    if (present(i.unit) && i.unit !== "1") {
+      out.add(i.unit);
+    }
+  }
+  if (c.output && present(c.output.unit) && c.output.unit !== "1") {
+    out.add(c.output.unit);
+  }
+  return [...out].sort();
+}
+function calculationUnit(c) {
+  const kind = present(c.ruleType) ? "formula" : "calculation";
+  const units = calculationUnits(c);
+  const payload = {
+    name: c.name,
+    ...present(c.ruleType) ? { rule_type: c.ruleType } : {},
+    ...present(c.category) ? { category: c.category } : {},
+    ...presentList(c.inputs) ? {
+      inputs: c.inputs.map((i) => ({
+        name: i.name,
+        type: i.type,
+        ...present(i.unit) ? { unit: i.unit } : {}
+      }))
+    } : {},
+    ...c.output && present(c.output.type) ? { output: c.output } : {},
+    ...c.lookup ? { lookup: c.lookup } : {},
+    ...present(c.profile) ? { profile: c.profile } : {}
+  };
+  return assemble(
+    {
+      id: present(c.identifier) ? c.identifier : `/calculation/${c.id}`,
+      kind,
+      name: c.label || c.name || c.id,
+      ...present(c.description) ? { definition: c.description } : {},
+      ...present(c.expression) ? { expression: c.expression } : {},
+      ...presentList(c.params) ? { expression_inputs: c.params } : {},
+      ...units.length > 0 ? { units } : {},
+      payload
+    },
+    collectClauses({
+      sourceRef: c.sourceRef,
+      sourceRefs: c.sourceRefs,
+      refs: c.refs
+    })
+  );
+}
+function symbolUnit(s) {
+  const units = present(s.unit) && s.unit !== "1" ? [s.unit] : void 0;
+  const payload = {
+    ...present(s.type) ? { symbol_type: s.type } : {},
+    ...present(s.kind) ? { symbol_kind: s.kind } : {},
+    ...present(s.quantityKind) ? { quantity_kind: s.quantityKind } : {},
+    ...present(s.origin) ? { origin: s.origin } : {},
+    ...present(s.latex) ? { latex: s.latex } : {},
+    ...s.formula && present(s.formula.display) ? { display: s.formula.display } : {},
+    ...present(s.calculation) ? { calculation: s.calculation } : {}
+  };
+  return assemble(
+    {
+      id: `/symbol/${s.id}`,
+      kind: "symbol",
+      ...present(s.name) ? { name: s.name } : {},
+      ...present(s.definition) ? { definition: s.definition } : {},
+      ...s.formula && present(s.formula.expression) ? {
+        expression: s.formula.expression,
+        ...presentList(s.formula.inputs) ? { expression_inputs: s.formula.inputs } : {}
+      } : {},
+      ...units ? { units } : {},
+      ...Object.keys(payload).length > 0 ? { payload } : {}
+    },
+    collectClauses({
+      sourceRef: s.sourceRef,
+      sourceRefs: s.sourceRefs,
+      refs: s.refs
+    })
+  );
+}
+function constraintUnit(c) {
+  return assemble(
+    {
+      id: `/constraint/${c.id}`,
+      kind: "constraint",
+      ...present(c.name) ? { name: c.name } : {},
+      ...present(c.violationMeaning) ? { statement: c.violationMeaning } : {},
+      ...present(c.check) ? { expression: c.check } : {},
+      payload: {
+        ...present(c.stereotype) ? { stereotype: c.stereotype } : {},
+        ...present(c.onViolation) ? { on_violation: c.onViolation } : {}
+      }
+    },
+    collectClauses(c)
+  );
+}
+function characteristicUnit(v) {
+  const units = present(v.unit) && v.unit !== "1" ? [v.unit] : void 0;
+  const payload = {
+    ...present(v.behavior) ? { behavior: v.behavior } : {},
+    ...present(v.quantityKind) ? { quantity_kind: v.quantityKind } : {},
+    ...v.seriesReduction ? { series_reduction: v.seriesReduction } : {}
+  };
+  return assemble(
+    {
+      id: `/characteristic/${v.id}`,
+      kind: "characteristic",
+      ...present(v.symbol) ? { name: v.symbol } : {},
+      ...present(v.derive) ? {
+        expression: v.derive,
+        ...presentList(v.inputs) ? { expression_inputs: v.inputs } : {}
+      } : {},
+      ...units ? { units } : {},
+      ...v.acceptance && present(v.acceptance.rule) ? { acceptance: v.acceptance.rule } : {},
+      ...Object.keys(payload).length > 0 ? { payload } : {}
+    },
+    collectClauses(v)
+  );
+}
+function tableUnit(t) {
+  const units = (t.columnDefs ?? []).map((c) => c.unit).filter((u) => present(u) && u !== "1").sort();
+  const payload = {
+    ...presentList(t.columnDefs) ? {
+      columns: t.columnDefs.map((c) => ({
+        name: c.name,
+        type: c.type,
+        ...present(c.unit) ? { unit: c.unit } : {}
+      }))
+    } : present(t.columns) ? { columns: t.columns } : {},
+    ...presentList(t.data) ? { rows: t.data } : {},
+    ...t.profiles ? { profiles: t.profiles } : {}
+  };
+  return assemble(
+    {
+      id: `/table/${t.id}`,
+      kind: "table",
+      ...present(t.title) ? { name: t.title } : {},
+      ...present(t.description) ? { definition: t.description } : {},
+      ...units.length > 0 ? { units: [...new Set(units)] } : {},
+      ...Object.keys(payload).length > 0 ? { payload } : {}
+    },
+    collectClauses({
+      sourceRef: t.sourceRef,
+      sourceRefs: t.sourceRefs,
+      refs: t.refs
+    })
+  );
+}
+function sequenceUnit(s) {
+  const payload = {
+    steps: s.steps.map((st) => ({
+      order: st.order,
+      ...present(st.test) ? { test: st.test } : {},
+      ...present(st.phase) ? { phase: st.phase } : {},
+      ...present(st.role) ? { role: st.role } : {},
+      ...st.dependsOn !== null ? { depends_on: st.dependsOn } : {}
+    })),
+    ...present(s.sampleApplicability) ? { sample_applicability: s.sampleApplicability } : {}
+  };
+  return assemble(
+    {
+      id: `/sequence/${s.id}`,
+      kind: "sequence",
+      ...present(s.name) ? { name: s.name } : {},
+      ...present(s.description) ? { statement: s.description } : {},
+      payload
+    },
+    collectClauses({ sourceRefs: s.sourceRefs, refs: s.refs })
+  );
+}
+function noteUnit(n) {
+  return assemble(
+    {
+      id: `/note/${n.id}`,
+      kind: "note",
+      name: n.type,
+      ...present(n.message) ? { statement: n.message } : {}
+    },
+    []
+  );
+}
+function stateMachineUnit(m) {
+  const id = m.entityName;
+  const payload = {
+    ...present(m.kind) ? { machine_kind: m.kind } : {},
+    ...present(m.initialState) ? { initial: m.initialState } : {},
+    ...presentList(m.states) ? { states: m.states.map((s) => s.name) } : {},
+    ...presentList(m.transitions) ? {
+      transitions: m.transitions.map((t) => ({
+        from: t.from,
+        to: t.to,
+        ...present(t.actionName) ? { action: t.actionName } : {},
+        ...present(t.guard) ? { guard: t.guard } : {}
+      }))
+    } : {}
+  };
+  return assemble(
+    {
+      id: `/state-machine/${id}`,
+      kind: "state_machine",
+      name: id,
+      ...Object.keys(payload).length > 0 ? { payload } : {}
+    },
+    []
+  );
+}
+function dimensionUnit(d) {
+  const payload = {
+    ...present(d.scope) ? { scope: d.scope } : {},
+    ...present(d.cardinality) ? { cardinality: d.cardinality } : {},
+    values: d.values.map((v) => ({
+      id: v.id,
+      ...present(v.label) ? { label: v.label } : {},
+      ...presentList(v.implies) ? { implies: v.implies } : {},
+      ...present(v.termRef) ? { term_ref: v.termRef } : {}
+    }))
+  };
+  return assemble(
+    {
+      id: `/dimension/${d.id}`,
+      kind: "dimension",
+      ...present(d.label) ? { name: d.label } : {},
+      ...present(d.description) ? { definition: d.description } : {},
+      payload
+    },
+    collectClauses(d)
+  );
+}
+function packageEdition(manifest) {
+  const first = manifest?.editions?.[0];
+  if (present(first)) {
+    return first;
+  }
+  const tail = /:(\d{4})$/.exec(manifest?.baseUrn ?? "");
+  return tail?.[1] ?? "";
+}
+function packageBlock(standard) {
+  const m = standard.packageManifest;
+  if (m) {
+    return {
+      id: m.id,
+      title: m.title,
+      kind: m.kind ?? "rec",
+      edition: packageEdition(m),
+      model_version: m.version,
+      editions: [...m.editions ?? []],
+      base_urn: m.baseUrn,
+      ...present(m.status) ? { status: m.status } : {},
+      default_spelling: m.defaultSpelling ?? "",
+      spellings: [
+        ...m.spellings ?? (m.defaultSpelling ? [m.defaultSpelling] : [])
+      ],
+      ...presentList(m.supersedes) ? { supersedes: [...m.supersedes] } : {}
+    };
+  }
+  const meta = standard.meta;
+  return {
+    id: meta?.namespace ?? "",
+    title: meta?.title ?? "",
+    kind: "",
+    edition: meta?.edition ?? "",
+    model_version: "",
+    editions: present(meta?.edition) ? [meta.edition] : [],
+    base_urn: "",
+    default_spelling: "",
+    spellings: []
+  };
+}
+function exportStandardRetrieval(standard, options = {}) {
+  const pkg = packageBlock(standard);
+  const built = [];
+  const push = (content, elementId) => {
+    built.push({ content, elementId });
+  };
+  for (const r of standard.requirements ?? []) {
+    push(requirementUnit(r), r.id);
+  }
+  for (const t of standard.conformanceTests ?? []) {
+    push(conformanceTestUnit(t), t.id);
+  }
+  for (const t of standard.terms ?? []) {
+    push(termUnit(t, pkg.base_urn), t.id);
+  }
+  for (const a of standard.attributeDefinitions ?? []) {
+    push(attributeUnit(a), a.id);
+  }
+  for (const b of standard.behaviors ?? []) {
+    push(behaviorUnit(b), b.id);
+  }
+  for (const c of standard.calculations ?? []) {
+    push(calculationUnit(c), c.id);
+  }
+  for (const s of standard.symbols ?? []) {
+    push(symbolUnit(s), s.id);
+  }
+  for (const c of standard.constraints ?? []) {
+    push(constraintUnit(c), c.id);
+  }
+  for (const v of standard.verdicts ?? []) {
+    push(characteristicUnit(v), v.id);
+  }
+  for (const t of standard.tables ?? []) {
+    push(tableUnit(t), t.id);
+  }
+  for (const s of standard.testSequences ?? []) {
+    push(sequenceUnit(s), s.id);
+  }
+  for (const n of standard.notes ?? []) {
+    push(noteUnit(n), n.id);
+  }
+  for (const m of standard.stateMachines ?? []) {
+    push(stateMachineUnit(m), m.entityName);
+  }
+  for (const i of standard.instruments ?? []) {
+    for (const d of i.dimensions ?? []) {
+      push(dimensionUnit(d), d.id);
+    }
+  }
+  const droppedTextBlocks = attachVariants(built, standard, pkg);
+  const units = built.map((b) => completeUnit(b.content, pkg));
+  const byKind = {};
+  let withClause = 0;
+  let anchorOnlyProvenance = 0;
+  let nonUrnDocRefs = 0;
+  let withoutProvenance = 0;
+  let withVariants = 0;
+  for (const u of units) {
+    byKind[u.kind] = (byKind[u.kind] ?? 0) + 1;
+    if (u.variants && Object.keys(u.variants).length > 0) {
+      withVariants++;
+    }
+    const clauses = u.clauses ?? [];
+    if (clauses.some((c) => c.clause)) {
+      withClause++;
+    } else if (clauses.length > 0) {
+      anchorOnlyProvenance++;
+    } else {
+      withoutProvenance++;
+    }
+    if (clauses.some((c) => c.doc && !c.doc.startsWith("urn:"))) {
+      nonUrnDocRefs++;
+    }
+  }
+  const document = {
+    projection: RETRIEVAL_PROJECTION,
+    facet_version: RETRIEVAL_FACET_VERSION,
+    package: pkg,
+    ...options.sourceHash !== void 0 ? { source_hash: options.sourceHash } : {},
+    units
+  };
+  return {
+    document,
+    json: JSON.stringify(sortDeep(document), null, 2) + "\n",
+    stats: {
+      units: units.length,
+      byKind,
+      withClause,
+      anchorOnlyProvenance,
+      nonUrnDocRefs,
+      withoutProvenance,
+      withVariants,
+      droppedTextBlocks
+    }
+  };
+}
+function exportPackageRetrieval(dir) {
+  const { standard } = loadPackageWithIssues(dir);
+  return exportStandardRetrieval(standard, {
+    sourceHash: packageSourceHash(dir)
+  });
+}
+
+// src/export/impact.ts
+var IMPACT_GRAPH_VERSION = "impact-graph/1";
+function provenanceOf2(el) {
+  const first = el.sourceRefs?.[0] ?? (el.sourceRef && typeof el.sourceRef === "object" ? el.sourceRef : null) ?? (el.source && typeof el.source === "object" ? el.source : null);
+  if (first && (first.doc || first.clause)) {
+    return { source: { doc: first.doc ?? "", clause: first.clause ?? "" } };
+  }
+  const ref = (el.refs ?? []).find((r) => r.predicate === "derives-from");
+  return ref ? { derivesFrom: ref.target } : {};
+}
+function impactGraph(standard) {
+  const forward = /* @__PURE__ */ new Map();
+  const add = (element, carrier, kind, facet, target, via) => {
+    if (target === void 0 || target === "") {
+      return;
+    }
+    const edge = { kind, facet, target, ...provenanceOf2(carrier) };
+    if (via !== void 0) {
+      edge.via = via;
+    }
+    const list = forward.get(element);
+    if (list) {
+      list.push(edge);
+    } else {
+      forward.set(element, [edge]);
+    }
+  };
+  const verdictIds = new Set((standard.verdicts ?? []).map((v) => v.id));
+  for (const r of standard.requirements ?? []) {
+    for (const p of r.bindsTo ?? []) {
+      add(r.id, r, "binding", "binds_to", p);
+    }
+    for (const d of r.dependencies ?? []) {
+      add(r.id, r, "prerequisite", "dependencies", d);
+    }
+    if (r.limit?.accepts?.verdict) {
+      add(
+        r.id,
+        r,
+        "acceptance",
+        "limit.accepts.verdict",
+        r.limit.accepts.verdict
+      );
+    }
+    for (const a of r.applicability ?? []) {
+      add(r.id, r, "classification", "applicability", a.dimension);
+    }
+    if (r.channel) {
+      add(r.id, r, "evidence channel", "channel", r.channel);
+    }
+  }
+  for (const t of standard.conformanceTests ?? []) {
+    for (const target of t.targets ?? []) {
+      add(t.id, t, "coverage", "targets", target);
+    }
+    add(
+      t.id,
+      t,
+      "specialization",
+      "inherits_from",
+      t.inheritsFrom || void 0
+    );
+    for (const d of t.dependencies ?? []) {
+      add(t.id, t, "prerequisite", "dependencies", d);
+    }
+    if (t.instances?.by) {
+      add(t.id, t, "instantiation", "instances.by", t.instances.by);
+    }
+    for (const f of t.resultForms ?? []) {
+      add(t.id, t, "evidence view", "result_forms", f);
+    }
+    for (const a of t.producesArtifacts ?? []) {
+      add(t.id, t, "issuance", "produces_artifacts", a);
+    }
+  }
+  for (const v of standard.verdicts ?? []) {
+    for (const inp of v.inputs ?? []) {
+      add(
+        v.id,
+        v,
+        verdictIds.has(inp) ? "acceptance chain" : "derivation",
+        "inputs",
+        inp
+      );
+    }
+    add(v.id, v, "state transition", "behavior", v.behavior || void 0);
+  }
+  for (const c of standard.calculations ?? []) {
+    for (const inp of c.inputs ?? []) {
+      add(c.id, c, "derivation", "inputs", inp.name);
+    }
+    if (c.lookup?.key) {
+      add(c.id, c, "data source", "lookup", c.lookup.key);
+    }
+    add(c.id, c, "data source", "profile", c.profile || void 0);
+    for (const p of c.params ?? []) {
+      add(c.id, c, "parameterization", "params", p);
+    }
+  }
+  for (const f of standard.forms ?? []) {
+    for (const r of f.requirements ?? []) {
+      add(f.id, f, "evidence scope", "requirements", r);
+    }
+    for (const table of f.calculationContext?.tables ?? []) {
+      add(f.id, f, "derivation context", "calculation_context", table);
+    }
+    const fields = (list) => {
+      for (const fld of list ?? []) {
+        add(f.id, f, "binding", "field.bind", fld.bind, fld.name);
+        add(
+          f.id,
+          f,
+          "binding",
+          "field.verdict",
+          fld.verdict || void 0,
+          fld.name
+        );
+        for (const t of fld.targets ?? []) {
+          add(f.id, f, "binding", "field.targets", t, fld.name);
+        }
+        fields(fld.fields);
+      }
+    };
+    fields(f.fields);
+  }
+  for (const fu of standard.formulasUsed ?? []) {
+    for (const formula of fu.formulas ?? []) {
+      add(fu.id, fu, "derivation", "formulas_used", formula);
+    }
+  }
+  const dims = [
+    ...standard.dimensions ?? [],
+    ...(standard.instruments ?? []).flatMap((i) => i.dimensions ?? [])
+  ];
+  for (const d of dims) {
+    for (const v of d.values ?? []) {
+      for (const target of v.implies ?? []) {
+        add(
+          d.id,
+          d,
+          "subsumption",
+          "values.implies",
+          `${d.id}.${target}`,
+          v.id
+        );
+      }
+    }
+  }
+  for (const i of standard.instances ?? []) {
+    add(i.id, {}, "instantiation", "of", i.of);
+    add(i.id, {}, "instantiation", "model", i.model || void 0);
+    add(i.id, {}, "instantiation", "group", i.group || void 0);
+    add(i.id, {}, "instantiation", "family", i.family || void 0);
+  }
+  const m = standard.packageManifest;
+  if (m) {
+    for (const u of m.uses ?? []) {
+      add(m.id, {}, "composition", "uses", u);
+    }
+    for (const mt of m.mapsTo ?? []) {
+      add(m.id, {}, "composition", "maps_to", mt);
+    }
+    for (const s of m.supersedes ?? []) {
+      add(m.id, {}, "edition lineage", "supersedes", s);
+    }
+    for (const s of m.replaces ?? []) {
+      add(m.id, {}, "edition lineage", "replaces", s);
+    }
+    for (const s of m.supersededBy ?? []) {
+      add(m.id, {}, "edition lineage", "superseded_by", s);
+    }
+  }
+  const reverse = {};
+  const forwardObj = {};
+  for (const [element, edges] of [...forward.entries()].sort()) {
+    forwardObj[element] = edges;
+    for (const e of edges) {
+      (reverse[e.target] ??= []).push({ ...e, element });
+    }
+  }
+  return {
+    version: IMPACT_GRAPH_VERSION,
+    package: {
+      id: m?.id ?? "",
+      version: m?.version ?? "",
+      baseUrn: m?.baseUrn ?? ""
+    },
+    forward: forwardObj,
+    reverse
+  };
+}
+function exportPackageImpact(dir) {
+  const standard = loadPackage(dir);
+  const graph = impactGraph(standard);
+  const byKind = {};
+  let edges = 0;
+  for (const list of Object.values(graph.forward)) {
+    for (const e of list) {
+      edges++;
+      byKind[e.kind] = (byKind[e.kind] ?? 0) + 1;
+    }
+  }
+  return {
+    graph,
+    json: JSON.stringify(graph, null, 2) + "\n",
+    stats: {
+      edges,
+      elements: Object.keys(graph.forward).length,
+      targets: Object.keys(graph.reverse).length,
+      byKind
+    }
+  };
+}
+
+// src/package-diff.ts
+import { existsSync as existsSync6, readdirSync as readdirSync5, readFileSync as readFileSync7 } from "fs";
+import { join as join6 } from "path";
+function packageMappings(dir, standard) {
+  const profiles = [...standard.mapProfiles ?? []];
+  if (existsSync6(dir)) {
+    for (const entry of readdirSync5(dir).sort()) {
+      if (!entry.endsWith(".prm")) {
+        continue;
+      }
+      profiles.push(
+        ...prmToMapProfiles(loadPrm(readFileSync7(join6(dir, entry), "utf8")))
+      );
+    }
+  }
+  const modelId = standard.packageManifest?.id ?? standard.meta?.namespace ?? "";
+  return profiles.flatMap((p) => mappingsFromProfile(p, modelId));
+}
+function packageClauseTexts(dir) {
+  const out = /* @__PURE__ */ new Map();
+  const prdDir = join6(dir, "sources-prd");
+  if (!existsSync6(prdDir)) {
+    return out;
+  }
+  for (const entry of readdirSync5(prdDir).sort()) {
+    if (!entry.endsWith(".sentences.json")) {
+      continue;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(readFileSync7(join6(prdDir, entry), "utf8"));
+    } catch {
+      continue;
+    }
+    const urn = payload.document?.urn ?? "";
+    if (!urn) {
+      continue;
+    }
+    const basis = normalizeSourceRef(urn, "").basis;
+    const byClause = /* @__PURE__ */ new Map();
+    for (const s of payload.sentences ?? []) {
+      if (!s.clause || s.text === void 0) {
+        continue;
+      }
+      (byClause.get(s.clause) ?? byClause.set(s.clause, []).get(s.clause)).push(s.text);
+    }
+    for (const [clause, texts] of byClause) {
+      out.set(clauseTextKey(basis, clause), texts.join("\n"));
+    }
+  }
+  return out;
+}
+function diffPackageDirs(dirA, dirB, options = {}) {
+  const loadedA = loadPackageWithIssues(dirA, {
+    resolvePackage: options.resolvePackage
   });
   const loadedB = loadPackageWithIssues(dirB, {
     resolvePackage: options.resolvePackage
@@ -23010,18 +24952,18 @@ function diffPackageDirs(dirA, dirB, options = {}) {
 // scripts/check.mts
 var CHECK_USAGE = "Usage: primmel check [--strict] [--audit] [--coverage] [--rules] [--with <pkg-id>=<dir>]\u2026 <package-dir>";
 var DIFF_USAGE = "Usage: primmel diff [--json] [--exit-code] [--compare-texts] [--with <pkg-id>=<dir>]\u2026 <a> <b>";
-var EXPORT_USAGE = "Usage: primmel export reqif|rdf <package-dir> [--out <file>] [--format turtle|jsonld]";
+var EXPORT_USAGE = "Usage: primmel export reqif|rdf|retrieval|impact <package-dir> [--out <file>] [--format turtle|jsonld]";
 function readablePackageDirProblem(target, needsManifest) {
   try {
-    if (!statSync3(target).isDirectory()) {
+    if (!statSync4(target).isDirectory()) {
       return "not a directory";
     }
-    readdirSync5(target);
+    readdirSync6(target);
   } catch (e) {
     const err = e;
     return err.code === "ENOENT" ? "no such directory" : err.message;
   }
-  if (needsManifest && !existsSync7(join6(target, "package.primmel"))) {
+  if (needsManifest && !existsSync7(join7(target, "package.primmel"))) {
     return "no package.primmel found";
   }
   return null;
@@ -23180,7 +25122,7 @@ function diffCli(args2) {
 }
 function exportCli(args2) {
   const surface = args2[0];
-  if (surface !== "reqif" && surface !== "rdf") {
+  if (surface !== "reqif" && surface !== "rdf" && surface !== "retrieval" && surface !== "impact") {
     console.error(EXPORT_USAGE);
     process.exit(2);
   }
@@ -23196,7 +25138,7 @@ function exportCli(args2) {
     process.exit(2);
   }
   const rdfFormat = values.get("--format") ?? "turtle";
-  if (surface === "reqif" && values.has("--format")) {
+  if (surface !== "rdf" && values.has("--format")) {
     console.error("--format applies to `primmel export rdf` only");
     console.error(EXPORT_USAGE);
     process.exit(2);
@@ -23215,7 +25157,17 @@ function exportCli(args2) {
   let document;
   let summary;
   try {
-    if (surface === "reqif") {
+    if (surface === "impact") {
+      const result = exportPackageImpact(dir);
+      document = result.json;
+      const s = result.stats;
+      summary = `${n(s.edges, "edge", "edges")} (${Object.entries(s.byKind).map(([k, c]) => `${c} ${k}`).join(", ")}), ${n(s.elements, "element", "elements")} declaring, ${n(s.targets, "target", "targets")} indexed`;
+    } else if (surface === "retrieval") {
+      const result = exportPackageRetrieval(dir);
+      document = result.json;
+      const s = result.stats;
+      summary = `${n(s.units, "unit", "units")} (${Object.entries(s.byKind).map(([k, c]) => `${c} ${k}`).join(", ")}), ${n(s.withClause, "unit", "units")} clause-cited` + (s.anchorOnlyProvenance > 0 ? `, ${n(s.anchorOnlyProvenance, "unit", "units")} with anchor-only provenance (ask-1 debt)` : "") + (s.nonUrnDocRefs > 0 ? `, ${n(s.nonUrnDocRefs, "unit", "units")} with legacy non-URN doc refs` : "") + (s.withoutProvenance > 0 ? `, ${n(s.withoutProvenance, "unit", "units")} without provenance` : "") + (s.withVariants > 0 ? `, ${n(s.withVariants, "unit", "units")} with language variants` : "") + (s.droppedTextBlocks > 0 ? `, ${n(s.droppedTextBlocks, "text block", "text blocks")} addressed at unprojected elements (dropped)` : "");
+    } else if (surface === "reqif") {
       const result = exportPackageReqif(dir);
       document = result.xml;
       const s = result.stats;