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

package/README.md

@@ -220,6 +220,29 @@ 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 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,6 +1,7 @@
 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';
@@ -15,6 +16,7 @@ export function parseFrontierSource(source, options = {}) {
   const operationBlocks = [];
   const conversionBlocks = [];
   const constraintSpaceBlocks = [];
+  const decisionGraphBlocks = [];
   const nativeSourceBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
@@ -40,8 +42,9 @@ 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));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, nativeSourceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, nativeSourceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -51,7 +54,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)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/metadata.js

@@ -21,13 +21,14 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], nativeSourceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], 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 (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length)) {
     metadata.universalAst = mergeNativeSourceBlocks(nativeSourceBlocks);
   }
@@ -112,10 +113,53 @@ 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 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.18",
+  "version": "0.3.19",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -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"