@shapeshift-labs/frontier-lang-parser 0.3.29 → 0.3.31

package/README.md

@@ -347,10 +347,10 @@ plugin WeatherWidget @id("plugin_weather_widget") {
 The parser stores these blocks in `metadata.applicationSurfaces` and mirrors
 them under `metadata.universalAst.applicationSurfaces`. They are composition
 contracts, not compatibility proof: `runtimeEquivalenceClaim`,
-`abiCompatibilityClaim`, `projectionEquivalenceClaim`,
-`pluginCompatibilityClaim`, and `sandboxSafetyClaim` remain false until a
-higher layer supplies source-bound runtime, ABI, projection, and sandbox
-evidence.
+`autoMergeClaim`, `semanticEquivalenceClaim`, `abiCompatibilityClaim`,
+`projectionEquivalenceClaim`, `pluginCompatibilityClaim`, and
+`sandboxSafetyClaim` remain false until a higher layer supplies source-bound
+runtime, ABI, projection, sandbox, and admission evidence.
 
 ## Authored target projection syntax
 
@@ -475,6 +475,26 @@ conversion TodoJavascriptToRust @id("conversion_todo_js_rust") {
 
 `constraint` rows accept every universal conversion constraint family used by route admission, including hyphenated spellings such as `module-constraint`, `scope-binding`, `memory-model`, `effect-constraint`, `control-flow`, `borrow-scope`, `borrow-checker`, `host-environment`, `callable-boundary`, `adt-pattern`, `data-layout`, `numeric-semantics`, `text-semantics`, `collection-semantics`, `serialization-semantics`, `dependency-semantics`, `object-model`, and `protocol`. The parser preserves family-specific fields such as module specifiers, package conditions, binding/reference ids, memory ordering, locks, capabilities, host permissions, callable signatures, pattern exhaustiveness, ABI/layout hints, numeric/text/collection behavior, wire formats, dependency lockfile evidence, and effect adapters as authored evidence inputs. Record-level targets use explicit labels such as `effectTarget` so `role target` rows cannot be mistaken for an authored target field. These rows do not prove translation equivalence; they make the required proof surface explicit for downstream gates and admission records.
 
+## Authored runtime capability syntax
+
+`.frontier` files can describe runtime host profiles and proof evidence directly with `runtimeCapabilities`, `runtimeCapabilityMatrix`, or `runtimeHosts` blocks. These blocks are the file-authored shape of the runtime capability matrix input used by conversion planning: they name source hosts, target hosts, host capability support, adapter requirements, and runtime proof signals without claiming that the runtime behavior is equivalent.
+
+```frontier
+runtimeCapabilities WebToRust @id("runtime_caps_web_rust") {
+  sourceHost web @id("runtime_host_js_web") language javascript runtime web host browser target javascript alias js|jsx evidence evidence_runtime_fetch
+  targetHost rust @id("runtime_host_rust_cli") language rust runtime cli host native-cli target rust alias rs evidence evidence_runtime_fetch
+  hostBinding webFetchBinding @id("runtime_binding_web_fetch") host runtime_host_js_web capability fetch kind native-api apiName fetch globalName window.fetch evidence evidence_runtime_fetch
+  hostBinding rustFetchBinding @id("runtime_binding_rust_fetch") host runtime_host_rust_cli capability fetch kind package package reqwest symbol Client evidence evidence_runtime_fetch
+  hostCapability webFetch @id("runtime_cap_web_fetch") host runtime_host_js_web capability fetch support native binding runtime_binding_web_fetch evidence evidence_runtime_fetch
+  hostCapability rustFetch @id("runtime_cap_rust_fetch") host runtime_host_rust_cli capability fetch support adapter binding runtime_binding_rust_fetch evidence evidence_runtime_fetch
+  requirement fetchAdapter @id("runtime_requirement_fetch_adapter") sourceHost runtime_host_js_web targetHost runtime_host_rust_cli capability fetch hostCapability runtime_cap_rust_fetch binding runtime_binding_rust_fetch requiredSignals source-hash|target-hash|runtime-command|probe-id|telemetry-hash|network-trace-hash proofEvidence evidence_runtime_fetch evidence evidence_runtime_fetch missingEvidence target-adapter-fixture proofGap rust-fetch-adapter-boundary readiness needs-review reason "Fetch adapter needs replay proof."
+  evidence fetchProbe @id("evidence_runtime_fetch") kind runtime-adapter-proof status passed capability fetch sourceHost runtime_host_js_web targetHost runtime_host_rust_cli runtimeProofSignals source-hash|target-hash|runtime-command|probe-id|telemetry-hash|network-trace-hash command "npm run probe:fetch" probeId fetch-probe telemetryHash hash_telemetry networkTraceHash hash_network
+  gap domProbe @id("runtime_gap_dom_probe") code runtime-dom-proof status missing summary "DOM proof is not provided."
+}
+```
+
+The parser projects these rows into `metadata.runtimeCapabilities` and `metadata.runtimeCapabilityMatrix` as `frontier.lang.authoredRuntimeCapabilityMatrixInput`. `sourceHost` and `targetHost` rows become host profiles and selectors, `hostCapability` rows attach support facts to a host, `hostBinding` rows preserve concrete native/package/API binding evidence, `requirement` rows become fail-closed runtime proof obligations, and `evidence` rows carry source-bound proof signals such as commands, probe ids, telemetry hashes, network traces, layout snapshots, bitmap hashes, sandbox policies, and adapter binding hashes. The compiler can use this authored input when building a `universalRuntimeCapabilityMatrix`, but the authored file still keeps `runtimeEquivalenceClaim`, `semanticEquivalenceClaim`, `renderEquivalenceClaim`, and `autoMergeClaim` false.
+
 ## Authored dialect registry syntax
 
 `.frontier` files can carry reusable dialect registries with `dialectRegistry` or `universalDialectRegistry` blocks. These blocks describe language-specific constructs that should stay visible during translation instead of being silently collapsed into generic stubs.

package/dist/application-surface.js

@@ -57,6 +57,11 @@ export function parseApplicationSurfaceBlock(block) {
 
 export function mergeApplicationSurfaceBlocks(blocks) {
   const records = blocks.flatMap((block) => block.records ?? []);
+  const evidenceIds = [
+    ...blocks.flatMap((block) => ids(block.evidence)),
+    ...records.flatMap((record) => record.evidenceIds ?? []),
+    ...records.flatMap((record) => record.proofEvidenceIds ?? [])
+  ];
   return {
     id: blocks.length === 1 ? blocks[0].id : 'applicationSurfaces:source',
     surfaces: blocks,
@@ -69,7 +74,7 @@ export function mergeApplicationSurfaceBlocks(blocks) {
     eventIds: idsByRecordKind(records, 'event'),
     assetIds: idsByRecordKind(records, 'asset'),
     gateIds: idsByRecordKind(records, 'gate'),
-    evidenceIds: blocks.flatMap((block) => ids(block.evidence)),
+    evidenceIds: [...new Set(evidenceIds.filter(Boolean))],
     proofGapCodes: [...new Set(blocks.flatMap((block) => (block.proofGaps ?? []).map((gap) => gap.code).filter(Boolean)))],
     summary: {
       surfaceCount: blocks.length,
@@ -100,7 +105,7 @@ function applicationRecord(kind, name, text, context) {
     surfaceName: context.surfaceName,
     role: context.role,
     identityKey: readInlineWord('identity', text) ?? readInlineWord('identityKey', text) ?? `${kind}:${context.role}:${recordName}`,
-    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text) ?? context.sourcePath,
+    sourcePath: readInlineWord('sourcePath', text) ?? context.sourcePath,
     sourceHash: readInlineWord('sourceHash', text) ?? context.sourceHash,
     sourceSpan: parseSpan(readInlineWord('sourceSpan', text)),
     evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),

package/dist/index.js

@@ -12,6 +12,7 @@ import { parsePackageManifestBlock } from './package-manifest.js';
 import { parseParadigmBlock } from './paradigm.js';
 import { parseProofBlock } from './proof.js';
 import { parseResourceGraphBlock } from './resource-graph.js';
+import { parseRuntimeCapabilityBlock } from './runtime-capability.js';
 import { parseNativeSourceBlock } from './source-evidence.js';
 import { parseTargetProjectionMetadata } from './target-projection.js';
 import { parseViewBlock } from './view.js';
@@ -31,6 +32,7 @@ export function parseFrontierSource(source, options = {}) {
   const packageManifestBlocks = [];
   const canvasSurfaceBlocks = [];
   const applicationSurfaceBlocks = [];
+  const runtimeCapabilityBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
   for (const block of readBlocks(source)) {
@@ -62,8 +64,9 @@ export function parseFrontierSource(source, options = {}) {
     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, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks, runtimeCapabilityBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -73,7 +76,7 @@ function readName(source) { return /module\s+([A-Za-z_$][\w$]*)/.exec(source)?.[
 function readId(source) { return /module\s+[A-Za-z_$][\w$]*\s+@id\(\s*["']([^"']+)["']\s*\)/.exec(source)?.[1]; }
 function readBlocks(source) {
   const blocks = [];
-  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations|conversion|universalConversionPlan|constraintSpace|possibilitySpace|decisionGraph|admissionGraph|dialectRegistry|universalDialectRegistry|interlingua|universalInterlingua|resourceGraph|semanticResourceGraph|packageManifest|packageGraph|packageSurface|canvasSurface|canvasGraph|applicationSurface|appHost|plugin|pluginSurface|pluginContract)\s+([^{}]+)\{/g;
+  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations|conversion|universalConversionPlan|constraintSpace|possibilitySpace|decisionGraph|admissionGraph|dialectRegistry|universalDialectRegistry|interlingua|universalInterlingua|resourceGraph|semanticResourceGraph|packageManifest|packageGraph|packageSurface|canvasSurface|canvasGraph|applicationSurface|appHost|plugin|pluginSurface|pluginContract|runtimeCapabilities|runtimeCapabilityMatrix|runtimeHosts)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/metadata.js

@@ -1,30 +1,15 @@
 import { mergeDialectRegistryBlocks } from './dialect-registry.js';
 import { mergeApplicationSurfaceBlocks } from './application-surface.js';
+import { mergeRuntimeCapabilityBlocks } from './runtime-capability.js';
 
 const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
 const PARADIGM_GROUPS = [
-  'bindingScopes',
-  'bindings',
-  'patterns',
-  'typeConstraints',
-  'evaluationModels',
-  'memoryLocations',
-  'effectRegions',
-  'controlRegions',
-  'logicPrograms',
-  'actorSystems',
-  'stackEffects',
-  'arrayShapes',
-  'numericKernels',
-  'dataflowNetworks',
-  'clockModels',
-  'objectModels',
-  'macroExpansions',
-  'reflectionBoundaries',
-  'loweringRecords'
+  'bindingScopes', 'bindings', 'patterns', 'typeConstraints', 'evaluationModels', 'memoryLocations', 'effectRegions',
+  'controlRegions', 'logicPrograms', 'actorSystems', 'stackEffects', 'arrayShapes', 'numericKernels', 'dataflowNetworks',
+  'clockModels', 'objectModels', 'macroExpansions', 'reflectionBoundaries', 'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = [], runtimeCapabilityBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
@@ -38,8 +23,12 @@ export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], op
   if (packageManifestBlocks.length) metadata.packageManifests = mergePackageManifestBlocks(packageManifestBlocks);
   if (canvasSurfaceBlocks.length) metadata.canvasSurfaces = mergeCanvasSurfaceBlocks(canvasSurfaceBlocks);
   if (applicationSurfaceBlocks.length) metadata.applicationSurfaces = mergeApplicationSurfaceBlocks(applicationSurfaceBlocks);
-  if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length) || packageManifestBlocks.length || canvasSurfaceBlocks.length || applicationSurfaceBlocks.length) {
-    metadata.universalAst = mergeUniversalAstBlocks(nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks);
+  if (runtimeCapabilityBlocks.length) {
+    metadata.runtimeCapabilities = mergeRuntimeCapabilityBlocks(runtimeCapabilityBlocks);
+    metadata.runtimeCapabilityMatrix = metadata.runtimeCapabilities;
+  }
+  if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length) || packageManifestBlocks.length || canvasSurfaceBlocks.length || applicationSurfaceBlocks.length || runtimeCapabilityBlocks.length) {
+    metadata.universalAst = mergeUniversalAstBlocks(nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks, runtimeCapabilityBlocks);
   }
   return Object.keys(metadata).length ? metadata : undefined;
 }
@@ -110,7 +99,7 @@ function mergeConstraintSpaceBlocks(blocks) {
   };
 }
 
-function mergeUniversalAstBlocks(blocks, packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = []) {
+function mergeUniversalAstBlocks(blocks, packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = [], runtimeCapabilityBlocks = []) {
   return {
     id: blocks.length === 1 ? `universalAst:${blocks[0].node.id}` : 'universalAst:source',
     nativeSourceIds: blocks.map((block) => block.node.id),
@@ -121,14 +110,17 @@ function mergeUniversalAstBlocks(blocks, packageManifestBlocks = [], canvasSurfa
     packageManifests: packageManifestBlocks,
     canvasSurfaces: canvasSurfaceBlocks,
     applicationSurfaces: applicationSurfaceBlocks,
+    runtimeCapabilities: runtimeCapabilityBlocks,
     packageManifestIds: ids(packageManifestBlocks),
     canvasSurfaceIds: ids(canvasSurfaceBlocks),
     applicationSurfaceIds: ids(applicationSurfaceBlocks),
+    runtimeCapabilityIds: ids(runtimeCapabilityBlocks),
     metadata: {
       authoredNativeSourceIds: blocks.map((block) => block.node.id),
       authoredPackageManifestIds: ids(packageManifestBlocks),
       authoredCanvasSurfaceIds: ids(canvasSurfaceBlocks),
-      authoredApplicationSurfaceIds: ids(applicationSurfaceBlocks)
+      authoredApplicationSurfaceIds: ids(applicationSurfaceBlocks),
+      authoredRuntimeCapabilityIds: ids(runtimeCapabilityBlocks)
     }
   };
 }

package/dist/runtime-capability-records.js

@@ -0,0 +1,153 @@
+export function summarizeRuntimeCapabilities(matrix) {
+  return {
+    blockCount: matrix.blocks?.length ?? 1,
+    hostProfileCount: matrix.hostProfiles.length,
+    sourceHostCount: matrix.sourceHosts.length,
+    targetHostCount: matrix.targetHosts.length,
+    hostCapabilityCount: matrix.hostCapabilities?.length ?? 0,
+    hostBindingCount: matrix.hostBindings?.length ?? 0,
+    capabilityCount: matrix.hostProfiles.reduce((total, profile) => total + Object.keys(profile.capabilities ?? {}).length, 0),
+    runtimeRequirementCount: matrix.runtimeRequirements.length,
+    evidenceCount: matrix.evidence.length,
+    proofGapCount: matrix.proofGaps.length
+  };
+}
+
+export function runtimeFalseClaims() {
+  return {
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    renderEquivalenceClaim: false,
+    projectionEquivalenceClaim: false,
+    hostCapabilityEquivalenceClaim: false
+  };
+}
+
+export function runtimeEvidence(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `runtime_evidence_${safeId(name)}`),
+    name,
+    kind: readInlineWord('kind', text) ?? 'runtime-adapter-proof',
+    status: readInlineWord('status', text) ?? 'unknown',
+    capability: readInlineWord('capability', text) ?? readInlineWord('runtimeCapability', text) ?? readInlineWord('runtimeProofCapability', text),
+    runtimeCapability: readInlineWord('runtimeCapability', text),
+    runtimeProofCapability: readInlineWord('runtimeProofCapability', text),
+    sourceHost: readInlineWord('sourceHost', text) ?? readInlineWord('sourceHostId', text),
+    targetHost: readInlineWord('targetHost', text) ?? readInlineWord('targetHostId', text),
+    adapterRequirementId: readInlineWord('adapterRequirement', text) ?? readInlineWord('adapterRequirementId', text),
+    runtimeAdapterRequirementId: readInlineWord('runtimeAdapterRequirement', text) ?? readInlineWord('runtimeAdapterRequirementId', text),
+    runtimeProofSignals: readInlineList(text, 'runtimeProofSignal', 'runtimeProofSignals', 'proofSignal', 'proofSignals', 'signal', 'signals'),
+    sourceHash: readInlineWord('sourceHash', text),
+    targetHash: readInlineWord('targetHash', text),
+    outputHash: readInlineWord('outputHash', text),
+    command: readInlineQuoted('command', text) ?? readInlineWord('command', text),
+    runtimeCommand: readInlineQuoted('runtimeCommand', text) ?? readInlineWord('runtimeCommand', text),
+    probeId: readInlineWord('probeId', text) ?? readInlineWord('probe', text),
+    telemetryHash: readInlineWord('telemetryHash', text),
+    eventTraceHash: readInlineWord('eventTraceHash', text),
+    networkTraceHash: readInlineWord('networkTraceHash', text),
+    storageSnapshotHash: readInlineWord('storageSnapshotHash', text),
+    filesystemTraceHash: readInlineWord('filesystemTraceHash', text),
+    processTraceHash: readInlineWord('processTraceHash', text),
+    environmentSnapshotHash: readInlineWord('environmentSnapshotHash', text),
+    shellPolicyHash: readInlineWord('shellPolicyHash', text) ?? readInlineWord('shellPolicy', text),
+    secretScopePolicyHash: readInlineWord('secretScopePolicyHash', text) ?? readInlineWord('secretScopePolicy', text),
+    domSnapshotHash: readInlineWord('domSnapshotHash', text),
+    computedStyleHash: readInlineWord('computedStyleHash', text),
+    layoutSnapshotHash: readInlineWord('layoutSnapshotHash', text),
+    accessibilitySnapshotHash: readInlineWord('accessibilitySnapshotHash', text),
+    focusTraceHash: readInlineWord('focusTraceHash', text),
+    bitmapHash: readInlineWord('bitmapHash', text),
+    drawCommandTraceHash: readInlineWord('drawCommandTraceHash', text),
+    gpuCommandTraceHash: readInlineWord('gpuCommandTraceHash', text),
+    wasmModuleHash: readInlineWord('wasmModuleHash', text),
+    sandboxPolicyHash: readInlineWord('sandboxPolicyHash', text),
+    workerMessageTraceHash: readInlineWord('workerMessageTraceHash', text),
+    deterministicInputHash: readInlineWord('deterministicInputHash', text),
+    adapterBindingHash: readInlineWord('adapterBindingHash', text),
+    path: readInlineWord('path', text),
+    summary: readInlineQuoted('summary', text),
+    claims: runtimeFalseClaims()
+  });
+}
+
+export function runtimeProofGap(name, text) {
+  const code = readInlineWord('code', text) ?? name;
+  return cleanRecord({
+    id: idFrom(text, `runtime_gap_${safeId(code)}`),
+    code,
+    status: readInlineWord('status', text) ?? 'not-claimed',
+    summary: readInlineQuoted('summary', text) ?? readInlineQuoted('message', text),
+    failClosed: true,
+    ...runtimeFalseClaims()
+  });
+}
+
+export function isPropertyLine(line) {
+  return /^(generatedAt|version|claim|claims)\s+/.test(line);
+}
+
+export function idFrom(text, fallback) {
+  return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback;
+}
+
+export function nameFrom(header) {
+  return /^([A-Za-z_$][\w$-]*)/.exec(header)?.[1] ?? 'RuntimeCapabilities';
+}
+
+export function readInlineWord(label, text) {
+  return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim();
+}
+
+export function readInlineQuoted(label, text) {
+  return new RegExp("(?:^|\\s)" + label + "\\s+[\"']([^\"']+)[\"']").exec(text)?.[1]?.trim();
+}
+
+export function readInlineFlag(label, text) {
+  return new RegExp('(?:^|\\s)' + label + '(?:\\s|$)').test(text) || undefined;
+}
+
+export function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(text)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+
+export function ids(records = []) {
+  return records.map((record) => record?.id).filter(Boolean);
+}
+
+export function hostIds(records = []) {
+  return records.map((record) => typeof record === 'string' ? record : record?.id).filter(Boolean);
+}
+
+export function uniqueRecords(records = []) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = record?.id ?? JSON.stringify(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export function uniqueHostSelectors(records = []) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = typeof record === 'string' ? record : record?.id ?? JSON.stringify(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0) && (!value || typeof value !== 'object' || Object.keys(value).length > 0)));
+}
+
+export function safeId(value) {
+  return String(value ?? 'unknown').replace(/[^A-Za-z0-9_$-]+/g, '_');
+}

package/dist/runtime-capability.js

@@ -0,0 +1,271 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import {
+  cleanRecord,
+  hostIds,
+  idFrom,
+  ids,
+  isPropertyLine,
+  nameFrom,
+  readInlineFlag,
+  readInlineList,
+  readInlineQuoted,
+  readInlineWord,
+  runtimeEvidence,
+  runtimeFalseClaims,
+  runtimeProofGap,
+  safeId,
+  summarizeRuntimeCapabilities,
+  uniqueHostSelectors,
+  uniqueRecords
+} from './runtime-capability-records.js';
+
+export function parseRuntimeCapabilityBlock(block) {
+  const name = nameFrom(block.header);
+  const matrix = {
+    kind: 'frontier.lang.authoredRuntimeCapabilityMatrixInput',
+    version: 1,
+    id: idFrom(block.header, `runtime_capabilities_${safeId(name)}`),
+    name,
+    hostProfiles: [],
+    sourceHosts: [],
+    targetHosts: [],
+    hostCapabilities: [],
+    hostBindings: [],
+    runtimeRequirements: [],
+    evidence: [],
+    proofGaps: [],
+    claims: runtimeFalseClaims(),
+    metadata: { authoredName: name, authoredBlockKind: block.kind }
+  };
+  const hostMap = new Map();
+
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || isPropertyLine(line)) continue;
+    const match = /^(host|runtimeHost|hostProfile|sourceHost|targetHost|capability|hostCapability|hostBinding|binding|requirement|runtimeRequirement|requiredRuntime|evidence|proofEvidence|gap|proofGap)\s+([A-Za-z_$@/.:*-][\w$./@:*+-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, rowKind, rowName, rest] = match;
+    if (rowKind === 'gap' || rowKind === 'proofGap') {
+      matrix.proofGaps.push(runtimeProofGap(rowName, rest));
+      continue;
+    }
+    if (rowKind === 'evidence' || rowKind === 'proofEvidence') {
+      matrix.evidence.push(runtimeEvidence(rowName, rest));
+      continue;
+    }
+    if (rowKind === 'requirement' || rowKind === 'runtimeRequirement' || rowKind === 'requiredRuntime') {
+      matrix.runtimeRequirements.push(runtimeRequirement(rowName, rest));
+      continue;
+    }
+    if (rowKind === 'capability' || rowKind === 'hostCapability') {
+      attachCapability(hostMap, matrix, rowName, rest);
+      continue;
+    }
+    if (rowKind === 'hostBinding' || rowKind === 'binding') {
+      matrix.hostBindings.push(runtimeHostBinding(rowName, rest));
+      continue;
+    }
+    const profile = runtimeHostProfile(rowKind, rowName, rest);
+    upsertHost(hostMap, matrix, profile, rowKind);
+  }
+
+  matrix.hostProfiles = [...hostMap.values()];
+  matrix.hostCapabilities = uniqueRecords(matrix.hostCapabilities);
+  matrix.hostBindings = uniqueRecords(matrix.hostBindings);
+  matrix.hostProfileIds = ids(matrix.hostProfiles);
+  matrix.sourceHostIds = hostIds(matrix.sourceHosts);
+  matrix.targetHostIds = hostIds(matrix.targetHosts);
+  matrix.hostCapabilityIds = ids(matrix.hostCapabilities);
+  matrix.hostBindingIds = ids(matrix.hostBindings);
+  matrix.runtimeRequirementIds = ids(matrix.runtimeRequirements);
+  matrix.evidenceIds = ids(matrix.evidence);
+  matrix.proofGapCodes = [...new Set(matrix.proofGaps.map((gap) => gap.code).filter(Boolean))];
+  matrix.summary = summarizeRuntimeCapabilities(matrix);
+  matrix.inputHash = hashSemanticValue({
+    kind: 'frontier.lang.runtimeCapabilities.authoredInput.v1',
+    hostProfiles: matrix.hostProfiles.map((profile) => ({
+      id: profile.id,
+      language: profile.language,
+      runtime: profile.runtime,
+      target: profile.target,
+      capabilities: Object.keys(profile.capabilities ?? {}).sort()
+    })),
+    hostCapabilities: matrix.hostCapabilityIds,
+    hostBindings: matrix.hostBindingIds,
+    sourceHosts: matrix.sourceHostIds,
+    targetHosts: matrix.targetHostIds,
+    runtimeRequirements: matrix.runtimeRequirements.map((requirement) => ({
+      id: requirement.id,
+      capability: requirement.capability,
+      sourceHost: requirement.sourceHost,
+      targetHost: requirement.targetHost,
+      requiredSignals: requirement.requiredSignals
+    })),
+    proofGaps: matrix.proofGapCodes
+  });
+  return matrix;
+}
+
+export function mergeRuntimeCapabilityBlocks(blocks) {
+  const hostProfiles = uniqueRecords(blocks.flatMap((block) => block.hostProfiles ?? []));
+  const sourceHosts = uniqueHostSelectors(blocks.flatMap((block) => block.sourceHosts ?? []));
+  const targetHosts = uniqueHostSelectors(blocks.flatMap((block) => block.targetHosts ?? []));
+  const hostCapabilities = uniqueRecords(blocks.flatMap((block) => block.hostCapabilities ?? []));
+  const hostBindings = uniqueRecords(blocks.flatMap((block) => block.hostBindings ?? []));
+  const runtimeRequirements = uniqueRecords(blocks.flatMap((block) => block.runtimeRequirements ?? []));
+  const evidence = uniqueRecords(blocks.flatMap((block) => block.evidence ?? []));
+  const proofGaps = uniqueRecords(blocks.flatMap((block) => block.proofGaps ?? []));
+  return {
+    kind: 'frontier.lang.authoredRuntimeCapabilityMatrixInput',
+    version: 1,
+    id: blocks.length === 1 ? blocks[0].id : 'runtimeCapabilities:source',
+    blocks,
+    blockIds: ids(blocks),
+    hostProfiles,
+    sourceHosts,
+    targetHosts,
+    hostCapabilities,
+    hostBindings,
+    runtimeRequirements,
+    evidence,
+    proofGaps,
+    hostProfileIds: ids(hostProfiles),
+    sourceHostIds: hostIds(sourceHosts),
+    targetHostIds: hostIds(targetHosts),
+    hostCapabilityIds: ids(hostCapabilities),
+    hostBindingIds: ids(hostBindings),
+    runtimeRequirementIds: ids(runtimeRequirements),
+    evidenceIds: ids(evidence),
+    proofGapCodes: [...new Set(proofGaps.map((gap) => gap.code).filter(Boolean))],
+    summary: summarizeRuntimeCapabilities({ hostProfiles, sourceHosts, targetHosts, hostCapabilities, hostBindings, runtimeRequirements, evidence, proofGaps }),
+    claims: runtimeFalseClaims(),
+    metadata: { authoredRuntimeCapabilityBlockIds: ids(blocks) }
+  };
+}
+
+function runtimeHostProfile(rowKind, name, text) {
+  const id = idFrom(text, name);
+  const [languageFromId, runtimeFromId] = String(id).includes(':') ? String(id).split(':') : [];
+  return cleanRecord({
+    kind: 'frontier.lang.runtimeHostProfile',
+    id,
+    name: readInlineWord('name', text) ?? name,
+    language: readInlineWord('language', text) ?? languageFromId,
+    aliases: readInlineList(text, 'alias', 'aliases'),
+    runtime: readInlineWord('runtime', text) ?? runtimeFromId,
+    host: readInlineWord('host', text),
+    target: readInlineWord('target', text),
+    capabilities: {},
+    notes: readInlineList(text, 'note', 'notes'),
+    role: rowKind === 'sourceHost' ? 'source' : rowKind === 'targetHost' ? 'target' : readInlineWord('role', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    sourceHash: readInlineWord('sourceHash', text),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    claims: runtimeFalseClaims()
+  });
+}
+
+function upsertHost(hostMap, matrix, profile, rowKind) {
+  const existing = hostMap.get(profile.id) ?? { capabilities: {} };
+  const merged = cleanRecord({
+    ...existing,
+    ...profile,
+    capabilities: { ...(existing.capabilities ?? {}), ...(profile.capabilities ?? {}) }
+  });
+  hostMap.set(merged.id, merged);
+  if (rowKind === 'sourceHost' || merged.role === 'source') matrix.sourceHosts.push(merged.id);
+  if (rowKind === 'targetHost' || merged.role === 'target') matrix.targetHosts.push(merged.id);
+}
+
+function attachCapability(hostMap, matrix, name, text) {
+  const hostId = readInlineWord('host', text) ?? readInlineWord('hostId', text) ?? readInlineWord('sourceHost', text) ?? readInlineWord('targetHost', text);
+  if (!hostId) return;
+  const profile = hostMap.get(hostId) ?? runtimeHostProfile('host', hostId, '');
+  const capability = readInlineWord('capability', text) ?? readInlineWord('kind', text) ?? name;
+  const bindingId = readInlineWord('bindingId', text) ?? readInlineWord('binding', text);
+  const capabilityRecord = cleanRecord({
+    kind: 'frontier.lang.runtimeCapability.hostCapability',
+    id: idFrom(text, `runtime_capability_${safeId(hostId)}_${safeId(capability)}`),
+    name,
+    hostId,
+    host: hostId,
+    capability,
+    support: readInlineWord('support', text) ?? 'native',
+    permission: readInlineWord('permission', text),
+    bindingId,
+    binding: bindingId,
+    requiredSignals: readInlineList(text, 'requiredSignal', 'requiredSignals', 'signal', 'signals'),
+    proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    missingEvidence: readInlineList(text, 'missingEvidence', 'missingEvidences'),
+    proofGaps: readInlineList(text, 'proofGap', 'proofGaps'),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    sourceHash: readInlineWord('sourceHash', text),
+    failClosed: true,
+    claims: runtimeFalseClaims()
+  });
+  const normalized = cleanRecord({
+    kind: capability,
+    support: capabilityRecord.support,
+    binding: capabilityRecord.binding ?? `${hostId}.${capability}`,
+    notes: readInlineList(text, 'note', 'notes'),
+    evidenceIds: capabilityRecord.evidenceIds,
+    sourcePath: capabilityRecord.sourcePath,
+    sourceHash: capabilityRecord.sourceHash
+  });
+  profile.capabilities = { ...(profile.capabilities ?? {}), [capability]: normalized };
+  hostMap.set(hostId, profile);
+  matrix.hostCapabilities.push(capabilityRecord);
+  if (readInlineFlag('source', text) || readInlineWord('role', text) === 'source') matrix.sourceHosts.push(hostId);
+  if (readInlineFlag('target', text) || readInlineWord('role', text) === 'target') matrix.targetHosts.push(hostId);
+}
+
+function runtimeHostBinding(name, text) {
+  return cleanRecord({
+    kind: 'frontier.lang.runtimeCapability.hostBinding',
+    id: idFrom(text, `runtime_binding_${safeId(name)}`),
+    name,
+    hostId: readInlineWord('host', text) ?? readInlineWord('hostId', text) ?? readInlineWord('sourceHost', text) ?? readInlineWord('targetHost', text),
+    capability: readInlineWord('capability', text) ?? readInlineWord('kind', text),
+    bindingKind: readInlineWord('bindingKind', text) ?? readInlineWord('kind', text),
+    packageName: readInlineWord('package', text) ?? readInlineWord('packageName', text),
+    importPath: readInlineWord('import', text) ?? readInlineWord('importPath', text),
+    symbol: readInlineWord('symbol', text),
+    apiName: readInlineWord('apiName', text),
+    globalName: readInlineWord('globalName', text),
+    command: readInlineQuoted('command', text) ?? readInlineWord('command', text),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceIds'),
+    missingEvidence: readInlineList(text, 'missingEvidence', 'missingEvidences'),
+    proofGaps: readInlineList(text, 'proofGap', 'proofGaps'),
+    failClosed: true,
+    claims: runtimeFalseClaims()
+  });
+}
+
+function runtimeRequirement(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `runtime_requirement_${safeId(name)}`),
+    name,
+    capability: readInlineWord('capability', text) ?? readInlineWord('kind', text) ?? name,
+    capabilities: readInlineList(text, 'capability', 'capabilities'),
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? readInlineWord('language', text),
+    target: readInlineWord('target', text) ?? readInlineWord('targetLanguage', text),
+    sourceRuntime: readInlineWord('sourceRuntime', text) ?? readInlineWord('runtime', text),
+    targetRuntime: readInlineWord('targetRuntime', text),
+    sourceHost: readInlineWord('sourceHost', text) ?? readInlineWord('sourceHostId', text),
+    targetHost: readInlineWord('targetHost', text) ?? readInlineWord('targetHostId', text),
+    reason: readInlineQuoted('reason', text) ?? readInlineWord('reason', text),
+    requiredSignals: readInlineList(text, 'requiredSignal', 'requiredSignals', 'signal', 'signals', 'proofSignal', 'proofSignals'),
+    proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    hostCapabilityIds: readInlineList(text, 'hostCapability', 'hostCapabilityIds'),
+    bindingIds: readInlineList(text, 'binding', 'bindingIds', 'hostBinding', 'hostBindingIds'),
+    missingEvidence: readInlineList(text, 'missingEvidence', 'missingEvidences'),
+    proofGaps: readInlineList(text, 'proofGap', 'proofGaps'),
+    status: readInlineWord('status', text),
+    readiness: readInlineWord('readiness', text),
+    failClosed: true,
+    claims: runtimeFalseClaims()
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.29",
+  "version": "0.3.31",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",