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

package/README.md

@@ -220,6 +220,57 @@ npm install @shapeshift-labs/frontier-lang-parser
 
 The parser projects text into `@shapeshift-labs/frontier-lang-kernel` documents. The syntax is intentionally small and experimental.
 
+## Authored decision graph syntax
+
+`.frontier` files can carry semantic merge admission evidence directly in `decisionGraph` or `admissionGraph` blocks. These blocks preserve the causal review shape around a candidate edit: semantic changes, gates, evidence records, patch events, admission decisions, merge decisions, graph nodes, and graph edges.
+
+```frontier
+decisionGraph TodoAdmission @id("decision_graph_todo") {
+  graphKind semantic-merge-admission
+  scope mod_todo
+  root merge_decision_title
+  subject action_add,field_title
+  node change @id("decision_node_change") kind semantic-change record semantic_change_title label "Title change" status passed
+  edge changeToGate @id("decision_edge_change_gate") from semantic_change_title to gate_typecheck kind gates status passed
+  change title @id("semantic_change_title") kind source-edit language typescript sourcePath src/todo.ts semanticNode field_title semanticSymbol symbol:Todo.title evidence evidence_typecheck
+  gate typecheck @id("gate_typecheck") kind typecheck status passed required command "npm run typecheck" semanticChange semantic_change_title evidence evidence_typecheck
+  evidence typecheck @id("evidence_typecheck") kind test status passed path reports/typecheck.json gate gate_typecheck semanticChange semantic_change_title
+  patchEvent workerPatch @id("patch_event_worker") patch patch_worker status passed baseHash h_base targetHash h_worker semanticChange semantic_change_title gate gate_typecheck evidence evidence_typecheck deterministic
+  admission titleSafe @id("admission_title_safe") candidate candidate_todo_title semanticChange semantic_change_title classification safe decision merge autoMergeable gate gate_typecheck evidence evidence_typecheck
+  merge titleMerge @id("merge_decision_title") candidate candidate_todo_title semanticChange semantic_change_title admissionDecision admission_title_safe decision merge autoMergeable gate gate_typecheck evidence evidence_typecheck
+}
+```
+
+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 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/decision-graph.js

