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

package/dist/internal/index-impl/semanticSliceAdmissionSurface.js

@@ -0,0 +1,142 @@
+import{idFragment,uniqueStrings}from'../../native-import-utils.js';
+
+export function semanticSliceAdmissionSelectedSurface(slice){
+  return{
+    entryRefs:[...(slice?.entryRefs??[])],
+    matchedEntryRefs:[...(slice?.matchedEntryRefs??[])],
+    unresolvedEntryRefs:[...(slice?.unresolvedEntryRefs??[])],
+    symbols:(slice?.symbols??[]).map(compactAdmissionSymbol),
+    ownershipRegions:(slice?.ownershipRegions??[]).map(compactAdmissionRegion),
+    nativeNodes:(slice?.nativeNodes??[]).map(compactAdmissionNativeNode),
+    relations:(slice?.relations??[]).map(compactAdmissionRelation),
+    occurrences:(slice?.occurrences??[]).map(compactAdmissionOccurrence),
+    sourceMapLinks:(slice?.sourceMapLinks??[]).map(compactAdmissionSourceMapLink),
+    sourceSpans:(slice?.sourceSpans??[]).map(compactAdmissionSpan),
+    sourceFiles:(slice?.sourceFiles??[]).map((file)=>({
+      path:file.path,
+      sourceHash:file.sourceHash,
+      spanCount:file.spanCount,
+      excerptCount:file.excerptCount,
+      sourceTextAvailable:file.sourceTextAvailable
+    })),
+    sourceHashes:slice?.mergeAdmission?.sourceHashes??[],
+    conflictKeys:uniqueStrings(slice?.mergeAdmission?.conflictKeys??[]),
+    ownershipKeys:uniqueStrings(slice?.mergeAdmission?.ownershipKeys??[])
+  };
+}
+
+export function semanticSliceSelectedSurfaceEvidence(slice,selectedSurface,testResult,readiness,action){
+  return{
+    id:`evidence_${idFragment(slice?.id??'slice')}_selected_surface`,
+    kind:'semantic-slice-selected-surface',
+    status:readiness==='blocked'||testResult?.status==='failed'?'failed':'passed',
+    path:slice?.sourcePath,
+    summary:`Semantic slice admission selected ${selectedSurface.symbols.length} symbol(s), ${selectedSurface.ownershipRegions.length} ownership region(s), ${selectedSurface.relations.length} relation(s), and ${selectedSurface.sourceFiles.length} source file(s).`,
+    metadata:{
+      sliceId:slice?.id,
+      action,
+      readiness,
+      testStatus:testResult?.status,
+      selectedSurface
+    }
+  };
+}
+
+function compactAdmissionSymbol(symbol){
+  return{
+    id:symbol.id,
+    name:symbol.name,
+    displayName:symbol.displayName,
+    kind:symbol.kind,
+    signature:symbol.signature,
+    nativeAstNodeId:symbol.nativeAstNodeId,
+    sourcePath:symbol.sourcePath,
+    sourceSpan:compactAdmissionSpan(symbol.sourceSpan),
+    ownershipRegionId:symbol.ownershipRegionId??symbol.metadata?.ownershipRegionId,
+    ownershipRegionKey:symbol.ownershipRegionKey??symbol.metadata?.ownershipRegionKey,
+    ownershipRegionKind:symbol.ownershipRegionKind??symbol.metadata?.ownershipRegionKind
+  };
+}
+
+function compactAdmissionRegion(region){
+  return{
+    id:region.id,
+    key:region.key,
+    conflictKey:region.conflictKey,
+    kind:region.kind??region.regionKind,
+    granularity:region.granularity,
+    symbolId:region.symbolId,
+    symbolName:region.symbolName,
+    nativeAstNodeId:region.nativeAstNodeId,
+    sourcePath:region.sourcePath,
+    sourceSpan:compactAdmissionSpan(region.sourceSpan)
+  };
+}
+
+function compactAdmissionNativeNode(node){
+  return{
+    id:node.id,
+    kind:node.kind,
+    languageKind:node.languageKind,
+    sourcePath:node.sourcePath,
+    sourceSpan:compactAdmissionSpan(node.sourceSpan??node.span),
+    parentId:node.parentId,
+    childCount:(node.children??[]).length
+  };
+}
+
+function compactAdmissionRelation(relation){
+  return{
+    id:relation.id,
+    predicate:relation.predicate,
+    kind:relation.kind,
+    sourceId:relation.sourceId,
+    targetId:relation.targetId
+  };
+}
+
+function compactAdmissionOccurrence(occurrence){
+  return{
+    id:occurrence.id,
+    symbolId:occurrence.symbolId,
+    nativeAstNodeId:occurrence.nativeAstNodeId,
+    role:occurrence.role,
+    sourcePath:occurrence.sourcePath,
+    sourceSpan:compactAdmissionSpan(occurrence.sourceSpan??occurrence.span)
+  };
+}
+
+function compactAdmissionSourceMapLink(link){
+  return{
+    id:link.id,
+    sourceMapId:link.sourceMapId,
+    sourcePath:link.sourcePath,
+    sourceHash:link.sourceHash,
+    targetPath:link.targetPath,
+    targetHash:link.targetHash,
+    semanticSymbolId:link.semanticSymbolId,
+    semanticOccurrenceId:link.semanticOccurrenceId,
+    semanticNodeId:link.semanticNodeId,
+    nativeAstNodeId:link.nativeAstNodeId,
+    ownershipRegionId:link.ownershipRegionId,
+    ownershipRegionKey:link.ownershipRegionKey,
+    ownershipRegionKind:link.ownershipRegionKind,
+    precision:link.precision,
+    sourceSpan:compactAdmissionSpan(link.sourceSpan)
+  };
+}
+
+function compactAdmissionSpan(span){
+  if(!span)return undefined;
+  return{
+    path:span.path,
+    sourceId:span.sourceId,
+    sourceHash:span.sourceHash,
+    startLine:span.startLine,
+    startColumn:span.startColumn,
+    endLine:span.endLine,
+    endColumn:span.endColumn,
+    startOffset:span.startOffset,
+    endOffset:span.endOffset
+  };
+}

