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

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/examples/js-frontier-rust-workbench-adapters.mjs

@@ -0,0 +1,89 @@
+export function createTsToRustWorkbenchAdapter() {
+  return {
+    id: 'frontier-lang-workbench-ts-to-rust',
+    sourceLanguage: 'typescript',
+    target: 'rust',
+    version: '0.0.0-demo',
+    capabilities: ['semantic-symbol-scaffold'],
+    coverage: {
+      readiness: 'ready',
+      handledLossKinds: ['opaqueNative', 'declarationOnlyCoverage', 'partialSemanticIndex', 'sourceMapApproximation', 'sourcePreservation'],
+      notes: ['Workbench adapter lowers TypeScript semantic symbols to Rust scaffolding and leaves bodies explicit.']
+    },
+    project(input) {
+      return {
+        output: rustFromSymbols(input.importResult.semanticIndex?.symbols ?? []),
+        readiness: 'ready',
+        evidence: [{
+          id: 'evidence_workbench_js_to_rust',
+          kind: 'projection',
+          status: 'passed',
+          summary: 'Workbench adapter projected TypeScript semantic symbols to Rust scaffolding.'
+        }]
+      };
+    }
+  };
+}
+
+export function createTsToPythonWorkbenchAdapter() {
+  return {
+    id: 'frontier-lang-workbench-ts-to-python',
+    sourceLanguage: 'typescript',
+    target: 'python',
+    version: '0.0.0-demo',
+    capabilities: ['semantic-symbol-scaffold'],
+    coverage: {
+      readiness: 'ready',
+      handledLossKinds: ['opaqueNative', 'declarationOnlyCoverage', 'partialSemanticIndex', 'sourceMapApproximation', 'sourcePreservation'],
+      notes: ['Workbench adapter lowers TypeScript semantic symbols to Python scaffolding and leaves bodies explicit.']
+    },
+    project(input) {
+      return {
+        output: pythonFromSymbols(input.importResult.semanticIndex?.symbols ?? []),
+        readiness: 'ready',
+        evidence: [{
+          id: 'evidence_workbench_js_to_python',
+          kind: 'projection',
+          status: 'passed',
+          summary: 'Workbench adapter projected TypeScript semantic symbols to Python scaffolding.'
+        }]
+      };
+    }
+  };
+}
+
+function rustFromSymbols(symbols) {
+  const lines = ['// Generated from Frontier semantic graph evidence.'];
+  for (const symbol of symbols) {
+    if (symbol.kind === 'class') lines.push('', `pub struct ${safeTypeName(symbol.name)};`);
+    if (symbol.kind === 'function' || symbol.kind === 'method') {
+      lines.push('', `pub fn ${safeRustName(symbol.name)}() {`, '    // port body from preserved TypeScript source', '}');
+    }
+  }
+  return `${lines.join('\n').trim()}\n`;
+}
+
+function pythonFromSymbols(symbols) {
+  const lines = ['# Generated from Frontier semantic graph evidence.'];
+  for (const symbol of symbols) {
+    if (symbol.kind === 'type' || symbol.kind === 'class') lines.push('', `class ${safeTypeName(symbol.name)}:`, '    pass');
+    if (symbol.kind === 'function' || symbol.kind === 'method') {
+      lines.push('', `def ${safePythonName(symbol.name)}(*args):`, '    raise NotImplementedError("port body from preserved TypeScript source")');
+    }
+  }
+  return `${lines.join('\n').trim()}\n`;
+}
+
+function safeTypeName(name) {
+  const clean = String(name).replace(/[^A-Za-z0-9_]/g, '');
+  return clean && /^[A-Z]/.test(clean) ? clean : `Frontier${clean || 'Type'}`;
+}
+
+function safeRustName(name) {
+  return String(name).replace(/\./g, '_').replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/[^A-Za-z0-9_]/g, '_').toLowerCase();
+}
+
+function safePythonName(name) {
+  const clean = String(name).replace(/\./g, '_').replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/[^A-Za-z0-9_]/g, '_').toLowerCase();
+  return /^[A-Za-z_]/.test(clean) ? clean : `frontier_${clean}`;
+}

package/examples/js-frontier-rust-workbench-bounds.mjs

@@ -1,4 +1,5 @@
 export function conversionBounds(sourceLanguage, targetLanguage) {
+  const targetDisplay = String(targetLanguage).replace('/', ' and ');
   return {
     sourceLanguage,
     targetLanguage,
@@ -10,13 +11,13 @@ export function conversionBounds(sourceLanguage, targetLanguage) {
     ],
     reviewRequired: [
       'Function bodies are preserved as source evidence and emitted as TODO scaffolds.',
-      'Types are declaration evidence, not a full Rust trait/lifetime/ownership proof.',
+      `Types are declaration evidence, not a full ${targetDisplay} runtime or ownership proof.`,
       'Runtime APIs such as fetch, timers, storage, DOM, Node, and npm crates need adapters.',
       'Round trips are useful for review, but not automatic semantic equivalence proofs.'
     ],
     unsupportedToday: [
-      'Behavior-preserving transpilation of arbitrary TypeScript or Rust.',
-      'Full generic constraints, overload resolution, conditional types, macros, and borrow checking.',
+      'Behavior-preserving transpilation of arbitrary TypeScript into Rust or Python.',
+      'Full generic constraints, overload resolution, conditional types, macros, and ownership inference.',
       'Async control-flow lowering, exception/error model conversion, and memory ownership synthesis.',
       'Perfect comments/trivia formatting in projected target code without richer parser evidence.'
     ]