@shapeshift-labs/frontier-lang-parser 0.3.38 → 0.3.40

package/README.md

@@ -88,6 +88,7 @@ The published Frontier package family is generated from one shared package catal
 - [`@shapeshift-labs/frontier-dnd`](https://www.npmjs.com/package/@shapeshift-labs/frontier-dnd): Renderer-neutral drag-and-drop sessions, sensor descriptors, collision ranking, drop planning, reorder patches, state partitioning, and registry evidence for Frontier apps.
 - [`@shapeshift-labs/frontier-dom`](https://www.npmjs.com/package/@shapeshift-labs/frontier-dom): Patch-native DOM and host renderer bindings, manifest hydration, JSX runtime/compiler helpers, SSR, devtools, and logging bridges.
 - [`@shapeshift-labs/frontier-playwright`](https://www.npmjs.com/package/@shapeshift-labs/frontier-playwright): Playwright/headless automation probes for Frontier state, DOM, devtools, marks, and timeline queries.
+- [`@shapeshift-labs/frontier-annotations`](https://www.npmjs.com/package/@shapeshift-labs/frontier-annotations): Browser harness DOM annotation overlay, selected-node targeting records, CSS/source-hint capture, AST/source graph context ranking, and Codex/frontier-swarm task planning for AI-operable UI fixes.
 - [`@shapeshift-labs/frontier-test`](https://www.npmjs.com/package/@shapeshift-labs/frontier-test): Serializable test/spec evidence manifests for Frontier apps, including fixtures, commands, expected patches/effects/routes/policies, coverage declarations, run plans, run records, report adapters, replay proofs, fuzzers, benchmarks, registry graph output, and impact queries.
 - [`@shapeshift-labs/frontier-fixtures`](https://www.npmjs.com/package/@shapeshift-labs/frontier-fixtures): Deterministic fixture and scenario generation for Frontier apps, including schema-valid sample state, related entity collections, actor personas, route states, replay-verified patch streams, event records, JSONL bundles, and evidence summaries.
 - [`@shapeshift-labs/frontier-component-preview`](https://www.npmjs.com/package/@shapeshift-labs/frontier-component-preview): Frontier-native component preview books, generated preview manifests, stateful variants, Vite virtual modules, standalone browser preview shells, inspector bridges, and preview harness evidence for Frontier apps.
@@ -192,6 +193,7 @@ Package source repositories:
 - [`siliconjungle/-shapeshift-labs-frontier-dnd`](https://github.com/siliconjungle/-shapeshift-labs-frontier-dnd)
 - [`siliconjungle/-shapeshift-labs-frontier-dom`](https://github.com/siliconjungle/-shapeshift-labs-frontier-dom)
 - [`siliconjungle/-shapeshift-labs-frontier-playwright`](https://github.com/siliconjungle/-shapeshift-labs-frontier-playwright)
+- [`siliconjungle/-shapeshift-labs-frontier-annotations`](https://github.com/siliconjungle/-shapeshift-labs-frontier-annotations)
 - [`siliconjungle/-shapeshift-labs-frontier-test`](https://github.com/siliconjungle/-shapeshift-labs-frontier-test)
 - [`siliconjungle/-shapeshift-labs-frontier-fixtures`](https://github.com/siliconjungle/-shapeshift-labs-frontier-fixtures)
 - [`siliconjungle/-shapeshift-labs-frontier-component-preview`](https://github.com/siliconjungle/-shapeshift-labs-frontier-component-preview)

package/dist/conversion-metadata.js

@@ -0,0 +1,43 @@
+export function mergeConversionBlocks(blocks) {
+  const plan = {
+    id: blocks.length === 1 ? blocks[0].id : 'universalConversionPlan:source',
+    targets: [...new Set(blocks.flatMap((block) => block.targets ?? []))],
+    metadata: { authoredConversionBlockIds: blocks.map((block) => block.id) }
+  };
+  for (const block of blocks) {
+    if (block.sourceLanguage && !plan.sourceLanguage) plan.sourceLanguage = block.sourceLanguage;
+    for (const [key, value] of Object.entries(block)) {
+      if (Array.isArray(value) && key !== 'targets') plan[key] = [...(plan[key] ?? []), ...value];
+      else if ((key === 'sourceRuntimes' || key === 'targetRuntimes') && value && typeof value === 'object') {
+        plan[key] = { ...(plan[key] ?? {}), ...value };
+      }
+    }
+  }
+  plan.evidenceIds = ids(plan.evidence);
+  plan.summary = {
+    evidenceCount: plan.evidence?.length ?? 0,
+    runtimeRequirementCount: plan.runtimeRequirements?.length ?? 0,
+    dialectCount: plan.dialects?.length ?? 0,
+    externCount: plan.externs?.length ?? 0,
+    constraintCount: conversionConstraintCount(plan)
+  };
+  plan.claims = {
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    conversionEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false
+  };
+  return plan;
+}
+
+function ids(records = []) {
+  return records.map((record) => record?.id).filter(Boolean);
+}
+
+function conversionConstraintCount(plan) {
+  return Object.entries(plan).reduce((total, [key, value]) => {
+    if (!Array.isArray(value)) return total;
+    if (key.endsWith('Constraints') || key === 'resourceTransfers') return total + value.length;
+    return total;
+  }, 0);
+}

package/dist/conversion.js

@@ -13,6 +13,7 @@ export function parseConversionBlock(block) {
     const runtimeRequirement = /^(?:runtimeRequirement|requiredRuntime|requiresRuntime)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
     const dialect = /^dialect\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
     const extern = /^extern\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    const evidence = /^(?:evidence|proofEvidence)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
     const constraint = /^constraint\s+([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
     if (target) plan.targets.push(target);
     else if (sourceLanguage) plan.sourceLanguage = sourceLanguage;
@@ -21,11 +22,35 @@ export function parseConversionBlock(block) {
     else if (runtimeRequirement) addRuntimeRequirement(plan, runtimeRequirement[1], runtimeRequirement[2]);
     else if (dialect) addDialectRecord(plan, dialect[1], dialect[2], false);
     else if (extern) addDialectRecord(plan, extern[1], extern[2], true);
+    else if (evidence) addEvidenceRecord(plan, evidence[1], evidence[2], authoredLine);
     else if (constraint) addConstraint(plan, constraint[1], constraint[2], constraint[3], authoredLine);
   }
   return cleanRecord({ ...plan, targets: unique(plan.targets) });
 }
 
+function addEvidenceRecord(plan, name, text, authoredLine = {}) {
+  plan.evidence = [...(plan.evidence ?? []), cleanRecord({
+    id: idFrom(text, `conversion_evidence_${name}`),
+    name,
+    kind: readInlineWord('kind', text) ?? 'conversion-route-evidence',
+    status: readInlineWord('status', text) ?? 'unknown',
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? readInlineWord('language', text) ?? plan.sourceLanguage,
+    target: readInlineWord('target', text) ?? readInlineWord('targetLanguage', text) ?? plan.targets[0],
+    routeId: readInlineWord('routeId', text) ?? readInlineWord('route', text),
+    path: readInlineWord('path', text) ?? readInlineWord('report', text),
+    command: readInlineQuoted('command', text) ?? readInlineWord('command', text),
+    probeId: readInlineWord('probeId', text) ?? readInlineWord('probe', text),
+    sourceHash: readInlineWord('sourceHash', text),
+    targetHash: readInlineWord('targetHash', text),
+    telemetryHash: readInlineWord('telemetryHash', text),
+    proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceId', 'proofEvidenceIds', 'proof'),
+    summary: readInlineQuoted('summary', text),
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: { authoredConversionBlockId: plan.id, autoMergeClaim: false, semanticEquivalenceClaim: false }
+  })];
+}
+
 function addRuntimeRequirement(plan, name, text) {
   plan.runtimeRequirements = [...(plan.runtimeRequirements ?? []), cleanRecord({
     id: idFrom(text, `runtime_requirement_${name}`),

package/dist/index.d.ts

@@ -22,11 +22,14 @@ export interface FrontierSourceSyntaxDiagnostic {
   readonly location: FrontierSourcePosition;
 }
 export interface FrontierSourceChildSyntaxRecord {
-  readonly kind: 'conversionConstraint';
+  readonly kind: 'conversionConstraint' | 'conversionEvidence' | 'conversionRuntimeRequirement' | 'conversionDialect' | 'conversionExtern' | 'conversionUnknownRow' | string;
+  readonly rowKind?: string;
+  readonly normalizedRowKind?: string;
   readonly name: string;
   readonly id?: string;
   readonly family?: string;
   readonly role?: string;
+  readonly reason?: string;
   readonly header: string;
   readonly startOffset: number;
   readonly endOffset: number;
@@ -60,6 +63,10 @@ export interface FrontierUnknownSourceBlockSyntaxRecord extends FrontierSourceBl
   readonly recognized: false;
   readonly reason: 'unsupported-top-level-block';
 }
+export interface FrontierUnknownSourceChildSyntaxRecord extends FrontierSourceChildSyntaxRecord {
+  readonly recognized: false;
+  readonly reason: string;
+}
 export interface FrontierSourceSyntaxReport {
   readonly kind: 'frontier.lang.sourceSyntaxReport';
   readonly version: 1;
@@ -68,10 +75,12 @@ export interface FrontierSourceSyntaxReport {
   readonly blocks: readonly FrontierSourceBlockSyntaxRecord[];
   readonly recognizedBlocks: readonly FrontierSourceBlockSyntaxRecord[];
   readonly unknownBlocks: readonly FrontierUnknownSourceBlockSyntaxRecord[];
+  readonly unknownChildren: readonly FrontierUnknownSourceChildSyntaxRecord[];
   readonly summary: {
     readonly blockCount: number;
     readonly recognizedBlockCount: number;
     readonly unknownBlockCount: number;
+    readonly unknownChildCount: number;
     readonly malformedBlockCount: number;
     readonly childCount: number;
     readonly recognizedChildCount: number;
@@ -79,6 +88,7 @@ export interface FrontierSourceSyntaxReport {
     readonly recognizedKinds: readonly string[];
     readonly recognizedChildKinds: readonly string[];
     readonly unknownKinds: readonly string[];
+    readonly unknownChildKinds: readonly string[];
     readonly failClosed: boolean;
     readonly unsupportedSyntax: boolean;
   };

package/dist/metadata.js

@@ -2,6 +2,7 @@ import { mergeDialectRegistryBlocks } from './dialect-registry.js';
 import { mergeApplicationSurfaceBlocks } from './application-surface.js';
 import { mergeRuntimeCapabilityBlocks } from './runtime-capability.js';
 import { mergeTargetProjectionTargets } from './target-projection-aggregate.js';
+import { mergeConversionBlocks } from './conversion-metadata.js';
 
 const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
 const PARADIGM_GROUPS = [
@@ -61,24 +62,6 @@ function mergeOperationBlocks(blocks) {
   };
 }
 
-function mergeConversionBlocks(blocks) {
-  const plan = {
-    id: blocks.length === 1 ? blocks[0].id : 'universalConversionPlan:source',
-    targets: [...new Set(blocks.flatMap((block) => block.targets ?? []))],
-    metadata: { authoredConversionBlockIds: blocks.map((block) => block.id) }
-  };
-  for (const block of blocks) {
-    if (block.sourceLanguage && !plan.sourceLanguage) plan.sourceLanguage = block.sourceLanguage;
-    for (const [key, value] of Object.entries(block)) {
-      if (Array.isArray(value) && key !== 'targets') plan[key] = [...(plan[key] ?? []), ...value];
-      else if ((key === 'sourceRuntimes' || key === 'targetRuntimes') && value && typeof value === 'object') {
-        plan[key] = { ...(plan[key] ?? {}), ...value };
-      }
-    }
-  }
-  return plan;
-}
-
 function mergeConstraintSpaceBlocks(blocks) {
   return {
     id: blocks.length === 1 ? blocks[0].id : 'constraintSpaces:source',

package/dist/source-syntax-children.js

@@ -1,8 +1,14 @@
+import { ROW_SYNTAX_CONFIG } from './source-syntax-row-config.js';
+
+const ROW_NAME_PATTERN = '([A-Za-z_$@./:*+-][\\w$./@:*+-]*)';
+
 export function readSourceSyntaxChildren(source, block, options = {}) {
   if (block.malformed) return [];
   if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') {
     return readConversionSyntaxChildren(source, block, options);
   }
+  const rowConfig = ROW_SYNTAX_CONFIG[block.kind];
+  if (rowConfig) return readGenericRowSyntaxChildren(source, block, options, rowConfig);
   return [];
 }
 
@@ -10,15 +16,104 @@ function readConversionSyntaxChildren(source, block, options) {
   const children = [];
   for (const line of readBodyLines(source, block)) {
     if (!line.text || line.text.startsWith('#')) continue;
+    const planField = /^(?:sourceLanguage|source|target|sourceRuntime|targetRuntime)\s+/.exec(line.text);
+    if (planField) continue;
+    const runtimeRequirement = /^(runtimeRequirement|requiredRuntime|requiresRuntime)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line.text);
+    if (runtimeRequirement) {
+      const [, rowKind, name, rest] = runtimeRequirement;
+      children.push(conversionChild(source, block, options, line, {
+        kind: 'conversionRuntimeRequirement',
+        rowKind,
+        normalizedRowKind: 'runtimeRequirement',
+        name,
+        id: idFrom(rest, `runtime_requirement_${name}`)
+      }));
+      continue;
+    }
+    const dialect = /^(dialect|extern)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line.text);
+    if (dialect) {
+      const [, rowKind, name, rest] = dialect;
+      children.push(conversionChild(source, block, options, line, {
+        kind: rowKind === 'extern' ? 'conversionExtern' : 'conversionDialect',
+        rowKind,
+        normalizedRowKind: rowKind,
+        name,
+        id: idFrom(rest, `${rowKind}_${name}`)
+      }));
+      continue;
+    }
+    const evidence = /^(evidence|proofEvidence)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line.text);
+    if (evidence) {
+      const [, rowKind, name, rest] = evidence;
+      children.push(conversionChild(source, block, options, line, {
+        kind: 'conversionEvidence',
+        rowKind,
+        normalizedRowKind: 'evidence',
+        name,
+        id: idFrom(rest, `conversion_evidence_${name}`)
+      }));
+      continue;
+    }
     const constraint = /^constraint\s+([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line.text);
-    if (!constraint) continue;
+    if (!constraint) {
+      const row = /^([A-Za-z_$][\w$-]*)\b/.exec(line.text);
+      children.push(conversionChild(source, block, options, line, {
+        kind: 'conversionUnknownRow',
+        rowKind: row?.[1],
+        normalizedRowKind: 'unknown',
+        name: row?.[1] ?? 'unknown',
+        id: `conversion_unknown_${safeId(row?.[1] ?? 'row')}_${line.startOffset}`,
+        reason: 'unsupported-conversion-row',
+        recognized: false
+      }));
+      continue;
+    }
     const [, family, name, rest] = constraint;
-    children.push(cleanRecord({
+    children.push(conversionChild(source, block, options, line, {
       kind: 'conversionConstraint',
       name,
       id: idFrom(rest, `conversion_constraint_${family}_${name}`),
       family,
       role: readInlineWord('role', rest) ?? 'source',
+      recognized: true
+    }));
+  }
+  return children;
+}
+
+function conversionChild(source, block, options, line, child) {
+  return cleanRecord({
+    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: true,
+    ...child
+  });
+}
+
+function readGenericRowSyntaxChildren(source, block, options, config) {
+  const children = [];
+  const rowPattern = new RegExp('^([A-Za-z_$][\\w$-]*)\\s+' + ROW_NAME_PATTERN + '(.*)$');
+  for (const line of readBodyLines(source, block)) {
+    if (!line.text || line.text.startsWith('#')) continue;
+    const row = rowPattern.exec(line.text);
+    if (!row) continue;
+    const [, rowKind, name, rest] = row;
+    if (!config.rowKinds.has(rowKind)) continue;
+    const normalizedRowKind = config.normalize?.(rowKind) ?? rowKind;
+    children.push(cleanRecord({
+      kind: config.childKind,
+      rowKind,
+      normalizedRowKind,
+      name,
+      id: idFrom(rest, `${config.idPrefix}_${safeId(normalizedRowKind)}_${safeId(name)}`),
       header: line.text,
       startOffset: line.startOffset,
       endOffset: line.endOffset,
@@ -72,6 +167,7 @@ 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)));
 }

package/dist/source-syntax-report.js

@@ -23,6 +23,10 @@ export function inspectFrontierSourceSyntax(source, options = {}) {
     reason: 'unsupported-top-level-block'
   }));
   const childRecords = blocks.flatMap((block) => block.children ?? []);
+  const unknownChildren = childRecords.filter((child) => !child.recognized).map((child) => ({
+    ...child,
+    reason: child.reason ?? 'unsupported-child-syntax'
+  }));
   const malformedBlockOpenOffsets = new Set(blocks.filter((block) => block.malformed).map((block) => block.bodyStartOffset - 1));
   const diagnostics = [
     ...blocks.flatMap((block) => block.diagnostics ?? []),
@@ -38,7 +42,7 @@ export function inspectFrontierSourceSyntax(source, options = {}) {
     }))
   ];
   const malformedBlocks = blocks.filter((block) => block.malformed);
-  const failClosed = unknownBlocks.length > 0 || diagnostics.length > 0;
+  const failClosed = unknownBlocks.length > 0 || unknownChildren.length > 0 || diagnostics.length > 0;
   return {
     kind: 'frontier.lang.sourceSyntaxReport',
     version: 1,
@@ -47,10 +51,12 @@ export function inspectFrontierSourceSyntax(source, options = {}) {
     blocks,
     recognizedBlocks,
     unknownBlocks,
+    unknownChildren,
     summary: {
       blockCount: blocks.length,
       recognizedBlockCount: recognizedBlocks.length,
       unknownBlockCount: unknownBlocks.length,
+      unknownChildCount: unknownChildren.length,
       malformedBlockCount: malformedBlocks.length,
       childCount: childRecords.length,
       recognizedChildCount: childRecords.filter((child) => child.recognized).length,
@@ -58,8 +64,9 @@ export function inspectFrontierSourceSyntax(source, options = {}) {
       recognizedKinds: unique(recognizedBlocks.map((block) => block.kind)),
       recognizedChildKinds: unique(childRecords.filter((child) => child.recognized).map((child) => child.kind)),
       unknownKinds: unique(unknownBlocks.map((block) => block.kind)),
+      unknownChildKinds: unique(unknownChildren.map((child) => child.rowKind ?? child.kind)),
       failClosed,
-      unsupportedSyntax: unknownBlocks.length > 0
+      unsupportedSyntax: unknownBlocks.length > 0 || unknownChildren.length > 0
     },
     diagnostics,
     metadata: {

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

@@ -0,0 +1,133 @@
+const appRows = words('mount provide provides required requires require route event asset gate gap proofGap evidence proofEvidence');
+const canvasRows = words('element command state stateWrite trace gap proofGap evidence proofEvidence');
+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 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');
+
+export const ROW_SYNTAX_CONFIG = Object.freeze({
+  interlingua: rowConfig('interlinguaRow', 'interlingua_row', interlinguaRows, normalizeInterlinguaRow),
+  universalInterlingua: rowConfig('interlinguaRow', 'interlingua_row', interlinguaRows, normalizeInterlinguaRow),
+  dialectRegistry: rowConfig('dialectRegistryRow', 'dialect_registry_row', dialectRows, normalizeDialectRegistryRow),
+  universalDialectRegistry: rowConfig('dialectRegistryRow', 'dialect_registry_row', dialectRows, normalizeDialectRegistryRow),
+  runtimeCapabilities: rowConfig('runtimeCapabilityRow', 'runtime_capability_row', runtimeRows, normalizeRuntimeCapabilityRow),
+  runtimeCapabilityMatrix: rowConfig('runtimeCapabilityRow', 'runtime_capability_row', runtimeRows, normalizeRuntimeCapabilityRow),
+  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 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 conflict proof proofObligation obligation'), normalizeResourceGraphRow),
+  applicationSurface: rowConfig('applicationSurfaceRow', 'application_surface_row', appRows, normalizeApplicationSurfaceRow),
+  appHost: rowConfig('applicationSurfaceRow', 'application_surface_row', appRows, normalizeApplicationSurfaceRow),
+  plugin: rowConfig('applicationSurfaceRow', 'application_surface_row', appRows, normalizeApplicationSurfaceRow),
+  pluginSurface: rowConfig('applicationSurfaceRow', 'application_surface_row', appRows, normalizeApplicationSurfaceRow),
+  pluginContract: rowConfig('applicationSurfaceRow', 'application_surface_row', appRows, normalizeApplicationSurfaceRow),
+  target: rowConfig('targetProjectionRow', 'target_projection_row', words('projection lowering layer')),
+  packageManifest: rowConfig('packageManifestRow', 'package_manifest_row', packageRows, normalizeProofEvidenceRows),
+  packageGraph: rowConfig('packageManifestRow', 'package_manifest_row', packageRows, normalizeProofEvidenceRows),
+  packageSurface: rowConfig('packageManifestRow', 'package_manifest_row', packageRows, normalizeProofEvidenceRows),
+  canvasSurface: rowConfig('canvasSurfaceRow', 'canvas_surface_row', canvasRows, normalizeCanvasSurfaceRow),
+  canvasGraph: rowConfig('canvasSurfaceRow', 'canvas_surface_row', canvasRows, normalizeCanvasSurfaceRow),
+  constraintSpace: rowConfig('constraintSpaceRow', 'constraint_space_row', constraintRows, normalizeConstraintSpaceRow),
+  possibilitySpace: rowConfig('constraintSpaceRow', 'constraint_space_row', constraintRows, normalizeConstraintSpaceRow),
+  decisionGraph: rowConfig('decisionGraphRow', 'decision_graph_row', words('node edge chunk gate evidence semanticChange change patchEvent patch admissionDecision admission candidateDecision candidate mergeDecision merge replay tournament tournamentCandidate panelProjection panel rsiLoop improvementFeedback feedback'), normalizeDecisionGraphRow),
+  admissionGraph: rowConfig('decisionGraphRow', 'decision_graph_row', words('node edge chunk gate evidence semanticChange change patchEvent patch admissionDecision admission candidateDecision candidate mergeDecision merge replay tournament tournamentCandidate panelProjection panel rsiLoop improvementFeedback feedback'), normalizeDecisionGraphRow),
+  operations: rowConfig('semanticOperationRow', 'semantic_operation_row', words('operation op'), normalizeOperationRow),
+  semanticOperations: rowConfig('semanticOperationRow', 'semantic_operation_row', words('operation op'), normalizeOperationRow),
+  paradigm: rowConfig('paradigmRow', 'paradigm_row', words('valueSemantics mutationModel effectModel ownership ownershipModel lifetime lifetimeModel bindingScope binding dispatch typeModel moduleModel concurrency errorModel memoryModel evaluation metaprogramming interop lowering'), normalizeParadigmRow),
+  paradigmSemantics: rowConfig('paradigmRow', 'paradigm_row', words('valueSemantics mutationModel effectModel ownership ownershipModel lifetime lifetimeModel bindingScope binding dispatch typeModel moduleModel concurrency errorModel memoryModel evaluation metaprogramming interop lowering'), normalizeParadigmRow),
+  proof: rowConfig('proofRow', 'proof_row', words('contract refinement invariant termination temporal obligation artifact assumption')),
+  nativeSource: rowConfig('nativeSourceRow', 'native_source_row', words('loss evidence proofEvidence sourceMap sourcemap mapping sourceMapMapping mergeCandidate candidate'), normalizeNativeSourceRow)
+});
+
+function rowConfig(childKind, idPrefix, rowKinds, normalize) {
+  return { childKind, idPrefix, rowKinds: new Set(rowKinds), normalize };
+}
+
+function words(source) { return source.split(/\s+/); }
+
+function normalizeInterlinguaRow(rowKind) {
+  if (rowKind === 'edge') return 'constraint';
+  if (rowKind === 'proof' || rowKind === 'proofObligation') return 'obligation';
+  if (rowKind === 'lower' || rowKind === 'lowering') return 'lowering';
+  if (rowKind === 'source' || rowKind === 'sourceLift') return 'lift';
+  return rowKind;
+}
+
+function normalizeDialectRegistryRow(rowKind) {
+  if (rowKind === 'record') return 'dialect';
+  return rowKind;
+}
+
+function normalizeRuntimeCapabilityRow(rowKind) {
+  if (rowKind === 'capability') return 'hostCapability';
+  if (rowKind === 'binding') return 'hostBinding';
+  if (rowKind === 'requirement' || rowKind === 'requiredRuntime') return 'runtimeRequirement';
+  if (rowKind === 'proofEvidence') return 'evidence';
+  if (rowKind === 'gap') return 'proofGap';
+  return rowKind;
+}
+
+function normalizeResourceGraphRow(rowKind) {
+  if (rowKind === 'life' || rowKind === 'lifetimeRegion') return 'lifetime';
+  if (rowKind === 'lifeRelation') return 'lifetimeRelation';
+  if (rowKind === 'borrowRegion') return 'borrowScope';
+  if (rowKind === 'unsafe') return 'unsafeBoundary';
+  if (rowKind === 'proof' || rowKind === 'proofObligation') return 'obligation';
+  return rowKind;
+}
+
+function normalizeApplicationSurfaceRow(rowKind) {
+  if (rowKind === 'provide' || rowKind === 'provides') return 'provided-surface';
+  if (rowKind === 'required' || rowKind === 'requires' || rowKind === 'require') return 'required-capability';
+  if (rowKind === 'proofEvidence') return 'evidence';
+  if (rowKind === 'gap') return 'proofGap';
+  return rowKind;
+}
+
+function normalizeProofEvidenceRows(rowKind) {
+  if (rowKind === 'proofEvidence') return 'evidence';
+  if (rowKind === 'gap') return 'proofGap';
+  return rowKind;
+}
+
+function normalizeCanvasSurfaceRow(rowKind) {
+  if (rowKind === 'stateWrite') return 'state-write';
+  return normalizeProofEvidenceRows(rowKind);
+}
+
+function normalizeConstraintSpaceRow(rowKind) {
+  if (rowKind === 'var') return 'variable';
+  if (rowKind === 'hard' || rowKind === 'soft') return 'constraint';
+  if (rowKind === 'prefer') return 'preference';
+  return rowKind;
+}
+
+function normalizeDecisionGraphRow(rowKind) {
+  if (rowKind === 'change') return 'semanticChange';
+  if (rowKind === 'patch') return 'patchEvent';
+  if (rowKind === 'admission') return 'admissionDecision';
+  if (rowKind === 'candidate') return 'candidateDecision';
+  if (rowKind === 'merge') return 'mergeDecision';
+  if (rowKind === 'panel') return 'panelProjection';
+  if (rowKind === 'feedback') return 'improvementFeedback';
+  return rowKind;
+}
+
+function normalizeOperationRow(rowKind) {
+  if (rowKind === 'op') return 'operation';
+  return rowKind;
+}
+
+function normalizeParadigmRow(rowKind) {
+  if (rowKind === 'ownership') return 'ownershipModel';
+  if (rowKind === 'lifetime') return 'lifetimeModel';
+  if (rowKind === 'binding') return 'bindingScope';
+  return rowKind;
+}
+
+function normalizeNativeSourceRow(rowKind) {
+  if (rowKind === 'proofEvidence') return 'evidence';
+  if (rowKind === 'sourcemap' || rowKind === 'mapping' || rowKind === 'sourceMapMapping') return 'sourceMap';
+  if (rowKind === 'candidate') return 'mergeCandidate';
+  return rowKind;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.38",
+  "version": "0.3.40",
   "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/target-projection-aggregate-smoke.mjs && node test/conversion-constraint-fields-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/target-projection-aggregate-smoke.mjs && node test/conversion-constraint-fields-smoke.mjs && node test/conversion-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",
     "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",