@shapeshift-labs/frontier-lang-parser 0.3.20 → 0.3.21

package/README.md

@@ -271,6 +271,27 @@ resourceGraph TodoResources @id("resource_graph_todo") {
 
 The parser projects these rows into `metadata.semanticResourceGraphs`. Resource graphs are evidence, not proof: generated claims for borrow-checker soundness, alias safety, lifetime soundness, semantic equivalence, and auto-merge stay false. Compiler conversion routes can use these authored graphs as source-side resource, ownership, lifetime, and borrow-checker evidence while still requiring target proof before admission.
 
+## Authored interlingua syntax
+
+`.frontier` files can carry universal interlingua route evidence directly in `interlingua` or `universalInterlingua` blocks. These blocks describe the source lift, represented and missing semantic layers, constraint edges, proof obligations, and target lowering disposition for a route without claiming semantic equivalence.
+
+```frontier
+interlingua JsToRust @id("interlingua_js_rust") {
+  route conversion_route_javascript_to_rust
+  sourceLanguage javascript
+  target rust
+  mode target-adapter
+  lift source @id("lift_js") sourceImport native_import_js sourcePath src/public-api.js sourceHash sha256:source sourceMap source_map_js ownership symbol:displayName conflict symbol:displayName evidence evidence_translation proof proof_translation
+  layer symbols @id("layer_symbols") kind semantic-symbol status represented evidence evidence_translation
+  layer ownership @id("layer_ownership") kind semantic-ownership status missing missingEvidence translation-borrow-scope:borrow-across-await
+  constraint borrowAwait @id("constraint_borrow_await") family borrow-scope layer semantic-ownership status needs-evidence action collect-borrow-scope required shared-borrow-compatible|borrow-across-await represented shared-borrow-compatible missing borrow-across-await missingEvidence translation-borrow-scope:borrow-across-await evidence evidence_borrow_scope obligation obligation_borrow_await
+  obligation borrowAwait @id("obligation_borrow_await") edge constraint_borrow_await family borrow-scope kind borrow-across-await status missing missingEvidence translation-borrow-scope:borrow-across-await evidence evidence_borrow_scope
+  lowering rustAdapter @id("lowering_rust_adapter") disposition target-adapter adapter fixture-js-rust adapterKind targetProjection readiness needs-review lossClass targetAdapterProjection proofEvidence proof_translation missingEvidence host-target-adapter-review review adapter-review
+}
+```
+
+The parser projects these rows into `metadata.universalInterlingua`. Interlingua records are route evidence: they expose queryable layer kinds, constraint families, obligation kinds/statuses, lowering disposition, proof ids, and missing evidence while keeping `autoMergeClaim` and `semanticEquivalenceClaim` false. The compiler can merge matching authored records into generated conversion routes by route id or source/target.
+
 ## Authored conversion syntax
 
 `.frontier` files can carry universal conversion evidence directly in `conversion` or `universalConversionPlan` blocks. The parser projects these records into `metadata.universalConversionPlan` for the compiler facade and downstream semantic merge tooling.

package/dist/index.js

@@ -2,6 +2,7 @@ import { actionNode, capabilityNode, createDocument, effectNode, entityNode, ext
 import { parseConstraintSpaceBlock } from './constraint-space.js';
 import { parseConversionBlock } from './conversion.js';
 import { parseDecisionGraphBlock } from './decision-graph.js';
+import { parseInterlinguaBlock } from './interlingua.js';
 import { createParsedMetadata } from './metadata.js';
 import { parseSemanticOperationsBlock } from './operations.js';
 import { parseParadigmBlock } from './paradigm.js';
@@ -18,6 +19,7 @@ export function parseFrontierSource(source, options = {}) {
   const conversionBlocks = [];
   const constraintSpaceBlocks = [];
   const decisionGraphBlocks = [];
+  const interlinguaBlocks = [];
   const resourceGraphBlocks = [];
   const nativeSourceBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
@@ -45,9 +47,10 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') conversionBlocks.push(parseConversionBlock(block));
     if (block.kind === 'constraintSpace' || block.kind === 'possibilitySpace') constraintSpaceBlocks.push(parseConstraintSpaceBlock(block));
     if (block.kind === 'decisionGraph' || block.kind === 'admissionGraph') decisionGraphBlocks.push(parseDecisionGraphBlock(block));
+    if (block.kind === 'interlingua' || block.kind === 'universalInterlingua') interlinguaBlocks.push(parseInterlinguaBlock(block));
     if (block.kind === 'resourceGraph' || block.kind === 'semanticResourceGraph') resourceGraphBlocks.push(parseResourceGraphBlock(block));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, resourceGraphBlocks, nativeSourceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -57,7 +60,7 @@ function readName(source) { return /module\s+([A-Za-z_$][\w$]*)/.exec(source)?.[
 function readId(source) { return /module\s+[A-Za-z_$][\w$]*\s+@id\(\s*["']([^"']+)["']\s*\)/.exec(source)?.[1]; }
 function readBlocks(source) {
   const blocks = [];
-  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations|conversion|universalConversionPlan|constraintSpace|possibilitySpace|decisionGraph|admissionGraph|resourceGraph|semanticResourceGraph)\s+([^{}]+)\{/g;
+  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations|conversion|universalConversionPlan|constraintSpace|possibilitySpace|decisionGraph|admissionGraph|interlingua|universalInterlingua|resourceGraph|semanticResourceGraph)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/interlingua.js

@@ -0,0 +1,240 @@
+const GROUPS = {
+  layer: 'layerRecords',
+  constraint: 'constraintEdges',
+  edge: 'constraintEdges',
+  obligation: 'obligations',
+  proofObligation: 'obligations',
+  lowering: 'loweringRecords',
+  lift: 'liftRecords',
+  evidence: 'evidenceRecords'
+};
+
+export function parseInterlinguaBlock(block) {
+  const name = nameFrom(block.header);
+  const record = {
+    kind: 'frontier.lang.universalInterlinguaRecord',
+    version: 1,
+    id: idFrom(block.header, `interlingua_${name}`),
+    routeId: readLine('route', block.body) ?? readLine('routeId', block.body),
+    sourceLanguage: readLine('sourceLanguage', block.body) ?? readLine('source', block.body),
+    target: readLine('target', block.body),
+    mode: readLine('mode', block.body),
+    layerRecords: [],
+    constraintEdges: [],
+    obligations: [],
+    loweringRecords: [],
+    liftRecords: [],
+    evidenceRecords: [],
+    claims: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    },
+    metadata: { name, authoredFrontierInterlingua: true }
+  };
+
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || isPropertyLine(line)) continue;
+    const match = /^([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, rowKind, rowName, rest] = match;
+    const normalized = normalizeRowKind(rowKind);
+    const parsed = parseInterlinguaRow(normalized, rowName, rest, record);
+    const group = GROUPS[normalized];
+    if (parsed && group) record[group].push(parsed);
+  }
+
+  record.lift = summarizeLift(record);
+  record.layers = summarizeLayers(record.layerRecords, record.constraintEdges);
+  record.constraints = summarizeConstraints(record.constraintEdges, record.obligations);
+  record.lowering = summarizeLowering(record);
+  record.query = summarizeQuery(record);
+  record.summary = summarize(record);
+
+  return {
+    id: record.id,
+    record,
+    records: [record, ...record.constraintEdges, ...record.obligations, ...record.layerRecords, ...record.loweringRecords, ...record.liftRecords, ...record.evidenceRecords],
+    summary: {
+      recordCount: 1,
+      ...record.summary
+    },
+    metadata: { name }
+  };
+}
+
+function parseInterlinguaRow(kind, name, text, parent) {
+  const common = commonRecord(kind, name, text, parent);
+  if (kind === 'layer') return cleanRecord({ ...common, layerKind: readInlineWord('layerKind', text) ?? readInlineWord('kind', text) ?? name, status: readInlineWord('status', text) ?? 'represented', sourceIds: readInlineList(text, 'source', 'sourceId', 'sourceIds'), targetIds: readInlineList(text, 'target', 'targetId', 'targetIds'), missingEvidence: readInlineList(text, 'missingEvidence'), blockers: readInlineList(text, 'blocker', 'blockers'), review: readInlineList(text, 'review') });
+  if (kind === 'constraint') return cleanRecord({ ...common, family: readInlineWord('family', text) ?? readInlineWord('kind', text) ?? name, layerKind: readInlineWord('layer', text) ?? readInlineWord('layerKind', text), status: readInlineWord('status', text) ?? 'required', action: readInlineWord('action', text), sourceId: readInlineWord('source', text) ?? readInlineWord('sourceId', text), requiredKinds: readInlineList(text, 'required', 'requiredKind', 'requiredKinds'), representedKinds: readInlineList(text, 'represented', 'representedKind', 'representedKinds'), missingKinds: readInlineList(text, 'missing', 'missingKind', 'missingKinds'), missingEvidence: readInlineList(text, 'missingEvidence'), blockers: readInlineList(text, 'blocker', 'blockers'), review: readInlineList(text, 'review'), obligationIds: readInlineList(text, 'obligation', 'obligationId', 'obligationIds') });
+  if (kind === 'obligation') return cleanRecord({ ...common, edgeId: readInlineWord('edge', text) ?? readInlineWord('edgeId', text), family: readInlineWord('family', text), obligationKind: readInlineWord('obligationKind', text) ?? readInlineWord('kind', text) ?? name, status: readInlineWord('status', text) ?? 'required', sourceId: readInlineWord('source', text) ?? readInlineWord('sourceId', text), sourceNodeIds: readInlineList(text, 'sourceNode', 'sourceNodeIds'), targetNodeIds: readInlineList(text, 'targetNode', 'targetNodeIds'), missingEvidence: readInlineList(text, 'missingEvidence'), severity: readInlineWord('severity', text) });
+  if (kind === 'lowering') return cleanRecord({ ...common, disposition: readInlineWord('disposition', text) ?? readInlineWord('kind', text), adapterId: readInlineWord('adapter', text) ?? readInlineWord('adapterId', text), adapterKind: readInlineWord('adapterKind', text), readiness: readInlineWord('readiness', text), routeAction: readInlineWord('routeAction', text), lossClass: readInlineWord('lossClass', text), lossIds: readInlineList(text, 'loss', 'lossId', 'lossIds'), proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceIds'), missingEvidence: readInlineList(text, 'missingEvidence'), blockers: readInlineList(text, 'blocker', 'blockers'), review: readInlineList(text, 'review') });
+  if (kind === 'lift') return cleanRecord({ ...common, sourceImportIds: readInlineList(text, 'sourceImport', 'sourceImportId', 'sourceImportIds'), sourcePaths: readInlineList(text, 'sourcePath', 'sourcePaths', 'path', 'paths'), sourceHashes: readInlineList(text, 'sourceHash', 'sourceHashes'), sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMapId', 'sourceMapIds'), sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappingId', 'sourceMapMappingIds'), ownershipKeys: readInlineList(text, 'ownership', 'ownershipKey', 'ownershipKeys'), conflictKeys: readInlineList(text, 'conflict', 'conflictKey', 'conflictKeys'), proofIds: readInlineList(text, 'proof', 'proofId', 'proofIds') });
+  if (kind === 'evidence') return cleanRecord({ ...common, evidenceKind: readInlineWord('evidenceKind', text) ?? readInlineWord('kind', text), status: readInlineWord('status', text), path: readInlineWord('path', text), command: readInlineQuoted('command', text) ?? readInlineWord('command', text) });
+  return undefined;
+}
+
+function commonRecord(kind, name, text, parent) {
+  return cleanRecord({
+    id: idFrom(text, `${recordPrefix(kind)}_${name}`),
+    recordKind: `frontier.lang.universalInterlingua.${recordKind(kind)}`,
+    name,
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text) ?? parent.routeId,
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? parent.sourceLanguage,
+    target: readInlineWord('target', text) ?? parent.target,
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds'),
+    metadata: { authoredName: name }
+  });
+}
+
+function summarizeLift(record) {
+  return cleanRecord({
+    sourceLanguage: record.sourceLanguage,
+    sourceImportIds: unique(record.liftRecords.flatMap((entry) => entry.sourceImportIds ?? [])),
+    sourcePaths: unique(record.liftRecords.flatMap((entry) => entry.sourcePaths ?? [])),
+    sourceHashes: unique(record.liftRecords.flatMap((entry) => entry.sourceHashes ?? [])),
+    sourceMapIds: unique(record.liftRecords.flatMap((entry) => entry.sourceMapIds ?? [])),
+    sourceMapMappingIds: unique(record.liftRecords.flatMap((entry) => entry.sourceMapMappingIds ?? [])),
+    ownershipKeys: unique(record.liftRecords.flatMap((entry) => entry.ownershipKeys ?? [])),
+    conflictKeys: unique(record.liftRecords.flatMap((entry) => entry.conflictKeys ?? [])),
+    evidenceIds: unique(allEvidence(record)),
+    proofIds: unique(record.liftRecords.flatMap((entry) => entry.proofIds ?? []))
+  });
+}
+
+function summarizeLayers(layers, edges) {
+  const byStatus = (status) => unique(layers.filter((layer) => layer.status === status).map((layer) => layer.layerKind));
+  return {
+    kinds: unique([...layers.map((layer) => layer.layerKind), ...edges.map((edge) => edge.layerKind)]),
+    representedKinds: byStatus('represented'),
+    missingKinds: unique([...byStatus('missing'), ...edges.filter((edge) => (edge.missingKinds ?? []).length || (edge.missingEvidence ?? []).length).map((edge) => edge.layerKind)]),
+    reviewKinds: byStatus('review'),
+    blockedKinds: byStatus('blocked'),
+    constructCount: layers.length,
+    representedCount: byStatus('represented').length,
+    missingCount: byStatus('missing').length,
+    reviewCount: byStatus('review').length,
+    blockedCount: byStatus('blocked').length
+  };
+}
+
+function summarizeConstraints(edges, obligations) {
+  const normalizedObligations = obligations.map((obligation) => cleanRecord({ ...obligation, kind: obligation.obligationKind ?? obligation.kind }));
+  return {
+    edges,
+    edgeCount: edges.length,
+    obligations: normalizedObligations,
+    obligationCount: normalizedObligations.length,
+    families: unique(edges.map((edge) => edge.family)),
+    statuses: unique(edges.map((edge) => edge.status)),
+    actions: unique(edges.map((edge) => edge.action)),
+    sourceIds: unique(edges.map((edge) => edge.sourceId)),
+    evidenceIds: unique(edges.flatMap((edge) => edge.evidenceIds ?? [])),
+    requiredKinds: unique(edges.flatMap((edge) => edge.requiredKinds ?? [])),
+    representedKinds: unique(edges.flatMap((edge) => edge.representedKinds ?? [])),
+    missingKinds: unique(edges.flatMap((edge) => edge.missingKinds ?? [])),
+    missingEvidence: unique(edges.flatMap((edge) => edge.missingEvidence ?? [])),
+    obligationKinds: unique(normalizedObligations.map((obligation) => obligation.kind)),
+    obligationStatuses: unique(normalizedObligations.map((obligation) => obligation.status)),
+    obligationEvidenceIds: unique(normalizedObligations.flatMap((obligation) => obligation.evidenceIds ?? [])),
+    obligationMissingEvidence: unique(normalizedObligations.flatMap((obligation) => obligation.missingEvidence ?? [])),
+    blockers: unique(edges.flatMap((edge) => edge.blockers ?? [])),
+    review: unique(edges.flatMap((edge) => edge.review ?? []))
+  };
+}
+
+function summarizeLowering(record) {
+  const latest = record.loweringRecords.at(-1) ?? {};
+  return cleanRecord({
+    disposition: latest.disposition,
+    mode: record.mode,
+    routeAction: latest.routeAction,
+    lossClass: latest.lossClass,
+    adapterId: latest.adapterId,
+    adapterKind: latest.adapterKind,
+    readiness: latest.readiness,
+    proofEvidenceIds: unique(record.loweringRecords.flatMap((entry) => entry.proofEvidenceIds ?? [])),
+    evidenceIds: unique(allEvidence(record)),
+    missingEvidence: unique(record.loweringRecords.flatMap((entry) => entry.missingEvidence ?? [])),
+    lossIds: unique(record.loweringRecords.flatMap((entry) => entry.lossIds ?? [])),
+    blockers: unique(record.loweringRecords.flatMap((entry) => entry.blockers ?? [])),
+    review: unique(record.loweringRecords.flatMap((entry) => entry.review ?? []))
+  });
+}
+
+function summarizeQuery(record) {
+  return {
+    layerKinds: record.layers.kinds,
+    representedLayerKinds: record.layers.representedKinds,
+    missingLayerKinds: record.layers.missingKinds,
+    reviewLayerKinds: record.layers.reviewKinds,
+    blockedLayerKinds: record.layers.blockedKinds,
+    constraintFamilies: record.constraints.families,
+    constraintStatuses: record.constraints.statuses,
+    constraintActions: record.constraints.actions,
+    constraintSourceIds: record.constraints.sourceIds,
+    constraintEvidenceIds: record.constraints.evidenceIds,
+    constraintRequiredKinds: record.constraints.requiredKinds,
+    constraintRepresentedKinds: record.constraints.representedKinds,
+    constraintMissingKinds: record.constraints.missingKinds,
+    constraintMissingEvidence: record.constraints.missingEvidence,
+    constraintObligationKinds: record.constraints.obligationKinds,
+    constraintObligationStatuses: record.constraints.obligationStatuses,
+    constraintObligationEvidenceIds: record.constraints.obligationEvidenceIds,
+    constraintObligationMissingEvidence: record.constraints.obligationMissingEvidence,
+    loweringDisposition: record.lowering.disposition,
+    missingEvidence: unique([...(record.lowering.missingEvidence ?? []), ...(record.constraints.missingEvidence ?? [])]),
+    proofEvidenceIds: record.lowering.proofEvidenceIds ?? [],
+    targetAdapterId: record.lowering.adapterId
+  };
+}
+
+function summarize(record) {
+  return {
+    layerCount: record.layers.constructCount,
+    constraintCount: record.constraints.edgeCount,
+    obligationCount: record.constraints.obligationCount,
+    loweringCount: record.loweringRecords.length,
+    liftCount: record.liftRecords.length,
+    evidenceCount: record.evidenceRecords.length,
+    missingEvidenceCount: record.query.missingEvidence.length,
+    blockerCount: (record.lowering.blockers ?? []).length + (record.constraints.blockers ?? []).length
+  };
+}
+
+function allEvidence(record) {
+  return [...record.evidenceRecords.map((entry) => entry.id), ...record.layerRecords.flatMap((entry) => entry.evidenceIds ?? []), ...record.constraintEdges.flatMap((entry) => entry.evidenceIds ?? []), ...record.obligations.flatMap((entry) => entry.evidenceIds ?? []), ...record.liftRecords.flatMap((entry) => entry.evidenceIds ?? [])];
+}
+
+function normalizeRowKind(kind) {
+  if (kind === 'constraintEdge') return 'constraint';
+  if (kind === 'proof' || kind === 'proofObligation') return 'obligation';
+  if (kind === 'lower' || kind === 'lowering') return 'lowering';
+  if (kind === 'source' || kind === 'sourceLift') return 'lift';
+  return kind;
+}
+
+function recordKind(kind) {
+  if (kind === 'constraint') return 'constraintEdge';
+  if (kind === 'obligation') return 'constraintObligation';
+  return kind;
+}
+
+function recordPrefix(kind) { return recordKind(kind).replace(/[A-Z]/g, (value) => `_${value.toLowerCase()}`); }
+function isPropertyLine(line) { return /^(route|routeId|sourceLanguage|source|target|mode)\s+/.test(line); }
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'Interlingua'; }
+function readLine(label, body) { return new RegExp('^\\s*' + label + '\\s+([^\\n]+)', 'm').exec(body)?.[1]?.trim(); }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function readInlineQuoted(label, text) { return new RegExp("(?:^|\\s)" + label + "\\s+[\"']([^\"']+)[\"']").exec(text)?.[1]?.trim(); }
+function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(text)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function unique(values = []) { return [...new Set(values.filter(Boolean))]; }
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/dist/metadata.js

@@ -21,7 +21,7 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
@@ -29,6 +29,7 @@ export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], op
   if (conversionBlocks.length) metadata.universalConversionPlan = mergeConversionBlocks(conversionBlocks);
   if (constraintSpaceBlocks.length) metadata.constraintSpaces = mergeConstraintSpaceBlocks(constraintSpaceBlocks);
   if (decisionGraphBlocks.length) metadata.decisionGraph = mergeDecisionGraphBlocks(decisionGraphBlocks);
+  if (interlinguaBlocks.length) metadata.universalInterlingua = mergeInterlinguaBlocks(interlinguaBlocks);
   if (resourceGraphBlocks.length) metadata.semanticResourceGraphs = mergeResourceGraphBlocks(resourceGraphBlocks);
   if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length)) {
     metadata.universalAst = mergeNativeSourceBlocks(nativeSourceBlocks);
@@ -153,6 +154,38 @@ function mergeDecisionGraphBlocks(blocks) {
   };
 }
 
