@primmel/primmel 1.7.0 → 1.8.0

package/dist-cli/primmel.mjs

@@ -263,6 +263,9 @@ function parse(mmelString, parsers, options = {}) {
     formulasUsed: {},
     // Primmel v3 ISO 24229 multilinguality (TODO.roadmap/25)
     texts: {},
+    // Primmel v3.1 dataspace + trust (TODO.primmel/10)
+    dataspaces: {},
+    policies: {},
     // Issue collection (duplicate IDs, etc.)
     issues: []
   };
@@ -417,12 +420,18 @@ function forEachEntry(data, visitor, errCtx) {
       () => t[i]
     );
     if (!claimed) {
-      if (keyword === "ref") {
+      if (keyword === "ref" || keyword === "corresponds") {
         i++;
         i++;
         if (i < t.length && t[i].startsWith("{")) {
           i++;
         }
+      } else if (keyword === "trust_ref") {
+        i++;
+        if (t[i] === "key") {
+          i++;
+          i++;
+        }
       } else {
         i++;
       }
@@ -430,7 +439,7 @@ function forEachEntry(data, visitor, errCtx) {
   }
 }
 function skipUnknownValue(t, i, keyword) {
-  if (keyword === "ref") {
+  if (keyword === "ref" || keyword === "corresponds") {
     i++;
     if (i < t.length) {
       i++;
@@ -440,6 +449,18 @@ function skipUnknownValue(t, i, keyword) {
     }
     return i;
   }
+  if (keyword === "trust_ref") {
+    if (i < t.length) {
+      i++;
+    }
+    if (t[i] === "key") {
+      i++;
+      if (i < t.length) {
+        i++;
+      }
+    }
+    return i;
+  }
   if (i < t.length) {
     i++;
   }
@@ -1289,6 +1310,86 @@ function dumpSourceRefAsRef(src, indent, escapeString2) {
   return `${indent}source { doc "${escapeString2(src.doc ?? "")}" clause "${escapeString2(String(src.clause ?? ""))}"` + (src.fragment ? ` fragment "${escapeString2(src.fragment)}"` : "") + " }\n";
 }
 
+// src/ser-des/config/correspondence.ts
+function parseCorresponds(t, i, stripWrapping2) {
+  if (t[i] === void 0) {
+    throw new Error(
+      "Parsing error: corresponds: Expecting value for corresponds (the scheme and the concept)"
+    );
+  }
+  const scheme = stripWrapping2(t[i++]);
+  if (t[i] === void 0) {
+    throw new Error(
+      "Parsing error: corresponds: Expecting value for corresponds (the concept)"
+    );
+  }
+  const corr = {
+    scheme,
+    concept: stripWrapping2(t[i++]),
+    projections: []
+  };
+  if (i < t.length && t[i].startsWith("{")) {
+    const block = unwrapBlock(t[i++]);
+    forEachEntry(
+      block,
+      (keyword, value, peek) => {
+        if (keyword === "projection") {
+          const codec = stripWrapping2(value());
+          const entries = [];
+          const next = peek();
+          if (next && next.startsWith("{")) {
+            forEachEntry(
+              unwrapBlock(value()),
+              (k, kv) => {
+                entries.push({ key: k, value: stripWrapping2(kv()) });
+                return true;
+              },
+              { construct: "corresponds.projection", id: codec }
+            );
+          }
+          corr.projections.push({ codec, entries });
+          return true;
+        }
+        return false;
+      },
+      { construct: "corresponds", id: corr.scheme }
+    );
+  }
+  return { corr, next: i };
+}
+function parseCorrespondsFromReaders(value, peek, stripWrapping2) {
+  const parts = [value(), value()];
+  const next = peek();
+  if (next && next.startsWith("{")) {
+    parts.push(value());
+  }
+  return parseCorresponds(parts, 0, stripWrapping2).corr;
+}
+function dumpCorrespondences(corrs, indent, escapeString2, dumpBareSafe2) {
+  if (!corrs || corrs.length === 0) {
+    return "";
+  }
+  let out = "";
+  for (const c of corrs) {
+    out += `${indent}corresponds ${dumpBareSafe2(c.scheme)} "${escapeString2(c.concept)}"`;
+    if (c.projections.length === 0) {
+      out += "\n";
+      continue;
+    }
+    out += " {\n";
+    for (const p of c.projections) {
+      out += `${indent}  projection ${dumpBareSafe2(p.codec)} {`;
+      for (const e of p.entries) {
+        out += ` ${dumpBareSafe2(e.key)} ${dumpBareSafe2(e.value)}`;
+      }
+      out += " }\n";
+    }
+    out += `${indent}}
+`;
+  }
+  return out;
+}
+
 // src/ser-des/config/series.ts
 function parseSeriesDecl(block) {
   const decl = { axes: [], cellSymbol: "", cellUnit: "" };
@@ -1697,6 +1798,10 @@ function parseFormField(name, block, type) {
         field.refs.push(r.ref);
       }
       i = r.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (field.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else if (cmd === "specification_reference") {
       field.specificationReference = stripWrapping(t[i++]);
     } else if (cmd === "applicability") {
@@ -2045,6 +2150,16 @@ function dumpFormField(field, indent) {
       );
     }
   }
+  if (field.correspondences && field.correspondences.length > 0) {
+    inner.push(
+      dumpCorrespondences(
+        field.correspondences,
+        "",
+        escapeString,
+        dumpBareSafe
+      ).trimEnd()
+    );
+  }
   if (field.specificationReference) {
     inner.push(
       'specification_reference "' + escapeString(field.specificationReference) + '"'
@@ -2740,6 +2855,10 @@ var parseProcess = function(id, data) {
         if (!foldRefIntoLegacy(result, r)) {
           (result.refs ??= []).push(r);
         }
+      } else if (keyword === "corresponds") {
+        (result.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
       } else {
         return false;
       }
@@ -3007,6 +3126,12 @@ var dumpProcess = function(process2, ctx) {
     out += dumpSourceRefAsRef(src, "  ", escapeString);
   }
   out += dumpRefs(process2.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    process2.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   if (process2.parent && (process2.children.length === 0 || !ctx?.nested)) {
     out += "  parent " + process2.parent + "\n";
   }
@@ -3754,8 +3879,12 @@ var parseTable = function(id, data) {
             (result.refs ??= []).push(rr.ref);
           }
           i = rr.next;
+        } else if (command === "corresponds") {
+          const cc = parseCorresponds(t, i, stripWrapping);
+          (result.correspondences ??= []).push(cc.corr);
+          i = cc.next;
         } else {
-          i++;
+          i = skipUnknownValue(t, i, command);
         }
       } else {
         throw new Error(
@@ -3826,6 +3955,12 @@ var dumpTable = function(t) {
   if (t.sourceDiscrepancy) {
     out += dumpSourceDiscrepancy(t.sourceDiscrepancy, "  ") + "\n";
   }
+  out += dumpCorrespondences(
+    t.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   if (t.overrides && Object.keys(t.overrides).length > 0) {
     out += "  overrides { ";
     for (const [key, o] of Object.entries(t.overrides)) {
@@ -4348,6 +4483,10 @@ var parseForm = function(id, data) {
             result.refs = [...result.refs ?? [], r.ref];
           }
           i = r.next;
+        } else if (command === "corresponds") {
+          const cc = parseCorresponds(t, i, stripWrapping);
+          result.correspondences = [...result.correspondences ?? [], cc.corr];
+          i = cc.next;
         } else if (command === "calculation_context") {
           result.calculationContext = parseCalculationContext(
             unwrapBlock(t[i++])
@@ -4640,6 +4779,12 @@ var dumpForm = function(f) {
       out += "  ref " + r.predicate + ' "' + escapeString(r.target) + '"' + (r.note ? ' { note "' + escapeString(r.note) + '" }' : "") + "\n";
     }
   }
+  out += dumpCorrespondences(
+    f.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   if (f.calculationContext) {
     const cc = f.calculationContext;
     let line = "  calculation_context { ";
@@ -4912,6 +5057,12 @@ var parseSymbol = function(id, data) {
         }
         return true;
       }
+      if (command === "corresponds") {
+        (result.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
+        return true;
+      }
       if (command === "name") {
         result.name = unwrapped(value);
       } else if (command === "definition") {
@@ -5062,6 +5213,12 @@ var dumpSymbol = function(s) {
     }
     out += "  }\n";
   }
+  out += dumpCorrespondences(
+    s.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -5115,6 +5272,10 @@ var parseCalculation = function(id, data) {
             (result.refs ??= []).push(rr.ref);
           }
           i = rr.next;
+        } else if (command === "corresponds") {
+          const cc = parseCorresponds(t, i, stripWrapping);
+          (result.correspondences ??= []).push(cc.corr);
+          i = cc.next;
         } else if (command === "source") {
           const inner = tokenize(unwrapBlock(t[i++]));
           const src = {
@@ -5386,6 +5547,12 @@ var dumpCalculation = function(c) {
   for (const r of c.refs ?? []) {
     out += "  ref " + r.predicate + ' "' + escapeString(r.target) + '"' + (r.note ? ' { note "' + escapeString(r.note) + '" }' : "") + "\n";
   }
+  out += dumpCorrespondences(
+    c.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   if (c.ref.length > 0) {
     out += "  reference {\n";
     for (const r of c.ref) {
@@ -6671,8 +6838,12 @@ var parseCompetenceKind = function(id, data) {
         (result.refs ??= []).push(rr.ref);
       }
       i = rr.next;
+    } else if (keyword === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else {
-      i++;
+      i = skipUnknownValue(t, i, keyword);
     }
   }
   return (ctx) => {
@@ -6694,6 +6865,12 @@ var dumpCompetenceKind = function(k) {
   for (const ms of k.methodStandards) {
     out += "  method_standard " + ms.id + ' "' + escapeString(ms.title) + '"\n';
   }
+  out += dumpCorrespondences(
+    k.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -7138,6 +7315,10 @@ var parseConformanceTest = function(id, data) {
         if (!foldRefIntoLegacy(result, rr)) {
           (result.refs ??= []).push(rr);
         }
+      } else if (keyword === "corresponds") {
+        (result.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
       } else if (keyword === "binds_to") {
         result.bindsTo = tokenizePackage(value());
       } else if (keyword === "applicability") {
@@ -7496,6 +7677,12 @@ var dumpConformanceTest = function(ct) {
   if (ct.sourceDiscrepancy) {
     out += dumpSourceDiscrepancy(ct.sourceDiscrepancy, "  ") + "\n";
   }
+  out += dumpCorrespondences(
+    ct.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -7524,6 +7711,12 @@ var parseTerm = function(id, data) {
         }
         return true;
       }
+      if (command === "corresponds") {
+        (result.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
+        return true;
+      }
       if (command === "label") {
         result.label = unwrapped(value);
       } else if (command === "definition") {
@@ -7643,6 +7836,12 @@ var dumpTerm = function(term) {
     }
     out += "  }\n";
   }
+  out += dumpCorrespondences(
+    term.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -7719,6 +7918,10 @@ var parseVerdict = function(id, data) {
         if (!foldRefIntoLegacy(result, r)) {
           (result.refs ??= []).push(r);
         }
+      } else if (keyword === "corresponds") {
+        (result.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
       } else {
         return false;
       }
@@ -7763,6 +7966,12 @@ var dumpVerdict = function(v) {
     out += dumpSourceRefAsRef(s, "  ", escapeString);
   }
   out += dumpRefs(v.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    v.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -7932,6 +8141,10 @@ var parseReferenceMaterial = function(id, data) {
         if (!foldRefIntoLegacy(result, r)) {
           (result.refs ??= []).push(r);
         }
+      } else if (keyword === "corresponds") {
+        (result.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
       } else if (keyword === "identity_fields") {
         result.identityFields = parseIdentityFields(unwrapBlock(value()));
       } else if (keyword === "constraints") {
@@ -7964,6 +8177,12 @@ var dumpReferenceMaterial = function(m) {
     out += dumpSourceRefAsRef(s, "  ", escapeString);
   }
   out += dumpRefs(m.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    m.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   if (m.identityFields.length > 0) {
     out += "  identity_fields {\n";
     for (const f of m.identityFields) {
@@ -8152,8 +8371,12 @@ var parseConstraint = function(id, data) {
         (result.refs ??= []).push(rr.ref);
       }
       i = rr.next;
+    } else if (keyword === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else {
-      i++;
+      i = skipUnknownValue(t, i, keyword);
     }
   }
   return (ctx) => {
@@ -8179,6 +8402,12 @@ var dumpConstraint = function(c) {
   if (c.source && (c.source.doc || c.source.clause)) {
     out += '  source { doc "' + escapeString(c.source.doc) + '" clause "' + escapeString(c.source.clause) + '"' + (c.source.fragment ? ' fragment "' + escapeString(c.source.fragment) + '"' : "") + " }\n";
   }
+  out += dumpCorrespondences(
+    c.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -8364,6 +8593,10 @@ var parseTestPointSet = function(id, data) {
         if (!foldRefIntoLegacy(result, r)) {
           (result.refs ??= []).push(r);
         }
+      } else if (keyword === "corresponds") {
+        (result.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
       } else if (keyword === "cardinality") {
         result.cardinality = parseCardinality(unwrapBlock(value()));
       } else if (keyword === "repetitions_per_point") {
@@ -8392,6 +8625,12 @@ var dumpTestPointSet = function(s) {
     out += dumpSourceRefAsRef(src, "  ", escapeString);
   }
   out += dumpRefs(s.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    s.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   const ckeys = Object.keys(s.cardinality);
   if (ckeys.length > 0) {
     out += "  cardinality {\n";
@@ -8697,6 +8936,10 @@ var parseRequirement = function(id, data) {
         (result.refs ??= []).push(r.ref);
       }
       i = r.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
@@ -8841,6 +9084,12 @@ var dumpRequirement = function(r) {
   for (const ref of r.refs ?? []) {
     out += "  ref " + ref.predicate + ' "' + escapeString(ref.target) + '"' + (ref.note ? ' { note "' + escapeString(ref.note) + '" }' : "") + "\n";
   }
+  out += dumpCorrespondences(
+    r.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -9024,6 +9273,10 @@ var parsePackage = function(data) {
         (manifest.refs ??= []).push(r.ref);
       }
       i = r.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (manifest.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else if (cmd === "scheme_type" || cmd === "schemeType") {
       manifest.schemeType = stripWrapping(t[i++]);
     } else if (cmd === "provides") {
@@ -9728,6 +9981,10 @@ var parseInstrument = function(id, data) {
         (result.refs ??= []).push(rr.ref);
       }
       i = rr.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
@@ -10230,6 +10487,12 @@ var dumpInstrument = function(inst) {
     out += dumpSourceRefAsRef(s, "  ", escapeString);
   }
   out += dumpRefs(inst.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    inst.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += dumpIdList("reference", inst.referenceIds, "  ");
   out += "}\n";
   return out;
@@ -10302,6 +10565,10 @@ var parseAttributeDefinition = function(id, data) {
         (result.refs ??= []).push(rr.ref);
       }
       i = rr.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
@@ -10327,6 +10594,12 @@ var dumpAttributeDefinition = function(a) {
     out += dumpSourceRefAsRef(s, "  ", escapeString);
   }
   out += dumpRefs(a.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    a.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   if (a.quantityKind) {
     out += "  quantity_kind " + a.quantityKind + "\n";
   }
@@ -10404,6 +10677,10 @@ var parseCapability = function(id, data) {
         (result.refs ??= []).push(rr.ref);
       }
       i = rr.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
@@ -10431,6 +10708,12 @@ var dumpCapability = function(c) {
   out += dumpIdList("verified_by_tests", c.verifiedByTests, "  ");
   out += dumpIdList("reference", c.referenceIds, "  ");
   out += dumpRefs(c.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    c.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -10471,6 +10754,10 @@ var parseBehavior = function(id, data) {
         (result.refs ??= []).push(rr.ref);
       }
       i = rr.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
@@ -10496,6 +10783,12 @@ var dumpBehavior = function(b) {
     out += dumpSourceRefAsRef(s, "  ", escapeString);
   }
   out += dumpRefs(b.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    b.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += dumpIdList("verified_by", b.verifiedBy, "  ");
   out += "}\n";
   return out;
@@ -10548,6 +10841,10 @@ var parseConditionSet = function(id, data) {
       } else {
         (result.refs ??= []).push(rr.ref);
       }
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else if (cmd === "reference") {
       result.referenceIds = readReference(t[i++]);
     } else {
@@ -10634,6 +10931,12 @@ var dumpConditionSet = function(cs) {
   }
   out += dumpIdList("reference", cs.referenceIds, "  ");
   out += dumpRefs(cs.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    cs.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -11629,6 +11932,10 @@ var parseArtifactDefinition = function(id, data) {
         (result.refs ??= []).push(rr.ref);
       }
       i = rr.next;
+    } else if (cmd === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      (result.correspondences ??= []).push(cc.corr);
+      i = cc.next;
     } else {
       i = skipUnknownValue(t, i, cmd);
     }
@@ -11696,6 +12003,12 @@ var dumpArtifactDefinition = function(d) {
     out += dumpSourceRefAsRef(s, "  ", escapeString);
   }
   out += dumpRefs(d.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    d.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += dumpIdList2("reference", d.referenceIds, "  ");
   out += "}\n";
   return out;
@@ -12287,6 +12600,10 @@ var parseTestSequence = function(id, data) {
         sequence.refs = [...sequence.refs ?? [], rr.ref];
       }
       i = rr.next;
+    } else if (command === "corresponds") {
+      const cc = parseCorresponds(t, i, stripWrapping);
+      sequence.correspondences = [...sequence.correspondences ?? [], cc.corr];
+      i = cc.next;
     } else if (command === "source") {
       sequence.sourceRefs.push(readSource(unwrapBlock(t[i++])));
     } else if (command === "step") {
@@ -12348,6 +12665,12 @@ var dumpTestSequence = function(seq) {
   for (const src of seq.sourceRefs) {
     out += dumpSourceRefAsRef(src, "  ", escapeString);
   }
+  out += dumpCorrespondences(
+    seq.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -12382,6 +12705,10 @@ var parseFormulasUsed = function(id, data) {
         if (!foldRefIntoLegacy(trace, r)) {
           (trace.refs ??= []).push(r);
         }
+      } else if (command === "corresponds") {
+        (trace.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
       } else if (command === "source") {
         trace.sourceRefs.push(readSource(unwrapBlock(value())));
       } else {
@@ -12413,6 +12740,12 @@ var dumpFormulasUsed = function(fu) {
   for (const src of fu.sourceRefs) {
     out += dumpSourceRefAsRef(src, "  ", escapeString);
   }
+  out += dumpCorrespondences(
+    fu.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
   out += "}\n";
   return out;
 };
@@ -12705,6 +13038,392 @@ var dualConstruct = {
   dump: dumpDual
 };
 
+// src/ser-des/config/trustRef.ts
+function parseTrustRefFromReaders(value, peek, stripWrapping2) {
+  const ref = { org: stripWrapping2(value()), kid: "" };
+  if (peek() === "key") {
+    value();
+    ref.kid = stripWrapping2(value());
+  }
+  return ref;
+}
+function dumpTrustRef(ref, indent, dumpBareSafe2) {
+  let out = `${indent}trust_ref ${dumpBareSafe2(ref.org)}`;
+  if (ref.kid !== "") {
+    out += ` key ${dumpBareSafe2(ref.kid)}`;
+  }
+  return out + "\n";
+}
+
+// src/ser-des/config/dataspace.ts
+var parseDataspace = function(id, data) {
+  const ds = {
+    id,
+    name: "",
+    description: "",
+    participantClasses: [],
+    artifactClasses: [],
+    policies: [],
+    defaultPolicy: "",
+    trustAnchors: [],
+    compatibleWith: [],
+    source: null,
+    sourceRefs: []
+  };
+  forEachEntry(
+    data,
+    (command, value, peek) => {
+      if (command === "name") {
+        ds.name = unwrapped(value);
+      } else if (command === "description") {
+        ds.description = unwrapped(value);
+      } else if (command === "participant_class") {
+        const pc = {
+          id: stripWrapping(value()),
+          label: "",
+          description: ""
+        };
+        const next = peek();
+        if (next && next.startsWith("{")) {
+          forEachEntry(
+            unwrapBlock(value()),
+            (facet, facetValue) => {
+              if (facet === "label") {
+                pc.label = unwrapped(facetValue);
+              } else if (facet === "description") {
+                pc.description = unwrapped(facetValue);
+              } else {
+                return false;
+              }
+              return true;
+            },
+            { construct: "dataspace.participant_class", id: pc.id }
+          );
+        }
+        ds.participantClasses.push(pc);
+      } else if (command === "artifact_class") {
+        const ac = {
+          id: stripWrapping(value()),
+          label: "",
+          description: "",
+          element: "",
+          policy: ""
+        };
+        const next = peek();
+        if (next && next.startsWith("{")) {
+          forEachEntry(
+            unwrapBlock(value()),
+            (facet, facetValue) => {
+              if (facet === "label") {
+                ac.label = unwrapped(facetValue);
+              } else if (facet === "description") {
+                ac.description = unwrapped(facetValue);
+              } else if (facet === "element") {
+                ac.element = stripWrapping(facetValue());
+              } else if (facet === "policy") {
+                ac.policy = stripWrapping(facetValue());
+              } else {
+                return false;
+              }
+              return true;
+            },
+            { construct: "dataspace.artifact_class", id: ac.id }
+          );
+        }
+        ds.artifactClasses.push(ac);
+      } else if (command === "policies") {
+        ds.policies = readEntryTokens(value());
+      } else if (command === "default_policy") {
+        ds.defaultPolicy = stripWrapping(value());
+      } else if (command === "trust_anchor") {
+        const ta = {
+          id: stripWrapping(value()),
+          trustRef: null,
+          role: "",
+          description: ""
+        };
+        const next = peek();
+        if (next && next.startsWith("{")) {
+          forEachEntry(
+            unwrapBlock(value()),
+            (facet, facetValue, facetPeek) => {
+              if (facet === "trust_ref") {
+                ta.trustRef = parseTrustRefFromReaders(
+                  facetValue,
+                  facetPeek,
+                  stripWrapping
+                );
+              } else if (facet === "role") {
+                ta.role = stripWrapping(facetValue());
+              } else if (facet === "description") {
+                ta.description = unwrapped(facetValue);
+              } else {
+                return false;
+              }
+              return true;
+            },
+            { construct: "dataspace.trust_anchor", id: ta.id }
+          );
+        }
+        ds.trustAnchors.push(ta);
+      } else if (command === "compatible_with") {
+        ds.compatibleWith = readEntryTokens(value());
+      } else if (command === "source") {
+        const src = readSource(unwrapBlock(value()));
+        ds.sourceRefs.push(src);
+        if (!ds.source) {
+          ds.source = src;
+        }
+      } else if (command === "ref") {
+        const r = parseRefFromReaders(value, peek, stripWrapping, unwrapBlock);
+        if (!foldRefIntoLegacy(ds, r)) {
+          (ds.refs ??= []).push(r);
+        }
+      } else if (command === "corresponds") {
+        (ds.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "dataspace", id }
+  );
+  return (ctx) => {
+    ctx.dataspaces[id] = ds;
+    return ctx;
+  };
+};
+var dumpDataspace = function(d) {
+  let out = "dataspace " + d.id + " {\n";
+  if (d.name) {
+    out += '  name "' + escapeString(d.name) + '"\n';
+  }
+  if (d.description) {
+    out += '  description "' + escapeString(d.description) + '"\n';
+  }
+  for (const pc of d.participantClasses) {
+    out += "  participant_class " + dumpBareSafe(pc.id) + " {\n";
+    if (pc.label) {
+      out += '    label "' + escapeString(pc.label) + '"\n';
+    }
+    if (pc.description) {
+      out += '    description "' + escapeString(pc.description) + '"\n';
+    }
+    out += "  }\n";
+  }
+  for (const ac of d.artifactClasses) {
+    out += "  artifact_class " + dumpBareSafe(ac.id) + " {\n";
+    if (ac.label) {
+      out += '    label "' + escapeString(ac.label) + '"\n';
+    }
+    if (ac.description) {
+      out += '    description "' + escapeString(ac.description) + '"\n';
+    }
+    if (ac.element) {
+      out += "    element " + dumpBareSafe(ac.element) + "\n";
+    }
+    if (ac.policy) {
+      out += "    policy " + dumpBareSafe(ac.policy) + "\n";
+    }
+    out += "  }\n";
+  }
+  if (d.policies.length > 0) {
+    out += "  policies { " + d.policies.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  if (d.defaultPolicy) {
+    out += "  default_policy " + dumpBareSafe(d.defaultPolicy) + "\n";
+  }
+  for (const ta of d.trustAnchors) {
+    out += "  trust_anchor " + dumpBareSafe(ta.id) + " {\n";
+    if (ta.trustRef) {
+      out += dumpTrustRef(ta.trustRef, "    ", dumpBareSafe);
+    }
+    if (ta.role) {
+      out += "    role " + dumpBareSafe(ta.role) + "\n";
+    }
+    if (ta.description) {
+      out += '    description "' + escapeString(ta.description) + '"\n';
+    }
+    out += "  }\n";
+  }
+  if (d.compatibleWith.length > 0) {
+    out += "  compatible_with { " + d.compatibleWith.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  const sources = d.sourceRefs && d.sourceRefs.length > 0 ? d.sourceRefs : d.source ? [d.source] : [];
+  for (const s of sources) {
+    out += dumpSourceRefAsRef(s, "  ", escapeString);
+  }
+  out += dumpRefs(d.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    d.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
+  out += "}\n";
+  return out;
+};
+var dataspaceConstruct = {
+  keyword: "dataspace",
+  field: "dataspaces",
+  takesID: true,
+  parse: parseDataspace,
+  dump: dumpDataspace
+};
+
+// src/types/Policy.ts
+var POLICY_RULE_KINDS = [
+  "permission",
+  "obligation",
+  "prohibition"
+];
+
+// src/ser-des/config/policy.ts
+var parsePolicy = function(id, data) {
+  const policy = {
+    id,
+    name: "",
+    description: "",
+    governs: [],
+    defaultPosture: null,
+    rules: [],
+    source: null,
+    sourceRefs: []
+  };
+  forEachEntry(
+    data,
+    (command, value, peek) => {
+      if (command === "name") {
+        policy.name = unwrapped(value);
+      } else if (command === "description") {
+        policy.description = unwrapped(value);
+      } else if (command === "governs") {
+        policy.governs = readEntryTokens(value());
+      } else if (command === "default_posture") {
+        const v = stripWrapping(value());
+        if (v !== "true" && v !== "false") {
+          throw new Error(
+            `Parsing error: policy. ID ${id}: default_posture is true | false, got "${v}"`
+          );
+        }
+        policy.defaultPosture = v === "true";
+      } else if (command === "rule") {
+        const rule = {
+          id: stripWrapping(value()),
+          kind: "",
+          action: "",
+          artifact: "",
+          constraints: []
+        };
+        const next = peek();
+        if (next && next.startsWith("{")) {
+          forEachEntry(
+            unwrapBlock(value()),
+            (facet, facetValue) => {
+              if (facet === "kind") {
+                const k = stripWrapping(facetValue());
+                if (!POLICY_RULE_KINDS.includes(k)) {
+                  throw new Error(
+                    `Parsing error: policy.rule. ID ${rule.id}: unknown rule kind "${k}" \u2014 rule kinds are ${POLICY_RULE_KINDS.join(" | ")} (fail-closed: a misspelt kind never parses into a rule that says nothing)`
+                  );
+                }
+                rule.kind = k;
+              } else if (facet === "action") {
+                rule.action = stripWrapping(facetValue());
+              } else if (facet === "artifact") {
+                rule.artifact = stripWrapping(facetValue());
+              } else if (facet === "constraint") {
+                rule.constraints.push(unwrapped(facetValue));
+              } else {
+                return false;
+              }
+              return true;
+            },
+            { construct: "policy.rule", id: rule.id }
+          );
+        }
+        policy.rules.push(rule);
+      } else if (command === "source") {
+        const src = readSource(unwrapBlock(value()));
+        policy.sourceRefs.push(src);
+        if (!policy.source) {
+          policy.source = src;
+        }
+      } else if (command === "ref") {
+        const r = parseRefFromReaders(value, peek, stripWrapping, unwrapBlock);
+        if (!foldRefIntoLegacy(policy, r)) {
+          (policy.refs ??= []).push(r);
+        }
+      } else if (command === "corresponds") {
+        (policy.correspondences ??= []).push(
+          parseCorrespondsFromReaders(value, peek, stripWrapping)
+        );
+      } else {
+        return false;
+      }
+      return true;
+    },
+    { construct: "policy", id }
+  );
+  return (ctx) => {
+    ctx.policies[id] = policy;
+    return ctx;
+  };
+};
+var dumpPolicy = function(p) {
+  let out = "policy " + p.id + " {\n";
+  if (p.name) {
+    out += '  name "' + escapeString(p.name) + '"\n';
+  }
+  if (p.description) {
+    out += '  description "' + escapeString(p.description) + '"\n';
+  }
+  if (p.defaultPosture !== null) {
+    out += "  default_posture " + (p.defaultPosture ? "true" : "false") + "\n";
+  }
+  if (p.governs.length > 0) {
+    out += "  governs { " + p.governs.map(dumpBareSafe).join(" ") + " }\n";
+  }
+  for (const r of p.rules) {
+    out += "  rule " + dumpBareSafe(r.id) + " {\n";
+    if (r.kind) {
+      out += "    kind " + r.kind + "\n";
+    }
+    if (r.action) {
+      out += "    action " + dumpBareSafe(r.action) + "\n";
+    }
+    if (r.artifact) {
+      out += "    artifact " + dumpBareSafe(r.artifact) + "\n";
+    }
+    for (const c of r.constraints) {
+      out += '    constraint "' + escapeString(c) + '"\n';
+    }
+    out += "  }\n";
+  }
+  const sources = p.sourceRefs && p.sourceRefs.length > 0 ? p.sourceRefs : p.source ? [p.source] : [];
+  for (const s of sources) {
+    out += dumpSourceRefAsRef(s, "  ", escapeString);
+  }
+  out += dumpRefs(p.refs, "  ", escapeString);
+  out += dumpCorrespondences(
+    p.correspondences,
+    "  ",
+    escapeString,
+    dumpBareSafe
+  );
+  out += "}\n";
+  return out;
+};
+var policyConstruct = {
+  keyword: "policy",
+  field: "policies",
+  takesID: true,
+  parse: parsePolicy,
+  dump: dumpPolicy
+};
+
 // src/ser-des/config/activityArchetype.ts
 var parseActivityArchetype = (id, data) => {
   const archetype = {
@@ -13114,7 +13833,15 @@ var CONSTRUCTS = [
     takesID: true,
     parse: parseText,
     dump: dumpText
-  })
+  }),
+  // Primmel v3.1 dataspace + trust (TODO.primmel/10; MN 114 clause 19):
+  // the dataspace definition as a model object, and the usage-policy set
+  // in Primmel's own policy grammar (ODRL is a codec output, never an
+  // import). The trust_ref form and the corresponds facet are shared
+  // sub-structures (config/trustRef.ts, config/correspondence.ts), not
+  // top-level constructs.
+  dataspaceConstruct,
+  policyConstruct
 ];
 function buildParserConfig(constructs) {
   const out = {};
@@ -15964,6 +16691,63 @@ var CHECK_RULES = [
     "error",
     "normal",
     "docs/primmel/18 \xA718.6 (the unified reference/relation construct)"
+  ),
+  // ── 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),
+  // the trust_ref form (opaque addressing — the checker verifies shape,
+  // NEVER resolution: the trust plane's membership is runtime fact), and
+  // the generalized corresponds annotations. C104: the dataspace's
+  // references resolve (policy register, default policy, per-class
+  // overrides, content elements, the compatibility register). C105:
+  // every trust anchor carries its trust_ref with an organization
+  // identifier. C106: a dataspace with no governance citation warns (an
+  // orphan definition). C107: the policy shape — at least one rule,
+  // every rule with its action, rule artifacts inside the governs
+  // register, governed classes resolving, at most one default-posture
+  // policy per class. C108: one corresponds entry per scheme per
+  // element (an error — the bridges read unambiguous mappings), and the
+  // irdi legacy spelling agreeing with `corresponds iec-cdd` (a warning
+  // leg).
+  R(
+    "C104",
+    "dataspace-references-resolve",
+    "dataspace",
+    "error",
+    "normal",
+    "TODO.primmel/10, MN 114 clause 19.1"
+  ),
+  R(
+    "C105",
+    "dataspace-trust-anchor-shape",
+    "dataspace",
+    "error",
+    "normal",
+    "TODO.primmel/10, MN 114 clauses 19.1/19.3"
+  ),
+  R(
+    "C106",
+    "dataspace-governance-provenance",
+    "dataspace",
+    "warning",
+    "normal",
+    "TODO.primmel/10, MN 114 clause 19.1"
+  ),
+  R(
+    "C107",
+    "policy-shape",
+    "dataspace",
+    "error",
+    "normal",
+    "TODO.primmel/10, MN 114 clause 19.2"
+  ),
+  R(
+    "C108",
+    "correspondence-shape",
+    "dataspace",
+    "error",
+    "normal",
+    "TODO.primmel/10, MN 114 clause 19.4"
   )
 ];
 var byId = new Map(CHECK_RULES.map((r) => [r.id, r]));
@@ -20023,6 +20807,230 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  {
+    const dataspaces = standard.dataspaces ?? [];
+    const policies = standard.policies ?? [];
+    const policyIds = new Set(policies.map((p) => p.id));
+    const dataspaceIds = new Set(dataspaces.map((d) => d.id));
+    const artifactClassIds = /* @__PURE__ */ new Set();
+    for (const d of dataspaces) {
+      for (const ac of d.artifactClasses) {
+        artifactClassIds.add(ac.id);
+      }
+    }
+    const elementIds = /* @__PURE__ */ new Set([
+      ...(standard.artifactDefinitions ?? []).map((a) => a.id),
+      ...(standard.forms ?? []).map((f) => f.id),
+      ...(standard.dataclasses ?? []).map((c) => c.id)
+    ]);
+    for (const d of dataspaces) {
+      for (const pid of d.policies) {
+        if (!policyIds.has(pid)) {
+          err(
+            "C104",
+            `dataspace ${d.id}: policies entry "${pid}" declares no policy of that id \u2014 the dataspace's policy register references declared policy constructs (dataspace-references-resolve)`
+          );
+        }
+      }
+      if (d.defaultPolicy !== "") {
+        if (!policyIds.has(d.defaultPolicy)) {
+          err(
+            "C104",
+            `dataspace ${d.id}: default_policy "${d.defaultPolicy}" declares no policy of that id \u2014 the standing default is a declared policy (dataspace-references-resolve)`
+          );
+        } else if (!d.policies.includes(d.defaultPolicy)) {
+          err(
+            "C104",
+            `dataspace ${d.id}: default_policy "${d.defaultPolicy}" is not in the dataspace's policies register \u2014 the default is one of the policy sets the dataspace carries (dataspace-references-resolve)`
+          );
+        }
+      }
+      for (const ac of d.artifactClasses) {
+        if (ac.policy !== "") {
+          if (!policyIds.has(ac.policy)) {
+            err(
+              "C104",
+              `dataspace ${d.id}: artifact class "${ac.id}" overrides with policy "${ac.policy}", which declares no policy of that id (dataspace-references-resolve)`
+            );
+          } else if (!d.policies.includes(ac.policy)) {
+            err(
+              "C104",
+              `dataspace ${d.id}: artifact class "${ac.id}" overrides with policy "${ac.policy}", which the dataspace's policies register does not carry \u2014 an override names a policy set the dataspace carries (dataspace-references-resolve)`
+            );
+          }
+        }
+        if (ac.element !== "" && !elementIds.has(ac.element)) {
+          err(
+            "C104",
+            `dataspace ${d.id}: artifact class "${ac.id}" declares element "${ac.element}", which names no declared artifact definition, form, or data class \u2014 the class's content definition must resolve (dataspace-references-resolve)`
+          );
+        }
+      }
+      for (const compat of d.compatibleWith) {
+        if (!dataspaceIds.has(compat)) {
+          err(
+            "C104",
+            `dataspace ${d.id}: compatible_with entry "${compat}" declares no dataspace of that id \u2014 compatibility is explicit and resolved (dataspace-references-resolve)`
+          );
+        } else if (compat === d.id) {
+          err(
+            "C104",
+            `dataspace ${d.id}: compatible_with names the dataspace itself \u2014 compatibility relates two dataspaces (dataspace-references-resolve)`
+          );
+        }
+      }
+      for (const ta of d.trustAnchors) {
+        if (!ta.trustRef || ta.trustRef.org === "") {
+          err(
+            "C105",
+            `dataspace ${d.id}: trust anchor "${ta.id}" declares no trust_ref with an organization identifier \u2014 an anchor without its trust reference anchors nothing (dataspace-trust-anchor-shape)`
+          );
+        }
+      }
+      const hasGovernance = (d.sourceRefs?.length ?? 0) > 0 || d.source && (d.source.doc || d.source.clause);
+      if (!hasGovernance) {
+        warn(
+          "C106",
+          `dataspace ${d.id}: the dataspace cites no governance clause \u2014 the definition's charter is its clause-cited provenance (ref derives-from); an orphan definition is a warning, never silent (dataspace-governance-provenance)`
+        );
+      }
+    }
+    for (const p of policies) {
+      if (p.rules.length === 0) {
+        err(
+          "C107",
+          `policy ${p.id}: a policy declares at least one rule \u2014 a rule-less set says nothing (policy-shape)`
+        );
+      }
+      for (const g of p.governs) {
+        if (!artifactClassIds.has(g)) {
+          err(
+            "C107",
+            `policy ${p.id}: governs entry "${g}" names no artifact class declared by the merged model's dataspaces \u2014 the governed classes resolve (policy-shape)`
+          );
+        }
+      }
+      for (const r of p.rules) {
+        if (r.action === "") {
+          err(
+            "C107",
+            `policy ${p.id}: rule "${r.id}" declares no action \u2014 a rule without its action says nothing (policy-shape)`
+          );
+        }
+        if (r.artifact !== "") {
+          if (p.governs.length > 0 && !p.governs.includes(r.artifact)) {
+            err(
+              "C107",
+              `policy ${p.id}: rule "${r.id}" constrains artifact class "${r.artifact}", which is not in the policy's governs register \u2014 a rule stays inside the register, or drops the facet to cover every governed class (policy-shape)`
+            );
+          }
+          if (!artifactClassIds.has(r.artifact)) {
+            err(
+              "C107",
+              `policy ${p.id}: rule "${r.id}" constrains artifact class "${r.artifact}", which no dataspace of the merged model declares (policy-shape)`
+            );
+          }
+        }
+      }
+    }
+    const postureByClass = /* @__PURE__ */ new Map();
+    for (const p of policies) {
+      if (p.defaultPosture !== true) {
+        continue;
+      }
+      for (const g of p.governs) {
+        postureByClass.set(g, [...postureByClass.get(g) ?? [], p.id]);
+      }
+    }
+    for (const [cls, ids] of postureByClass) {
+      if (ids.length > 1) {
+        err(
+          "C107",
+          `artifact class "${cls}" is governed by ${ids.length} default-posture policies (${ids.join(", ")}) \u2014 the standing default is one policy per class; the rest attach by explicit reference (policy-shape)`
+        );
+      }
+    }
+    const corrElements = [];
+    const collect = (kind, items) => {
+      for (const it of items ?? []) {
+        if (it.correspondences && it.correspondences.length > 0) {
+          corrElements.push({ kind, id: it.id, corrs: it.correspondences });
+        }
+      }
+    };
+    collect("dataspace", dataspaces);
+    collect("policy", policies);
+    collect("instrument", standard.instruments ?? []);
+    collect("attribute_definition", standard.attributeDefinitions ?? []);
+    collect("capability", standard.capabilities ?? []);
+    collect("behavior", standard.behaviors ?? []);
+    collect("condition_set", standard.conditionSets ?? []);
+    collect("requirement", standard.requirements ?? []);
+    collect("conformance_test", standard.conformanceTests ?? []);
+    collect("form", standard.forms ?? []);
+    collect("table", standard.tables ?? []);
+    collect("symbol", standard.symbols ?? []);
+    collect("calculation", standard.calculations ?? []);
+    collect("term", standard.terms ?? []);
+    collect("artifact_definition", standard.artifactDefinitions ?? []);
+    collect("verdict", standard.verdicts ?? []);
+    collect("reference_material", standard.referenceMaterials ?? []);
+    collect("test_point_set", standard.testPointSets ?? []);
+    collect("competence_kind", standard.competenceKinds ?? []);
+    collect("constraint", standard.constraints ?? []);
+    collect("test_sequence", standard.testSequences ?? []);
+    collect("formulas_used", standard.formulasUsed ?? []);
+    collect("process", standard.processes ?? []);
+    for (const f of standard.forms ?? []) {
+      for (const fld of f.fields ?? []) {
+        if (fld.correspondences && fld.correspondences.length > 0) {
+          corrElements.push({
+            kind: "field",
+            id: `${f.id}.${fld.name}`,
+            corrs: fld.correspondences
+          });
+        }
+      }
+    }
+    if (standard.packageManifest?.correspondences?.length) {
+      corrElements.push({
+        kind: "package",
+        id: standard.packageManifest.id,
+        corrs: standard.packageManifest.correspondences
+      });
+    }
+    for (const el of corrElements) {
+      const byScheme = /* @__PURE__ */ new Map();
+      for (const c of el.corrs) {
+        byScheme.set(c.scheme, (byScheme.get(c.scheme) ?? 0) + 1);
+        if (c.scheme === "" || c.concept === "") {
+          err(
+            "C108",
+            `${el.kind} ${el.id}: a corresponds entry carries an empty scheme or concept \u2014 the entry names its scheme and the scheme's concept identifier (correspondence-shape)`
+          );
+        }
+      }
+      for (const [scheme, n] of byScheme) {
+        if (n > 1) {
+          err(
+            "C108",
+            `${el.kind} ${el.id}: ${n} corresponds entries name scheme "${scheme}" \u2014 one element has at most one correspondence per scheme, so every bridge reads an unambiguous mapping (correspondence-shape)`
+          );
+        }
+      }
+    }
+    for (const a of standard.attributeDefinitions ?? []) {
+      if (a.irdi && a.irdi !== "") {
+        const cdd = (a.correspondences ?? []).find((c) => c.scheme === "iec-cdd");
+        if (cdd && cdd.concept !== a.irdi) {
+          warn(
+            "C108",
+            `attribute_definition ${a.id}: irdi "${a.irdi}" disagrees with corresponds iec-cdd "${cdd.concept}" \u2014 the legacy single-scheme spelling and the generalized annotation name the same concept, or the irdi facet retires (correspondence-shape)`
+          );
+        }
+      }
+    }
+  }
   const level = strictness === "audit" ? "audit" : "normal";
   const { allowlist, issues: allowlistParseIssues } = loadAllowlist(dir);
   issues.push(...allowlistParseIssues);