@shapeshift-labs/frontier-lang-parser 0.3.74 → 0.3.76

package/dist/index.js

@@ -8,6 +8,7 @@ import { parseDecisionGraphBlock } from './decision-graph.js';
 import { parseDialectRegistryBlock } from './dialect-registry.js';
 import { parseGateAdmissionEvidenceBlock } from './gate-admission-evidence.js';
 import { parseInterlinguaBlock } from './interlingua.js';
+import { parseMachineGraphBlock } from './machine-graph.js';
 import { createParsedMetadata } from './metadata.js';
 import { parseEntityBlock, parseStateBlock, readTypeFields } from './member-records.js';
 import { parseSemanticEditRecordsBlock } from './semantic-edit-records.js';
@@ -38,7 +39,7 @@ export function parseFrontierSource(source, options = {}) {
   const gateAdmissionEvidenceBlocks = [];
   const dialectRegistryBlocks = [];
   const interlinguaBlocks = [];
-  const resourceGraphBlocks = [];
+  const resourceGraphBlocks = [], machineGraphBlocks = [];
   const nativeSourceBlocks = [];
   const packageManifestBlocks = [];
   const canvasSurfaceBlocks = [];
@@ -74,12 +75,13 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'dialectRegistry' || block.kind === 'universalDialectRegistry') dialectRegistryBlocks.push(parseDialectRegistryBlock(block));
     if (block.kind === 'interlingua' || block.kind === 'universalInterlingua') interlinguaBlocks.push(parseInterlinguaBlock(block));
     if (block.kind === 'resourceGraph' || block.kind === 'semanticResourceGraph') resourceGraphBlocks.push(parseResourceGraphBlock(block));
+    if (block.kind === 'machineGraph' || block.kind === 'executionGraph' || block.kind === 'lowLevelGraph') machineGraphBlocks.push(parseMachineGraphBlock(block));
     if (block.kind === 'packageManifest' || block.kind === 'packageGraph' || block.kind === 'packageSurface') packageManifestBlocks.push(parsePackageManifestBlock(block));
     if (block.kind === 'canvasSurface' || block.kind === 'canvasGraph') canvasSurfaceBlocks.push(parseCanvasSurfaceBlock(block));
     if (block.kind === 'applicationSurface' || block.kind === 'appHost' || block.kind === 'plugin' || block.kind === 'pluginSurface' || block.kind === 'pluginContract') applicationSurfaceBlocks.push(parseApplicationSurfaceBlock(block));
     if (block.kind === 'runtimeCapabilities' || block.kind === 'runtimeCapabilityMatrix' || block.kind === 'runtimeHosts') runtimeCapabilityBlocks.push(parseRuntimeCapabilityBlock(block));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, semanticEditBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, gateAdmissionEvidenceBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks, runtimeCapabilityBlocks, targetProjectionTargets });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, semanticEditBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, gateAdmissionEvidenceBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, machineGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks, runtimeCapabilityBlocks, targetProjectionTargets });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 

package/dist/machine-graph-metadata.js

@@ -0,0 +1,66 @@
+export function mergeMachineGraphBlocks(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 : 'machineGraphs:source',
+    graphs,
+    machineGraphs: graphs,
+    records,
+    graphIds: ids(graphs),
+    recordIds: ids(records),
+    labelIds: blocks.flatMap((block) => ids(block.graph?.labels)),
+    directiveIds: blocks.flatMap((block) => ids(block.graph?.directives)),
+    registerIds: blocks.flatMap((block) => ids(block.graph?.registers)),
+    flagIds: blocks.flatMap((block) => ids(block.graph?.flags)),
+    basicBlockIds: blocks.flatMap((block) => ids(block.graph?.basicBlocks)),
+    instructionIds: blocks.flatMap((block) => ids(block.graph?.instructions)),
+    operandIds: blocks.flatMap((block) => ids(block.graph?.operands)),
+    memoryEffectIds: blocks.flatMap((block) => ids(block.graph?.memoryEffects)),
+    controlEdgeIds: blocks.flatMap((block) => ids(block.graph?.controlEdges)),
+    branchIds: blocks.flatMap((block) => ids(block.graph?.branches)),
+    callIds: blocks.flatMap((block) => ids(block.graph?.calls)),
+    returnIds: blocks.flatMap((block) => ids(block.graph?.returns)),
+    interruptIds: blocks.flatMap((block) => ids(block.graph?.interrupts)),
+    proofObligationIds: blocks.flatMap((block) => ids(block.graph?.proofObligations)),
+    proofGapCodes: unique(blocks.flatMap((block) => block.graph?.query?.proofGapCodes ?? [])),
+    evidenceIds: unique(blocks.flatMap((block) => block.graph?.query?.evidenceIds ?? [])),
+    proofEvidenceIds: unique(blocks.flatMap((block) => block.graph?.query?.proofEvidenceIds ?? [])),
+    sourceMapIds: unique(blocks.flatMap((block) => block.graph?.query?.sourceMapIds ?? [])),
+    sourceMapMappingIds: unique(blocks.flatMap((block) => block.graph?.query?.sourceMapMappingIds ?? [])),
+    conflictKeys: unique(blocks.flatMap((block) => block.graph?.query?.conflictKeys ?? [])),
+    summary: summary(blocks, records),
+    metadata: { authoredMachineGraphBlockIds: blocks.map((block) => block.id) }
+  };
+}
+
+function summary(blocks, records) {
+  return {
+    graphCount: blocks.length,
+    recordCount: records.length,
+    labelCount: sum(blocks, 'labels'),
+    directiveCount: sum(blocks, 'directives'),
+    registerCount: sum(blocks, 'registers'),
+    flagCount: sum(blocks, 'flags'),
+    basicBlockCount: sum(blocks, 'basicBlocks'),
+    instructionCount: sum(blocks, 'instructions'),
+    operandCount: sum(blocks, 'operands'),
+    memoryEffectCount: sum(blocks, 'memoryEffects'),
+    controlEdgeCount: sum(blocks, 'controlEdges'),
+    branchCount: sum(blocks, 'branches'),
+    callCount: sum(blocks, 'calls'),
+    returnCount: sum(blocks, 'returns'),
+    interruptCount: sum(blocks, 'interrupts'),
+    proofObligationCount: sum(blocks, 'proofObligations'),
+    proofGapCount: sum(blocks, 'proofGaps'),
+    evidenceCount: sum(blocks, 'evidence'),
+    memoryEffectsWithoutProof: sum(blocks, 'memoryEffectsWithoutProof'),
+    controlEdgesWithoutProof: sum(blocks, 'controlEdgesWithoutProof'),
+    branchesWithoutProof: sum(blocks, 'branchesWithoutProof'),
+    callsWithoutProof: sum(blocks, 'callsWithoutProof'),
+    interruptsWithoutProof: sum(blocks, 'interruptsWithoutProof')
+  };
+}
+
+function ids(records = []) { return records.map((record) => record?.id).filter(Boolean); }
+function unique(values = []) { return [...new Set(values.filter(Boolean))]; }
+function sum(blocks, key) { return blocks.reduce((total, block) => total + (block.summary?.[key] ?? 0), 0); }

