@shapeshift-labs/frontier-lang-parser 0.3.13 → 0.3.15

package/README.md

@@ -220,6 +220,25 @@ 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 conversion syntax
+
+`.frontier` files can carry universal conversion evidence directly in `conversion` or `universalConversionPlan` blocks. The parser projects these records into `metadata.universalConversionPlan` for the compiler facade and downstream semantic merge tooling.
+
+```frontier
+conversion TodoJavascriptToRust @id("conversion_todo_js_rust") {
+  sourceLanguage javascript
+  target rust
+  sourceRuntime javascript node
+  targetRuntime rust cli
+  runtimeRequirement fetchRuntime @id("runtime_requirement_fetch") capability fetch sourceRuntime node targetRuntime cli evidence artifact_todo_title_probe
+  dialect nodeProcess @id("dialect_node_process") language javascript dialect node.runtime kind runtime target rust disposition unsupported readiness blocked loss loss_node_process_projection
+  extern viteRoutes @id("extern_vite_routes") language javascript dialect vite.plugin.virtual-module externKind generatorArtifact target rust disposition runtime-required evidence evidence_vite_routes_manifest bindingSymbol virtual:routes
+  constraint type publicApi @id("type_constraint_public_api") role source kind public-function symbol symbol:addTodo signatureHash sig_add_todo evidence artifact_todo_title_probe
+}
+```
+
+`sourceRuntime` and `targetRuntime` become runtime maps. `runtimeRequirement` rows become proof obligations for host/runtime capabilities. `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.
+
 ## Benchmarks
 
 Run the package-local benchmark with:

package/dist/conversion.js

@@ -1,10 +1,22 @@
 const FAMILIES = {
   type: { field: 'typeConstraints', sourceKey: 'sourceTypes', targetKey: 'targetTypes' },
   typeConstraint: { field: 'typeConstraints', sourceKey: 'sourceTypes', targetKey: 'targetTypes' },
+  resourceTransfer: { field: 'resourceTransfers', sourceKey: 'sourceGraphs', targetKey: 'targetGraphs', graph: true },
+  resourceTransferConstraint: { field: 'resourceTransfers', sourceKey: 'sourceGraphs', targetKey: 'targetGraphs', graph: true },
+  'resource-transfer': { field: 'resourceTransfers', sourceKey: 'sourceGraphs', targetKey: 'targetGraphs', graph: true },
+  ownership: { field: 'resourceTransfers', sourceKey: 'sourceGraphs', targetKey: 'targetGraphs', graph: true },
   controlFlow: { field: 'controlFlowConstraints', sourceKey: 'sourceControlFlows', targetKey: 'targetControlFlows' },
   controlFlowConstraint: { field: 'controlFlowConstraints', sourceKey: 'sourceControlFlows', targetKey: 'targetControlFlows' },
   lifetime: { field: 'lifetimeConstraints', sourceKey: 'sourceLifetimeConstraints', targetKey: 'targetLifetimeConstraints' },
   lifetimeConstraint: { field: 'lifetimeConstraints', sourceKey: 'sourceLifetimeConstraints', targetKey: 'targetLifetimeConstraints' },
+  borrowScope: { field: 'borrowScopeConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
+  borrowScopeConstraint: { field: 'borrowScopeConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
+  'borrow-scope': { field: 'borrowScopeConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
+  'borrow-scope-constraint': { field: 'borrowScopeConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
+  borrowChecker: { field: 'borrowCheckerConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
+  borrowCheckerConstraint: { field: 'borrowCheckerConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
+  'borrow-checker': { field: 'borrowCheckerConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
+  'borrow-checker-constraint': { field: 'borrowCheckerConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
   callableBoundary: { field: 'callableBoundaryConstraints', sourceKey: 'sourceCallables', targetKey: 'targetCallables' },
   adtPattern: { field: 'adtPatternConstraints', sourceKey: 'sourcePatterns', targetKey: 'targetPatterns' },
   dataLayout: { field: 'dataLayoutConstraints', sourceKey: 'sourceLayouts', targetKey: 'targetLayouts' },
@@ -34,14 +46,75 @@ export function parseConversionBlock(block) {
     if (!line || line.startsWith('#')) continue;
     const target = /^target\s+([^\s,]+)/.exec(line)?.[1];
     const sourceLanguage = /^sourceLanguage\s+([^\s,]+)/.exec(line)?.[1] ?? /^source\s+([^\s,]+)/.exec(line)?.[1];
+    const sourceRuntime = /^sourceRuntime\s+([^\s,]+)\s+([^\s,]+)/.exec(line);
+    const targetRuntime = /^targetRuntime\s+([^\s,]+)\s+([^\s,]+)/.exec(line);
+    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 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;
+    else if (sourceRuntime) plan.sourceRuntimes = { ...(plan.sourceRuntimes ?? {}), [sourceRuntime[1]]: sourceRuntime[2] };
+    else if (targetRuntime) plan.targetRuntimes = { ...(plan.targetRuntimes ?? {}), [targetRuntime[1]]: targetRuntime[2] };
+    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 (constraint) addConstraint(plan, constraint[1], constraint[2], constraint[3]);
   }
   return cleanRecord({ ...plan, targets: unique(plan.targets) });
 }
 
+function addRuntimeRequirement(plan, name, text) {
+  plan.runtimeRequirements = [...(plan.runtimeRequirements ?? []), cleanRecord({
+    id: idFrom(text, `runtime_requirement_${name}`),
+    name,
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? plan.sourceLanguage,
+    target: readInlineWord('target', text) ?? readInlineWord('targetLanguage', text) ?? plan.targets[0],
+    capability: readInlineWord('capability', text) ?? readInlineWord('kind', text) ?? name,
+    kind: readInlineWord('kind', text),
+    sourceRuntime: readInlineWord('sourceRuntime', text) ?? readInlineWord('runtime', text),
+    targetRuntime: readInlineWord('targetRuntime', text),
+    sourceHost: readInlineWord('sourceHost', text),
+    targetHost: readInlineWord('targetHost', text),
+    reason: readInlineQuoted('reason', text) ?? readInlineWord('reason', text),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds')
+  })];
+}
+
+function addDialectRecord(plan, name, text, isExtern) {
+  const projection = cleanRecord({
+    disposition: readInlineWord('disposition', text),
+    readiness: readInlineWord('readiness', text),
+    targets: readInlineList(text, 'target', 'targets', 'targetLanguage') ?? plan.targets,
+    evidenceIds: readInlineList(text, 'projectionEvidence', 'projectionEvidenceIds', 'evidence', 'evidenceIds'),
+    lossIds: readInlineList(text, 'projectionLoss', 'projectionLossIds', 'loss', 'lossId', 'lossIds')
+  });
+  const record = cleanRecord({
+    id: idFrom(text, `${isExtern ? 'extern' : 'dialect'}_${name}`),
+    language: readInlineWord('language', text) ?? plan.sourceLanguage,
+    dialect: readInlineWord('dialect', text) ?? name,
+    name: readInlineWord('name', text) ?? name,
+    nativeKind: readInlineWord('nativeKind', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    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('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', 'evidenceIds'),
+    projection
+  });
+  if (isExtern) {
+    const binding = cleanRecord({ module: readInlineWord('module', text), path: readInlineWord('bindingPath', text), symbol: readInlineWord('bindingSymbol', text) ?? readInlineWord('symbol', text), abi: readInlineWord('abi', text), version: readInlineWord('version', text) });
+    plan.externs = [...(plan.externs ?? []), cleanRecord({ ...record, externKind: readInlineWord('externKind', text) ?? readInlineWord('kind', text) ?? 'extern', ...(Object.keys(binding).length ? { binding } : {}) })];
+  } else {
+    plan.dialects = [...(plan.dialects ?? []), cleanRecord({ ...record, constructKind: readInlineWord('constructKind', text) ?? readInlineWord('kind', text) ?? 'runtime', externIds: readInlineList(text, 'extern', 'externIds') })];
+  }
+}
+
 function addConstraint(plan, family, name, text) {
   const config = FAMILIES[family] ?? { field: family.endsWith('s') ? family : `${family}Constraints`, sourceKey: 'sourceRecords', targetKey: 'targetRecords' };
   const role = readInlineWord('role', text) ?? 'source';
@@ -58,7 +131,7 @@ function addConstraint(plan, family, name, text) {
     metadata: { name, family, authoredConversionBlockId: plan.id }
   });
   const recordKey = role === 'target' ? config.targetKey : config.sourceKey;
-  entry[recordKey] = [record];
+  entry[recordKey] = [config.graph ? resourceGraphFromRecord(record, entry) : record];
   plan[config.field] = [...(plan[config.field] ?? []), entry];
 }
 
@@ -75,17 +148,28 @@ function parseConstraintRecord(name, text, role) {
     symbolId: readInlineWord('symbol', text) ?? readInlineWord('symbolId', text),
     symbolName: readInlineWord('symbolName', text),
     localName: readInlineWord('localName', text),
+    ownerId: readInlineWord('owner', text) ?? readInlineWord('ownerId', text),
+    ownerKind: readInlineWord('ownerKind', text),
+    mode: readInlineWord('mode', text) ?? readInlineWord('loanMode', text),
+    aliasKind: readInlineWord('aliasKind', text),
+    moveKind: readInlineWord('moveKind', text),
+    dropKind: readInlineWord('dropKind', text),
+    resourceKind: readInlineWord('resourceKind', text),
+    scopeKind: readInlineWord('scopeKind', text),
     typeKind: readInlineWord('typeKind', text),
     signatureHash: readInlineWord('signatureHash', text),
     contractHash: readInlineWord('contractHash', text),
     typeHash: readInlineWord('typeHash', text),
     flowKind: readInlineWord('flowKind', text),
+    controlFlowKind: readInlineWord('controlFlowKind', text),
+    sourceControlFlowId: readInlineWord('sourceControlFlowId', text),
     sourceId: readInlineWord('from', text) ?? readInlineWord('sourceId', text),
     targetId: readInlineWord('to', text) ?? readInlineWord('targetId', text),
     label: readInlineWord('label', text),
     conditionHash: readInlineWord('conditionHash', text),
     orderingKey: readInlineWord('orderingKey', text) ?? readInlineWord('orderKey', text),
     lifetimeKind: readInlineWord('lifetimeKind', text),
+    lifetimeRegionId: readInlineWord('lifetimeRegion', text) ?? readInlineWord('lifetimeRegionId', text),
     regionKind: readInlineWord('regionKind', text),
     predicate: readInlineQuoted('predicate', text) ?? readInlineWord('predicate', text),
     resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text),
@@ -103,6 +187,94 @@ function parseConstraintRecord(name, text, role) {
   });
 }
 
+function resourceGraphFromRecord(record, entry) {
+  const tokens = lowerTokens(record);
+  const resourceId = record.resourceId ?? record.symbolId ?? `${record.id}_resource`;
+  const evidenceIds = record.evidenceIds ?? entry.evidenceIds;
+  return cleanRecord({
+    id: `${record.id}_resource_graph`,
+    sourceLanguage: entry.sourceLanguage,
+    target: entry.target,
+    sourcePath: record.sourcePath,
+    sourceHash: record.sourceHash,
+    evidenceIds,
+    resources: [{
+      id: resourceId,
+      resourceKind: record.resourceKind ?? record.kind ?? record.constraintKind,
+      sourcePath: record.sourcePath,
+      sourceHash: record.sourceHash,
+      evidenceIds,
+      metadata: { factKinds: record.factKinds, constraintKinds: record.constraintKinds }
+    }],
+    owners: needsOwner(tokens, record) ? [{
+      id: `${record.id}_owner`,
+      resourceId,
+      ownerId: record.ownerId ?? record.symbolId ?? `${resourceId}:owner`,
+      ownerKind: record.ownerKind ?? tokenKind(tokens, /owner|single-owner/) ?? 'owner',
+      evidenceIds
+    }] : undefined,
+    loans: needsLoan(tokens, record) ? [{
+      id: `${record.id}_loan`,
+      resourceId,
+      mode: record.mode ?? loanMode(tokens),
+      lifetimeRegionId: record.lifetimeRegionId,
+      evidenceIds
+    }] : undefined,
+    aliases: tokenMatches(tokens, /alias/) ? [{
+      id: `${record.id}_alias`,
+      resourceId,
+      aliasKind: record.aliasKind ?? tokenKind(tokens, /alias/) ?? 'alias',
+      evidenceIds
+    }] : undefined,
+    moves: tokenMatches(tokens, /move|transfer/) ? [{
+      id: `${record.id}_move`,
+      resourceId,
+      moveKind: record.moveKind ?? tokenKind(tokens, /move|transfer/) ?? 'move',
+      evidenceIds
+    }] : undefined,
+    drops: tokenMatches(tokens, /drop/) ? [{
+      id: `${record.id}_drop`,
+      resourceId,
+      dropKind: record.dropKind ?? tokenKind(tokens, /drop/) ?? 'drop',
+      evidenceIds
+    }] : undefined,
+    lifetimeRegions: record.lifetimeKind || record.lifetimeRegionId || tokenMatches(tokens, /lifetime/) ? [{
+      id: record.lifetimeRegionId ?? `${record.id}_lifetime`,
+      resourceId,
+      lifetimeKind: record.lifetimeKind ?? tokenKind(tokens, /lifetime/) ?? record.regionKind,
+      evidenceIds
+    }] : undefined,
+    borrowScopes: needsLoan(tokens, record) || record.scopeKind ? [{
+      id: `${record.id}_borrow_scope`,
+      resourceId,
+      scopeKind: record.scopeKind ?? record.kind,
+      lifetimeRegionId: record.lifetimeRegionId,
+      constraintKinds: record.constraintKinds,
+      evidenceIds
+    }] : undefined,
+    unsafeBoundaries: tokenMatches(tokens, /unsafe|raw/) ? [{
+      id: `${record.id}_unsafe`,
+      resourceId,
+      kind: tokenKind(tokens, /unsafe|raw/) ?? 'unsafe-boundary',
+      evidenceIds
+    }] : undefined
+  });
+}
+
+function lowerTokens(record) {
+  return unique([record.kind, record.constraintKind, record.scopeKind, record.resourceKind, record.ownerKind, record.mode, record.aliasKind, record.moveKind, record.dropKind, record.lifetimeKind, record.regionKind, record.flowKind, record.controlFlowKind, ...(record.constraintKinds ?? []), ...(record.factKinds ?? [])].filter(Boolean).map((value) => String(value).toLowerCase()));
+}
+function needsOwner(tokens, record) { return record.ownerId || record.ownerKind || tokenMatches(tokens, /owner|single-owner/); }
+function needsLoan(tokens, record) { return record.mode || tokenMatches(tokens, /borrow|loan|raw/); }
+function loanMode(tokens) {
+  if (tokens.includes('shared-borrow') || tokens.includes('shared')) return 'shared';
+  if (tokens.includes('exclusive-borrow') || tokens.includes('mutable') || tokens.includes('exclusive')) return 'exclusive';
+  if (tokens.includes('raw-access-boundary') || tokens.includes('raw')) return 'raw';
+  if (tokens.includes('move')) return 'move';
+  return 'unknown';
+}
+function tokenMatches(tokens, pattern) { return tokens.some((token) => pattern.test(token)); }
+function tokenKind(tokens, pattern) { return tokens.find((token) => pattern.test(token)); }
 function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
 function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'Conversion'; }
 function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }

package/dist/metadata.js

@@ -66,6 +66,9 @@ function mergeConversionBlocks(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;

package/package.json

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