@shapeshift-labs/frontier-lang-parser 0.3.22 → 0.3.24

package/README.md

@@ -220,6 +220,23 @@ npm install @shapeshift-labs/frontier-lang-parser
 
 The parser projects text into `@shapeshift-labs/frontier-lang-kernel` documents. The syntax is intentionally small and experimental.
 
+## Authored target projection syntax
+
+`.frontier` target blocks can carry projection contracts next to their emit settings. These rows describe what a target lowering claims to represent, what it still needs proof for, and which losses or missing evidence must stay visible to merge and translation tooling.
+
+```frontier
+target rust @id("target_rust") {
+  language rust
+  package example_todo
+  emitPath src/generated/todo.rs
+  moduleFormat crate
+  projection rustAdapter @id("target_projection_rust") disposition target-adapter readiness needs-review represented semantic-symbol|source-map missing semantic-ownership evidence artifact_todo_title_probe proof artifact_todo_title_probe loss loss_borrow_scope missingEvidence translation-borrow-scope:borrow-across-await
+  layer ownership @id("target_layer_rust_ownership") kind semantic-ownership status missing missingEvidence translation-borrow-scope:borrow-across-await
+}
+```
+
+The parser stores these rows on the target node metadata as `projectionContracts` and `projectionLayers`. They are target-lowering evidence, not proof of equivalence: `autoMergeClaim` and `semanticEquivalenceClaim` remain false.
+
 ## Authored decision graph syntax
 
 `.frontier` files can carry semantic merge admission evidence directly in `decisionGraph` or `admissionGraph` blocks. These blocks preserve the causal review shape around a candidate edit: semantic changes, gates, evidence records, patch events, admission decisions, merge decisions, graph nodes, and graph edges.