package/dist/machine-graph.js

@@ -0,0 +1,307 @@
+import { createRowIdentityTracker } from './row-identity.js';
+
+const GROUPS = {
+  label: 'labels',
+  directive: 'directives',
+  register: 'registers',
+  flag: 'flags',
+  basicBlock: 'basicBlocks',
+  instruction: 'instructions',
+  operand: 'operands',
+  memoryEffect: 'memoryEffects',
+  controlEdge: 'controlEdges',
+  branch: 'branches',
+  call: 'calls',
+  return: 'returns',
+  interrupt: 'interrupts',
+  proofObligation: 'proofObligations',
+  proofGap: 'proofGaps',
+  evidence: 'evidence'
+};
+
+export function parseMachineGraphBlock(block) {
+  const name = nameFrom(block.header);
+  const rowIdentity = createRowIdentityTracker();
+  const graph = {
+    kind: 'frontier.lang.machineGraph',
+    version: 1,
+    id: idFrom(block.header, `machine_graph_${name}`),
+    architecture: readLine('architecture', block.body) ?? readLine('arch', block.body),
+    dialect: readLine('dialect', block.body),
+    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) ?? [],
+    labels: [],
+    directives: [],
+    registers: [],
+    flags: [],
+    basicBlocks: [],
+    instructions: [],
+    operands: [],
+    memoryEffects: [],
+    controlEdges: [],
+    branches: [],
+    calls: [],
+    returns: [],
+    interrupts: [],
+    proofObligations: [],
+    proofGaps: [],
+    evidence: [],
+    parser: { status: 'authored', errors: rowIdentity.errors },
+    claims: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      binaryEquivalenceClaim: false,
+      timingEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false
+    },
+    metadata: { name }
+  };
+
+  for (const authoredLine of readAuthoredLines(block)) {
+    const line = authoredLine.text;
+    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 = normalizeMachineRowKind(rowKind);
+    const record = parseMachineRecord(normalized, rowName, rest, graph, authoredLine);
+    const group = GROUPS[normalized];
+    if (record && group) rowIdentity.push(graph[group], record, { rowKind, normalizedRowKind: normalized, name: rowName });
+  }
+
+  graph.summary = summarizeMachineGraph(graph);
+  graph.status = deriveMachineGraphStatus(graph.status, graph.summary);
+  graph.query = {
+    labelIds: ids(graph.labels),
+    directiveIds: ids(graph.directives),
+    registerIds: ids(graph.registers),
+    flagIds: ids(graph.flags),
+    basicBlockIds: ids(graph.basicBlocks),
+    instructionIds: ids(graph.instructions),
+    operandIds: ids(graph.operands),
+    memoryEffectIds: ids(graph.memoryEffects),
+    controlEdgeIds: ids(graph.controlEdges),
+    branchIds: ids(graph.branches),
+    callIds: ids(graph.calls),
+    returnIds: ids(graph.returns),
+    interruptIds: ids(graph.interrupts),
+    controlFlowEdgeIds: ids([...graph.controlEdges, ...graph.branches, ...graph.calls, ...graph.returns, ...graph.interrupts]),
+    proofObligationIds: ids(graph.proofObligations),
+    proofGapCodes: unique(graph.proofGaps.map((record) => record.code)),
+    evidenceIds: unique([...graph.evidenceIds, ...ids(graph.evidence), ...allMachineRecords(graph).flatMap((record) => record.evidenceIds ?? [])]),
+    proofEvidenceIds: unique(allMachineRecords(graph).flatMap((record) => record.proofEvidenceIds ?? [])),
+    sourceMapIds: unique(allMachineRecords(graph).flatMap((record) => record.sourceMapIds ?? [])),
+    sourceMapMappingIds: unique(allMachineRecords(graph).flatMap((record) => record.sourceMapMappingIds ?? [])),
+    conflictKeys: unique(allMachineRecords(graph).map((record) => record.conflictKey)),
+    blockerReasonCodes: machineBlockerReasonCodes(graph)
+  };
+
+  return {
+    id: graph.id,
+    graph,
+    records: allMachineRecords(graph),
+    summary: {
+      graphCount: 1,
+      ...graph.summary
+    },
+    metadata: { name }
+  };
+}
+
+function parseMachineRecord(kind, name, text, graph, authoredLine = {}) {
+  const common = commonRecord(kind, name, text, graph, authoredLine);
+  if (kind === 'label') return cleanRecord({ ...common, labelKind: word('kind', text) ?? 'label', address: word('address', text) ?? word('addr', text), symbol: word('symbol', text) ?? name, exported: flag('exported', text) });
+  if (kind === 'directive') return cleanRecord({ ...common, directiveKind: word('kind', text) ?? word('directiveKind', text) ?? name, value: quoted('value', text) ?? word('value', text), arguments: list(text, 'argument', 'arguments', 'arg', 'args') });
+  if (kind === 'register') return cleanRecord({ ...common, registerName: word('register', text) ?? word('registerName', text) ?? name, registerKind: word('kind', text) ?? word('registerKind', text), widthBits: number('widthBits', text) ?? number('width', text), bank: word('bank', text), aliases: list(text, 'alias', 'aliases'), role: word('role', text) });
+  if (kind === 'flag') return cleanRecord({ ...common, flagName: word('flag', text) ?? word('flagName', text) ?? name, flagKind: word('kind', text) ?? word('flagKind', text), bit: number('bit', text), registerId: word('register', text) ?? word('registerId', text) });
+  if (kind === 'basicBlock') return cleanRecord({ ...common, blockKind: word('kind', text) ?? word('blockKind', text), entryInstructionId: word('entryInstruction', text) ?? word('entryInstructionId', text), exitInstructionId: word('exitInstruction', text) ?? word('exitInstructionId', text), instructionIds: list(text, 'instruction', 'instructions', 'instructionId', 'instructionIds'), successorIds: list(text, 'successor', 'successors', 'successorId', 'successorIds'), predecessorIds: list(text, 'predecessor', 'predecessors', 'predecessorId', 'predecessorIds'), address: word('address', text) ?? word('addr', text), proofStatus: word('proofStatus', text) ?? word('status', text) });
+  if (kind === 'instruction') return cleanRecord({ ...common, mnemonic: word('mnemonic', text) ?? word('op', text) ?? name, opcode: word('opcode', text), instructionKind: word('kind', text) ?? word('instructionKind', text), operationKind: word('operation', text) ?? word('operationKind', text), address: word('address', text) ?? word('addr', text), addressMode: word('addressMode', text) ?? word('mode', text), sizeBytes: number('sizeBytes', text) ?? number('size', text), cycles: number('cycles', text), reads: list(text, 'read', 'reads'), writes: list(text, 'write', 'writes'), flagsRead: list(text, 'flagRead', 'flagsRead'), flagsWritten: list(text, 'flagWrite', 'flagsWritten'), registerIds: list(text, 'register', 'registers', 'registerId', 'registerIds'), memoryEffectIds: list(text, 'memoryEffect', 'memoryEffects', 'memoryEffectId', 'memoryEffectIds'), controlFlow: word('controlFlow', text), branchTarget: word('branchTarget', text), callTarget: word('callTarget', text), proofStatus: word('proofStatus', text) ?? word('status', text), semanticEquivalenceClaim: false, binaryEquivalenceClaim: false, timingEquivalenceClaim: false });
+  if (kind === 'operand') return cleanRecord({ ...common, instructionId: word('instruction', text) ?? word('instructionId', text), operandIndex: number('index', text) ?? number('operandIndex', text), operandKind: word('kind', text) ?? word('operandKind', text), value: quoted('value', text) ?? word('value', text), registerIds: list(text, 'register', 'registers', 'registerId', 'registerIds'), memoryReference: quoted('memoryReference', text) ?? word('memoryReference', text) ?? word('memory', text), address: word('address', text) ?? word('addr', text), addressMode: word('addressMode', text) ?? word('mode', text), immediate: word('immediate', text), widthBits: number('widthBits', text) ?? number('width', text) });
+  if (kind === 'memoryEffect') return cleanRecord({ ...common, instructionId: word('instruction', text) ?? word('instructionId', text), resourceId: word('resource', text) ?? word('resourceId', text), memoryKind: word('memoryKind', text), effectKind: word('effectKind', text) ?? word('kind', text) ?? name, address: word('address', text) ?? word('addr', text), addressSpace: word('addressSpace', text) ?? word('space', text), widthBits: number('widthBits', text) ?? number('width', text), memoryOrder: word('memoryOrder', text) ?? word('ordering', text), reads: list(text, 'read', 'reads'), writes: list(text, 'write', 'writes'), bank: word('bank', text), volatile: flag('volatile', text), atomic: flag('atomic', text), io: flag('io', text), proofStatus: word('proofStatus', text) ?? word('status', text) ?? 'missing', semanticEquivalenceClaim: false, runtimeEquivalenceClaim: false });
+  if (kind === 'controlEdge') return cleanRecord({ ...common, instructionId: word('instruction', text) ?? word('instructionId', text), fromInstructionId: word('fromInstruction', text) ?? word('fromInstructionId', text) ?? word('from', text), toInstructionId: word('toInstruction', text) ?? word('toInstructionId', text) ?? word('to', text), fromBlockId: word('fromBlock', text) ?? word('fromBlockId', text), toBlockId: word('toBlock', text) ?? word('toBlockId', text), targetId: word('target', text) ?? word('targetId', text), edgeKind: word('edgeKind', text) ?? word('kind', text) ?? name, condition: quoted('condition', text) ?? word('condition', text), flagIds: list(text, 'flag', 'flags', 'flagId', 'flagIds', 'conditionFlag', 'conditionFlags'), callTarget: word('callTarget', text), returnTarget: word('returnTarget', text), proofStatus: word('proofStatus', text) ?? word('status', text) ?? 'missing', semanticEquivalenceClaim: false, runtimeEquivalenceClaim: false });
+  if (kind === 'branch') return cleanRecord({ ...common, instructionId: word('instruction', text) ?? word('instructionId', text), fromInstructionId: word('fromInstruction', text) ?? word('fromInstructionId', text) ?? word('from', text), toInstructionId: word('toInstruction', text) ?? word('toInstructionId', text), targetId: word('target', text) ?? word('targetId', text) ?? word('to', text), branchKind: word('kind', text) ?? word('branchKind', text), condition: quoted('condition', text) ?? word('condition', text), flagIds: list(text, 'flag', 'flags', 'flagId', 'flagIds'), proofStatus: word('proofStatus', text) ?? word('status', text) ?? 'missing', semanticEquivalenceClaim: false, runtimeEquivalenceClaim: false });
+  if (kind === 'call') return cleanRecord({ ...common, instructionId: word('instruction', text) ?? word('instructionId', text), targetId: word('target', text) ?? word('targetId', text), callableId: word('callable', text) ?? word('callableId', text), callingConvention: word('callingConvention', text) ?? word('convention', text), stackEffect: word('stackEffect', text), proofStatus: word('proofStatus', text) ?? word('status', text) ?? 'missing', semanticEquivalenceClaim: false, runtimeEquivalenceClaim: false });
+  if (kind === 'return') return cleanRecord({ ...common, instructionId: word('instruction', text) ?? word('instructionId', text), fromCallableId: word('fromCallable', text) ?? word('fromCallableId', text) ?? word('from', text), stackEffect: word('stackEffect', text), proofStatus: word('proofStatus', text) ?? word('status', text) });
+  if (kind === 'interrupt') return cleanRecord({ ...common, vector: word('vector', text), handlerId: word('handler', text) ?? word('handlerId', text), interruptKind: word('kind', text) ?? word('interruptKind', text), proofStatus: word('proofStatus', text) ?? word('status', text) ?? 'missing', semanticEquivalenceClaim: false, runtimeEquivalenceClaim: false });
+  if (kind === 'proofObligation') return cleanRecord({ ...common, subjectId: word('subject', text) ?? word('subjectId', text), subjectKind: word('subjectKind', text), obligationKind: word('obligationKind', text) ?? word('kind', text) ?? name, status: word('status', text) ?? 'missing', statement: quoted('statement', text) ?? quoted('summary', text), evidenceIds: list(text, 'evidence', 'evidenceIds') ?? common.evidenceIds, missingEvidence: list(text, 'missingEvidence') ?? common.missingEvidence, semanticEquivalenceClaim: false, runtimeEquivalenceClaim: false });
+  if (kind === 'proofGap') return cleanRecord({ ...common, code: word('code', text) ?? word('reasonCode', text) ?? name, status: word('status', text) ?? 'missing', summary: quoted('summary', text) ?? quoted('message', text), failClosed: common.failClosed ?? true, semanticEquivalenceClaim: false, binaryEquivalenceClaim: false, timingEquivalenceClaim: false, runtimeEquivalenceClaim: false });
+  if (kind === 'evidence') return cleanRecord({ ...common, evidenceKind: word('kind', text) ?? word('evidenceKind', text), status: word('status', text) ?? 'unknown', path: word('path', text), command: quoted('command', text) ?? word('command', text), sourceHash: word('sourceHash', text), traceHash: word('traceHash', text), binaryHash: word('binaryHash', text) });
+  return undefined;
+}
+
+function commonRecord(kind, name, text, graph, authoredLine = {}) {
+  return cleanRecord({
+    recordKind: recordKind(kind),
+    id: idFrom(text, `${recordPrefix(kind)}_${name}`),
+    name,
+    sourcePath: word('sourcePath', text) ?? word('path', text) ?? graph.sourcePath,
+    sourceHash: word('sourceHash', text) ?? graph.sourceHash,
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    evidenceIds: list(text, 'evidence', 'evidenceIds') ?? graph.evidenceIds,
+    proofEvidenceIds: list(text, 'proofEvidence', 'proofEvidenceId', 'proofEvidenceIds'),
+    proofObligationIds: list(text, 'proofObligation', 'proofObligations', 'proofObligationId', 'proofObligationIds', 'obligation', 'obligations'),
+    missingEvidence: list(text, 'missingEvidence'),
+    sourceMapIds: list(text, 'sourceMap', 'sourceMaps', 'sourceMapId', 'sourceMapIds'),
+    sourceMapMappingIds: list(text, 'sourceMapMapping', 'sourceMapMappings', 'sourceMapMappingId', 'sourceMapMappingIds'),
+    semanticNodeId: word('semanticNode', text) ?? word('semanticNodeId', text),
+    semanticSymbolId: word('semanticSymbol', text) ?? word('semanticSymbolId', text),
+    conflictKey: word('conflictKey', text),
+    reasonCode: word('reasonCode', text) ?? word('code', text),
+    failClosed: flag('failClosed', text),
+    metadata: { authoredName: name }
+  });
+}
+
+function summarizeMachineGraph(graph) {
+  return {
+    records: allMachineRecords(graph).length,
+    labels: graph.labels.length,
+    directives: graph.directives.length,
+    registers: graph.registers.length,
+    flags: graph.flags.length,
+    basicBlocks: graph.basicBlocks.length,
+    instructions: graph.instructions.length,
+    operands: graph.operands.length,
+    memoryEffects: graph.memoryEffects.length,
+    controlEdges: graph.controlEdges.length,
+    branches: graph.branches.length,
+    calls: graph.calls.length,
+    returns: graph.returns.length,
+    interrupts: graph.interrupts.length,
+    proofObligations: graph.proofObligations.length,
+    proofGaps: graph.proofGaps.length,
+    evidence: graph.evidence.length,
+    memoryEffectsWithoutProof: graph.memoryEffects.filter((record) => record.proofStatus !== 'passed').length,
+    controlEdgesWithoutProof: graph.controlEdges.filter((record) => record.proofStatus !== 'passed').length,
+    branchesWithoutProof: graph.branches.filter((record) => record.proofStatus !== 'passed').length,
+    callsWithoutProof: graph.calls.filter((record) => record.proofStatus !== 'passed').length,
+    interruptsWithoutProof: graph.interrupts.filter((record) => record.proofStatus !== 'passed').length,
+    parseErrors: graph.parser?.errors?.length ?? 0,
+    reasonCodes: unique([...unprovedMachineRecords(graph), ...graph.proofGaps].map((record) => record.reasonCode ?? record.code))
+  };
+}
+
+function deriveMachineGraphStatus(authoredStatus, summary) {
+  if (
+    summary.proofGaps > 0 ||
+    summary.memoryEffectsWithoutProof > 0 ||
+    summary.controlEdgesWithoutProof > 0 ||
+    summary.branchesWithoutProof > 0 ||
+    summary.callsWithoutProof > 0 ||
+    summary.interruptsWithoutProof > 0
+  ) return 'blocked';
+  return authoredStatus ?? 'partial';
+}
+
+function machineBlockerReasonCodes(graph) {
+  return unique([...unprovedMachineRecords(graph), ...graph.proofGaps].map((record) => record.reasonCode ?? record.code));
+}
+
+function unprovedMachineRecords(graph) {
+  return [
+    ...graph.memoryEffects,
+    ...graph.controlEdges,
+    ...graph.branches,
+    ...graph.calls,
+    ...graph.interrupts
+  ].filter((record) => record.proofStatus !== 'passed');
+}
+
+function allMachineRecords(graph) {
+  return [
+    ...graph.labels,
+    ...graph.directives,
+    ...graph.registers,
+    ...graph.flags,
+    ...graph.basicBlocks,
+    ...graph.instructions,
+    ...graph.operands,
+    ...graph.memoryEffects,
+    ...graph.controlEdges,
+    ...graph.branches,
+    ...graph.calls,
+    ...graph.returns,
+    ...graph.interrupts,
+    ...graph.proofObligations,
+    ...graph.proofGaps,
+    ...graph.evidence
+  ];
+}
+
+export function normalizeMachineRowKind(kind) {
+  if (kind === 'reg') return 'register';
+  if (kind === 'block') return 'basicBlock';
+  if (kind === 'inst' || kind === 'instr' || kind === 'op' || kind === 'opcode') return 'instruction';
+  if (kind === 'arg') return 'operand';
+  if (kind === 'mem' || kind === 'memory' || kind === 'memoryAccess' || kind === 'effect' || kind === 'load' || kind === 'store' || kind === 'atomic' || kind === 'fence' || kind === 'memoryEffect') return 'memoryEffect';
+  if (kind === 'edge') return 'controlEdge';
+  if (kind === 'ret') return 'return';
+  if (kind === 'irq' || kind === 'exception') return 'interrupt';
+  if (kind === 'proof' || kind === 'obligation') return 'proofObligation';
+  if (kind === 'gap' || kind === 'proofGap') return 'proofGap';
+  if (kind === 'proofEvidence') return 'evidence';
+  return kind;
+}
+
+function recordKind(kind) {
+  if (kind === 'memoryEffect') return 'memory-effect';
+  if (kind === 'proofGap') return 'proof-gap';
+  return kind;
+}
+
+function recordPrefix(kind) {
+  return recordKind(kind).replace(/-/g, '_');
+}
+
+function isGraphPropertyLine(line) {
+  const property = /^(architecture|arch|dialect|sourceLanguage|language|sourcePath|path|sourceHash|status|evidence|evidenceIds)\s+/.exec(line)?.[1];
+  if (!property) return false;
+  if ((property === 'evidence' || property === 'evidenceIds') && /@id\(/.test(line)) return false;
+  return true;
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'MachineGraph'; }
+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 word(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function quoted(label, text) { return new RegExp("(?:^|\\s)" + label + "\\s+[\"']([^\"']+)[\"']").exec(text)?.[1]?.trim(); }
+function flag(label, text) { return new RegExp('(?:^|\\s)' + label + '(?:\\s|$)').test(text) || undefined; }
+function number(label, text) {
+  const value = word(label, text);
+  return value === undefined ? undefined : Number(value);
+}
+function list(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 readAuthoredLines(block) {
+  const lines = block.body.split('\n');
+  const records = [];
+  let lineStart = block.syntax?.bodyStartOffset ?? 0;
+  for (const rawLine of lines) {
+    const rawEnd = lineStart + rawLine.length;
+    const leading = /^\s*/.exec(rawLine)?.[0].length ?? 0;
+    const trailing = /\s*$/.exec(rawLine)?.[0].length ?? 0;
+    const startOffset = lineStart + leading;
+    const endOffset = Math.max(startOffset, rawEnd - trailing);
+    records.push({ text: rawLine.trim(), sourceSpan: typeof block.sourceSpan === 'function' ? block.sourceSpan(startOffset, endOffset) : undefined });
+    lineStart = rawEnd + 1;
+  }
+  return records;
+}
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/dist/metadata.js

@@ -5,7 +5,7 @@ import { mergeTargetProjectionTargets } from './target-projection-aggregate.js';
 import { mergeConversionBlocks } from './conversion-metadata.js';
 import { mergeSemanticEditBlocks } from './semantic-edit-metadata.js';
 import { mergeGateAdmissionEvidenceBlocks } from './gate-admission-evidence.js';
-
+import { mergeMachineGraphBlocks } from './machine-graph-metadata.js';
 const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
 const PARADIGM_GROUPS = [
   'bindingScopes', 'bindings', 'patterns', 'typeConstraints', 'evaluationModels', 'memoryLocations', 'effectRegions',
@@ -13,7 +13,7 @@ const PARADIGM_GROUPS = [
   'clockModels', 'objectModels', 'macroExpansions', 'reflectionBoundaries', 'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], semanticEditBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], gateAdmissionEvidenceBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = [], runtimeCapabilityBlocks = [], targetProjectionTargets = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], semanticEditBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], gateAdmissionEvidenceBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], machineGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = [], runtimeCapabilityBlocks = [], targetProjectionTargets = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
@@ -26,6 +26,7 @@ export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], op
   if (dialectRegistryBlocks.length) metadata.dialects = mergeDialectRegistryBlocks(dialectRegistryBlocks);
   if (interlinguaBlocks.length) metadata.universalInterlingua = mergeInterlinguaBlocks(interlinguaBlocks);
   if (resourceGraphBlocks.length) metadata.semanticResourceGraphs = mergeResourceGraphBlocks(resourceGraphBlocks);
+  if (machineGraphBlocks.length) metadata.machineGraphs = mergeMachineGraphBlocks(machineGraphBlocks);
   if (packageManifestBlocks.length) metadata.packageManifests = mergePackageManifestBlocks(packageManifestBlocks);
   if (canvasSurfaceBlocks.length) metadata.canvasSurfaces = mergeCanvasSurfaceBlocks(canvasSurfaceBlocks);
   if (applicationSurfaceBlocks.length) metadata.applicationSurfaces = mergeApplicationSurfaceBlocks(applicationSurfaceBlocks);

package/dist/resource-graph.js

@@ -86,6 +86,7 @@ export function parseResourceGraphBlock(block) {
   graph.outlives = graph.lifetimeRelations;
   graph.borrowScopeRegions = graph.borrowScopes;
   graph.summary = summarize(graph);
+  graph.status = deriveGraphStatus(graph.status, graph.summary);
   graph.query = {
     resourceIds: ids(graph.resources),
     ownerIds: ids(graph.owners),
@@ -97,7 +98,7 @@ export function parseResourceGraphBlock(block) {
     lowLevelPrimitiveIds: ids([...graph.memoryRegions, ...graph.dataLayouts, ...graph.pointerEdges, ...graph.memoryAccesses, ...graph.abiBoundaries, ...graph.synchronizationEdges, ...graph.traps, ...graph.undefinedBehaviors]),
     sourcePaths: unique(allRecords(graph).map((record) => record.sourcePath)),
     evidenceIds: unique([...graph.evidenceIds, ...allRecords(graph).flatMap((record) => record.evidenceIds ?? [])]),
-    blockerReasonCodes: unique([...graph.conflicts, ...graph.synchronizationEdges, ...graph.traps, ...graph.undefinedBehaviors].map((record) => record.reasonCode))
+    blockerReasonCodes: blockerReasonCodes(graph)
   };
 
   return {
@@ -187,6 +188,22 @@ function summarize(graph) {
   };
 }
 
+function deriveGraphStatus(authoredStatus, summary) {
+  if (
+    summary.conflicts > 0 ||
+    summary.unsafeBoundariesWithoutProof > 0 ||
+    summary.synchronizationEdgesWithoutProof > 0 ||
+    summary.trapsWithoutProof > 0 ||
+    summary.undefinedBehaviorsWithoutProof > 0
+  ) return 'blocked';
+  return authoredStatus ?? 'partial';
+}
+
+function blockerReasonCodes(graph) {
+  const unprovedSynchronizationEdges = graph.synchronizationEdges.filter((record) => record.proofStatus !== 'passed');
+  return unique([...graph.conflicts, ...unprovedSynchronizationEdges, ...graph.traps, ...graph.undefinedBehaviors].map((record) => record.reasonCode));
+}
+
 function allRecords(graph) {
   return [
     ...graph.resources,

package/dist/source-block-kinds.js

@@ -33,6 +33,9 @@ export const FrontierSourceBlockKinds = Object.freeze([
   'universalInterlingua',
   'resourceGraph',
   'semanticResourceGraph',
+  'machineGraph',
+  'executionGraph',
+  'lowLevelGraph',
   'packageManifest',
   'packageGraph',
   'packageSurface',

package/dist/source-syntax-children.js

@@ -227,9 +227,9 @@ function readGenericRowSyntaxChildren(source, block, options, config) {
   for (const line of readBodyLines(source, block)) {
     if (!line.text || line.text.startsWith('#')) continue;
     const row = rowPattern.exec(line.text);
-    if (!row) { if (config.childKind === 'gateAdmissionEvidenceRow') children.push(genericUnknownRowChild(source, block, options, line, config, undefined, undefined, 'unsupported-gate-admission-row')); continue; }
+    if (!row) { if (unknownGenericRowsFailClosed(config)) children.push(genericUnknownRowChild(source, block, options, line, config, undefined, undefined, unsupportedGenericRowReason(config))); continue; }
     const [, rowKind, name, rest] = row;
-    if (!config.rowKinds.has(rowKind)) { if (config.childKind === 'gateAdmissionEvidenceRow') children.push(genericUnknownRowChild(source, block, options, line, config, rowKind, name, 'unsupported-gate-admission-row')); continue; }
+    if (!config.rowKinds.has(rowKind)) { if (unknownGenericRowsFailClosed(config)) children.push(genericUnknownRowChild(source, block, options, line, config, rowKind, name, unsupportedGenericRowReason(config))); continue; }
     const normalizedRowKind = config.normalize?.(rowKind) ?? rowKind;
     const id = idFrom(rest, `${config.idPrefix}_${safeId(normalizedRowKind)}_${safeId(name)}`);
     let recognized = true;
@@ -268,13 +268,16 @@ function genericUnknownRowChild(source, block, options, line, config, rowKind, n
   const resolvedName = name ?? rowKind ?? 'unknown';
   return cleanRecord({
     kind: config.childKind === 'gateAdmissionEvidenceRow' ? 'gateAdmissionUnknownRow' : 'genericUnknownRow', rowKind,
-    normalizedRowKind: 'unknown', name: resolvedName, id: `gate_admission_unknown_${safeId(rowKind ?? 'row')}_${line.startOffset}`,
+    normalizedRowKind: 'unknown', name: resolvedName, id: `${config.idPrefix}_unknown_${safeId(rowKind ?? 'row')}_${line.startOffset}`,
     header: line.text, startOffset: line.startOffset, endOffset: line.endOffset, location: sourcePosition(source, line.startOffset),
     parentKind: block.kind, parentId: block.id, parentName: block.name, moduleId: block.moduleId, moduleName: block.moduleName,
     sourceSpan: sourceSpan(source, block, line.startOffset, line.endOffset, options), recognized: false, reason
   });
 }
 
+function unknownGenericRowsFailClosed(config) { return config.childKind === 'gateAdmissionEvidenceRow' || config.childKind === 'machineGraphRow'; }
+function unsupportedGenericRowReason(config) { return config.childKind === 'machineGraphRow' ? 'unsupported-machine-graph-row' : 'unsupported-gate-admission-row'; }
+
 function readBodyLines(source, block) { return readTextLines(source, block.bodyStartOffset, block.bodyEndOffset); }
 
 function readTextLines(source, startOffset, endOffset) {
@@ -294,10 +297,7 @@ function readTextLines(source, startOffset, endOffset) {
   return records;
 }
 
-function sourcePosition(source, offset) {
-  const lines = source.slice(0, offset).split('\n');
-  return { line: lines.length, column: lines[lines.length - 1].length + 1, offset };
-}
+function sourcePosition(source, offset) { const lines = source.slice(0, offset).split('\n'); return { line: lines.length, column: lines[lines.length - 1].length + 1, offset }; }
 
 function sourceSpan(source, block, startOffset, endOffset, options = {}) {
   return cleanRecord({
@@ -315,6 +315,4 @@ function sourceSpan(source, block, startOffset, endOffset, options = {}) {
 function idFrom(header, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(header)?.[1] ?? fallback; }
 function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
 function safeId(value) { return String(value).replace(/[^A-Za-z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'row'; }
-function cleanRecord(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
-}
+function cleanRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0))); }

package/dist/source-syntax-row-config.js

@@ -3,6 +3,7 @@ const canvasRows = words('element command state stateWrite trace gap proofGap ev
 const constraintRows = words('variable var constraint hard soft preference prefer collapse admission');
 const dialectRows = words('dialect record extern');
 const interlinguaRows = words('layer constraint edge obligation proofObligation proof lowering lower source sourceLift lift evidence');
+const machineRows = words('label directive register reg flag conditionFlag basicBlock block instruction inst instr op opcode operand arg memoryEffect memoryAccess load store atomic fence memory mem effect controlEdge edge branch call return ret interrupt irq exception proof proofObligation obligation gap proofGap evidence proofEvidence');
 const packageRows = words('metadata dependency script export gap proofGap evidence proofEvidence');
 const runtimeRows = words('host runtimeHost hostProfile sourceHost targetHost capability hostCapability hostBinding binding requirement runtimeRequirement requiredRuntime evidence proofEvidence gap proofGap');
 const semanticEditRows = words('script semanticEditScript projection semanticEditProjection replay semanticEditReplay');
@@ -18,6 +19,9 @@ export const ROW_SYNTAX_CONFIG = Object.freeze({
   runtimeHosts: rowConfig('runtimeCapabilityRow', 'runtime_capability_row', runtimeRows, normalizeRuntimeCapabilityRow),
   resourceGraph: rowConfig('resourceGraphRow', 'resource_graph_row', words('resource owner loan alias move drop escape lifetime lifetimeRegion life outlives lifetimeRelation lifeRelation borrow borrowScope borrowRegion unsafe unsafeBoundary memory memoryRegion region layout dataLayout pointer ptr address access memoryAccess atomic volatile abi abiBoundary callBoundary sync synchronization synchronisation synchronizationEdge synchronisationEdge happensBefore hb fence fenceEdge barrier barrierEdge trap traps undefined undefinedBehavior undefinedBehaviour ub conflict proof proofObligation obligation'), normalizeResourceGraphRow),
   semanticResourceGraph: rowConfig('resourceGraphRow', 'resource_graph_row', words('resource owner loan alias move drop escape lifetime lifetimeRegion life outlives lifetimeRelation lifeRelation borrow borrowScope borrowRegion unsafe unsafeBoundary memory memoryRegion region layout dataLayout pointer ptr address access memoryAccess atomic volatile abi abiBoundary callBoundary sync synchronization synchronisation synchronizationEdge synchronisationEdge happensBefore hb fence fenceEdge barrier barrierEdge trap traps undefined undefinedBehavior undefinedBehaviour ub conflict proof proofObligation obligation'), normalizeResourceGraphRow),
+  machineGraph: rowConfig('machineGraphRow', 'machine_graph_row', machineRows, normalizeMachineGraphRow),
+  executionGraph: rowConfig('machineGraphRow', 'machine_graph_row', machineRows, normalizeMachineGraphRow),
+  lowLevelGraph: rowConfig('machineGraphRow', 'machine_graph_row', machineRows, normalizeMachineGraphRow),
   applicationSurface: rowConfig('applicationSurfaceRow', 'application_surface_row', appRows, normalizeApplicationSurfaceRow),
   appHost: rowConfig('applicationSurfaceRow', 'application_surface_row', appRows, normalizeApplicationSurfaceRow),
   plugin: rowConfig('applicationSurfaceRow', 'application_surface_row', appRows, normalizeApplicationSurfaceRow),
@@ -91,6 +95,22 @@ function normalizeResourceGraphRow(rowKind) {
   return rowKind;
 }
 
+function normalizeMachineGraphRow(rowKind) {
+  if (rowKind === 'reg') return 'register';
+  if (rowKind === 'conditionFlag') return 'flag';
+  if (rowKind === 'block') return 'basicBlock';
+  if (rowKind === 'inst' || rowKind === 'instr' || rowKind === 'op' || rowKind === 'opcode') return 'instruction';
+  if (rowKind === 'arg') return 'operand';
+  if (rowKind === 'memory' || rowKind === 'mem' || rowKind === 'memoryAccess' || rowKind === 'effect' || rowKind === 'load' || rowKind === 'store' || rowKind === 'atomic' || rowKind === 'fence') return 'memoryEffect';
+  if (rowKind === 'edge') return 'controlEdge';
+  if (rowKind === 'ret') return 'return';
+  if (rowKind === 'irq' || rowKind === 'exception') return 'interrupt';
+  if (rowKind === 'proof' || rowKind === 'obligation') return 'proofObligation';
+  if (rowKind === 'gap') return 'proofGap';
+  if (rowKind === 'proofEvidence') return 'evidence';
+  return rowKind;
+}
+
 function normalizeApplicationSurfaceRow(rowKind) {
   if (rowKind === 'provide' || rowKind === 'provides') return 'provided-surface';
   if (rowKind === 'required' || rowKind === 'requires' || rowKind === 'require') return 'required-capability';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.74",
+  "version": "0.3.76",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
   ],
   "scripts": {
     "build": "node scripts/build.mjs",
-    "test": "npm run build && node test/smoke.mjs && node test/member-identity-smoke.mjs && node test/generic-row-parse-identity-smoke.mjs && node test/type-variant-payload-smoke.mjs && node test/type-generic-ref-smoke.mjs && node test/type-parameter-constraints-smoke.mjs && node test/type-structural-expression-smoke.mjs && node test/action-body-smoke.mjs && node test/action-structured-literals-smoke.mjs && node test/action-return-smoke.mjs && node test/action-else-smoke.mjs && node test/action-match-smoke.mjs && node test/action-for-in-smoke.mjs && node test/action-repeat-smoke.mjs && node test/action-call-smoke.mjs && node test/semantic-operation-edit-smoke.mjs && node test/target-projection-aggregate-smoke.mjs && node test/conversion-constraint-fields-smoke.mjs && node test/conversion-evidence-smoke.mjs && node test/gate-admission-evidence-smoke.mjs && node test/package-canvas-surface-smoke.mjs && node test/view-render-graph-smoke.mjs && node test/resource-graph-smoke.mjs && node test/interlingua-smoke.mjs && node test/dialect-registry-smoke.mjs",
+    "test": "npm run build && node test/smoke.mjs && node test/member-identity-smoke.mjs && node test/generic-row-parse-identity-smoke.mjs && node test/type-variant-payload-smoke.mjs && node test/type-generic-ref-smoke.mjs && node test/type-parameter-constraints-smoke.mjs && node test/type-structural-expression-smoke.mjs && node test/action-body-smoke.mjs && node test/action-structured-literals-smoke.mjs && node test/action-return-smoke.mjs && node test/action-else-smoke.mjs && node test/action-match-smoke.mjs && node test/action-for-in-smoke.mjs && node test/action-repeat-smoke.mjs && node test/action-call-smoke.mjs && node test/semantic-operation-edit-smoke.mjs && node test/target-projection-aggregate-smoke.mjs && node test/conversion-constraint-fields-smoke.mjs && node test/conversion-evidence-smoke.mjs && node test/gate-admission-evidence-smoke.mjs && node test/package-canvas-surface-smoke.mjs && node test/view-render-graph-smoke.mjs && node test/resource-graph-smoke.mjs && node test/machine-graph-smoke.mjs && node test/interlingua-smoke.mjs && node test/dialect-registry-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",