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

package/README.md

@@ -328,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';
@@ -20,6 +21,7 @@ export function parseFrontierSource(source, options = {}) {
   const conversionBlocks = [];
   const constraintSpaceBlocks = [];
   const decisionGraphBlocks = [];
+  const dialectRegistryBlocks = [];
   const interlinguaBlocks = [];
   const resourceGraphBlocks = [];
   const nativeSourceBlocks = [];
@@ -48,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 } : {}) });
 }
 
@@ -61,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;

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/package.json

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