@@ -0,0 +1,239 @@
+import {
+  createDecisionGraphAdmissionDecisionRecord,
+  createDecisionGraphCandidateDecisionRecord,
+  createDecisionGraphChunkRecord,
+  createDecisionGraphEvidenceRecord,
+  createDecisionGraphGateRecord,
+  createDecisionGraphGraphRecord,
+  createDecisionGraphImprovementFeedbackRecord,
+  createDecisionGraphMergeDecisionRecord,
+  createDecisionGraphPanelProjectionRecord,
+  createDecisionGraphPatchEventRecord,
+  createDecisionGraphReplayRecord,
+  createDecisionGraphRsiLoopRecord,
+  createDecisionGraphSemanticChangeRecord,
+  createDecisionGraphTournamentCandidateRecord,
+  createDecisionGraphTournamentRecord
+} from '@shapeshift-labs/frontier-lang-kernel';
+
+const RECORD_FIELDS = Object.freeze({
+  gate: 'gateIds',
+  evidence: 'evidenceIds',
+  semanticChange: 'semanticChangeIds',
+  patchEvent: 'patchEventIds',
+  admissionDecision: 'admissionDecisionIds',
+  candidateDecision: 'decisionIds',
+  mergeDecision: 'decisionIds',
+  replay: 'replayRecordIds',
+  tournament: 'tournamentRecordIds',
+  tournamentCandidate: 'tournamentRecordIds',
+  rsiLoop: 'rsiLoopIds',
+  improvementFeedback: 'feedbackIds'
+});
+
+export function parseDecisionGraphBlock(block) {
+  const name = nameFrom(block.header);
+  const graph = {
+    id: idFrom(block.header, `decisionGraph_${name}`),
+    graphKind: readLine('graphKind', block.body) ?? readLine('kind', block.body) ?? 'semantic-merge-admission',
+    scopeId: readLine('scope', block.body) ?? readLine('scopeId', block.body),
+    rootId: readLine('root', block.body) ?? readLine('rootId', block.body),
+    status: readLine('status', block.body) ?? 'open',
+    subjectIds: readListLine('subject', block.body) ?? readListLine('subjects', block.body) ?? [],
+    nodes: [],
+    edges: [],
+    records: [],
+    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);
+    if (normalized === 'node') graph.nodes.push(parseNode(rowName, rest));
+    else if (normalized === 'edge') graph.edges.push(parseEdge(rowName, rest));
+    else {
+      const record = parseDecisionRecord(normalized, rowName, rest, graph.id);
+      if (record) graph.records.push(record);
+    }
+  }
+
+  const grouped = groupRecords(graph.records);
+  const graphRecord = createDecisionGraphGraphRecord({
+    id: graph.id,
+    graphKind: graph.graphKind,
+    scopeId: graph.scopeId,
+    rootId: graph.rootId,
+    status: graph.status,
+    subjectIds: graph.subjectIds,
+    recordIds: graph.records.map((record) => record.id),
+    nodeIds: graph.nodes.map((node) => node.id),
+    edgeIds: graph.edges.map((edge) => edge.id),
+    semanticChangeIds: grouped.semanticChangeIds,
+    admissionDecisionIds: grouped.admissionDecisionIds,
+    decisionIds: grouped.decisionIds,
+    gateIds: grouped.gateIds,
+    evidenceIds: grouped.evidenceIds,
+    replayRecordIds: grouped.replayRecordIds,
+    patchEventIds: grouped.patchEventIds,
+    tournamentRecordIds: grouped.tournamentRecordIds,
+    rsiLoopIds: grouped.rsiLoopIds,
+    nodes: graph.nodes,
+    edges: graph.edges,
+    metadata: graph.metadata
+  });
+
+  return {
+    id: graph.id,
+    graph: graphRecord,
+    records: graph.records,
+    nodes: graph.nodes,
+    edges: graph.edges,
+    summary: {
+      graphCount: 1,
+      recordCount: graph.records.length,
+      nodeCount: graph.nodes.length,
+      edgeCount: graph.edges.length,
+      semanticChangeCount: grouped.semanticChangeIds.length,
+      gateCount: grouped.gateIds.length,
+      evidenceCount: grouped.evidenceIds.length,
+      admissionDecisionCount: grouped.admissionDecisionIds.length,
+      decisionCount: grouped.decisionIds.length,
+      patchEventCount: grouped.patchEventIds.length,
+      replayCount: grouped.replayRecordIds.length,
+      tournamentCount: grouped.tournamentRecordIds.length,
+      rsiLoopCount: grouped.rsiLoopIds.length
+    },
+    metadata: { name }
+  };
+}
+
+function parseNode(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `decision_node_${name}`),
+    nodeKind: readInlineWord('nodeKind', text) ?? readInlineWord('kind', text) ?? 'record',
+    recordId: readInlineWord('record', text) ?? readInlineWord('recordId', text),
+    label: readInlineQuoted('label', text) ?? readInlineWord('label', text) ?? name,
+    status: readInlineWord('status', text)
+  });
+}
+
+function parseEdge(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `decision_edge_${name}`),
+    edgeKind: readInlineWord('edgeKind', text) ?? readInlineWord('kind', text) ?? 'relates-to',
+    fromId: readInlineWord('from', text) ?? readInlineWord('fromId', text) ?? readInlineWord('source', text) ?? readInlineWord('sourceId', text),
+    toId: readInlineWord('to', text) ?? readInlineWord('toId', text) ?? readInlineWord('target', text) ?? readInlineWord('targetId', text),
+    status: readInlineWord('status', text)
+  });
+}
+
+function parseDecisionRecord(kind, name, text, graphId) {
+  const common = commonRecord(name, text, graphId);
+  if (kind === 'chunk') return createDecisionGraphChunkRecord({ ...common, chunkKind: readInlineWord('chunkKind', text) ?? readInlineWord('kind', text), sequence: readInlineNumber('sequence', text), recordIds: readInlineList(text, 'record', 'records', 'recordIds') });
+  if (kind === 'gate') return createDecisionGraphGateRecord({ ...common, gateKind: readInlineWord('gateKind', text) ?? readInlineWord('kind', text) ?? name, command: readInlineQuoted('command', text) ?? readInlineWord('command', text), required: readInlineFlag('required', text) });
+  if (kind === 'evidence') return createDecisionGraphEvidenceRecord({ ...common, evidenceKind: readInlineWord('evidenceKind', text) ?? readInlineWord('kind', text) ?? name, path: readInlineWord('path', text) });
+  if (kind === 'semanticChange') return createDecisionGraphSemanticChangeRecord({ ...common, changeKind: readInlineWord('changeKind', text) ?? readInlineWord('kind', text) ?? 'semantic', language: readInlineWord('language', text), sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text), baseHash: readInlineWord('baseHash', text), targetHash: readInlineWord('targetHash', text), patchIds: readInlineList(text, 'patch', 'patches', 'patchId', 'patchIds'), operationIds: readInlineList(text, 'operation', 'operations', 'operationId', 'operationIds'), semanticNodeIds: readInlineList(text, 'semanticNode', 'semanticNodes', 'semanticNodeId', 'semanticNodeIds'), semanticSymbolIds: readInlineList(text, 'semanticSymbol', 'semanticSymbols', 'symbol', 'symbols', 'semanticSymbolId', 'semanticSymbolIds'), effectIds: readInlineList(text, 'effect', 'effects', 'effectId', 'effectIds'), regions: readInlineList(text, 'region', 'regions'), risk: readInlineWord('risk', text) });
+  if (kind === 'patchEvent') return createDecisionGraphPatchEventRecord({ ...common, eventId: readInlineWord('event', text) ?? readInlineWord('eventId', text), patchId: readInlineWord('patch', text) ?? readInlineWord('patchId', text), patchIds: readInlineList(text, 'patch', 'patches', 'patchId', 'patchIds'), actor: readInlineWord('actor', text), at: readInlineWord('at', text), baseHash: readInlineWord('baseHash', text), targetHash: readInlineWord('targetHash', text), operationIds: readInlineList(text, 'operation', 'operations', 'operationId', 'operationIds'), deterministic: readInlineFlag('deterministic', text) });
+  if (kind === 'admissionDecision') return createDecisionGraphAdmissionDecisionRecord({ ...common, admissionId: readInlineWord('admission', text) ?? readInlineWord('admissionId', text), candidateId: readInlineWord('candidate', text) ?? readInlineWord('candidateId', text), classification: readInlineWord('classification', text), decision: readInlineWord('decision', text), autoMergeable: readInlineFlag('autoMergeable', text) || readInlineFlag('autoMerge', text), conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys'), conflictKeyKinds: readInlineList(text, 'conflictKeyKind', 'conflictKeyKinds'), reasons: readInlineList(text, 'reason', 'reasons') });
+  if (kind === 'candidateDecision') return createDecisionGraphCandidateDecisionRecord({ ...common, candidateId: readInlineWord('candidate', text) ?? readInlineWord('candidateId', text), decision: readInlineWord('decision', text), score: readInlineNumber('score', text), rank: readInlineNumber('rank', text), reviewerIds: readInlineList(text, 'reviewer', 'reviewers', 'reviewerId', 'reviewerIds'), reasons: readInlineList(text, 'reason', 'reasons') });
+  if (kind === 'mergeDecision') return createDecisionGraphMergeDecisionRecord({ ...common, decision: readInlineWord('decision', text), autoMergeable: readInlineFlag('autoMergeable', text) || readInlineFlag('autoMerge', text), baseHash: readInlineWord('baseHash', text), targetHash: readInlineWord('targetHash', text), conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys'), reasons: readInlineList(text, 'reason', 'reasons'), candidateDecisionIds: readInlineList(text, 'candidateDecision', 'candidateDecisionId', 'candidateDecisionIds') });
+  if (kind === 'replay') return createDecisionGraphReplayRecord({ ...common, eventIds: readInlineList(text, 'event', 'events', 'eventId', 'eventIds'), patchIds: readInlineList(text, 'patch', 'patches', 'patchId', 'patchIds'), baseHash: readInlineWord('baseHash', text), finalHash: readInlineWord('finalHash', text), issues: readInlineList(text, 'issue', 'issues'), replayComplete: readInlineFlag('replayComplete', text), deterministic: readInlineFlag('deterministic', text) });
+  if (kind === 'tournament') return createDecisionGraphTournamentRecord({ ...common, tournamentId: readInlineWord('tournament', text) ?? readInlineWord('tournamentId', text), tournamentKind: readInlineWord('tournamentKind', text) ?? readInlineWord('kind', text), winnerCandidateId: readInlineWord('winner', text) ?? readInlineWord('winnerCandidateId', text) });
+  if (kind === 'tournamentCandidate') return createDecisionGraphTournamentCandidateRecord({ ...common, tournamentId: readInlineWord('tournament', text) ?? readInlineWord('tournamentId', text), candidateId: readInlineWord('candidate', text) ?? readInlineWord('candidateId', text), lane: readInlineWord('lane', text), taskId: readInlineWord('task', text) ?? readInlineWord('taskId', text), agentId: readInlineWord('agent', text) ?? readInlineWord('agentId', text), score: readInlineNumber('score', text), rank: readInlineNumber('rank', text) });
+  if (kind === 'panelProjection') return createDecisionGraphPanelProjectionRecord({ ...common, panelId: readInlineWord('panel', text) ?? readInlineWord('panelId', text), projectionKind: readInlineWord('projectionKind', text) ?? readInlineWord('kind', text), mergeDecisionIds: readInlineList(text, 'mergeDecision', 'mergeDecisionId', 'mergeDecisionIds'), fields: readInlineList(text, 'field', 'fields') });
+  if (kind === 'rsiLoop') return createDecisionGraphRsiLoopRecord({ ...common, loopId: readInlineWord('loop', text) ?? readInlineWord('loopId', text), loopKind: readInlineWord('loopKind', text) ?? readInlineWord('kind', text), iteration: readInlineNumber('iteration', text), objective: readInlineQuoted('objective', text) ?? readInlineWord('objective', text), action: readInlineWord('action', text), feedbackIds: readInlineList(text, 'feedback', 'feedbackId', 'feedbackIds') });
+  if (kind === 'improvementFeedback') return createDecisionGraphImprovementFeedbackRecord({ ...common, loopId: readInlineWord('loop', text) ?? readInlineWord('loopId', text), loopKind: readInlineWord('loopKind', text), feedbackKind: readInlineWord('feedbackKind', text) ?? readInlineWord('kind', text), subjectId: readInlineWord('subject', text) ?? readInlineWord('subjectId', text), severity: readInlineWord('severity', text), action: readInlineWord('action', text), feedback: readInlineQuoted('feedback', text) });
+  return undefined;
+}
+
+function commonRecord(name, text, graphId) {
+  return cleanRecord({
+    id: idFrom(text, undefined),
+    name,
+    graphIds: [graphId],
+    status: readInlineWord('status', text),
+    subjectIds: readInlineList(text, 'subject', 'subjects', 'subjectId', 'subjectIds'),
+    candidateIds: readInlineList(text, 'candidate', 'candidates', 'candidateId', 'candidateIds'),
+    semanticMergeCandidateIds: readInlineList(text, 'semanticMergeCandidate', 'semanticMergeCandidates', 'semanticMergeCandidateId', 'semanticMergeCandidateIds'),
+    semanticChangeIds: readInlineList(text, 'semanticChange', 'semanticChanges', 'semanticChangeId', 'semanticChangeIds'),
+    admissionDecisionIds: readInlineList(text, 'admissionDecision', 'admissionDecisionId', 'admissionDecisionIds'),
+    decisionIds: readInlineList(text, 'decisionId', 'decisionIds'),
+    gateIds: readInlineList(text, 'gate', 'gates', 'gateId', 'gateIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds'),
+    replayRecordIds: readInlineList(text, 'replay', 'replayId', 'replayRecord', 'replayRecordId', 'replayRecordIds'),
+    patchEventIds: readInlineList(text, 'patchEvent', 'patchEventId', 'patchEventIds'),
+    tournamentRecordIds: readInlineList(text, 'tournamentRecord', 'tournamentRecordId', 'tournamentRecordIds'),
+    rsiLoopIds: readInlineList(text, 'rsiLoop', 'rsiLoopId', 'rsiLoopIds'),
+    summary: readInlineQuoted('summary', text),
+    metadata: { authoredName: name }
+  });
+}
+
+function groupRecords(records) {
+  const grouped = {
+    gateIds: [],
+    evidenceIds: [],
+    semanticChangeIds: [],
+    patchEventIds: [],
+    admissionDecisionIds: [],
+    decisionIds: [],
+    replayRecordIds: [],
+    tournamentRecordIds: [],
+    rsiLoopIds: [],
+    feedbackIds: []
+  };
+  for (const record of records) {
+    const key = RECORD_FIELDS[recordName(record)];
+    if (key && record.id) grouped[key].push(record.id);
+  }
+  return Object.fromEntries(Object.entries(grouped).map(([key, value]) => [key, unique(value)]));
+}
+
+function recordName(record) {
+  return String(record?.recordKind ?? record?.kind ?? '').replace('frontier.lang.decisionGraph.', '');
+}
+
+function normalizeRowKind(kind) {
+  if (kind === 'change') return 'semanticChange';
+  if (kind === 'patch') return 'patchEvent';
+  if (kind === 'admission') return 'admissionDecision';
+  if (kind === 'candidate') return 'candidateDecision';
+  if (kind === 'merge') return 'mergeDecision';
+  if (kind === 'panel') return 'panelProjection';
+  if (kind === 'feedback') return 'improvementFeedback';
+  return kind;
+}
+
+function isGraphPropertyLine(line) {
+  return /^(graphKind|kind|scope|scopeId|root|rootId|status|subject|subjects)\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] ?? 'DecisionGraph'; }
+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 readInlineFlag(label, text) { return new RegExp('(?:^|\\s)' + label + '(?:\\s|$)').test(text) || undefined; }
+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 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/index.js

@@ -1,10 +1,12 @@
 import { actionNode, capabilityNode, createDocument, effectNode, entityNode, externNode, latticeNode, migrationNode, stateNode, targetNode, typeNode } from '@shapeshift-labs/frontier-lang-kernel';
 import { parseConstraintSpaceBlock } from './constraint-space.js';
 import { parseConversionBlock } from './conversion.js';
+import { parseDecisionGraphBlock } from './decision-graph.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';
 
@@ -15,6 +17,8 @@ export function parseFrontierSource(source, options = {}) {
   const operationBlocks = [];
   const conversionBlocks = [];
   const constraintSpaceBlocks = [];
+  const decisionGraphBlocks = [];
+  const resourceGraphBlocks = [];
   const nativeSourceBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
@@ -40,8 +44,10 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'operations' || block.kind === 'semanticOperations') operationBlocks.push(parseSemanticOperationsBlock(block));
     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 === 'resourceGraph' || block.kind === 'semanticResourceGraph') resourceGraphBlocks.push(parseResourceGraphBlock(block));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, nativeSourceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, resourceGraphBlocks, nativeSourceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -51,7 +57,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)\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|resourceGraph|semanticResourceGraph)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/metadata.js

