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

package/README.md

@@ -243,6 +243,55 @@ decisionGraph TodoAdmission @id("decision_graph_todo") {
 
 The parser projects these rows into `metadata.decisionGraph`. Decision graph records are normalized by the kernel helpers, so authored files can describe why a merge is admissible without embedding raw JSON. This is intentionally evidence-first: a safe merge can be represented as a graph of changes, gates, evidence, and decisions, while missing proof can remain explicit as blocked or review-required records.
 
+## Authored resource graph syntax
+
+`.frontier` files can carry semantic resource graph evidence directly in `resourceGraph` or `semanticResourceGraph` blocks. These blocks make ownership, aliases, loans, moves, drops, lifetimes, unsafe boundaries, conflicts, and proof obligations explicit for translation and semantic merge admission.
+
+```frontier
+resourceGraph TodoResources @id("resource_graph_todo") {
+  sourceLanguage javascript
+  sourcePath src/todo.ts
+  sourceHash sha256:example
+  evidence artifact_todo_title_probe
+  resource todos @id("resource_todos") kind collection owner owner_todo_store
+  owner todoStore @id("owner_todo_store") kind store
+  lifetime request @id("life_request") kind lexical startLine 1 endLine 80
+  loan readTodos @id("loan_read_todos") resource resource_todos owner owner_todo_store lifetime life_request mode shared access read
+  alias todosAlias @id("alias_todos") resource resource_todos owner owner_todo_store alias alias:todos kind local
+  move todoMove @id("move_todos") resource resource_todos fromOwner owner_todo_store toOwner owner_worker kind transfer
+  drop todoDrop @id("drop_todos") resource resource_todos owner owner_worker lifetime life_request kind lexical-drop order 1
+  escape todoEscape @id("escape_todos") resource resource_todos loan loan_read_todos lifetime life_request kind returned-borrow status needs-proof
+  outlives requestModule @id("life_request_outlives_module") from life_module to life_request kind contains
+  borrow readScope @id("borrow_scope_todos") resource resource_todos lifetime life_request kind shared-borrow constraint shared|read-only
+  unsafe ffiBoundary @id("unsafe_todos_ffi") resource resource_todos kind ffi proofStatus missing
+  conflict aliasConflict @id("conflict_todos_alias") resource resource_todos loan loan_read_todos alias alias_todos reasonCode exclusive-resource-alias-overlap-requires-proof status open severity error
+  proof aliasProof @id("proof_obligation_alias") resource resource_todos conflict conflict_todos_alias kind alias-safety status open statement "Prove the alias cannot mutate during the shared loan."
+}
+```
+
+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,10 +2,12 @@ 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';
 import { parseProofBlock } from './proof.js';
+import { parseResourceGraphBlock } from './resource-graph.js';
 import { parseNativeSourceBlock } from './source-evidence.js';
 import { parseViewBlock } from './view.js';
 
@@ -17,6 +19,8 @@ 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';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
@@ -43,8 +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, nativeSourceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -54,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)\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 = [], 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,8 @@ 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);
   }
@@ -152,6 +154,83 @@ 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 ?? []);
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'semanticResourceGraphs:source',
+    graphs,
+    resourceGraphs: graphs,
+    records,
+    graphIds: ids(graphs),
+    recordIds: ids(records),
+    resourceIds: blocks.flatMap((block) => ids(block.graph?.resources)),
+    ownerIds: blocks.flatMap((block) => ids(block.graph?.owners)),
+    loanIds: blocks.flatMap((block) => ids(block.graph?.loans)),
+    aliasIds: blocks.flatMap((block) => ids(block.graph?.aliases)),
+    moveIds: blocks.flatMap((block) => ids(block.graph?.moves)),
+    dropIds: blocks.flatMap((block) => ids(block.graph?.drops)),
+    escapeIds: blocks.flatMap((block) => ids(block.graph?.escapes)),
+    lifetimeRegionIds: blocks.flatMap((block) => ids(block.graph?.lifetimeRegions)),
+    lifetimeRelationIds: blocks.flatMap((block) => ids(block.graph?.lifetimeRelations)),
+    borrowScopeIds: blocks.flatMap((block) => ids(block.graph?.borrowScopes)),
+    unsafeBoundaryIds: blocks.flatMap((block) => ids(block.graph?.unsafeBoundaries)),
+    conflictIds: blocks.flatMap((block) => ids(block.graph?.conflicts)),
+    proofObligationIds: blocks.flatMap((block) => ids(block.graph?.proofObligations)),
+    summary: {
+      graphCount: blocks.length,
+      recordCount: records.length,
+      resourceCount: sum(blocks, 'resources'),
+      ownerCount: sum(blocks, 'owners'),
+      loanCount: sum(blocks, 'loans'),
+      aliasCount: sum(blocks, 'aliases'),
+      moveCount: sum(blocks, 'moves'),
+      dropCount: sum(blocks, 'drops'),
+      escapeCount: sum(blocks, 'escapes'),
+      lifetimeRegionCount: sum(blocks, 'lifetimeRegions'),
+      lifetimeRelationCount: sum(blocks, 'lifetimeRelations'),
+      borrowScopeCount: sum(blocks, 'borrowScopes'),
+      unsafeBoundaryCount: sum(blocks, 'unsafeBoundaries'),
+      conflictCount: sum(blocks, 'conflicts'),
+      proofObligationCount: sum(blocks, 'proofObligations'),
+      unsafeBoundariesWithoutProof: sum(blocks, 'unsafeBoundariesWithoutProof')
+    },
+    metadata: { authoredResourceGraphBlockIds: blocks.map((block) => block.id) }
+  };
+}
+
 function ids(records = []) {
   return records.map((record) => record?.id).filter(Boolean);
 }

