@shapeshift-labs/frontier-lang-parser 0.3.75 → 0.3.77

package/README.md

@@ -97,6 +97,12 @@ The published Frontier package family is generated from one shared package catal
 - [`@shapeshift-labs/frontier-documentation`](https://www.npmjs.com/package/@shapeshift-labs/frontier-documentation): Frontier-native documentation manifests, generated documentation books, package/API/source discovery, Vite virtual modules, standalone browser docs shells, inspector bridges, search indexes, and documentation harness evidence for Frontier apps and packages.
 - [`@shapeshift-labs/frontier-ast-walk`](https://www.npmjs.com/package/@shapeshift-labs/frontier-ast-walk): Dependency-light source graph, import/export/declaration/call analysis, Frontier package-use discovery, and business-logic placement findings for Frontier tools, apps, docs, fuzzers, benchmarks, and agent evidence.
 - [`@shapeshift-labs/frontier-history`](https://www.npmjs.com/package/@shapeshift-labs/frontier-history): Serializable temporal explanation and causality records for Frontier apps, including field-change explanations, action/workflow/policy/effect/trace/test provenance, audit windows, undo planning, registry/provenance graph output, JSONL replay bundles, and proof hashes.
+- [`@shapeshift-labs/frontier-explain`](https://www.npmjs.com/package/@shapeshift-labs/frontier-explain): Renderer-neutral interactive explanation contracts for Frontier apps, including explanation manifests, narrative graphs, figure specs, model/state records, controls, semantic trace and replay records, structure projections, invariants, accessibility metadata, provenance, and evidence/probe contracts.
+- [`@shapeshift-labs/frontier-explain-graph`](https://www.npmjs.com/package/@shapeshift-labs/frontier-explain-graph): Graph, grid, tree, table, matrix, and algorithm/data-structure explanation builders for Frontier interactive explanations, including stable projections, worklist/frontier panels, pseudocode links, operation vocabularies, trace fixtures, counters, and invariant witnesses.
+- [`@shapeshift-labs/frontier-explain-sim`](https://www.npmjs.com/package/@shapeshift-labs/frontier-explain-sim): Simulation explanation contracts for Frontier interactive explanations, including deterministic clocks, phases, sampled fields, constraint records, particle/advection frames, curve samples, plot materialization records, and replayable simulation evidence without owning domain-specific solvers.
+- [`@shapeshift-labs/frontier-explain-render`](https://www.npmjs.com/package/@shapeshift-labs/frontier-explain-render): Renderer-neutral materialization for Frontier explanations, including frame records, mark/layer/label layout records, hit regions, linked representation frames, static fallback frames, coordinate spaces, cameras, and renderer adapter records.
+- [`@shapeshift-labs/frontier-explain-test`](https://www.npmjs.com/package/@shapeshift-labs/frontier-explain-test): Reusable test and evidence contracts for Frontier explanations, including deterministic replay checks, figure probes, control replay plans, accessibility expectations, static fallback checks, trace assertions, visual evidence records, and evidence summaries.
+- [`@shapeshift-labs/frontier-explain-author`](https://www.npmjs.com/package/@shapeshift-labs/frontier-explain-author): Serializable authoring contracts for Frontier explanations, including explanation documents, narrative graphs, control presets, citation/provenance records, authoring diagnostics, stale-link checks, gallery records, and publication planning records.
 - [`@shapeshift-labs/frontier-application`](https://www.npmjs.com/package/@shapeshift-labs/frontier-application): Serializable whole-application graph and impact queries for Frontier apps, including features, owners, packages, routes, views, actions, mutations, state paths, effects, workers, assets, tests, traces, policies, workflows, migrations, benchmarks, registry graph output, feature maps, JSONL bundles, and proof hashes.
 - [`@shapeshift-labs/frontier-linter`](https://www.npmjs.com/package/@shapeshift-labs/frontier-linter): Serializable Frontier lint rules, diagnostics, fixes, reports, and fast rule execution for package catalogs, registry graphs, application maps, manifests, traces, policies, workflows, workers, assets, tests, benchmarks, and source snippets.
 - [`@shapeshift-labs/frontier-framework`](https://www.npmjs.com/package/@shapeshift-labs/frontier-framework): High-level app framework package for Frontier applications, including configuration, CLI scaffolding, Vite builds, monorepo layout, TSX route builds, split frontend/backend deploy artifacts, backend-neutral Fetch handler and sync transport contracts, runtime data-source migrations, devtools, harness gates, agent MCP/tool manifests, CI evidence gates, workflow manifests, SARIF/linter output, replay scripts, and evidence manifest output.
@@ -204,6 +210,12 @@ Package source repositories:
 - [`siliconjungle/-shapeshift-labs-frontier-documentation`](https://github.com/siliconjungle/-shapeshift-labs-frontier-documentation)
 - [`siliconjungle/-shapeshift-labs-frontier-ast-walk`](https://github.com/siliconjungle/-shapeshift-labs-frontier-ast-walk)
 - [`siliconjungle/-shapeshift-labs-frontier-history`](https://github.com/siliconjungle/-shapeshift-labs-frontier-history)
+- [`siliconjungle/-shapeshift-labs-frontier-explain`](https://github.com/siliconjungle/-shapeshift-labs-frontier-explain)
+- [`siliconjungle/-shapeshift-labs-frontier-explain-graph`](https://github.com/siliconjungle/-shapeshift-labs-frontier-explain-graph)
+- [`siliconjungle/-shapeshift-labs-frontier-explain-sim`](https://github.com/siliconjungle/-shapeshift-labs-frontier-explain-sim)
+- [`siliconjungle/-shapeshift-labs-frontier-explain-render`](https://github.com/siliconjungle/-shapeshift-labs-frontier-explain-render)
+- [`siliconjungle/-shapeshift-labs-frontier-explain-test`](https://github.com/siliconjungle/-shapeshift-labs-frontier-explain-test)
+- [`siliconjungle/-shapeshift-labs-frontier-explain-author`](https://github.com/siliconjungle/-shapeshift-labs-frontier-explain-author)
 - [`siliconjungle/-shapeshift-labs-frontier-application`](https://github.com/siliconjungle/-shapeshift-labs-frontier-application)
 - [`siliconjungle/-shapeshift-labs-frontier-linter`](https://github.com/siliconjungle/-shapeshift-labs-frontier-linter)
 - [`siliconjungle/-shapeshift-labs-frontier-framework`](https://github.com/siliconjungle/-shapeshift-labs-frontier-framework)

package/dist/index.d.ts

@@ -29,6 +29,14 @@ export interface FrontierSourceChildSyntaxRecord {
   readonly id?: string;
   readonly family?: string;
   readonly role?: string;
+  readonly parentRenderId?: string;
+  readonly typeSource?: string;
+  readonly action?: string;
+  readonly value?: string;
+  readonly values?: readonly string[];
+  readonly expression?: string;
+  readonly viewRenderKind?: string;
+  readonly optional?: boolean;
   readonly reason?: string;
   readonly header: string;
   readonly startOffset: number;

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/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

@@ -1,9 +1,9 @@
 import { readActionSyntaxChildren } from './action-syntax-children.js';
 import { ROW_SYNTAX_CONFIG } from './source-syntax-row-config.js';
 import { readTypeExpressionSyntaxChildren } from './source-syntax-type-expressions.js';
+import { readViewSyntaxChildren } from './source-syntax-view-children.js';
 import { inspectTypeExpressionSyntax } from './type-expressions.js';
 import { inspectVariantPayload } from './type-variants.js';
-
 const ROW_NAME_PATTERN = '([A-Za-z_$@./:*+-][\\w$./@:*+-]*)';
 
 export function readSourceSyntaxChildren(source, block, options = {}) {
@@ -31,6 +31,8 @@ export function readSourceSyntaxChildren(source, block, options = {}) {
       duplicateNameReason: 'duplicate-state-collection-name',
       duplicateIdReason: 'duplicate-state-collection-id'
     });
+  } else if (block.kind === 'view') {
+    children = readViewSyntaxChildren(source, block, options);
   } else {
     const rowConfig = ROW_SYNTAX_CONFIG[block.kind];
     if (rowConfig) children = readGenericRowSyntaxChildren(source, block, options, rowConfig);
@@ -227,9 +229,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 +270,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 +299,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 +317,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/dist/source-syntax-view-children.js

@@ -0,0 +1,152 @@
+export function readViewSyntaxChildren(source, block, options = {}) {
+  const children = [];
+  const ranges = readRenderRanges(source.slice(block.bodyStartOffset, block.bodyEndOffset), block.bodyStartOffset);
+  for (const line of readBodyLines(source, block.bodyStartOffset, block.bodyEndOffset)) {
+    if (!line.text || line.text.startsWith('#') || inRange(line.startOffset, ranges)) continue;
+    const child = viewRowChild(source, block, options, line);
+    children.push(child ?? unknownViewChild(source, block, options, line, 'unsupported-view-row'));
+  }
+  for (const range of ranges) {
+    children.push(renderHeaderChild(source, block, options, range));
+    const nested = ranges.filter((candidate) => candidate.parentRenderId === range.id);
+    for (const line of readBodyLines(source, range.bodyStartOffset, range.bodyEndOffset)) {
+      if (!line.text || line.text.startsWith('#') || inRange(line.startOffset, nested)) continue;
+      const child = renderRowChild(source, block, options, line, range);
+      children.push(child ?? unknownViewChild(source, block, options, line, 'unsupported-view-render-row', range.id));
+    }
+  }
+  return children;
+}
+
+function viewRowChild(source, block, options, line) {
+  const reads = /^(reads?)\s+(.+)$/.exec(line.text);
+  if (reads) return childRecord(source, block, options, line, { kind: 'viewRead', rowKind: reads[1], name: reads[2].trim(), id: `view_read_${safeId(block.name)}_${line.startOffset}`, values: readList(reads[2]) });
+  const dispatch = /^(dispatch(?:es)?)\s+(.+)$/.exec(line.text);
+  if (dispatch) return childRecord(source, block, options, line, { kind: 'viewDispatch', rowKind: dispatch[1], name: dispatch[2].trim(), id: `view_dispatch_${safeId(block.name)}_${line.startOffset}`, values: readList(dispatch[2]) });
+  const prop = /^prop\s+([A-Za-z_$][\w$.-]*)(?:\s+@id\(\s*["']([^"']+)["']\s*\))?\s*:\s*(.+)$/.exec(line.text);
+  if (prop) return childRecord(source, block, options, line, { kind: 'viewProp', rowKind: 'prop', name: prop[1], id: prop[2] ?? `view_prop_${prop[1]}`, typeSource: prop[3].replace(/\s+optional\s*$/, '').trim(), optional: /\soptional\s*$/.test(prop[3]) || undefined });
+  const event = /^event\s+([A-Za-z_$][\w$.-]*)(?:\s+@id\(\s*["']([^"']+)["']\s*\))?(.*)$/.exec(line.text);
+  if (event) return childRecord(source, block, options, line, { kind: 'viewEvent', rowKind: 'event', name: event[1], id: event[2] ?? `view_event_${event[1]}`, action: readInlineWord('action', event[3]), typeSource: readInlineType('input', event[3]) });
+  return undefined;
+}
+
+function renderHeaderChild(source, block, options, range) {
+  return childRecord(source, block, options, range, {
+    kind: 'viewRender',
+    rowKind: 'render',
+    name: range.name,
+    id: range.id,
+    viewRenderKind: readInlineWord('kind', range.header) ?? 'element',
+    parentRenderId: range.parentRenderId
+  });
+}
+
+function renderRowChild(source, block, options, line, range) {
+  const identity = /^(identity|key)\s+(.+)$/.exec(line.text);
+  if (identity) return childRecord(source, block, options, line, { kind: 'viewRenderIdentity', rowKind: identity[1], name: identity[2].trim(), id: `${range.id}_${identity[1]}`, value: identity[2].trim(), parentRenderId: range.id });
+  const text = /^text\s+(.+)$/.exec(line.text);
+  if (text) return childRecord(source, block, options, line, { kind: 'viewRenderText', rowKind: 'text', name: 'text', id: `${range.id}_text`, ...readRenderValue(text[1]), parentRenderId: range.id });
+  const attr = /^(component|tag|tagName|kind)\s+(.+)$/.exec(line.text);
+  if (attr) return childRecord(source, block, options, line, { kind: 'viewRenderAttribute', rowKind: attr[1], name: attr[1], id: `${range.id}_${safeId(attr[1])}`, value: attr[2].trim(), parentRenderId: range.id });
+  const prop = /^prop\s+([A-Za-z_$][\w$.-]*)\s+(.+)$/.exec(line.text);
+  if (prop) return childRecord(source, block, options, line, { kind: 'viewRenderProp', rowKind: 'prop', name: prop[1], id: `${range.id}_prop_${safeId(prop[1])}`, ...readRenderValue(prop[2]), parentRenderId: range.id });
+  const event = /^on\s+([A-Za-z_$][\w$.-]*)\s+([A-Za-z_$][\w$.-]*)/.exec(line.text);
+  if (event) return childRecord(source, block, options, line, { kind: 'viewRenderEvent', rowKind: 'on', name: event[1], id: `${range.id}_on_${safeId(event[1])}`, action: event[2], parentRenderId: range.id });
+  const child = /^(children?|child)\s+(.+)$/.exec(line.text);
+  if (child) return childRecord(source, block, options, line, { kind: 'viewRenderChildren', rowKind: child[1], name: 'children', id: `${range.id}_children`, values: readList(child[2]), parentRenderId: range.id });
+  return undefined;
+}
+
+function readRenderRanges(body, baseOffset, parentRenderId) {
+  const ranges = [];
+  for (const range of readTopLevelRenderRanges(body, baseOffset, parentRenderId)) {
+    ranges.push(range, ...readRenderRanges(body.slice(range.bodyStartOffset - baseOffset, range.bodyEndOffset - baseOffset), range.bodyStartOffset, range.id));
+  }
+  return ranges;
+}
+
+function readTopLevelRenderRanges(body, baseOffset, parentRenderId) {
+  const structure = scanStructure(body), ranges = [];
+  const header = /(^|\n)\s*render\s+([^{}\n]+)\{/g;
+  let match;
+  while ((match = header.exec(body))) {
+    const start = match.index + match[1].length + (/^\s*/.exec(body.slice(match.index + match[1].length))?.[0].length ?? 0);
+    const open = header.lastIndex - 1;
+    if (!structure.codeOffsets[start] || !structure.codeOffsets[open] || structure.depthBefore[start] !== 0) continue;
+    const close = structure.bracePairs.get(open);
+    if (close === undefined) continue;
+    const headerText = (match[2] ?? '').trim(), name = nameFrom(headerText);
+    ranges.push({ header: headerText, name, id: idFrom(headerText, `render_${name}`), startOffset: baseOffset + start, endOffset: baseOffset + close + 1, bodyStartOffset: baseOffset + open + 1, bodyEndOffset: baseOffset + close, parentRenderId });
+    header.lastIndex = close + 1;
+  }
+  return ranges;
+}
+
+function childRecord(source, block, options, line, input) {
+  return cleanRecord({
+    ...input,
+    normalizedRowKind: input.normalizedRowKind ?? input.rowKind,
+    header: line.header ?? line.text ?? source.slice(line.startOffset, line.endOffset).trim(),
+    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: input.recognized ?? true
+  });
+}
+
+function unknownViewChild(source, block, options, line, reason, parentRenderId) {
+  const rowKind = /^([A-Za-z_$][\w$-]*)\b/.exec(line.text)?.[1];
+  return childRecord(source, block, options, line, { kind: 'viewUnknownRow', rowKind, normalizedRowKind: 'unknown', name: rowKind ?? 'unknown', id: `view_unknown_${safeId(rowKind ?? 'row')}_${line.startOffset}`, parentRenderId, recognized: false, reason });
+}
+
+function readBodyLines(source, startOffset, endOffset) {
+  const lines = source.slice(startOffset, endOffset).split('\n');
+  const records = [];
+  let lineStart = startOffset;
+  for (const rawLine of lines) {
+    const rawEnd = lineStart + rawLine.length, leading = /^\s*/.exec(rawLine)?.[0].length ?? 0, trailing = /\s*$/.exec(rawLine)?.[0].length ?? 0;
+    const start = lineStart + leading, end = Math.max(start, rawEnd - trailing);
+    records.push({ text: rawLine.trim(), startOffset: start, endOffset: end });
+    lineStart = rawEnd + 1;
+  }
+  return records;
+}
+
+function scanStructure(source) {
+  const depthBefore = new Int32Array(source.length + 1), codeOffsets = new Uint8Array(source.length), stack = [], bracePairs = new Map();
+  let depth = 0, state = 'code', quote = '';
+  for (let index = 0; index < source.length; index++) {
+    depthBefore[index] = depth;
+    const char = source[index], next = source[index + 1];
+    if (state === 'line-comment') { if (char === '\n') state = 'code'; continue; }
+    if (state === 'block-comment') { if (char === '*' && next === '/') { index++; state = 'code'; } continue; }
+    if (state === 'string') { if (char === '\\') { index++; continue; } if (char === quote) state = 'code'; continue; }
+    codeOffsets[index] = 1;
+    if (char === '#') { state = 'line-comment'; continue; }
+    if (char === '"' || char === "'" || char === '`') { state = 'string'; quote = char; continue; }
+    if (char === '/' && next === '*') { index++; state = 'block-comment'; continue; }
+    if (char === '/' && next === '/') { index++; state = 'line-comment'; continue; }
+    if (char === '{') { stack.push(index); depth++; continue; }
+    if (char === '}') { const open = stack.pop(); if (open !== undefined) { depth = Math.max(0, depth - 1); bracePairs.set(open, index); } }
+  }
+  depthBefore[source.length] = depth;
+  return { depthBefore, codeOffsets, bracePairs };
+}
+
+function inRange(offset, ranges) { return ranges.some((range) => offset >= range.startOffset && offset < range.endOffset); }
+function readList(value) { return value.split(',').map((item) => item.trim()).filter(Boolean); }
+function readInlineWord(label, text = '') { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function readInlineType(label, text = '') { return new RegExp('(?:^|\\s)' + label + '\\s+(.+)$').exec(text)?.[1]?.trim(); }
+function readRenderValue(value) { const quoted = /^["']([^"']+)["']$/.exec(value.trim()); return quoted ? { value: quoted[1] } : { expression: value.trim() }; }
+function idFrom(header, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(header)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$.-]*)/.exec(header)?.[1] ?? 'Unnamed'; }
+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({ sourceId: options.documentId, path: options.sourcePath, blockId: block.id, blockKind: block.kind, startOffset, endOffset, start: sourcePosition(source, startOffset), end: sourcePosition(source, endOffset) }); }
+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))); }

package/package.json

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