package/dist/internal/index-impl/semanticSliceExpectationAssertions.js

@@ -0,0 +1,100 @@
+import{semanticSliceAssertion}from'./semanticSliceAssertion.js';import{semanticSliceExpectationRecords}from'./semanticSliceExpectationRecords.js';import{semanticSliceRegionMatchesRef}from'./semanticSliceRegionMatchesRef.js';import{semanticSliceSymbolMatchesRef}from'./semanticSliceSymbolMatchesRef.js';
+
+export function semanticSliceExpectationAssertions(slice, options = {}) {
+  const assertions = [];
+  for (const expectation of semanticSliceTestExpectations(slice, options)) {
+    if (expectation.category === 'symbol') {
+      const ok = (slice?.symbols ?? []).some((symbol) => semanticSliceSymbolMatchesRef(symbol, expectation.ref));
+      assertions.push(semanticSliceAssertion(expectation.id, ok, ok ? `Expected symbol ${expectation.ref} is present.` : `Expected symbol ${expectation.ref} is missing.`, {
+        expectedRef: expectation.ref,
+        selectedSymbols: compactSymbols(slice?.symbols)
+      }));
+      continue;
+    }
+    if (expectation.category === 'region') {
+      const ok = (slice?.ownershipRegions ?? []).some((region) => semanticSliceRegionMatchesRef(region, expectation.ref));
+      assertions.push(semanticSliceAssertion(expectation.id, ok, ok ? `Expected region ${expectation.ref} is present.` : `Expected region ${expectation.ref} is missing.`, {
+        expectedRef: expectation.ref,
+        selectedRegions: compactRegions(slice?.ownershipRegions)
+      }));
+      continue;
+    }
+    if (expectation.category === 'sourceHash') {
+      const actual = semanticSliceActualSourceHash(slice, expectation.path);
+      const ok = Boolean(actual) && actual === expectation.expected;
+      assertions.push(semanticSliceAssertion(expectation.id, ok, ok ? `Expected source hash matched for ${expectation.path ?? 'the selected source file'}.` : `Expected source hash did not match for ${expectation.path ?? 'the selected source file'}.`, {
+        path: expectation.path,
+        expectedSourceHash: expectation.expected,
+        actualSourceHash: actual,
+        selectedSourceHashes: slice?.mergeAdmission?.sourceHashes ?? []
+      }));
+      continue;
+    }
+    if (expectation.category === 'summaryCount') {
+      const actual = semanticSliceSummaryCount(slice, expectation.key);
+      const ok = actual === expectation.expected;
+      assertions.push(semanticSliceAssertion(expectation.id, ok, ok ? `Expected ${expectation.key} count matched.` : `Expected ${expectation.key} count did not match.`, {
+        key: expectation.key,
+        expected: expectation.expected,
+        actual
+      }));
+    }
+  }
+  return assertions;
+}
+
+function semanticSliceTestExpectations(slice, options) {
+  const known = new Set(['symbol', 'region', 'sourceHash', 'summaryCount']);
+  const records = [
+    ...(slice?.verification?.expectedAssertions ?? []).filter((record) => known.has(record?.category)),
+    ...semanticSliceExpectationRecords(options)
+  ];
+  const seen = new Set();
+  const result = [];
+  for (const record of records) {
+    const key = `${record.id}:${record.expected}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
+function semanticSliceActualSourceHash(slice, path) {
+  const hashes = slice?.mergeAdmission?.sourceHashes ?? [];
+  if (path) return hashes.find((entry) => entry.path === path)?.sourceHash ?? (slice?.sourceFiles ?? []).find((file) => file.path === path)?.sourceHash;
+  if (hashes.length === 1) return hashes[0]?.sourceHash;
+  if ((slice?.sourceFiles?.length ?? 0) === 1) return slice.sourceFiles[0]?.sourceHash;
+  return undefined;
+}
+
+function semanticSliceSummaryCount(slice, key) {
+  if (key === 'symbols') return slice?.summary?.symbols ?? slice?.symbols?.length ?? 0;
+  if (key === 'ownershipRegions') return slice?.summary?.ownershipRegions ?? slice?.ownershipRegions?.length ?? 0;
+  if (key === 'sourceFiles') return slice?.summary?.sourceFiles ?? slice?.sourceFiles?.length ?? 0;
+  return undefined;
+}
+
+function compactSymbols(symbols) {
+  return (symbols ?? []).map((symbol) => ({
+    id: symbol.id,
+    name: symbol.name,
+    displayName: symbol.displayName,
+    nativeAstNodeId: symbol.nativeAstNodeId,
+    ownershipRegionId: symbol.ownershipRegionId ?? symbol.metadata?.ownershipRegionId,
+    ownershipRegionKey: symbol.ownershipRegionKey ?? symbol.metadata?.ownershipRegionKey
+  }));
+}
+
+function compactRegions(regions) {
+  return (regions ?? []).map((region) => ({
+    id: region.id,
+    key: region.key,
+    kind: region.kind ?? region.regionKind,
+    granularity: region.granularity,
+    symbolId: region.symbolId,
+    symbolName: region.symbolName,
+    sourcePath: region.sourcePath,
+    nativeAstNodeId: region.nativeAstNodeId
+  }));
+}

package/dist/internal/index-impl/semanticSliceExpectationRecords.js

@@ -0,0 +1,75 @@
+import{readStringArray}from'./readStringArray.js';
+
+export function semanticSliceExpectationRecords(options={}) {
+  const records = [];
+  for (const ref of readStringArray(options.expectedSymbols ?? options.expectedSymbolRefs)) {
+    records.push({ id: `expectedSymbol:${ref}`, category: 'symbol', ref, expected: true });
+  }
+  for (const ref of readStringArray(options.expectedRegions ?? options.expectedRegionRefs)) {
+    records.push({ id: `expectedRegion:${ref}`, category: 'region', ref, expected: true });
+  }
+  for (const entry of semanticSliceSourceHashExpectationRecords(options.expectedSourceHashes)) {
+    records.push(entry);
+  }
+  addSummaryCount(records, 'symbols', options.expectedSymbolCount);
+  addSummaryCount(records, 'ownershipRegions', options.expectedRegionCount);
+  addSummaryCount(records, 'sourceFiles', options.expectedSourceFileCount);
+  return uniqueExpectationRecords(records);
+}
+
+export function semanticSliceSourceHashExpectationRecords(value) {
+  const records = [];
+  const add = (path, sourceHash) => {
+    if (!sourceHash) return;
+    const normalizedPath = path === undefined || path === null || path === '' ? undefined : String(path);
+    records.push({
+      id: `expectedSourceHash:${normalizedPath ?? '*'}`,
+      category: 'sourceHash',
+      path: normalizedPath,
+      expected: String(sourceHash)
+    });
+  };
+  if (!value) return records;
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      if (Array.isArray(entry)) {
+        add(entry[0], entry[1]);
+        continue;
+      }
+      if (entry && typeof entry === 'object') {
+        add(entry.path ?? entry.sourcePath, entry.sourceHash ?? entry.hash ?? entry.expected);
+      }
+    }
+    return records;
+  }
+  if (typeof value.entries === 'function') {
+    for (const [path, sourceHash] of value.entries()) add(path, sourceHash);
+    return records;
+  }
+  if (typeof value === 'object') {
+    for (const [path, sourceHash] of Object.entries(value)) add(path, sourceHash);
+  }
+  return records;
+}
+
+function addSummaryCount(records, key, value) {
+  if (!Number.isFinite(value)) return;
+  records.push({
+    id: `expectedCount:${key}`,
+    category: 'summaryCount',
+    key,
+    expected: Math.max(0, Math.floor(value))
+  });
+}
+
+function uniqueExpectationRecords(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records) {
+    const key = `${record.id}:${record.expected}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}

package/dist/internal/index-impl/semanticSliceExpectedAssertions.js

@@ -1,8 +1,11 @@
-export function semanticSliceExpectedAssertions(selection, unresolvedEntryRefs) {
+import{semanticSliceExpectationRecords}from'./semanticSliceExpectationRecords.js';
+
+export function semanticSliceExpectedAssertions(selection, unresolvedEntryRefs, options = {}) {
   return [
     { id: 'entryRefsResolved', expected: unresolvedEntryRefs.length === 0 },
     { id: 'nonEmptySelection', expected: selection.symbols.length + selection.regions.length + selection.nativeNodes.length > 0 },
     { id: 'sourceMapLinks', expected: selection.mappings.length > 0 },
-    { id: 'conflictKeys', expected: true }
+    { id: 'conflictKeys', expected: true },
+    ...semanticSliceExpectationRecords(options)
   ];
 }

package/dist/internal/index-impl/testSemanticSlice.js

@@ -1,5 +1,5 @@
 import{idFragment,maxSemanticMergeReadiness}from'../../native-import-utils.js';
-import{semanticSliceAssertion}from'./semanticSliceAssertion.js';import{semanticSliceSourceHashAssertions}from'./semanticSliceSourceHashAssertions.js';
+import{semanticSliceAssertion}from'./semanticSliceAssertion.js';import{semanticSliceExpectationAssertions}from'./semanticSliceExpectationAssertions.js';import{semanticSliceSourceHashAssertions}from'./semanticSliceSourceHashAssertions.js';
 export function testSemanticSlice(slice, options = {}) {
   const assertions = [];
   assertions.push(semanticSliceAssertion('kind', slice?.kind === 'frontier.lang.semanticSlice', 'Input is a Frontier semantic slice.'));
@@ -11,6 +11,8 @@ export function testSemanticSlice(slice, options = {}) {
   assertions.push(semanticSliceAssertion('conflictKeys', (slice?.mergeAdmission?.conflictKeys?.length ?? 0) > 0, 'Slice exposes merge-admission conflict keys.'));
   const sourceHashAssertions = semanticSliceSourceHashAssertions(slice, options.currentSources);
   assertions.push(...sourceHashAssertions);
+  const expectationAssertions = semanticSliceExpectationAssertions(slice, options);
+  assertions.push(...expectationAssertions);
   const failed = assertions.filter((assertion) => assertion.status === 'failed');
   const warnings = assertions.filter((assertion) => assertion.status === 'warning');
   const readiness = failed.length
@@ -31,6 +33,7 @@ export function testSemanticSlice(slice, options = {}) {
       warnings: warnings.length,
       failed: failed.length,
       sourceHashChecks: sourceHashAssertions.length,
+      expectedAssertions: expectationAssertions.length,
       symbols: slice?.summary?.symbols ?? slice?.symbols?.length ?? 0,
       ownershipRegions: slice?.summary?.ownershipRegions ?? slice?.ownershipRegions?.length ?? 0,
       sourceMapLinks: slice?.summary?.sourceMapLinks ?? slice?.sourceMapLinks?.length ?? 0

package/dist/language-adapter-package-contracts.js

@@ -10,6 +10,7 @@ import {
   normalizeNativeLanguageId,
   uniqueStrings
 } from './native-import-utils.js';
+import { packageRows } from './language-adapter-package-rows.js';
 
 export const LanguageAdapterPackageReleaseReadinessStatuses = Object.freeze([
   'ready',
@@ -18,23 +19,6 @@ export const LanguageAdapterPackageReleaseReadinessStatuses = Object.freeze([
   'blocked'
 ]);
 
-const packageRows = [
-  row('@shapeshift-labs/frontier-lang-typescript', '0.3.8', 'typescript', 'typescript-compiler-api', { target: 'typescript' }),
-  row('@shapeshift-labs/frontier-lang-javascript', '0.2.8', 'javascript', 'estree', { target: 'javascript', formats: ['estree', 'babel'] }),
-  row('@shapeshift-labs/frontier-lang-rust', '0.2.8', 'rust', 'rust-syn', { target: 'rust', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'macroExpansionEvidence'] }),
-  row('@shapeshift-labs/frontier-lang-python', '0.2.8', 'python', 'python-ast', { target: 'python', formats: ['python-ast', 'libcst'] }),
-  row('@shapeshift-labs/frontier-lang-c', '0.2.8', 'c', 'clang-ast-json', { target: 'c', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'compileCommandsHash', 'preprocessorRecordsHash'] }),
-  platform('@shapeshift-labs/frontier-lang-java', '0.1.8', 'java', 'java-ast', ['semanticdb', 'lsp']),
-  platform('@shapeshift-labs/frontier-lang-kotlin', '0.1.8', 'kotlin', 'kotlin-psi', ['semanticdb', 'lsp']),
-  platform('@shapeshift-labs/frontier-lang-swift', '0.1.8', 'swift', 'swift-syntax', ['sourcekit-lsp', 'lsp']),
-  platform('@shapeshift-labs/frontier-lang-csharp', '0.1.8', 'csharp', 'roslyn-csharp', ['lsp']),
-  platform('@shapeshift-labs/frontier-lang-go', '0.1.8', 'go', 'go-ast', ['lsp']),
-  platform('@shapeshift-labs/frontier-lang-clang', '0.1.8', 'c', 'clang-ast-json', ['lsp'], {
-    supportedLanguages: ['c', 'cpp'],
-    proofKeys: ['parserAst', 'semanticIndex', 'compileCommandsHash', 'preprocessorRecordsHash']
-  })
-];
-
 export const LanguageAdapterPackageContracts = Object.freeze(packageRows.map(createLanguageAdapterPackageContract));
 
 export function createLanguageAdapterPackageContract(input = {}) {
@@ -131,7 +115,7 @@ export function getLanguageAdapterPackageContract(ref, contracts = LanguageAdapt
     contract.packageName === text ||
     contract.package.name === text ||
     contract.package.adapterId === text ||
-    contract.sourceParser.language === normalized
+    (normalized && contractSupportsLanguage(contract, normalized))
   );
 }
 
@@ -142,7 +126,7 @@ export function queryLanguageAdapterPackageContracts(query = {}, contracts = Lan
   return (contracts ?? []).filter((contract) =>
     (!query.packageName || contract.packageName === query.packageName) &&
     (!query.packageClass || contract.package.packageClass === query.packageClass) &&
-    (!language || contract.sourceParser.language === language) &&
+    contractSupportsLanguage(contract, language) &&
     (!target || contract.targetProjection.targets.includes(target)) &&
     (!semanticFormat || contract.semanticIndex.formats.map((format) => format.toLowerCase()).includes(semanticFormat)) &&
     (query.releaseReady === undefined || contract.releaseReadiness.releaseReady === query.releaseReady) &&
@@ -168,44 +152,6 @@ export function summarizeLanguageAdapterPackageContracts(contracts = LanguageAda
   });
 }
 
-function row(packageName, packageVersion, language, parser, input = {}) {
-  return {
-    packageName,
-    packageVersion,
-    language,
-    parser,
-    supportedFormats: input.formats,
-    target: input.target,
-    packageClass: 'target-projection',
-    releaseReadiness: { status: 'ready-with-losses', releaseReady: true, versionSource: 'package-json-dependency' },
-    semanticIndex: { formats: ['frontier-semantic-index', 'scip', 'lsif', 'lsp'], hostEvidenceRequired: false },
-    proofKeys: input.proofKeys
-  };
-}
-
-function platform(packageName, packageVersion, language, parser, semanticFormats, input = {}) {
-  const published = packageVersion !== '0.0.0';
-  return {
-    packageName,
-    packageVersion,
-    language,
-    parser,
-    supportedLanguages: input.supportedLanguages,
-    supportedFormats: input.formats,
-    packageClass: 'platform-importer',
-    targetProjection: { targets: [], caveats: input.targetCaveats },
-    releaseReadiness: {
-      status: published ? 'ready-with-losses' : 'needs-review',
-      releaseReady: published,
-      versionSource: published ? 'static-package-catalog' : 'related-package-catalog-placeholder',
-      signals: input.signals
-    },
-    semanticIndex: { formats: ['frontier-semantic-index', ...semanticFormats], hostEvidenceRequired: true },
-    proofEvidence: { hostEvidenceRequired: true, requiredEvidenceKeys: input.proofKeys ?? ['parserAst', 'semanticIndex', 'buildGraphEvidence'] },
-    parserCaveats: input.parserCaveats
-  };
-}
-
 function projectionRows(input, language) {
   const targets = input.targetProjection?.targets ?? input.targets ?? input.target ?? nativeProjectionTargetsForLanguage(language);
   const normalizedTargets = freezeStrings(targets);
@@ -274,6 +220,15 @@ function targetProjectionCaveats(targetRows, packageClass) {
   return caveats;
 }
 
+function contractSupportsLanguage(contract, language) {
+  if (!language) return true;
+  const languageIds = [
+    contract.sourceParser?.language,
+    ...(contract.sourceParser?.supportedLanguages ?? [])
+  ].map(normalizeNativeLanguageId).filter(Boolean);
+  return languageIds.includes(language);
+}
+
 function adapterFamily(language, parser) {
   if (language === 'javascript' || language === 'typescript') return 'javascript-typescript';
   if (language === 'java' || language === 'kotlin') return 'jvm';

package/dist/language-adapter-package-rows.js

@@ -0,0 +1,116 @@
+const packageRows = [
+  row('@shapeshift-labs/frontier-lang-typescript', '0.3.8', 'typescript', 'typescript-compiler-api', { target: 'typescript' }),
+  row('@shapeshift-labs/frontier-lang-javascript', '0.2.8', 'javascript', 'estree', { target: 'javascript', formats: ['estree', 'babel'] }),
+  row('@shapeshift-labs/frontier-lang-rust', '0.2.8', 'rust', 'rust-syn', { target: 'rust', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'macroExpansionEvidence'] }),
+  row('@shapeshift-labs/frontier-lang-python', '0.2.8', 'python', 'python-ast', { target: 'python', formats: ['python-ast', 'libcst'] }),
+  row('@shapeshift-labs/frontier-lang-c', '0.2.8', 'c', 'clang-ast-json', { target: 'c', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'compileCommandsHash', 'preprocessorRecordsHash'] }),
+  platform('@shapeshift-labs/frontier-lang-java', '0.1.8', 'java', 'java-ast', ['semanticdb', 'lsp']),
+  platform('@shapeshift-labs/frontier-lang-kotlin', '0.1.8', 'kotlin', 'kotlin-psi', ['semanticdb', 'lsp']),
+  platform('@shapeshift-labs/frontier-lang-swift', '0.1.8', 'swift', 'swift-syntax', ['sourcekit-lsp', 'lsp']),
+  platform('@shapeshift-labs/frontier-lang-csharp', '0.1.8', 'csharp', 'roslyn-csharp', ['lsp']),
+  platform('@shapeshift-labs/frontier-lang-go', '0.1.8', 'go', 'go-ast', ['lsp']),
+  platform('@shapeshift-labs/frontier-lang-clang', '0.1.8', 'c', 'clang-ast-json', ['lsp'], {
+    supportedLanguages: ['c', 'cpp'],
+    proofKeys: ['parserAst', 'semanticIndex', 'compileCommandsHash', 'preprocessorRecordsHash']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-lisp', 'lisp', 'tree-sitter-lisp', ['lsp'], {
+    supportedLanguages: ['lisp', 'common-lisp', 'scheme', 'racket'],
+    formats: ['tree-sitter'],
+    family: 'lisp-scheme',
+    parserCaveats: ['Lisp and Scheme contracts need host evidence for reader conditionals, package/module systems, macros, quoting semantics, source ranges, and comment/trivia preservation.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-haskell', 'haskell', 'ghc-api', ['lsp'], {
+    parserCaveats: ['GHC API parse trees require host evidence for CPP, Template Haskell, quasiquotes, package flags, renamer/typechecker facts, source ranges, and layout-sensitive source preservation.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-erlang', 'erlang', 'erl_parse', ['lsp'], {
+    parserCaveats: ['Erlang parser contracts require host evidence for include paths, record definitions, macros, parse transforms, specs, source ranges, and comments/trivia preservation.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-elixir', 'elixir', 'elixir-quoted', ['lsp'], {
+    parserCaveats: ['Elixir quoted AST contracts require host evidence for macro expansion, aliases/imports, protocols, Mix compile context, generated code, source ranges, and formatter trivia.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-ruby', 'ruby', 'prism', ['lsp'], {
+    parserCaveats: ['Ruby parser contracts require host evidence for dynamic constant lookup, refinements, metaprogramming, comments/trivia, source ranges, and optional type signature ecosystems.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-php', 'php', 'php-parser', ['lsp'], {
+    parserCaveats: ['PHP parser contracts require host evidence for Composer/autoload context, conditional declarations, attributes, PHPDoc, generated code, source ranges, and comments/trivia.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-lua', 'lua', 'luaparse', ['lsp'], {
+    parserCaveats: ['Lua parser contracts require host evidence for dynamic module loading, metatables, embedded DSLs, comments/trivia, source ranges, and version-specific syntax.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-r', 'r', 'r-parser', ['lsp'], {
+    parserCaveats: ['R parser contracts require host evidence for non-standard evaluation, library search paths, generated code, comments/trivia, source ranges, and version-specific syntax.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-julia', 'julia', 'julia-syntax', ['lsp'], {
+    parserCaveats: ['Julia parser contracts require host evidence for macro expansion, generated functions, multiple dispatch/type facts, package environments, source ranges, and comments/trivia.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-zig', 'zig', 'zig-ast', ['lsp'], {
+    parserCaveats: ['Zig parser contracts require host evidence for comptime evaluation, build.zig context, imports, generated code, source ranges, and comments/trivia preservation.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-ocaml', 'ocaml', 'ocaml-parsetree', ['lsp'], {
+    parserCaveats: ['OCaml parsetree contracts require host evidence for PPX rewrites, module/functor resolution, typedtree facts, Dune context, source ranges, and comments/trivia.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-scala', 'scala', 'scalameta', ['semanticdb', 'lsp'], {
+    parserCaveats: ['Scala parser contracts require host evidence for Scala 2/3 dialects, macros, givens/implicits, SemanticDB/TASTy facts, build targets, source ranges, and comments/trivia.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-dart', 'dart', 'dart-analyzer', ['lsp'], {
+    parserCaveats: ['Dart analyzer contracts require host evidence for analysis context, null-safety mode, package config, build_runner generated sources, source ranges, and comments/trivia.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-sql', 'sql', 'sqlparser', ['lsp'], {
+    supportedLanguages: ['sql', 'postgresql', 'postgres', 'mysql', 'sqlite', 'tsql'],
+    parserCaveats: ['SQL parser contracts require host evidence for dialect selection, schema/catalog metadata, migrations, vendor extensions, procedural SQL blocks, source ranges, and comments/trivia.']
+  }),
+  plannedPlatform('@shapeshift-labs/frontier-lang-shader', 'shader', 'tree-sitter-shader', ['lsp', 'spirv-reflect'], {
+    supportedLanguages: ['shader', 'glsl', 'hlsl', 'wgsl', 'slang'],
+    formats: ['tree-sitter'],
+    family: 'shader',
+    parserCaveats: ['Shader parser contracts require host evidence for dialect selection, preprocessor/includes, entry points, resource layouts, generated variants, source ranges, and reflection data.']
+  })
+];
+
+export { packageRows };
+
+function row(packageName, packageVersion, language, parser, input = {}) {
+  return {
+    packageName,
+    packageVersion,
+    language,
+    parser,
+    supportedFormats: input.formats,
+    target: input.target,
+    packageClass: 'target-projection',
+    releaseReadiness: { status: 'ready-with-losses', releaseReady: true, versionSource: 'package-json-dependency' },
+    semanticIndex: { formats: ['frontier-semantic-index', 'scip', 'lsif', 'lsp'], hostEvidenceRequired: false },
+    proofKeys: input.proofKeys
+  };
+}
+
+function platform(packageName, packageVersion, language, parser, semanticFormats, input = {}) {
+  const published = packageVersion !== '0.0.0';
+  return {
+    packageName,
+    packageVersion,
+    language,
+    parser,
+    family: input.family,
+    supportedLanguages: input.supportedLanguages,
+    supportedFormats: input.formats,
+    packageClass: 'platform-importer',
+    targetProjection: { targets: [], caveats: input.targetCaveats },
+    releaseReadiness: {
+      status: published ? 'ready-with-losses' : 'needs-review',
+      releaseReady: published,
+      versionSource: published ? 'static-package-catalog' : 'related-package-catalog-placeholder',
+      signals: input.signals
+    },
+    semanticIndex: { formats: ['frontier-semantic-index', ...semanticFormats], hostEvidenceRequired: true },
+    proofEvidence: { hostEvidenceRequired: true, requiredEvidenceKeys: input.proofKeys ?? ['parserAst', 'semanticIndex', 'buildGraphEvidence'] },
+    parserCaveats: input.parserCaveats
+  };
+}
+
+function plannedPlatform(packageName, language, parser, semanticFormats, input = {}) {
+  return platform(packageName, '0.0.0', language, parser, semanticFormats, {
+    proofKeys: ['parserAst', 'semanticIndex', 'sourceMap', 'sourcePreservationEvidence', 'projectionCaveats'],
+    ...input
+  });
+}

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;
+}