@@ -311,6 +328,21 @@ conversion TodoJavascriptToRust @id("conversion_todo_js_rust") {
 
 `sourceRuntime` and `targetRuntime` become runtime maps. `runtimeRequirement` rows become proof obligations for host/runtime capabilities, including authored `requiredSignals` denominators such as source hashes, target hashes, probe ids, runtime commands, telemetry hashes, and capability-specific trace hashes. `proofEvidence` and `evidence` attach evidence ids, but the compiler still requires bound evidence records before a proof obligation is satisfied. `dialect` and `extern` rows preserve dialect-specific constructs, projection readiness, loss/evidence ids, and binding metadata without requiring the authored Frontier file to drop down to raw JSON.
 
+## 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.
+
+```frontier
+dialectRegistry RuntimeDialects @id("dialect_registry_runtime") {
+  language javascript
+  sourcePath src/runtime.ts
+  dialect nodeProcess @id("dialect_registry_node_process") dialect node.runtime kind runtime name process.env target rust disposition unsupported readiness blocked loss loss_node_process_projection evidence evidence_node_runtime sourceMap sourcemap_todo_ts
+  extern viteRoutes @id("dialect_registry_vite_routes") dialect vite.plugin.virtual-module externKind generatorArtifact target rust disposition runtime-required readiness needs-review evidence evidence_vite_routes_manifest bindingSymbol virtual:routes module vite
+}
+```
+
+The parser projects these rows into `metadata.dialects` as a `frontier.lang.universalDialectRegistry`-shaped object. `dialect` rows become universal dialect records, `extern` rows become universal extern records, and projection fields preserve target disposition, readiness, evidence ids, loss ids, source-map ids, and binding metadata. Registry records are evidence for route scoring, not proof of equivalent behavior: authored metadata keeps `autoMergeClaim` and `semanticEquivalenceClaim` false.
+
 ## Authored possibility spaces
 
 `.frontier` files can describe a governed space of valid implementations with `constraintSpace` or `possibilitySpace` blocks. These blocks are metadata-only: they do not add kernel nodes, but they preserve the variables, hard constraints, preferences, collapse strategies, and admission rules that let tools reason about semantic merge, translation, refactoring, and runtime projection as constraint satisfaction.

package/dist/dialect-registry.js

@@ -0,0 +1,184 @@
+export function parseDialectRegistryBlock(block) {
+  const name = nameFrom(block.header);
+  const registry = {
+    kind: 'frontier.lang.universalDialectRegistry',
+    version: 1,
+    id: idFrom(block.header, `dialect_registry_${name}`),
+    language: readWord('language', block.body),
+    dialect: readWord('dialect', block.body),
+    sourcePath: readWord('sourcePath', block.body) ?? readWord('path', block.body),
+    dialects: [],
+    externs: [],
+    metadata: {
+      authoredDialectRegistry: true,
+      authoredDialectRegistryBlockName: name,
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    }
+  };
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const dialect = /^(?:dialect|record)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    const extern = /^extern\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (dialect) registry.dialects.push(dialectRecord(registry, dialect[1], dialect[2]));
+    if (extern) registry.externs.push(externRecord(registry, extern[1], extern[2]));
+  }
+  return summarizeRegistry(registry);
+}
+
+export function mergeDialectRegistryBlocks(blocks = []) {
+  if (!blocks.length) return undefined;
+  return summarizeRegistry({
+    kind: 'frontier.lang.universalDialectRegistry',
+    version: 1,
+    id: blocks.length === 1 ? blocks[0].id : 'dialect_registry:source',
+    language: first(blocks.map((block) => block.language)),
+    dialects: uniqueById(blocks.flatMap((block) => block.dialects ?? [])),
+    externs: uniqueById(blocks.flatMap((block) => block.externs ?? [])),
+    metadata: {
+      authoredDialectRegistryBlockIds: blocks.map((block) => block.id),
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    }
+  });
+}
+
+function dialectRecord(registry, name, text) {
+  return cleanRecord({
+    kind: 'frontier.lang.universalDialectRecord',
+    version: 1,
+    id: idFrom(text, `dialect_${name}`),
+    language: readInlineWord('language', text) ?? registry.language,
+    dialect: readInlineWord('dialect', text) ?? registry.dialect ?? name,
+    constructKind: readInlineWord('constructKind', text) ?? readInlineWord('kind', text) ?? 'runtime',
+    name: readInlineWord('name', text) ?? name,
+    nativeKind: readInlineWord('nativeKind', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text) ?? registry.sourcePath,
+    nativeSourceId: readInlineWord('nativeSource', text) ?? readInlineWord('nativeSourceId', text),
+    nativeAstId: readInlineWord('nativeAst', text) ?? readInlineWord('nativeAstId', text),
+    nativeAstNodeId: readInlineWord('nativeAstNode', text) ?? readInlineWord('nativeAstNodeId', text),
+    semanticNodeId: readInlineWord('semanticNode', text) ?? readInlineWord('semanticNodeId', text),
+    semanticSymbolId: readInlineWord('symbol', text) ?? readInlineWord('semanticSymbol', text) ?? readInlineWord('semanticSymbolId', text),
+    semanticOccurrenceId: readInlineWord('semanticOccurrence', text) ?? readInlineWord('semanticOccurrenceId', text),
+    sourceMapId: readInlineWord('sourceMap', text) ?? readInlineWord('sourceMapId', text),
+    sourceMapMappingId: readInlineWord('sourceMapMapping', text) ?? readInlineWord('sourceMapMappingId', text),
+    externIds: readInlineList(text, 'extern', 'externId', 'externIds') ?? [],
+    lossIds: readInlineList(text, 'loss', 'lossId', 'lossIds') ?? [],
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds') ?? [],
+    projection: projectionRecord(text),
+    metadata: { semanticEquivalenceClaim: false, autoMergeClaim: false }
+  });
+}
+
+function externRecord(registry, name, text) {
+  const binding = cleanRecord({
+    module: readInlineWord('module', text),
+    path: readInlineWord('bindingPath', text) ?? readInlineWord('path', text),
+    symbol: readInlineWord('bindingSymbol', text) ?? readInlineWord('symbol', text),
+    abi: readInlineWord('abi', text),
+    version: readInlineWord('version', text)
+  });
+  return cleanRecord({
+    kind: 'frontier.lang.universalExternRecord',
+    version: 1,
+    id: idFrom(text, `extern_${name}`),
+    language: readInlineWord('language', text) ?? registry.language,
+    dialect: readInlineWord('dialect', text) ?? registry.dialect ?? name,
+    externKind: readInlineWord('externKind', text) ?? readInlineWord('kind', text) ?? 'foreignSymbol',
+    name: readInlineWord('name', text) ?? name,
+    ...(Object.keys(binding).length ? { binding } : {}),
+    sourcePath: readInlineWord('sourcePath', text) ?? registry.sourcePath,
+    nativeSourceId: readInlineWord('nativeSource', text) ?? readInlineWord('nativeSourceId', text),
+    nativeAstId: readInlineWord('nativeAst', text) ?? readInlineWord('nativeAstId', text),
+    nativeAstNodeId: readInlineWord('nativeAstNode', text) ?? readInlineWord('nativeAstNodeId', text),
+    semanticNodeId: readInlineWord('semanticNode', text) ?? readInlineWord('semanticNodeId', text),
+    semanticSymbolId: readInlineWord('semanticSymbol', text) ?? readInlineWord('semanticSymbolId', text),
+    sourceMapId: readInlineWord('sourceMap', text) ?? readInlineWord('sourceMapId', text),
+    sourceMapMappingId: readInlineWord('sourceMapMapping', text) ?? readInlineWord('sourceMapMappingId', text),
+    lossIds: readInlineList(text, 'loss', 'lossId', 'lossIds') ?? [],
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds') ?? [],
+    projection: projectionRecord(text),
+    metadata: { semanticEquivalenceClaim: false, autoMergeClaim: false }
+  });
+}
+
+function projectionRecord(text) {
+  const lossIds = readInlineList(text, 'projectionLoss', 'projectionLossIds', 'loss', 'lossId', 'lossIds') ?? [];
+  const disposition = readInlineWord('disposition', text) ?? (lossIds.length ? 'lossy' : 'review-required');
+  return cleanRecord({
+    disposition,
+    readiness: readInlineWord('readiness', text) ?? readinessForDisposition(disposition),
+    targets: readInlineList(text, 'target', 'targets', 'targetLanguage') ?? [],
+    lossIds,
+    evidenceIds: readInlineList(text, 'projectionEvidence', 'projectionEvidenceIds', 'evidence', 'evidenceId', 'evidenceIds') ?? [],
+    sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMapId', 'sourceMapIds'),
+    sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappingId', 'sourceMapMappingIds'),
+    notes: readInlineList(text, 'note', 'notes')
+  });
+}
+
+function summarizeRegistry(registry) {
+  const dialects = uniqueById(registry.dialects ?? []);
+  const externs = uniqueById(registry.externs ?? []);
+  const records = [...dialects, ...externs];
+  return cleanRecord({
+    ...registry,
+    dialects,
+    externs,
+    summary: {
+      dialects: dialects.length,
+      externs: externs.length,
+      records: records.length,
+      languages: unique(records.map((record) => record.language)),
+      dialectNames: unique(records.map((record) => record.dialect)),
+      constructKinds: countBy(dialects.map((record) => record.constructKind)),
+      externKinds: countBy(externs.map((record) => record.externKind)),
+      lossIds: unique(records.flatMap((record) => record.lossIds ?? [])),
+      evidenceIds: unique(records.flatMap((record) => record.evidenceIds ?? [])),
+      sourceMapIds: unique(records.flatMap((record) => [record.sourceMapId, ...(record.projection?.sourceMapIds ?? [])])),
+      projectionDispositions: countBy(records.map((record) => record.projection?.disposition)),
+      projectionReadiness: records.reduce((readiness, record) => maxReadiness(readiness, record.projection?.readiness ?? 'ready'), 'ready'),
+      recordsWithLosses: records.filter((record) => (record.lossIds ?? []).length).length,
+      recordsWithProjectionEvidence: records.filter((record) => (record.projection?.evidenceIds ?? []).length).length
+    }
+  });
+}
+
+function readinessForDisposition(disposition) {
+  if (disposition === 'preserved' || disposition === 'lossless') return 'ready';
+  if (disposition === 'lossy' || disposition === 'declaration-only') return 'ready-with-losses';
+  if (disposition === 'stub-only' || disposition === 'unsupported') return 'blocked';
+  return 'needs-review';
+}
+
+function maxReadiness(left, right) {
+  const order = ['ready', 'ready-with-losses', 'needs-review', 'blocked'];
+  return order.indexOf(right) > order.indexOf(left) ? right : left;
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'Unnamed'; }
+function readWord(label, body) { return new RegExp('^\\s*' + label + '\\s+([^\\s,]+)', 'm').exec(body)?.[1]?.trim(); }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = readInlineWord(label, text);
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function cleanRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function unique(values) { return [...new Set(values.filter(Boolean))]; }
+function first(values) { return values.find(Boolean); }
+function uniqueById(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    if (!record?.id || seen.has(record.id)) return false;
+    seen.add(record.id);
+    return true;
+  });
+}
+function countBy(values) {
+  return values.filter(Boolean).reduce((counts, value) => ({ ...counts, [value]: (counts[value] ?? 0) + 1 }), {});
+}