package/dist/resource-graph.js

@@ -0,0 +1,208 @@
+const GROUPS = {
+  resource: 'resources',
+  owner: 'owners',
+  loan: 'loans',
+  alias: 'aliases',
+  move: 'moves',
+  drop: 'drops',
+  escape: 'escapes',
+  lifetimeRegion: 'lifetimeRegions',
+  lifetimeRelation: 'lifetimeRelations',
+  borrowScope: 'borrowScopes',
+  unsafeBoundary: 'unsafeBoundaries',
+  conflict: 'conflicts',
+  proofObligation: 'proofObligations'
+};
+
+export function parseResourceGraphBlock(block) {
+  const name = nameFrom(block.header);
+  const graph = {
+    kind: 'frontier.lang.semanticResourceGraph',
+    version: 1,
+    id: idFrom(block.header, `resource_graph_${name}`),
+    sourceLanguage: readLine('sourceLanguage', block.body) ?? readLine('language', block.body),
+    sourcePath: readLine('sourcePath', block.body) ?? readLine('path', block.body),
+    sourceHash: readLine('sourceHash', block.body),
+    status: readLine('status', block.body) ?? 'partial',
+    evidenceIds: readListLine('evidence', block.body) ?? readListLine('evidenceIds', block.body) ?? [],
+    resources: [],
+    owners: [],
+    loans: [],
+    aliases: [],
+    moves: [],
+    drops: [],
+    escapes: [],
+    lifetimeRegions: [],
+    lifetimeRelations: [],
+    outlives: [],
+    borrowScopes: [],
+    borrowScopeRegions: [],
+    unsafeBoundaries: [],
+    conflicts: [],
+    proofObligations: [],
+    claims: {
+      borrowCheckerClaim: false,
+      aliasSafetyClaim: false,
+      lifetimeSoundnessClaim: false,
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    },
+    metadata: { name }
+  };
+
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || isGraphPropertyLine(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 record = parseResourceRecord(normalized, rowName, rest, graph);
+    const group = GROUPS[normalized];
+    if (record && group) graph[group].push(record);
+  }
+
+  graph.outlives = graph.lifetimeRelations;
+  graph.borrowScopeRegions = graph.borrowScopes;
+  graph.summary = summarize(graph);
+  graph.query = {
+    resourceIds: ids(graph.resources),
+    ownerIds: ids(graph.owners),
+    lifetimeRegionIds: ids(graph.lifetimeRegions),
+    sourcePaths: unique(allRecords(graph).map((record) => record.sourcePath)),
+    evidenceIds: unique([...graph.evidenceIds, ...allRecords(graph).flatMap((record) => record.evidenceIds ?? [])]),
+    blockerReasonCodes: unique(graph.conflicts.map((record) => record.reasonCode))
+  };
+
+  return {
+    id: graph.id,
+    graph,
+    records: allRecords(graph),
+    summary: {
+      graphCount: 1,
+      ...graph.summary
+    },
+    metadata: { name }
+  };
+}
+
+function parseResourceRecord(kind, name, text, graph) {
+  const common = commonRecord(kind, name, text, graph);
+  if (kind === 'resource') return cleanRecord({ ...common, resourceKind: readInlineWord('resourceKind', text) ?? readInlineWord('kind', text) ?? name, ownerId: readInlineWord('owner', text) ?? readInlineWord('ownerId', text), ownerName: readInlineWord('ownerName', text) });
+  if (kind === 'owner') return cleanRecord({ ...common, ownerKind: readInlineWord('ownerKind', text) ?? readInlineWord('kind', text) ?? 'owner' });
+  if (kind === 'loan') return cleanRecord({ ...common, resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text), ownerId: readInlineWord('owner', text) ?? readInlineWord('ownerId', text), lifetimeRegionId: readInlineWord('lifetime', text) ?? readInlineWord('lifetimeRegion', text) ?? readInlineWord('lifetimeRegionId', text), mode: readInlineWord('mode', text) ?? 'unknown', access: readInlineWord('access', text) });
+  if (kind === 'alias') return cleanRecord({ ...common, resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text), ownerId: readInlineWord('owner', text) ?? readInlineWord('ownerId', text), aliasId: readInlineWord('alias', text) ?? readInlineWord('aliasId', text), aliasKind: readInlineWord('aliasKind', text) ?? readInlineWord('kind', text) ?? 'alias' });
+  if (kind === 'move') return cleanRecord({ ...common, resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text), fromOwnerId: readInlineWord('fromOwner', text) ?? readInlineWord('fromOwnerId', text), toOwnerId: readInlineWord('toOwner', text) ?? readInlineWord('toOwnerId', text), moveKind: readInlineWord('moveKind', text) ?? readInlineWord('kind', text) });
+  if (kind === 'drop') return cleanRecord({ ...common, resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text), ownerId: readInlineWord('owner', text) ?? readInlineWord('ownerId', text), lifetimeRegionId: readInlineWord('lifetime', text) ?? readInlineWord('lifetimeRegion', text) ?? readInlineWord('lifetimeRegionId', text), dropKind: readInlineWord('dropKind', text) ?? readInlineWord('kind', text) ?? 'drop', line: readInlineNumber('line', text), order: readInlineNumber('order', text) });
+  if (kind === 'escape') return cleanRecord({ ...common, resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text), ownerId: readInlineWord('owner', text) ?? readInlineWord('ownerId', text), lifetimeRegionId: readInlineWord('lifetime', text) ?? readInlineWord('lifetimeRegion', text) ?? readInlineWord('lifetimeRegionId', text), loanId: readInlineWord('loan', text) ?? readInlineWord('loanId', text), escapeKind: readInlineWord('escapeKind', text) ?? readInlineWord('kind', text) ?? 'escape', status: readInlineWord('status', text) ?? 'needs-proof' });
+  if (kind === 'lifetimeRegion') return cleanRecord({ ...common, lifetimeKind: readInlineWord('lifetimeKind', text) ?? readInlineWord('kind', text) ?? 'lexical', startLine: readInlineNumber('startLine', text), endLine: readInlineNumber('endLine', text) });
+  if (kind === 'lifetimeRelation') return cleanRecord({ ...common, relationKind: readInlineWord('relationKind', text) ?? readInlineWord('kind', text) ?? 'outlives', fromLifetimeId: readInlineWord('fromLifetime', text) ?? readInlineWord('fromLifetimeId', text) ?? readInlineWord('from', text), toLifetimeId: readInlineWord('toLifetime', text) ?? readInlineWord('toLifetimeId', text) ?? readInlineWord('to', text), from: readInlineWord('from', text), to: readInlineWord('to', text) });
+  if (kind === 'borrowScope') return cleanRecord({ ...common, scopeKind: readInlineWord('scopeKind', text) ?? readInlineWord('kind', text) ?? 'borrow-scope', constraintKind: readInlineWord('constraintKind', text), constraintKinds: readInlineList(text, 'constraint', 'constraints', 'constraintKind', 'constraintKinds') ?? [], ownershipKind: readInlineWord('ownershipKind', text), lifetimeKind: readInlineWord('lifetimeKind', text), controlFlowKind: readInlineWord('controlFlowKind', text), sourceControlFlowId: readInlineWord('sourceControlFlow', text) ?? readInlineWord('sourceControlFlowId', text), lifetimeRegionId: readInlineWord('lifetime', text) ?? readInlineWord('lifetimeRegion', text) ?? readInlineWord('lifetimeRegionId', text), resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text) });
+  if (kind === 'unsafeBoundary') return cleanRecord({ ...common, resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text), unsafeBoundary: true, proofStatus: readInlineWord('proofStatus', text) ?? readInlineWord('status', text) ?? 'missing', kind: readInlineWord('kind', text) });
+  if (kind === 'conflict') return cleanRecord({ ...common, resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text), ownerId: readInlineWord('owner', text) ?? readInlineWord('ownerId', text), loanId: readInlineWord('loan', text) ?? readInlineWord('loanId', text), aliasId: readInlineWord('alias', text) ?? readInlineWord('aliasId', text), unsafeBoundaryId: readInlineWord('unsafeBoundary', text) ?? readInlineWord('unsafeBoundaryId', text), reasonCode: readInlineWord('reasonCode', text), message: readInlineQuoted('message', text), status: readInlineWord('status', text) ?? 'open', severity: readInlineWord('severity', text) ?? 'error' });
+  if (kind === 'proofObligation') return cleanRecord({ ...common, resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text), conflictId: readInlineWord('conflict', text) ?? readInlineWord('conflictId', text), kind: readInlineWord('kind', text), status: readInlineWord('status', text) ?? 'open', statement: readInlineQuoted('statement', text) });
+  return undefined;
+}
+
+function commonRecord(kind, name, text, graph) {
+  return cleanRecord({
+    recordKind: recordKind(kind),
+    id: idFrom(text, `${recordPrefix(kind)}_${name}`),
+    name,
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text) ?? graph.sourcePath,
+    sourceHash: readInlineWord('sourceHash', text) ?? graph.sourceHash,
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds') ?? graph.evidenceIds,
+    metadata: { authoredName: name }
+  });
+}
+
+function summarize(graph) {
+  return {
+    records: allRecords(graph).length,
+    resources: graph.resources.length,
+    owners: graph.owners.length,
+    loans: graph.loans.length,
+    aliases: graph.aliases.length,
+    moves: graph.moves.length,
+    drops: graph.drops.length,
+    escapes: graph.escapes.length,
+    lifetimeRegions: graph.lifetimeRegions.length,
+    lifetimeRelations: graph.lifetimeRelations.length,
+    borrowScopes: graph.borrowScopes.length,
+    unsafeBoundaries: graph.unsafeBoundaries.length,
+    conflicts: graph.conflicts.length,
+    proofObligations: graph.proofObligations.length,
+    unsafeBoundariesWithoutProof: graph.unsafeBoundaries.filter((record) => record.proofStatus !== 'passed').length,
+    reasonCodes: unique(graph.conflicts.map((record) => record.reasonCode))
+  };
+}
+
+function allRecords(graph) {
+  return [
+    ...graph.resources,
+    ...graph.owners,
+    ...graph.loans,
+    ...graph.aliases,
+    ...graph.moves,
+    ...graph.drops,
+    ...graph.escapes,
+    ...graph.lifetimeRegions,
+    ...graph.lifetimeRelations,
+    ...graph.borrowScopes,
+    ...graph.unsafeBoundaries,
+    ...graph.conflicts,
+    ...graph.proofObligations
+  ];
+}
+
+function normalizeRowKind(kind) {
+  if (kind === 'lifetime' || kind === 'life') return 'lifetimeRegion';
+  if (kind === 'outlives' || kind === 'lifetimeRelation' || kind === 'lifeRelation') return 'lifetimeRelation';
+  if (kind === 'borrow' || kind === 'borrowScope' || kind === 'borrowRegion') return 'borrowScope';
+  if (kind === 'unsafe' || kind === 'unsafeBoundary') return 'unsafeBoundary';
+  if (kind === 'proof' || kind === 'obligation' || kind === 'proofObligation') return 'proofObligation';
+  return kind;
+}
+
+function recordKind(kind) {
+  if (kind === 'lifetimeRegion') return 'lifetime-region';
+  if (kind === 'lifetimeRelation') return 'lifetime-relation';
+  if (kind === 'borrowScope') return 'borrow-scope';
+  if (kind === 'unsafeBoundary') return 'unsafe-boundary';
+  if (kind === 'proofObligation') return 'proof-obligation';
+  return kind;
+}
+
+function recordPrefix(kind) {
+  return recordKind(kind).replace(/-/g, '_');
+}
+
+function isGraphPropertyLine(line) {
+  return /^(sourceLanguage|language|sourcePath|path|sourceHash|status|evidence|evidenceIds)\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] ?? 'ResourceGraph'; }
+function readLine(label, body) { return new RegExp('^\\s*' + label + '\\s+([^\\n]+)', 'm').exec(body)?.[1]?.trim(); }
+function readListLine(label, body) {
+  const line = readLine(label, body);
+  return line ? line.split(/[|,]/).map((item) => item.trim()).filter(Boolean) : undefined;
+}
+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 readInlineNumber(label, text) {
+  const value = readInlineWord(label, text);
+  return value === undefined ? undefined : Number(value);
+}
+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 ids(records = []) { return records.map((record) => record?.id).filter(Boolean); }
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.19",
+  "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",
+    "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",