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

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

@@ -0,0 +1,190 @@
+export function routeExplanationSummary(plan, routes) {
+  const missingEvidence = uniqueStrings(routes.flatMap((route) => route.missingEvidence));
+  const blockers = uniqueStrings(routes.flatMap((route) => route.blockers));
+  const review = uniqueStrings(routes.flatMap((route) => route.review));
+  const readiness = aggregateReadiness(routes.map((route) => route.semanticMerge.readiness));
+  const routeScores = routes.map((route) => route.semanticMerge.score).filter((score) => Number.isFinite(score));
+  return {
+    kind: 'frontier.workbench.routeExplanation',
+    version: 1,
+    planId: plan.id,
+    summary: {
+      routes: routes.length,
+      targetAdapterRoutes: plan.summary.targetAdapterRoutes,
+      missingEvidence: missingEvidence.length,
+      blockers: blockers.length,
+      reviewReasons: review.length,
+      autoMergeClaims: plan.summary.autoMergeClaims,
+      semanticEquivalenceClaims: plan.summary.semanticEquivalenceClaims
+    },
+    semanticMerge: {
+      readiness,
+      ready: readiness === 'ready' && missingEvidence.length === 0 && blockers.length === 0,
+      admissionAction: aggregateAdmissionAction(routes.map((route) => route.semanticMerge.admissionAction)),
+      score: routeScores.length ? Math.min(...routeScores) : 0,
+      risk: aggregateRisk(routes.map((route) => route.semanticMerge.risk)),
+      missingEvidence,
+      missingEvidenceDetails: missingEvidence.map(evidenceGapDetail),
+      blockers,
+      review,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    },
+    routes
+  };
+}
+
+export function explainRoute(route, context) {
+  const missingEvidence = routeMissingEvidence(route, context.projection);
+  const semanticReadiness = routeSemanticMergeReadiness(route, missingEvidence);
+  const semanticAdmissionAction = routeSemanticAdmissionAction(route, semanticReadiness, missingEvidence);
+  return {
+    id: route?.id ?? `conversion_${context.sourceLanguage}_to_${context.target}`,
+    sourceLanguage: route?.sourceLanguage ?? context.sourceLanguage,
+    target: route?.target ?? context.target,
+    mode: route?.mode ?? 'blocked',
+    routeAction: route?.routeAction ?? 'blocked',
+    readiness: route?.readiness ?? 'blocked',
+    priority: route?.priority ?? 'blocker',
+    adapter: route?.adapter,
+    adapterKind: route?.adapterKind,
+    targetPath: context.projection?.targetPath,
+    missingEvidence,
+    missingEvidenceDetails: missingEvidence.map(evidenceGapDetail),
+    blockers: route?.blockers ?? ['No conversion route was planned.'],
+    review: route?.review ?? [],
+    evidence: {
+      imports: route?.evidence?.imports ?? 0,
+      importReadiness: route?.evidence?.importReadiness,
+      symbols: route?.evidence?.symbols ?? 0,
+      sourceMapMappings: route?.evidence?.sourceMapMappings ?? 0,
+      parserRows: route?.evidence?.parserRows ?? 0,
+      mergeReadyParsers: route?.evidence?.mergeReadyParsers ?? 0,
+      targetSupported: route?.evidence?.targetSupported === true,
+      targetAdapter: route?.evidence?.targetAdapter ?? route?.adapter,
+      projectionEvidenceIds: (context.projection?.evidence ?? []).map((record) => record.id).filter(Boolean)
+    },
+    semanticMerge: {
+      readiness: semanticReadiness,
+      score: route?.mergeScore?.value ?? 0,
+      risk: routeSemanticRisk(route, semanticReadiness),
+      admissionAction: semanticAdmissionAction,
+      penalties: uniqueStrings([
+        ...(route?.mergeScore?.penalties ?? []),
+        ...missingEvidence.map((key) => `Missing evidence: ${key}`)
+      ]).slice(0, 6),
+      autoMergeClaim: route?.autoMergeClaim === true,
+      semanticEquivalenceClaim: route?.semanticEquivalenceClaim === true
+    },
+    explanation: routeExplanationText(route, missingEvidence, semanticReadiness)
+  };
+}
+
+function routeMissingEvidence(route, projection) {
+  const missing = new Set(route?.missingEvidence ?? []);
+  if ((route?.evidence?.mergeReadyParsers ?? 0) === 0) missing.add('merge-ready-parser');
+  if (!hasProofEvidence(projection?.evidence ?? [])) missing.add('proof-or-replay-evidence');
+  if (!hasRuntimeAdapterEvidence(projection?.evidence ?? [])) missing.add('runtime-adapter-evidence');
+  return [...missing].sort();
+}
+
+function routeExplanationText(route, missingEvidence, semanticReadiness) {
+  if (!route) return 'No conversion route was planned for this target.';
+  const adapter = route.adapter ? ` through ${route.adapter}` : '';
+  const evidence = missingEvidence.length ? ` missing ${missingEvidence.join(', ')}` : ' with required evidence attached';
+  return `${route.sourceLanguage} -> ${route.target} uses ${route.mode}${adapter}; semantic merge readiness is ${semanticReadiness}${evidence}.`;
+}
+
+function evidenceGapDetail(key) {
+  const details = {
+    'merge-ready-parser': {
+      key,
+      label: 'Merge-ready parser evidence',
+      status: 'missing',
+      summary: 'Attach exact parser, source range, token/trivia, and feature coverage evidence before merge admission.'
+    },
+    'proof-or-replay-evidence': {
+      key,
+      label: 'Proof or replay evidence',
+      status: 'missing',
+      summary: 'Attach proof, oracle, replay, or behavior test evidence for the projected route.'
+    },
+    'runtime-adapter-evidence': {
+      key,
+      label: 'Runtime adapter evidence',
+      status: 'missing',
+      summary: 'Attach runtime adapter evidence for imports, effects, host APIs, package modules, and target runtime shims.'
+    },
+    'source-preservation-hash': {
+      key,
+      label: 'Source preservation hash',
+      status: 'missing',
+      summary: 'Attach exact source preservation evidence so source text can be traced to merge candidates.'
+    },
+    'target-adapter': {
+      key,
+      label: 'Target adapter',
+      status: 'missing',
+      summary: 'Add a source-to-target projection adapter for emitted target code.'
+    },
+    'target-adapter-evidence': {
+      key,
+      label: 'Target adapter evidence',
+      status: 'missing',
+      summary: 'Attach run evidence from the host-owned target projection adapter.'
+    }
+  };
+  return details[key] ?? { key, label: key, status: 'missing', summary: 'Attach route evidence before merge admission.' };
+}
+
+function hasProofEvidence(evidence) {
+  return evidence.some((record) => /proof|oracle|replay|behavior|test|verification/.test(String(record.kind ?? record.metadata?.kind ?? record.type ?? '')));
+}
+
+function hasRuntimeAdapterEvidence(evidence) {
+  return evidence.some((record) => {
+    const capabilities = record.metadata?.capabilities ?? [];
+    return record.metadata?.runtimeAdapterEvidence === true
+      || capabilities.includes('runtime-adapter')
+      || /runtime/.test(String(record.kind ?? record.metadata?.kind ?? record.type ?? ''));
+  });
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+function aggregateReadiness(values) {
+  const rank = { ready: 0, 'ready-with-losses': 1, 'needs-review': 2, blocked: 3 };
+  return values.reduce((current, value) => (rank[value] ?? 3) > (rank[current] ?? 3) ? value : current, 'ready');
+}
+
+function routeSemanticMergeReadiness(route, missingEvidence) {
+  const base = route?.mergeScore?.readiness ?? route?.readiness ?? 'blocked';
+  if (!missingEvidence.length || base === 'blocked') return base;
+  return aggregateReadiness([base, 'needs-review']);
+}
+
+function routeSemanticAdmissionAction(route, readiness, missingEvidence) {
+  if ((route?.mergeScore?.action ?? route?.admissionAction) === 'reject' || readiness === 'blocked') return 'reject';
+  if (readiness === 'ready' && missingEvidence.length === 0) return route?.mergeScore?.action ?? 'admit';
+  return 'prioritize';
+}
+
+function routeSemanticRisk(route, readiness) {
+  if (readiness === 'blocked') return 'high';
+  if (readiness === 'needs-review') return 'medium';
+  return route?.mergeScore?.risk ?? 'low';
+}
+
+function aggregateAdmissionAction(values) {
+  if (values.includes('reject')) return 'reject';
+  if (values.includes('prioritize')) return 'prioritize';
+  return values[0] ?? 'prioritize';
+}
+
+function aggregateRisk(values) {
+  if (values.includes('high')) return 'high';
+  if (values.includes('medium')) return 'medium';
+  return values[0] ?? 'low';
+}

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

@@ -1,3 +1,5 @@
+import { workbenchRouteStyles } from './js-frontier-rust-workbench-route-styles.mjs';
+
 export function workbenchStyles() {
   return `
 :root {
@@ -69,8 +71,8 @@ body {
 .brand h1 { margin: 0; font-size: 15px; line-height: 1.1; letter-spacing: 0; }
 .brand p { margin: 4px 0 0; color: var(--muted); font-size: 12px; }
 
-.topActions { display: flex; align-items: center; gap: 8px; }
-.iconButton, .segmented button, .modeGroup button, .runButton {
+.topActions { display: flex; align-items: center; gap: 8px; margin: 0; }
+.iconButton, .segmented button, .runButton {
   height: 32px;
   border: 1px solid var(--line);
   background: var(--panel-2);
@@ -79,17 +81,7 @@ body {
 }
 .iconButton { width: 34px; font-size: 16px; cursor: pointer; }
 .runButton { min-width: 64px; padding: 0 14px; cursor: pointer; color: var(--green); }
-.modeGroup { display: flex; }
-.modeGroup button {
-  width: 84px;
-  border-radius: 0;
-  font-size: 12px;
-  cursor: pointer;
-}
-.modeGroup button:first-child { border-radius: 7px 0 0 7px; }
-.modeGroup button:last-child { border-radius: 0 7px 7px 0; border-left: 0; }
-.modeGroup button[aria-pressed="true"] { background: #213127; color: var(--green); }
-.iconButton:hover, .segmented button:hover, .modeGroup button:hover, .runButton:hover { background: var(--panel-3); }
+.iconButton:hover, .segmented button:hover, .runButton:hover { background: var(--panel-3); }
 
 .statusStrip {
   position: fixed;
@@ -97,7 +89,7 @@ body {
   z-index: 19;
   height: var(--status-height);
   display: grid;
-  grid-template-columns: repeat(4, minmax(0, 1fr));
+  grid-template-columns: repeat(5, minmax(0, 1fr));
   background: #0f1214;
   overflow: hidden;
 }
@@ -132,7 +124,7 @@ body {
   height: calc(100dvh - var(--chrome-height));
   min-height: 0;
   display: grid;
-  grid-template-columns: minmax(270px, 0.95fr) minmax(330px, 1.1fr) minmax(300px, 1fr);
+  grid-template-columns: minmax(260px, 0.9fr) minmax(320px, 1.1fr) minmax(280px, 1fr) minmax(280px, 1fr);
   overflow: hidden;
 }
 .pane {
@@ -189,6 +181,9 @@ textarea, .codeBlock {
   overscroll-behavior: contain;
   white-space: pre;
 }
+textarea[readonly] {
+  cursor: default;
+}
 
 .graphView {
   padding: 12px;
@@ -230,44 +225,7 @@ textarea, .codeBlock {
   font-size: 11px;
   text-transform: uppercase;
 }
-.edgeList {
-  display: grid;
-  gap: 6px;
-  margin: 0;
-  padding: 0;
-  list-style: none;
-}
-.edgeList li {
-  border-left: 2px solid var(--blue);
-  background: rgba(109, 180, 232, .08);
-  padding: 6px 8px;
-  color: var(--muted);
-  font-size: 12px;
-  overflow-wrap: anywhere;
-}
-.boundsGrid {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 8px;
-}
-.boundCard {
-  border: 1px solid var(--line);
-  border-radius: 8px;
-  background: #12171a;
-  padding: 10px;
-}
-.boundCard strong {
-  display: block;
-  margin-bottom: 8px;
-  font-size: 12px;
-}
-.boundCard ul {
-  margin: 0;
-  padding-left: 16px;
-  color: var(--muted);
-  font-size: 11px;
-  line-height: 1.45;
-}
+${workbenchRouteStyles()}
 .segmented { display: flex; gap: 0; }
 .segmented button {
   width: 58px;
@@ -291,7 +249,7 @@ textarea, .codeBlock {
   }
   .workspace {
     grid-template-columns: 1fr;
-    grid-template-rows: repeat(3, minmax(0, 1fr));
+    grid-template-rows: repeat(4, minmax(0, 1fr));
     overflow: hidden;
   }
   .pane {

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

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import http from 'node:http';
-import { compileNativeSource, createSemanticImportSidecar, importNativeSource, writeUniversalAstJson } from '../dist/index.js';
-import { conversionBounds } from './js-frontier-rust-workbench-bounds.mjs';
+import { convertSource } from './js-frontier-rust-workbench-convert.mjs';
 import { renderWorkbenchHtml } from './js-frontier-rust-workbench-html.mjs';
 import { workbenchClientScript } from './js-frontier-rust-workbench-client.mjs';
 import { workbenchStyles } from './js-frontier-rust-workbench-styles.mjs';
@@ -24,21 +23,61 @@ export class TodoStore {
   }
 }
 `;
-const sampleRustSource = `// Generated from Frontier semantic graph evidence.
-pub fn add_todo() {
-    // port body from preserved TypeScript source
-}
-
-pub struct TodoStore;
-`;
 
 if (args.smoke) {
   const result = convertSource(sampleSource, { sourceLanguage: 'typescript' });
   assert(result.summary.symbols >= 2, 'expected semantic symbols');
-  assert(result.projection.output.includes('pub'), 'expected Rust projection');
-  const reverse = convertSource(result.projection.output, { sourceLanguage: 'rust' });
-  assert(reverse.projection.output.includes('export'), 'expected TypeScript projection');
-  console.log(JSON.stringify({ ok: true, summary: result.summary }, null, 2));
+  assert(result.frontier.universalAst.valid, 'expected valid universal AST summary');
+  assert(result.projections.rust.output.includes('pub'), 'expected Rust projection');
+  assert(result.projections.python.output.includes('def add_todo'), 'expected Python projection');
+  assert(result.routeExplanation.routes.length === 2, 'expected route explanation for both targets');
+  assert(result.routeExplanation.semanticMerge.readiness === 'blocked', 'expected blocked semantic merge readiness');
+  assert(result.routeExplanation.semanticMerge.missingEvidence.includes('proof-or-replay-evidence'), 'expected missing proof evidence');
+  assert(result.routeExplanation.semanticMerge.missingEvidence.includes('merge-ready-parser'), 'expected missing parser evidence');
+  assert(result.routeExplanation.semanticMerge.missingEvidence.includes('runtime-adapter-evidence'), 'expected missing runtime adapter evidence');
+  const html = renderWorkbenchHtml({
+    sourceLanguage: 'typescript',
+    sources: { typescript: sampleSource },
+    result
+  });
+  const client = workbenchClientScript();
+  const styles = workbenchStyles();
+  assert(html.includes('id="convertForm"'), 'expected submit form');
+  assert(html.includes('id="typescriptInput"'), 'expected TypeScript input pane');
+  assert(html.includes('id="frontierJson"'), 'expected Frontier graph JSON pane');
+  assert(html.includes('id="rustOutput"'), 'expected Rust output pane');
+  assert(html.includes('id="pythonOutput"'), 'expected Python output pane');
+  assert(client.includes("addEventListener('submit'"), 'expected submit-based conversion listener');
+  assert(client.includes('Route Explanation'), 'expected route explanation rendering');
+  assert(styles.includes('grid-template-columns: minmax(260px, 0.9fr) minmax(320px, 1.1fr) minmax(280px, 1fr) minmax(280px, 1fr);'), 'expected four-pane desktop scaffold');
+  assert(styles.includes('overflow: auto'), 'expected scrollable pane bodies');
+  assert(styles.includes('.workspace {'), 'expected fixed workspace section');
+  assert(styles.includes('.routeCard'), 'expected route explanation styles');
+  console.log(JSON.stringify({
+    ok: true,
+    summary: result.summary,
+    projections: {
+      rust: { ok: result.projections.rust.ok, readiness: result.projections.rust.readiness },
+      python: { ok: result.projections.python.ok, readiness: result.projections.python.readiness }
+    },
+    routeExplanation: {
+      semanticMerge: result.routeExplanation.semanticMerge,
+      routes: result.routeExplanation.routes.map((route) => ({
+        target: route.target,
+        mode: route.mode,
+        routeAction: route.routeAction,
+        readiness: route.readiness,
+        admissionAction: route.semanticMerge.admissionAction,
+        missingEvidence: route.missingEvidence
+      }))
+    },
+    layout: {
+      submitBased: true,
+      panes: ['typescript', 'frontier', 'rust', 'python'],
+      independentScrollRegions: 4,
+      fixedSections: ['topbar', 'statusStrip', 'workspace']
+    }
+  }, null, 2));
 } else {
   const server = http.createServer(routeRequest);
   server.listen(port, '127.0.0.1', () => {
@@ -51,7 +90,7 @@ async function routeRequest(request, response) {
     if (request.method === 'GET' && request.url === '/') {
       return send(response, 200, renderWorkbenchHtml({
         sourceLanguage: 'typescript',
-        sources: { typescript: sampleSource, rust: sampleRustSource },
+        sources: { typescript: sampleSource },
         result: convertSource(sampleSource, { sourceLanguage: 'typescript' })
       }), 'text/html; charset=utf-8');
     }
@@ -66,7 +105,7 @@ async function routeRequest(request, response) {
       return sendJson(response, 200, {
         ok: true,
         result: convertSource(String(body.source ?? ''), {
-          sourceLanguage: body.sourceLanguage ?? 'typescript'
+          sourceLanguage: 'typescript'
         })
       });
     }
@@ -76,205 +115,6 @@ async function routeRequest(request, response) {
   }
 }
 
-function convertSource(source, options = {}) {
-  const sourceLanguage = normalizeSourceLanguage(options.sourceLanguage);
-  const target = sourceLanguage === 'rust' ? 'typescript' : 'rust';
-  const imported = importNativeSource({
-    language: sourceLanguage,
-    sourcePath: `workbench/input.${sourceExtension(sourceLanguage)}`,
-    sourceText: source
-  });
-  const projection = compileNativeSource(imported, {
-    target,
-    targetPath: `workbench/output.${targetExtension(target)}`,
-    targetAdapters: [createTsToRustWorkbenchAdapter(), createRustToTsWorkbenchAdapter()],
-    emitOnBlocked: true
-  });
-  const sidecar = createSemanticImportSidecar(imported, { generatedAt: 0, targetPath: projection.sourceMap?.targetPath });
-  return {
-    sourceHash: imported.nativeSource.sourceHash,
-    sourceLanguage,
-    summary: {
-      readiness: sidecar.summary.readiness,
-      symbols: imported.semanticIndex.symbols.length,
-      sourceMapMappings: imported.sourceMaps[0]?.mappings.length ?? 0,
-      losses: imported.losses.length,
-      patchHints: sidecar.patchHints.length
-    },
-    frontier: {
-      universalAst: universalAstSummary(imported),
-      semanticIndexId: imported.semanticIndex.id,
-      sidecarId: sidecar.id,
-      symbols: imported.semanticIndex.symbols.map(symbolSummary),
-      relations: relationSummaries(imported),
-      losses: imported.losses.map(lossSummary),
-      patchHints: sidecar.patchHints.map((hint) => ({
-        id: hint.id,
-        readiness: hint.readiness,
-        operations: hint.supportedOperations,
-        ownershipKey: hint.ownershipKey
-      }))
-    },
-    bounds: conversionBounds(sourceLanguage, target),
-    projection: {
-      target,
-      targetLanguage: target,
-      sourceLanguage,
-      mode: projection.outputMode,
-      readiness: projection.readiness.readiness,
-      ok: projection.ok,
-      output: projection.output,
-      sourceMapMappings: projection.sourceMap?.mappings.length ?? 0
-    }
-  };
-}
-
-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.'
-        }]
-      };
-    }
-  };
-}
-
-function createRustToTsWorkbenchAdapter() {
-  return {
-    id: 'frontier-lang-workbench-rust-to-ts',
-    sourceLanguage: 'rust',
-    target: 'typescript',
-    version: '0.0.0-demo',
-    capabilities: ['semantic-symbol-scaffold'],
-    coverage: {
-      readiness: 'ready',
-      handledLossKinds: ['opaqueNative', 'macroExpansion', 'declarationOnlyCoverage', 'partialSemanticIndex', 'sourceMapApproximation', 'sourcePreservation'],
-      notes: ['Workbench adapter lowers Rust semantic symbols to TypeScript scaffolding and leaves bodies explicit.']
-    },
-    project(input) {
-      return {
-        output: tsFromSymbols(input.importResult.semanticIndex?.symbols ?? []),
-        readiness: 'ready',
-        evidence: [{
-          id: 'evidence_workbench_rust_to_ts',
-          kind: 'projection',
-          status: 'passed',
-          summary: 'Workbench adapter projected Rust semantic symbols to TypeScript 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 tsFromSymbols(symbols) {
-  const lines = ['// Generated from Frontier semantic graph evidence.'];
-  for (const symbol of symbols) {
-    if (symbol.kind === 'type' || symbol.kind === 'class') lines.push('', `export class ${safeTypeName(symbol.name)} {}`);
-    if (symbol.kind === 'function' || symbol.kind === 'method') {
-      lines.push('', `export function ${safeJsName(symbol.name)}(...args: unknown[]) {`, "  throw new Error('port body from preserved Rust source');", '}');
-    }
-  }
-  return `${lines.join('\n').trim()}\n`;
-}
-
-function universalAstSummary(imported) {
-  const summary = { valid: true, validationError: undefined };
-  let parsed = imported.universalAst;
-  try {
-    parsed = JSON.parse(writeUniversalAstJson(imported.universalAst));
-  } catch (error) {
-    summary.valid = false;
-    summary.validationError = String(error.message || error);
-  }
-  return {
-    ...summary,
-    kind: parsed.kind,
-    id: parsed.id,
-    nativeSources: parsed.nativeSources?.length ?? 0,
-    semanticSymbols: parsed.semanticIndex?.symbols?.length ?? 0,
-    sourceMaps: parsed.sourceMaps?.length ?? 0,
-    layers: Object.keys(parsed.layers ?? {})
-  };
-}
-
-function symbolSummary(symbol) {
-  return {
-    id: symbol.id,
-    name: symbol.name,
-    kind: symbol.kind,
-    language: symbol.language,
-    region: symbol.metadata?.ownershipRegionKind,
-    ownershipKey: symbol.metadata?.ownershipRegionKey
-  };
-}
-
-function relationSummaries(imported) {
-  const names = new Map(imported.semanticIndex.symbols.map((symbol) => [symbol.id, symbol.name]));
-  return imported.semanticIndex.relations.map((relation) => ({
-    id: relation.id,
-    predicate: relation.predicate,
-    label: `${names.get(relation.sourceId) ?? relation.sourceId} ${relation.predicate} ${names.get(relation.targetId) ?? relation.targetId}`
-  }));
-}
-
-function lossSummary(loss) {
-  return { id: loss.id, kind: loss.kind, severity: loss.severity, message: loss.message };
-}
-
-function normalizeSourceLanguage(language) {
-  return String(language || 'typescript').toLowerCase() === 'rust' ? 'rust' : 'typescript';
-}
-
-function targetExtension(target) {
-  return target === 'rust' ? 'rs' : 'ts';
-}
-
-function sourceExtension(language) {
-  return language === 'rust' ? 'rs' : 'ts';
-}
-
-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 safeJsName(name) {
-  const clean = String(name).replace(/[^A-Za-z0-9_$]/g, '_');
-  return /^[A-Za-z_$]/.test(clean) ? clean : `frontier_${clean}`;
-}
-
 function sendJson(response, status, value) {
   return send(response, status, JSON.stringify(value), 'application/json; charset=utf-8');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.65",
+  "version": "0.2.67",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",