@@ -21,13 +21,15 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], nativeSourceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
   if (operationBlocks.length) metadata.semanticOperations = mergeOperationBlocks(operationBlocks);
   if (conversionBlocks.length) metadata.universalConversionPlan = mergeConversionBlocks(conversionBlocks);
   if (constraintSpaceBlocks.length) metadata.constraintSpaces = mergeConstraintSpaceBlocks(constraintSpaceBlocks);
+  if (decisionGraphBlocks.length) metadata.decisionGraph = mergeDecisionGraphBlocks(decisionGraphBlocks);
+  if (resourceGraphBlocks.length) metadata.semanticResourceGraphs = mergeResourceGraphBlocks(resourceGraphBlocks);
   if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length)) {
     metadata.universalAst = mergeNativeSourceBlocks(nativeSourceBlocks);
   }
@@ -112,10 +114,98 @@ function mergeNativeSourceBlocks(blocks) {
   };
 }
 
+function mergeDecisionGraphBlocks(blocks) {
+  const records = blocks.flatMap((block) => block.records ?? []);
+  const graphs = blocks.map((block) => block.graph).filter(Boolean);
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'decisionGraph:source',
+    graphs,
+    records,
+    nodes: blocks.flatMap((block) => block.nodes ?? []),
+    edges: blocks.flatMap((block) => block.edges ?? []),
+    graphIds: ids(graphs),
+    recordIds: ids(records),
+    gateIds: idsByKind(records, 'frontier.lang.decisionGraph.gate'),
+    evidenceIds: idsByKind(records, 'frontier.lang.decisionGraph.evidence'),
+    semanticChangeIds: idsByKind(records, 'frontier.lang.decisionGraph.semanticChange'),
+    patchEventIds: idsByKind(records, 'frontier.lang.decisionGraph.patchEvent'),
+    admissionDecisionIds: idsByKind(records, 'frontier.lang.decisionGraph.admissionDecision'),
+    decisionIds: idsByKind(records, 'frontier.lang.decisionGraph.candidateDecision').concat(idsByKind(records, 'frontier.lang.decisionGraph.mergeDecision')),
+    replayRecordIds: idsByKind(records, 'frontier.lang.decisionGraph.replay'),
+    tournamentRecordIds: idsByKind(records, 'frontier.lang.decisionGraph.tournament').concat(idsByKind(records, 'frontier.lang.decisionGraph.tournamentCandidate')),
+    rsiLoopIds: idsByKind(records, 'frontier.lang.decisionGraph.rsiLoop'),
+    summary: {
+      graphCount: blocks.length,
+      recordCount: records.length,
+      nodeCount: sum(blocks, 'nodeCount'),
+      edgeCount: sum(blocks, 'edgeCount'),
+      semanticChangeCount: sum(blocks, 'semanticChangeCount'),
+      gateCount: sum(blocks, 'gateCount'),
+      evidenceCount: sum(blocks, 'evidenceCount'),
+      admissionDecisionCount: sum(blocks, 'admissionDecisionCount'),
+      decisionCount: sum(blocks, 'decisionCount'),
+      patchEventCount: sum(blocks, 'patchEventCount'),
+      replayCount: sum(blocks, 'replayCount'),
+      tournamentCount: sum(blocks, 'tournamentCount'),
+      rsiLoopCount: sum(blocks, 'rsiLoopCount')
+    },
+    metadata: { authoredDecisionGraphBlockIds: 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);
 }
 
+function idsByKind(records = [], kind) {
+  return ids(records.filter((record) => record?.recordKind === kind || record?.kind === kind));
+}
+
 function sum(blocks, key) {
   return blocks.reduce((total, block) => total + (block.summary?.[key] ?? 0), 0);
 }

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.18",
+  "version": "0.3.20",
   "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",
     "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",
@@ -54,7 +54,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@shapeshift-labs/frontier-lang-kernel": "0.3.12"
+    "@shapeshift-labs/frontier-lang-kernel": "0.3.13"
   },
   "devDependencies": {
     "typescript": "^5.9.3"