package/dist/index.js

@@ -2,6 +2,7 @@ import { actionNode, capabilityNode, createDocument, effectNode, entityNode, ext
 import { parseConstraintSpaceBlock } from './constraint-space.js';
 import { parseConversionBlock } from './conversion.js';
 import { parseDecisionGraphBlock } from './decision-graph.js';
+import { parseDialectRegistryBlock } from './dialect-registry.js';
 import { parseInterlinguaBlock } from './interlingua.js';
 import { createParsedMetadata } from './metadata.js';
 import { parseSemanticOperationsBlock } from './operations.js';
@@ -9,6 +10,7 @@ import { parseParadigmBlock } from './paradigm.js';
 import { parseProofBlock } from './proof.js';
 import { parseResourceGraphBlock } from './resource-graph.js';
 import { parseNativeSourceBlock } from './source-evidence.js';
+import { parseTargetProjectionMetadata } from './target-projection.js';
 import { parseViewBlock } from './view.js';
 
 export function parseFrontierSource(source, options = {}) {
@@ -19,6 +21,7 @@ export function parseFrontierSource(source, options = {}) {
   const conversionBlocks = [];
   const constraintSpaceBlocks = [];
   const decisionGraphBlocks = [];
+  const dialectRegistryBlocks = [];
   const interlinguaBlocks = [];
   const resourceGraphBlocks = [];
   const nativeSourceBlocks = [];
@@ -47,10 +50,11 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') conversionBlocks.push(parseConversionBlock(block));
     if (block.kind === 'constraintSpace' || block.kind === 'possibilitySpace') constraintSpaceBlocks.push(parseConstraintSpaceBlock(block));
     if (block.kind === 'decisionGraph' || block.kind === 'admissionGraph') decisionGraphBlocks.push(parseDecisionGraphBlock(block));
+    if (block.kind === '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));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -60,7 +64,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|interlingua|universalInterlingua|resourceGraph|semanticResourceGraph)\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)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;
@@ -193,6 +197,7 @@ function parseLattice(block) {
 }
 function parseTarget(block) {
   const name = nameFrom(block.header);
+  const metadata = parseTargetProjectionMetadata(block.body, name);
   return targetNode({
     id: idFrom(block.header, `target_${name}`),
     name,
@@ -201,7 +206,8 @@ function parseTarget(block) {
       packageName: readWord('package', block.body),
       emitPath: readWord('emitPath', block.body),
       moduleFormat: readWord('moduleFormat', block.body)
-    }
+    },
+    ...(metadata ? { metadata } : {})
   });
 }
 function readList(label, body) { const line = new RegExp('^\\s*' + label + '\\s+([^\\n]+)', 'm').exec(body)?.[1]; return line ? line.split(',').map((item) => item.trim()).filter(Boolean) : undefined; }

package/dist/metadata.js

@@ -1,3 +1,5 @@
+import { mergeDialectRegistryBlocks } from './dialect-registry.js';
+
 const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
 const PARADIGM_GROUPS = [
   'bindingScopes',
@@ -21,7 +23,7 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
@@ -29,6 +31,7 @@ export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], op
   if (conversionBlocks.length) metadata.universalConversionPlan = mergeConversionBlocks(conversionBlocks);
   if (constraintSpaceBlocks.length) metadata.constraintSpaces = mergeConstraintSpaceBlocks(constraintSpaceBlocks);
   if (decisionGraphBlocks.length) metadata.decisionGraph = mergeDecisionGraphBlocks(decisionGraphBlocks);
+  if (dialectRegistryBlocks.length) metadata.dialects = mergeDialectRegistryBlocks(dialectRegistryBlocks);
   if (interlinguaBlocks.length) metadata.universalInterlingua = mergeInterlinguaBlocks(interlinguaBlocks);
   if (resourceGraphBlocks.length) metadata.semanticResourceGraphs = mergeResourceGraphBlocks(resourceGraphBlocks);
   if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length)) {

package/dist/target-projection.js

@@ -0,0 +1,84 @@
+export function parseTargetProjectionMetadata(body, targetName) {
+  const projectionContracts = readTargetProjectionContracts(body, targetName);
+  const projectionLayers = readTargetProjectionLayers(body, targetName);
+  if (!projectionContracts.length && !projectionLayers.length) return undefined;
+  return cleanObject({
+    authoredTargetProjection: true,
+    projectionContracts,
+    projectionLayers,
+    projectionContractIds: projectionContracts.map((entry) => entry.id),
+    projectionLayerIds: projectionLayers.map((entry) => entry.id),
+    evidenceIds: uniqueStrings([...projectionContracts.flatMap((entry) => entry.evidenceIds ?? []), ...projectionLayers.flatMap((entry) => entry.evidenceIds ?? [])]),
+    proofEvidenceIds: uniqueStrings(projectionContracts.flatMap((entry) => entry.proofEvidenceIds ?? [])),
+    lossIds: uniqueStrings(projectionContracts.flatMap((entry) => entry.lossIds ?? [])),
+    missingEvidence: uniqueStrings([...projectionContracts.flatMap((entry) => entry.missingEvidence ?? []), ...projectionLayers.flatMap((entry) => entry.missingEvidence ?? [])]),
+    semanticEquivalenceClaim: false,
+    autoMergeClaim: false
+  });
+}
+
+function readTargetProjectionContracts(body, targetName) {
+  const rows = [];
+  const re = /^\s*(projection|lowering)\s+([A-Za-z_$][\w$-]*)([^\n]*)$/gm;
+  let match;
+  while ((match = re.exec(body))) {
+    const [, rowKind, name, text] = match;
+    rows.push(cleanObject({
+      id: idFrom(text, `target_projection_${targetName}_${name}`),
+      kind: 'frontier.lang.targetProjectionContract',
+      name,
+      rowKind,
+      disposition: readInlineWord('disposition', text) ?? readInlineWord('mode', text),
+      readiness: readInlineWord('readiness', text),
+      adapterId: readInlineWord('adapter', text) ?? readInlineWord('adapterId', text),
+      sourceLanguage: readInlineWord('sourceLanguage', text) ?? readInlineWord('source', text),
+      representedLayerKinds: readInlineList(text, 'represented', 'representedLayerKinds'),
+      missingLayerKinds: readInlineList(text, 'missing', 'missingLayerKinds'),
+      requiredLayerKinds: readInlineList(text, 'requires', 'required', 'requiredLayerKinds'),
+      evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds'),
+      proofEvidenceIds: readInlineList(text, 'proof', 'proofEvidence', 'proofEvidenceIds'),
+      lossIds: readInlineList(text, 'loss', 'lossId', 'lossIds'),
+      missingEvidence: readInlineList(text, 'missingEvidence'),
+      review: readInlineList(text, 'review'),
+      blockers: readInlineList(text, 'blocker', 'blockers'),
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    }));
+  }
+  return rows;
+}
+
+function readTargetProjectionLayers(body, targetName) {
+  const rows = [];
+  const re = /^\s*layer\s+([A-Za-z_$][\w$-]*)([^\n]*)$/gm;
+  let match;
+  while ((match = re.exec(body))) {
+    const [, name, text] = match;
+    rows.push(cleanObject({
+      id: idFrom(text, `target_layer_${targetName}_${name}`),
+      kind: 'frontier.lang.targetProjectionLayer',
+      name,
+      layerKind: readInlineWord('kind', text) ?? readInlineWord('layerKind', text) ?? name,
+      status: readInlineWord('status', text) ?? 'represented',
+      evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds'),
+      missingEvidence: readInlineList(text, 'missingEvidence'),
+      review: readInlineList(text, 'review'),
+      blockers: readInlineList(text, 'blocker', 'blockers'),
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    }));
+  }
+  return rows;
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(text)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function uniqueStrings(values) { return [...new Set(values.filter(Boolean))]; }
+function cleanObject(object) { return Object.fromEntries(Object.entries(object).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.22",
+  "version": "0.3.24",
   "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/resource-graph-smoke.mjs && node test/interlingua-smoke.mjs",
+    "test": "npm run build && node test/smoke.mjs && node test/resource-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",