@shapeshift-labs/frontier-lang-compiler 0.2.65 → 0.2.67

package/dist/native-region-scanner-core.js

@@ -9,7 +9,7 @@ function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fi
     name,
     symbolKind,
     symbolId: `symbol:${input.language}:${idFragment(name)}`,
-    span: spanForLine(input, lineNumber),
+    span: options.span ?? spanForLine(input, lineNumber),
     fields,
     metadata: { scan: 'lightweight-declaration', hasBody, ...options.metadata },
     ...(options.regionKind ? { regionKind: options.regionKind } : {}),
@@ -18,8 +18,8 @@ function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fi
   };
 }
 
-function nativeImportDeclaration(input, lineNumber, importPath, languageKind, symbolKind) {
-  const name = String(importPath);
+function nativeImportDeclaration(input, lineNumber, importPath, languageKind, symbolKind, options = {}) {
+  const name = String(options.name ?? importPath);
   const nodeId = `native_${idFragment(languageKind)}_${lineNumber}_${idFragment(name)}`;
   return {
     nodeId,
@@ -27,15 +27,44 @@ function nativeImportDeclaration(input, lineNumber, importPath, languageKind, sy
     languageKind: `${input.language}.${languageKind}`,
     name,
     symbolKind,
-    symbolId: `symbol:${input.language}:import:${idFragment(name)}`,
-    role: 'import',
-    importPath: name,
-    span: spanForLine(input, lineNumber),
-    fields: { importPath: name },
-    metadata: { scan: 'lightweight-import' }
+    symbolId: options.symbolId ?? `symbol:${input.language}:import:${idFragment(name)}`,
+    role: options.role ?? 'import',
+    importPath: String(importPath),
+    span: options.span ?? spanForLine(input, lineNumber),
+    fields: { importPath: String(importPath), ...options.fields },
+    metadata: { scan: 'lightweight-import', ...options.metadata },
+    ...(options.regionKind ? { regionKind: options.regionKind } : {})
   };
 }
 
+function nativeImportBindingDeclaration(input, lineNumber, importPath, binding, options = {}) {
+  const localName = String(binding.localName ?? binding.name ?? importPath);
+  const importedName = binding.importedName ?? localName;
+  const importKind = binding.importKind ?? 'named';
+  return nativeImportDeclaration(input, lineNumber, importPath, options.languageKind ?? 'ImportBinding', binding.symbolKind ?? 'import', {
+    name: localName,
+    symbolId: options.symbolId ?? `symbol:${input.language}:import:${idFragment(`${importPath}:${localName}`)}`,
+    span: options.span,
+    fields: {
+      localName,
+      importedName,
+      importKind,
+      importPath: String(importPath),
+      ...(binding.exportedName ? { exportedName: binding.exportedName } : {}),
+      ...(binding.typeOnly ? { typeOnly: true } : {})
+    },
+    metadata: {
+      scan: 'lightweight-import-binding',
+      localName,
+      importedName,
+      importKind,
+      ...(binding.exportedName ? { exportedName: binding.exportedName } : {}),
+      ...(binding.typeOnly ? { typeOnly: true } : {}),
+      ...options.metadata
+    }
+  });
+}
+
 function nativeMacroLoss(input, lineNumber, source, kind, name = idFragment(source).slice(0, 40)) {
   const nodeId = `native_${kind}_${lineNumber}_${idFragment(name)}`;
   return {
@@ -133,12 +162,14 @@ function sourceLines(sourceText) {
 }
 
 function spanForLine(input, lineNumber) {
+  const line = sourceLines(input.sourceText)[lineNumber - 1]?.line ?? '';
   return {
     sourceId: input.sourceHash,
     path: input.sourcePath,
     startLine: lineNumber,
     endLine: lineNumber,
-    startColumn: 1
+    startColumn: 1,
+    endColumn: line.length + 1
   };
 }
 
@@ -172,6 +203,7 @@ export {
   lightweightCoverageLosses,
   nativeDeclaration,
   nativeImportDeclaration,
+  nativeImportBindingDeclaration,
   nativeMacroLoss,
   sourceLines,
   splitParameters,

package/dist/native-region-scanner-js-helpers.js

@@ -3,6 +3,7 @@ import {
   nativeDeclaration,
   splitParameters
 } from './native-region-scanner-core.js';
+import { jsImportDeclarations } from './native-region-scanner-js-imports.js';
 
 function jsCommentOnlyLine(trimmed) {
   return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
@@ -247,6 +248,7 @@ export {
   jsDeclarationScanLine,
   jsExportedContainerDeclaration,
   jsInitializerKind,
+  jsImportDeclarations,
   jsObjectPropertyDeclaration,
   jsObjectRegionContext,
   jsRegionKindForDeclarationName,

package/dist/native-region-scanner-js-imports.js

@@ -0,0 +1,111 @@
+import {
+  nativeImportBindingDeclaration,
+  nativeImportDeclaration
+} from './native-region-scanner-core.js';
+
+export function jsImportDeclarations(input, lineNumber, trimmed) {
+  const importEquals = trimmed.match(/^import\s+(type\s+)?([A-Za-z_$][\w$]*)\s*=\s*require\s*\(\s*(['"])([^'"]+)\3\s*\)/);
+  if (importEquals) return jsImportModuleDeclarations(input, lineNumber, importEquals[4], 'ImportEqualsDeclaration', [{
+    localName: importEquals[2],
+    importedName: 'default',
+    importKind: 'commonjs-require',
+    typeOnly: Boolean(importEquals[1])
+  }]);
+  const importMatch = trimmed.match(/^import\s+(type\s+)?(?:(.+?)\s+from\s+)?(['"])([^'"]+)\3/);
+  if (importMatch) {
+    const typeOnly = Boolean(importMatch[1]);
+    const importPath = importMatch[4];
+    const clause = importMatch[2]?.trim();
+    const bindings = clause ? jsImportBindingsFromClause(clause, { typeOnly }) : [];
+    return jsImportModuleDeclarations(input, lineNumber, importPath, 'ImportDeclaration', bindings, { typeOnly, sideEffectOnly: bindings.length === 0 });
+  }
+  const exportMatch = trimmed.match(/^export\s+(type\s+)?(?:(\*)\s+from|\*\s+as\s+([A-Za-z_$][\w$]*)\s+from|\{([^}]+)\}\s+from)\s+(['"])([^'"]+)\5/);
+  if (exportMatch) {
+    const typeOnly = Boolean(exportMatch[1]);
+    const importPath = exportMatch[6];
+    const bindings = exportMatch[3]
+      ? [{ localName: exportMatch[3], importedName: '*', exportedName: exportMatch[3], importKind: 'namespace-reexport', typeOnly }]
+      : exportMatch[4]
+        ? jsNamedImportBindings(exportMatch[4], { typeOnly, reexport: true })
+        : [];
+    return jsImportModuleDeclarations(input, lineNumber, importPath, 'ExportFromDeclaration', bindings, { typeOnly, reexport: true, exportStar: Boolean(exportMatch[2]) });
+  }
+  const requireMatch = trimmed.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:await\s+)?(?:require|import)\s*\(\s*(['"])([^'"]+)\2\s*\)/);
+  if (requireMatch) return jsImportModuleDeclarations(input, lineNumber, requireMatch[3], 'CommonJsRequireDeclaration', [{
+    localName: requireMatch[1],
+    importedName: 'default',
+    importKind: trimmed.includes('import') ? 'dynamic-import-binding' : 'commonjs-require'
+  }]);
+  return [];
+}
+
+function jsImportModuleDeclarations(input, lineNumber, importPath, languageKind, bindings = [], metadata = {}) {
+  const bindingSummaries = bindings.map((binding) => ({
+    localName: binding.localName,
+    importedName: binding.importedName,
+    importKind: binding.importKind,
+    ...(binding.exportedName ? { exportedName: binding.exportedName } : {}),
+    ...(binding.typeOnly ? { typeOnly: true } : {})
+  }));
+  return [
+    nativeImportDeclaration(input, lineNumber, importPath, languageKind, 'module', {
+      fields: {
+        moduleOnly: true,
+        importBindings: bindingSummaries,
+        ...(metadata.typeOnly ? { typeOnly: true } : {}),
+        ...(metadata.sideEffectOnly ? { sideEffectOnly: true } : {}),
+        ...(metadata.reexport ? { reexport: true } : {}),
+        ...(metadata.exportStar ? { exportStar: true } : {})
+      },
+      metadata: {
+        moduleOnly: true,
+        bindingCount: bindings.length,
+        ...metadata
+      }
+    }),
+    ...bindings.map((binding) => nativeImportBindingDeclaration(input, lineNumber, importPath, binding))
+  ];
+}
+
+function jsImportBindingsFromClause(clause, options = {}) {
+  const source = String(clause ?? '').trim();
+  if (!source) return [];
+  const namespace = source.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
+  if (namespace) return [{ localName: namespace[1], importedName: '*', importKind: 'namespace', typeOnly: options.typeOnly }];
+  const bindings = [];
+  const named = source.match(/\{([^}]*)\}/);
+  const defaultPart = source.replace(/\{[^}]*\}/, '').split(',').map((part) => part.trim()).filter(Boolean)[0];
+  if (defaultPart && /^[A-Za-z_$][\w$]*$/.test(defaultPart)) {
+    bindings.push({ localName: defaultPart, importedName: 'default', importKind: 'default', typeOnly: options.typeOnly });
+  }
+  if (named) bindings.push(...jsNamedImportBindings(named[1], options));
+  return bindings;
+}
+
+function jsNamedImportBindings(raw, options = {}) {
+  return String(raw ?? '')
+    .split(',')
+    .map((part) => jsNamedImportBinding(part, options))
+    .filter(Boolean);
+}
+
+function jsNamedImportBinding(raw, options = {}) {
+  let text = String(raw ?? '').trim();
+  if (!text) return undefined;
+  let typeOnly = Boolean(options.typeOnly);
+  if (text.startsWith('type ')) {
+    typeOnly = true;
+    text = text.slice(5).trim();
+  }
+  const match = text.match(/^([A-Za-z_$][\w$]*|\*)\s*(?:as\s+([A-Za-z_$][\w$]*))?$/);
+  if (!match) return undefined;
+  const importedName = match[1];
+  const localName = match[2] ?? importedName;
+  return {
+    localName,
+    importedName,
+    exportedName: options.reexport ? localName : undefined,
+    importKind: options.reexport ? 'reexport' : typeOnly ? 'type-named' : 'named',
+    typeOnly
+  };
+}

package/dist/native-region-scanner-js.js

@@ -12,6 +12,7 @@ import {
   jsDeclarationScanLine,
   jsExportedContainerDeclaration,
   jsInitializerKind,
+  jsImportDeclarations,
   jsObjectPropertyDeclaration,
   jsObjectRegionContext,
   jsRegionKindForDeclarationName,
@@ -22,11 +23,18 @@ import {
 
 function scanJavaScriptLike(input) {
   const declarations = [];
+  const lines = sourceLines(input.sourceText);
+  const pushDeclaration = (declaration) => {
+    if (declaration) declarations.push(jsDeclarationWithSourceSpan(input, declaration, lines));
+  };
+  const pushDeclarations = (items) => {
+    for (const declaration of items ?? []) pushDeclaration(declaration);
+  };
   let currentClass;
   let classDepth = 0;
   let currentObject;
   const lexicalState = { inBlockComment: false, inTemplateString: false };
-  for (const { line, number } of sourceLines(input.sourceText)) {
+  for (const { line, number } of lines) {
     const scanLine = jsDeclarationScanLine(line, lexicalState);
     const trimmed = scanLine.trim();
     if (!trimmed || jsCommentOnlyLine(trimmed)) continue;
@@ -35,42 +43,42 @@ function scanJavaScriptLike(input) {
     if (currentObject) {
       const routeRecord = jsRouteRecordDeclaration(input, number, trimmed, currentObject);
       if (routeRecord) {
-        declarations.push(routeRecord);
+        pushDeclaration(routeRecord);
       } else {
         const property = jsObjectPropertyDeclaration(input, number, trimmed, currentObject);
-        if (property) declarations.push(property);
+        if (property) pushDeclaration(property);
       }
     }
-    if ((match = trimmed.match(/^import\s+(?:.+?\s+from\s+)?['"]([^'"]+)['"]/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDeclaration', 'module'));
+    const importDeclarations = jsImportDeclarations(input, number, trimmed);
+    if (importDeclarations.length) {
+      pushDeclarations(importDeclarations);
     } else if ((match = trimmed.match(/^import\s*\(\s*['"]([^'"]+)['"]\s*\)/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'DynamicImportExpression', 'module'));
-    } else if ((match = trimmed.match(/^export\s+(?:\*\s+from|\{[^}]*\}\s+from)\s+['"]([^'"]+)['"]/))) {
-      declarations.push(nativeImportDeclaration(input, number, match[1], 'ExportFromDeclaration', 'module'));
-    } else if ((match = declarationLine.match(/^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, declarationLine.includes('{')));
-    } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'ExportDefaultFunctionDeclaration', 'function', match[1] ?? 'default', { parameters: splitParameters(match[2]), exportDefault: true }, trimmed.includes('{')));
+      pushDeclaration(nativeImportDeclaration(input, number, match[1], 'DynamicImportExpression', 'module'));
+    } else if ((match = declarationLine.match(/^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, declarationLine.includes('{')));
+    } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'ExportDefaultFunctionDeclaration', 'function', match[1] ?? 'default', { parameters: splitParameters(match[2]), exportDefault: true }, trimmed.includes('{')));
     } else if ((match = declarationLine.match(/^(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/))) {
-      declarations.push(nativeDeclaration(input, number, declarationLine.startsWith('default ') ? 'ExportDefaultClassDeclaration' : 'ClassDeclaration', 'class', match[1], { exportDefault: declarationLine.startsWith('default ') || undefined }, declarationLine.includes('{')));
-      if (declarationLine.includes('{') && !declarationLine.includes('}')) {
+      pushDeclaration(nativeDeclaration(input, number, declarationLine.startsWith('default ') ? 'ExportDefaultClassDeclaration' : 'ClassDeclaration', 'class', match[1], { exportDefault: declarationLine.startsWith('default ') || undefined }, declarationLine.includes('{')));
+      pushDeclarations(jsInlineClassMemberDeclarations(input, number, declarationLine, match[1]));
+      if (jsStructureDelta(declarationLine).value > 0) {
         currentClass = match[1];
         classDepth = 0;
       }
     } else if ((match = declarationLine.match(/^interface\s+([A-Za-z_$][\w$]*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'InterfaceDeclaration', 'interface', match[1], {}, declarationLine.includes('{')));
+      pushDeclaration(nativeDeclaration(input, number, 'InterfaceDeclaration', 'interface', match[1], {}, declarationLine.includes('{')));
     } else if ((match = declarationLine.match(/^(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'EnumDeclaration', 'type', match[1], {}, declarationLine.includes('{')));
+      pushDeclaration(nativeDeclaration(input, number, 'EnumDeclaration', 'type', match[1], {}, declarationLine.includes('{')));
     } else if ((match = declarationLine.match(/^(?:namespace|module)\s+([A-Za-z_$][\w$.]*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'ModuleDeclaration', 'module', match[1], {}, declarationLine.includes('{')));
+      pushDeclaration(nativeDeclaration(input, number, 'ModuleDeclaration', 'module', match[1], {}, declarationLine.includes('{')));
     } else if ((match = declarationLine.match(/^type\s+([A-Za-z_$][\w$]*)\s*=/))) {
-      declarations.push(nativeDeclaration(input, number, 'TypeAliasDeclaration', 'type', match[1], {}, false));
-    } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(?([^=;]*)\)?\s*=>/))) {
-      declarations.push(nativeDeclaration(input, number, 'VariableFunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+      pushDeclaration(nativeDeclaration(input, number, 'TypeAliasDeclaration', 'type', match[1], {}, false));
+    } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::\s*[^=]+)?=\s*(?:async\s*)?(?:<[^=]+>\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'VariableFunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, true));
     } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\b/))) {
       const initializerKind = jsInitializerKind(declarationLine, match[1]);
       const regionKind = jsRegionKindForDeclarationName(match[1], declarationLine);
-      declarations.push(nativeDeclaration(input, number, 'VariableDeclaration', jsVariableSymbolKind(regionKind, initializerKind), match[1], {
+      pushDeclaration(nativeDeclaration(input, number, 'VariableDeclaration', jsVariableSymbolKind(regionKind, initializerKind), match[1], {
         initializerKind
       }, jsVariableHasBody(initializerKind, declarationLine), {
         regionKind,
@@ -78,21 +86,21 @@ function scanJavaScriptLike(input) {
       }));
       currentObject = jsObjectRegionContext(match[1], declarationLine, number, regionKind);
     } else if ((match = jsExportedContainerDeclaration(input, number, trimmed))) {
-      declarations.push(match.declaration);
+      pushDeclaration(match.declaration);
       currentObject = match.context;
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function\*?\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/))) {
       const regionKind = jsRegionKindForDeclarationName(match[1], trimmed);
-      declarations.push(nativeDeclaration(input, number, 'CommonJsExport', 'variable', match[1], { export: 'commonjs' }, false, { regionKind }));
-    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
-      declarations.push(nativeDeclaration(input, number, 'MethodDefinition', 'method', `${currentClass}.${match[1]}`, {
+      pushDeclaration(nativeDeclaration(input, number, 'CommonJsExport', 'variable', match[1], { export: 'commonjs' }, false, { regionKind }));
+    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
+      pushDeclaration(nativeDeclaration(input, number, 'MethodDefinition', 'method', `${currentClass}.${match[1]}`, {
         methodName: match[1],
         owner: currentClass,
         parameters: splitParameters(match[2])
       }, declarationLine.includes('{') || declarationLine.includes('=>')));
-    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*([A-Za-z_$][\w$]*)\s*(?::\s*([^=;{]+))?(?:[=;]|$)/))) {
-      declarations.push(nativeDeclaration(input, number, 'PropertyDefinition', 'property', `${currentClass}.${match[1]}`, {
+    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*([A-Za-z_$][\w$]*)[?!]?\s*(?::\s*([^=;{]+))?(?:[=;]|$)/))) {
+      pushDeclaration(nativeDeclaration(input, number, 'PropertyDefinition', 'property', `${currentClass}.${match[1]}`, {
         propertyName: match[1],
         owner: currentClass,
         valueType: match[2]?.trim()
@@ -113,4 +121,79 @@ function scanJavaScriptLike(input) {
   return declarations;
 }
 
+function jsDeclarationWithSourceSpan(input, declaration, lines) {
+  const startLine = declaration.span?.startLine ?? 1;
+  const endLine = declaration.metadata?.hasBody ? jsBalancedDeclarationEndLine(input, lines, startLine) : startLine;
+  const endLineText = lines[Math.max(0, endLine - 1)]?.line ?? '';
+  return {
+    ...declaration,
+    span: {
+      ...declaration.span,
+      sourceId: declaration.span?.sourceId ?? input.sourceHash,
+      path: declaration.span?.path ?? input.sourcePath,
+      startLine,
+      endLine,
+      startColumn: declaration.span?.startColumn ?? 1,
+      endColumn: declaration.span?.endColumn ?? endLineText.length + 1
+    }
+  };
+}
+
+function jsBalancedDeclarationEndLine(input, lines, startLine) {
+  const state = { inBlockComment: false, inTemplateString: false };
+  let depth = 0;
+  let opened = false;
+  for (let index = Math.max(0, startLine - 1); index < lines.length; index += 1) {
+    const scanLine = jsDeclarationScanLine(lines[index].line, state);
+    const delta = jsStructureDelta(scanLine);
+    if (delta.opened) opened = true;
+    depth += delta.value;
+    if (opened && depth <= 0) return lines[index].number;
+  }
+  return startLine;
+}
+
+function jsStructureDelta(source) {
+  let value = 0;
+  let opened = false;
+  let quote;
+  let escaped = false;
+  for (const char of String(source ?? '')) {
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') {
+      value += 1;
+      opened = true;
+    } else if (char === '}' || char === ']' || char === ')') {
+      value -= 1;
+    }
+  }
+  return { value, opened };
+}
+
+function jsInlineClassMemberDeclarations(input, lineNumber, declarationLine, className) {
+  const open = declarationLine.indexOf('{');
+  const close = declarationLine.lastIndexOf('}');
+  if (open < 0 || close <= open) return [];
+  const body = declarationLine.slice(open + 1, close);
+  const declarations = [];
+  for (const match of body.matchAll(/(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={;]+)?\s*(?:\{|=>)/g)) {
+    if (jsControlKeyword(match[1])) continue;
+    declarations.push(nativeDeclaration(input, lineNumber, 'MethodDefinition', 'method', `${className}.${match[1]}`, {
+      methodName: match[1],
+      owner: className,
+      parameters: splitParameters(match[2])
+    }, true));
+  }
+  return declarations;
+}
+
 export { scanJavaScriptLike };

package/dist/universal-conversion-plan-summary.js

@@ -0,0 +1,42 @@
+export function conversionPlanSummary(routes) {
+  const summary = {
+    routes: routes.length,
+    byMode: {},
+    byReadiness: {},
+    byAdmissionAction: {},
+    readyRoutes: 0,
+    reviewRoutes: 0,
+    blockedRoutes: 0,
+    preserveSourceRoutes: 0,
+    targetAdapterRoutes: 0,
+    stubOnlyRoutes: 0,
+    semanticIndexOnlyRoutes: 0,
+    missingEvidence: 0,
+    runtimeAdapterRequirements: 0,
+    runtimeRoutesWithAdapters: 0,
+    blockers: 0,
+    reviewReasons: 0,
+    autoMergeClaims: 0,
+    semanticEquivalenceClaims: 0
+  };
+  for (const route of routes) {
+    summary.byMode[route.mode] = (summary.byMode[route.mode] ?? 0) + 1;
+    summary.byReadiness[route.readiness] = (summary.byReadiness[route.readiness] ?? 0) + 1;
+    summary.byAdmissionAction[route.admissionAction] = (summary.byAdmissionAction[route.admissionAction] ?? 0) + 1;
+    if (route.readiness === 'ready') summary.readyRoutes += 1;
+    if (route.readiness === 'needs-review' || route.readiness === 'ready-with-losses') summary.reviewRoutes += 1;
+    if (route.readiness === 'blocked') summary.blockedRoutes += 1;
+    if (route.mode === 'preserve-source') summary.preserveSourceRoutes += 1;
+    if (route.mode === 'target-adapter') summary.targetAdapterRoutes += 1;
+    if (route.mode === 'stub-only') summary.stubOnlyRoutes += 1;
+    if (route.mode === 'semantic-index-only') summary.semanticIndexOnlyRoutes += 1;
+    summary.missingEvidence += route.missingEvidence.length;
+    summary.runtimeAdapterRequirements += route.runtimeAdapterRequirements.length;
+    if (route.runtimeAdapterRequirements.length) summary.runtimeRoutesWithAdapters += 1;
+    summary.blockers += route.blockers.length;
+    summary.reviewReasons += route.review.length;
+    if (route.autoMergeClaim) summary.autoMergeClaims += 1;
+    if (route.semanticEquivalenceClaim) summary.semanticEquivalenceClaims += 1;
+  }
+  return summary;
+}

package/dist/universal-conversion-plan.js

@@ -9,6 +9,10 @@ import {
   normalizeProjectionMatrixTargets
 } from './coverage-matrix-profiles.js';
 import { createUniversalCapabilityMatrix } from './universal-capability-matrix.js';
+import {
+  createUniversalRuntimeCapabilityMatrix,
+  runtimeRouteForConversion
+} from './universal-runtime-capabilities.js';
 import {
   conversionMergeRefs,
   importsForConversionLanguage
@@ -17,6 +21,7 @@ import {
   conversionMergeScore,
   conversionScoreComponents
 } from './universal-conversion-plan-scoring.js';
+import { conversionPlanSummary } from './universal-conversion-plan-summary.js';
 
 export function createUniversalConversionPlan(input = {}, context = {}) {
   const generatedAt = input.generatedAt ?? Date.now();
@@ -25,12 +30,21 @@ export function createUniversalConversionPlan(input = {}, context = {}) {
     ? input.universalCapabilityMatrix
     : createUniversalCapabilityMatrix({ ...input, generatedAt }, context);
   const targets = conversionTargets(input, matrix, context);
+  const runtimeMatrix = input.universalRuntimeCapabilityMatrix?.kind === 'frontier.lang.universalRuntimeCapabilityMatrix'
+    ? input.universalRuntimeCapabilityMatrix
+    : createUniversalRuntimeCapabilityMatrix({
+      ...input,
+      generatedAt,
+      sourceLanguages: matrix.languages,
+      targets
+    }, context);
   const evidence = input.evidence ?? [];
   const routes = (matrix.languages ?? []).flatMap((language) => targets.map((target) => conversionRoute(language, target, {
     evidence,
     generatedAt,
     imports: input.imports ?? [],
-    matrix
+    matrix,
+    runtimeMatrix
   }, id)));
   return {
     kind: 'frontier.lang.universalConversionPlan',
@@ -41,6 +55,7 @@ export function createUniversalConversionPlan(input = {}, context = {}) {
     summary: conversionPlanSummary(routes),
     matrices: {
       universalCapability: matrix,
+      runtimeCapabilities: runtimeMatrix,
       projectionReadiness: matrix.matrices?.projectionReadiness,
       projectionTargets: matrix.matrices?.projectionTargets
     },
@@ -90,6 +105,8 @@ function conversionRoute(language, target, input, planId) {
   const sourceTarget = nativeLanguageCompileTarget(language.language, language.aliases) ?? normalizeNativeLanguageId(language.language);
   const targetCell = (language.projection?.targets ?? []).find((entry) => entry.target === target);
   const readinessCell = projectionReadinessCell(input.matrix, language, target);
+  const runtimeRoute = runtimeRouteForConversion(input.runtimeMatrix, language, target);
+  const runtime = conversionRuntime(runtimeRoute);
   const mode = conversionMode(language, target, sourceTarget, targetCell);
   const blockers = conversionBlockers(language, targetCell, mode);
   const review = conversionReviewReasons(language, targetCell, mode);
@@ -115,6 +132,8 @@ function conversionRoute(language, target, input, planId) {
     adapterKind: targetCell?.adapterKind,
     sourceProjection: language.projection?.sourceProjection,
     projectionReadiness: readinessCell,
+    runtime,
+    runtimeAdapterRequirements: runtime.adapterRequirements,
     evidence: conversionEvidence(language, targetCell),
     missingEvidence: conversionMissingEvidence(language, targetCell, mode),
     blockers,
@@ -172,6 +191,32 @@ function conversionReviewReasons(language, targetCell, mode) {
   ]);
 }
 
+function conversionRuntime(runtimeRoute) {
+  if (!runtimeRoute) {
+    return {
+      requiredCapabilities: [],
+      satisfiedCapabilities: [],
+      adapterRequirements: [],
+      missingCapabilities: [],
+      readiness: 'ready',
+      blockers: [],
+      review: []
+    };
+  }
+  return {
+    routeId: runtimeRoute.id,
+    source: runtimeRoute.source,
+    target: runtimeRoute.target,
+    requiredCapabilities: runtimeRoute.requiredCapabilities,
+    satisfiedCapabilities: runtimeRoute.satisfiedCapabilities,
+    adapterRequirements: runtimeRoute.adapterRequirements,
+    missingCapabilities: runtimeRoute.missingCapabilities,
+    readiness: runtimeRoute.readiness,
+    blockers: runtimeRoute.blockers,
+    review: runtimeRoute.review
+  };
+}
+
 function projectionReadinessCell(matrix, language, target) {
   const ids = uniqueStrings([language.language, ...(language.aliases ?? [])].map(normalizeNativeLanguageId));
   return (matrix.matrices?.projectionReadiness?.languages ?? [])
@@ -238,42 +283,3 @@ function conversionTasks(language, target, mode, blockers, review) {
     ...(blockers.length || review.length ? [`collect proof, replay, or oracle evidence for ${language.language} to ${target}`] : [])
   ]);
 }
-
-function conversionPlanSummary(routes) {
-  const summary = {
-    routes: routes.length,
-    byMode: {},
-    byReadiness: {},
-    byAdmissionAction: {},
-    readyRoutes: 0,
-    reviewRoutes: 0,
-    blockedRoutes: 0,
-    preserveSourceRoutes: 0,
-    targetAdapterRoutes: 0,
-    stubOnlyRoutes: 0,
-    semanticIndexOnlyRoutes: 0,
-    missingEvidence: 0,
-    blockers: 0,
-    reviewReasons: 0,
-    autoMergeClaims: 0,
-    semanticEquivalenceClaims: 0
-  };
-  for (const route of routes) {
-    summary.byMode[route.mode] = (summary.byMode[route.mode] ?? 0) + 1;
-    summary.byReadiness[route.readiness] = (summary.byReadiness[route.readiness] ?? 0) + 1;
-    summary.byAdmissionAction[route.admissionAction] = (summary.byAdmissionAction[route.admissionAction] ?? 0) + 1;
-    if (route.readiness === 'ready') summary.readyRoutes += 1;
-    if (route.readiness === 'needs-review' || route.readiness === 'ready-with-losses') summary.reviewRoutes += 1;
-    if (route.readiness === 'blocked') summary.blockedRoutes += 1;
-    if (route.mode === 'preserve-source') summary.preserveSourceRoutes += 1;
-    if (route.mode === 'target-adapter') summary.targetAdapterRoutes += 1;
-    if (route.mode === 'stub-only') summary.stubOnlyRoutes += 1;
-    if (route.mode === 'semantic-index-only') summary.semanticIndexOnlyRoutes += 1;
-    summary.missingEvidence += route.missingEvidence.length;
-    summary.blockers += route.blockers.length;
-    summary.reviewReasons += route.review.length;
-    if (route.autoMergeClaim) summary.autoMergeClaims += 1;
-    if (route.semanticEquivalenceClaim) summary.semanticEquivalenceClaims += 1;
-  }
-  return summary;
-}