+function mergeInterlinguaBlocks(blocks) {
+  const interlinguaRecords = blocks.map((block) => block.record).filter(Boolean);
+  const records = blocks.flatMap((block) => block.records ?? []);
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'universalInterlingua:source',
+    interlinguaRecords,
+    records,
+    recordIds: ids(records),
+    interlinguaRecordIds: ids(interlinguaRecords),
+    layerIds: blocks.flatMap((block) => ids(block.record?.layerRecords)),
+    constraintIds: blocks.flatMap((block) => ids(block.record?.constraintEdges)),
+    obligationIds: blocks.flatMap((block) => ids(block.record?.obligations)),
+    loweringIds: blocks.flatMap((block) => ids(block.record?.loweringRecords)),
+    liftIds: blocks.flatMap((block) => ids(block.record?.liftRecords)),
+    evidenceIds: [...new Set(blocks.flatMap((block) => block.record?.query?.proofEvidenceIds ?? []).concat(blocks.flatMap((block) => block.record?.query?.constraintEvidenceIds ?? [])))],
+    routeIds: [...new Set(interlinguaRecords.map((record) => record.routeId).filter(Boolean))],
+    summary: {
+      interlinguaCount: interlinguaRecords.length,
+      recordCount: records.length,
+      layerCount: sum(blocks, 'layerCount'),
+      constraintCount: sum(blocks, 'constraintCount'),
+      obligationCount: sum(blocks, 'obligationCount'),
+      loweringCount: sum(blocks, 'loweringCount'),
+      liftCount: sum(blocks, 'liftCount'),
+      evidenceCount: sum(blocks, 'evidenceCount'),
+      missingEvidenceCount: sum(blocks, 'missingEvidenceCount'),
+      blockerCount: sum(blocks, 'blockerCount')
+    },
+    metadata: { authoredInterlinguaBlockIds: blocks.map((block) => block.id) }
+  };
+}
+
 function mergeResourceGraphBlocks(blocks) {
   const graphs = blocks.map((block) => block.graph).filter(Boolean);
   const records = blocks.flatMap((block) => block.records ?? []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.20",
+  "version": "0.3.21",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
   ],
   "scripts": {
     "build": "node scripts/build.mjs",
-    "test": "npm run build && node test/smoke.mjs && node test/resource-graph-smoke.mjs",
+    "test": "npm run build && node test/smoke.mjs && node test/resource-graph-smoke.mjs && node test/interlingua-smoke.mjs",
     "typecheck": "node ./node_modules/typescript/bin/tsc --noEmit -p test/tsconfig.json",
     "fuzz": "npm run build && node fuzz/smoke.mjs",
     "bench": "npm run build && node bench/smoke.mjs",