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

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

@@ -0,0 +1,217 @@
+import{countBy,uniqueStrings}from'../../native-import-utils.js';
+
+const precisionRank=Object.freeze({exact:0,line:1,declaration:2,estimated:3,unknown:4,none:5});
+
+export function createRoundtripAudit(input){
+  const disposition=roundtripAuditDisposition(input);
+  return{
+    schema:'frontier.lang.nativeRoundtripAuditSignal',
+    version:1,
+    disposition,
+    claim:roundtripAuditClaim(disposition),
+    sourceLanguage:input.sourceLanguage,
+    target:input.target,
+    sameLanguage:input.sameLanguage,
+    outputMode:input.outputMode,
+    projectionMode:input.projectionMode,
+    sourceHashVerified:input.sourceHashVerified,
+    outputSourceMapPrecision:input.sourceMapEvidence.precision,
+    universalSourceMapPrecision:input.universalSourceMapEvidence.precision,
+    targetProjectionAdapterId:input.targetProjection?.adapter?.id,
+    targetCoverageLossClass:selectedTargetCoverageLossClass(input),
+    reviewRequired:input.semanticMerge!=='ready',
+    semanticMergeReadiness:input.semanticMerge,
+    semanticEquivalenceClaim:false,
+    autoMergeClaim:false,
+    paths:roundtripAuditPaths(input,disposition),
+    sourcePreservation:input.sourcePreservation,
+    generatedStubs:summarizeGeneratedStubs(input,disposition),
+    adapterProjection:summarizeAdapterProjection(input,disposition),
+    sourceMaps:summarizeRouteSourceMaps(input),
+    hashChecks:input.hashChecks,
+    commentsTrivia:summarizeCommentsTrivia(input.sourcePreservation),
+    targetCoverage:summarizeTargetCoverage(input),
+    semanticEquivalence:summarizeSemanticEquivalence(),
+    blockingLossCount:input.lossSummary.blockingLossIds.length,
+    reviewLossCount:input.lossSummary.reviewLossIds.length,
+    reasonCodes:uniqueStrings([
+      `status:${input.status}`,
+      `semantic:${input.semanticMerge}`,
+      `output:${input.outputMode??'unknown'}`,
+      `projection:${input.projectionMode??'unknown'}`,
+      input.sourceHashVerified?'source-hash:verified':'source-hash:unverified',
+      `output-source-map:${input.sourceMapEvidence.precision}`,
+      `universal-source-map:${input.universalSourceMapEvidence.precision}`,
+      selectedTargetCoverageLossClass(input)?`target-loss:${selectedTargetCoverageLossClass(input)}`:undefined,
+      matrixTargetCoverageLossClass(input)?`target-matrix-loss:${matrixTargetCoverageLossClass(input)}`:undefined,
+      input.targetProjection?.adapter?.id?`target-adapter:${input.targetProjection.adapter.id}`:undefined,
+      input.lossSummary.blockingLossIds.length?'losses:blocking':undefined,
+      input.lossSummary.reviewLossIds.length?'losses:review':undefined
+    ])
+  };
+}
+function roundtripAuditDisposition(input){
+  if(input.outputMode==='target-adapter')return'adapter-projected';
+  if(input.projectionMode==='native-source-stubs'||input.outputMode==='target-stubs')return'stub-only';
+  if(input.sourceHashVerified&&input.outputMode==='preserved-source'&&input.hasOutputSourceMaps&&input.sourceMapEvidence.precision==='exact')return'reversible';
+  if(input.sourceHashVerified||input.projectionMode==='preserved-source')return'preserved-source';
+  return'review-required';
+}
+function roundtripAuditClaim(disposition){
+  if(disposition==='reversible')return'source-text-reversible';
+  if(disposition==='preserved-source')return'source-preserved';
+  if(disposition==='stub-only')return'declaration-stubs-only';
+  if(disposition==='adapter-projected')return'host-adapter-projected';
+  return'review-required';
+}
+function roundtripAuditPaths(input,disposition){
+  const reversibleAvailable=input.sourceHashVerified&&input.outputMode==='preserved-source'&&input.hasOutputSourceMaps&&input.sourceMapEvidence.precision==='exact';
+  const preservedAvailable=input.sourceHashVerified||input.projectionMode==='preserved-source';
+  const stubAvailable=input.projectionMode==='native-source-stubs'||input.outputMode==='target-stubs';
+  const adapterAvailable=input.outputMode==='target-adapter'||Boolean(input.targetProjection?.adapter?.id);
+  return{
+    reversible:routePathSignal(disposition==='reversible',reversibleAvailable,[
+      input.sourceHashVerified?'source-hash:verified':'source-hash:unverified',
+      input.hasOutputSourceMaps?'output-source-map:present':'output-source-map:missing',
+      `output-source-map:${input.sourceMapEvidence.precision}`
+    ]),
+    preservedSource:routePathSignal(disposition==='preserved-source',preservedAvailable,[
+      `projection:${input.projectionMode??'unknown'}`,
+      input.sourceHashVerified?'source-hash:verified':'source-hash:unverified'
+    ]),
+    stubOnly:routePathSignal(disposition==='stub-only',stubAvailable,[
+      `projection:${input.projectionMode??'unknown'}`,
+      `output:${input.outputMode??'unknown'}`
+    ]),
+    adapterProjected:routePathSignal(disposition==='adapter-projected',adapterAvailable,[
+      `output:${input.outputMode??'unknown'}`,
+      input.targetProjection?.adapter?.id?`target-adapter:${input.targetProjection.adapter.id}`:undefined
+    ])
+  };
+}
+function routePathSignal(selected,available,reasonCodes){
+  return{
+    selected,
+    available,
+    reasonCodes:uniqueStrings([
+      selected?'path:selected':undefined,
+      available?'path:available':'path:not-available',
+      ...reasonCodes
+    ])
+  };
+}
+function summarizeGeneratedStubs(input,disposition){
+  const declarations=input.targetProjection?[]:input.projection?.declarations??[];
+  const projectionDeclarations=input.projection?.declarations??[];
+  return{
+    available:input.projectionMode==='native-source-stubs'||input.outputMode==='target-stubs'||projectionDeclarations.length>0,
+    selected:disposition==='stub-only',
+    projectionMode:input.projectionMode,
+    outputMode:input.outputMode,
+    declarationCount:projectionDeclarations.length,
+    emittedDeclarationCount:declarations.length,
+    declarationKinds:countBy(projectionDeclarations.map((declaration)=>declaration?.kind??'unknown')),
+    declarationsWithSourceSpan:projectionDeclarations.filter((declaration)=>declaration?.sourceSpan).length,
+    symbolIds:uniqueStrings(projectionDeclarations.map((declaration)=>declaration?.symbolId)),
+    nativeAstNodeIds:uniqueStrings(projectionDeclarations.map((declaration)=>declaration?.nativeAstNodeId)),
+    lossCount:input.projection?.losses?.length??0
+  };
+}
+function summarizeAdapterProjection(input,disposition){
+  const targetProjection=input.targetProjection;
+  return{
+    available:Boolean(targetProjection),
+    selected:disposition==='adapter-projected',
+    id:targetProjection?.id,
+    adapterId:targetProjection?.adapter?.id,
+    adapterVersion:targetProjection?.adapter?.version,
+    outputMode:targetProjection?.outputMode,
+    readiness:targetProjection?.readiness?.readiness,
+    lossCount:targetProjection?.losses?.length??0,
+    evidenceIds:evidenceIds(targetProjection?.evidence),
+    sourceMaps:summarizeSourceMaps(targetProjection?.sourceMaps??[])
+  };
+}
+function summarizeRouteSourceMaps(input){
+  return{
+    hasOutputSourceMaps:input.hasOutputSourceMaps,
+    output:input.sourceMapEvidence,
+    universal:input.universalSourceMapEvidence,
+    outputExact:input.sourceMapEvidence.precision==='exact',
+    outputEstimated:input.sourceMapEvidence.precision==='estimated'||numeric(input.sourceMapEvidence.byPrecision?.estimated)>0,
+    universalEstimated:input.universalSourceMapEvidence.precision==='estimated'||numeric(input.universalSourceMapEvidence.byPrecision?.estimated)>0
+  };
+}
+function summarizeCommentsTrivia(sourcePreservation){
+  return{
+    comments:sourcePreservation.comments,
+    trivia:sourcePreservation.trivia,
+    directives:sourcePreservation.directives,
+    tokens:sourcePreservation.tokens,
+    whitespace:sourcePreservation.whitespace,
+    truncated:sourcePreservation.truncated,
+    exactSourceAvailable:sourcePreservation.exactSourceAvailable,
+    sourceTextAvailable:sourcePreservation.sourceTextAvailable
+  };
+}
+function summarizeTargetCoverage(input){
+  const coverage=input.targetCoverage;
+  const lossClass=selectedTargetCoverageLossClass(input);
+  return{
+    target:input.target??coverage?.target??input.targetProjection?.target,
+    supported:adapterProjectionSelected(input)?true:coverage?.supported,
+    readiness:coverage?.readiness??input.targetProjection?.readiness?.readiness,
+    lossClass,
+    adapterId:coverage?.adapter??input.targetProjection?.adapter?.id,
+    adapterKind:adapterProjectionSelected(input)?'targetProjection':coverage?.adapterKind,
+    adapterVersion:coverage?.adapterVersion??input.targetProjection?.adapter?.version,
+    lossKinds:uniqueStrings(coverage?.lossKinds),
+    categories:uniqueStrings(coverage?.categories),
+    reason:coverage?.reason,
+    notes:uniqueStrings(coverage?.notes)
+  };
+}
+function selectedTargetCoverageLossClass(input){
+  const projectedLossClass=input.targetProjection?.coverage?.lossClass
+    ??input.targetProjection?.metadata?.targetProjectionCoverage?.lossClass
+    ??input.targetProjection?.metadata?.lossClass;
+  if(projectedLossClass)return projectedLossClass;
+  if(adapterProjectionSelected(input))return'targetAdapterProjection';
+  return input.targetCoverage?.lossClass;
+}
+function matrixTargetCoverageLossClass(input){
+  const selected=selectedTargetCoverageLossClass(input);
+  const matrix=input.targetCoverage?.lossClass;
+  return matrix&&matrix!==selected?matrix:undefined;
+}
+function adapterProjectionSelected(input){
+  return input.outputMode==='target-adapter'||Boolean(input.targetProjection?.adapter?.id);
+}
+function summarizeSemanticEquivalence(){
+  return{
+    claimed:false,
+    evidenceIds:[],
+    reasonCode:'proof-adapter:not-provided'
+  };
+}
+function evidenceIds(evidence){return uniqueStrings((evidence??[]).map((record)=>record?.id));}
+function summarizeSourceMaps(sourceMaps){
+  const maps=sourceMaps??[];
+  const mappings=maps.flatMap((sourceMap)=>sourceMap?.mappings??[]);
+  const precisions=mappings.map((mapping)=>normalizePrecision(mapping?.precision));
+  return{
+    total:maps.length,
+    ids:uniqueStrings(maps.map((sourceMap)=>sourceMap?.id)),
+    mappings:mappings.length,
+    precision:worstPrecision(precisions),
+    byPrecision:countBy(precisions),
+    byOrigin:countBy(mappings.map((mapping)=>mapping?.metadata?.sourceMapOrigin??'native-import')),
+    withSourceSpan:mappings.filter((mapping)=>mapping?.sourceSpan).length,
+    withGeneratedSpan:mappings.filter((mapping)=>mapping?.generatedSpan).length,
+    withSemanticSymbol:mappings.filter((mapping)=>mapping?.semanticSymbolId||mapping?.semanticNodeId).length,
+    targetPaths:uniqueStrings(maps.map((sourceMap)=>sourceMap?.targetPath).concat(mappings.map((mapping)=>mapping?.generatedSpan?.targetPath)))
+  };
+}
+function normalizePrecision(value){const precision=String(value??'unknown');return Object.prototype.hasOwnProperty.call(precisionRank,precision)?precision:'unknown';}
+function worstPrecision(precisions){if(!precisions.length)return'none';return precisions.reduce((worst,next)=>precisionRank[next]>precisionRank[worst]?next:worst,'exact');}
+function numeric(value,fallback=0){const number=Number(value);return Number.isFinite(number)?number:fallback;}

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

@@ -0,0 +1,160 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{nativeImportCategoryForLossKind}from'./nativeImportCategoryForLossKind.js';
+
+export function importLosses(imported){
+  const nativeAst=imported?.nativeAst??imported?.nativeSource?.ast;
+  const losses=[
+    ...(imported?.losses??[]),
+    ...(nativeAst?.losses??[]),
+    ...(imported?.universalAst?.losses??[])
+  ];
+  const seen=new Set();
+  const result=[];
+  for(const loss of losses){
+    const id=loss?.id??`loss_${result.length+1}`;
+    if(seen.has(id)) continue;
+    seen.add(id);
+    result.push(loss?.id?loss:{...loss,id});
+  }
+  return result;
+}
+
+export function sourceLossClasses(imported,losses){
+  const lossSummary=imported?.metadata?.nativeImportLossSummary
+    ??imported?.nativeSource?.metadata?.nativeImportLossSummary
+    ??imported?.nativeAst?.metadata?.nativeImportLossSummary
+    ??imported?.universalAst?.metadata?.nativeImportLossSummary;
+  return uniqueStrings([
+    ...(lossSummary?.categories??[]),
+    ...(losses??[]).map(lossClassForLoss),
+    ...sourceProjectionLossClasses(imported)
+  ].filter(Boolean));
+}
+
+function lossClassForLoss(loss){
+  return loss?.metadata?.targetLossClass
+    ??loss?.metadata?.lossClass
+    ??loss?.metadata?.lossCategory
+    ??nativeImportCategoryForLossKind(loss?.kind);
+}
+
+function sourceProjectionLossClasses(imported){
+  const matrixClasses=projectionMatricesForImport(imported).flatMap((matrix)=>[
+    ...Object.entries(matrix?.summary?.byLossClass??{}).filter(([,count])=>count>0).map(([lossClass])=>lossClass),
+    ...(matrix?.languages??[]).flatMap((language)=>[
+      ...Object.entries(language?.summary?.byLossClass??{}).filter(([,count])=>count>0).map(([lossClass])=>lossClass),
+      ...(language?.targets??[]).map((target)=>target?.lossClass)
+    ])
+  ]);
+  return uniqueStrings([
+    ...targetProjectionEntriesForImport(imported).map((entry)=>entry.lossClass),
+    ...matrixClasses
+  ].filter(Boolean));
+}
+
+function targetProjectionEntriesForImport(imported){
+  return [
+    imported?.targetCoverage,
+    imported?.metadata?.targetCoverage,
+    imported?.metadata?.targetProjectionCoverage,
+    ...(imported?.targetCoverages??[]),
+    ...(imported?.metadata?.targetCoverages??[])
+  ].flatMap((entry)=>Array.isArray(entry)?entry:[entry])
+    .filter((entry)=>entry&&typeof entry==='object'&&(entry.target||entry.lossClass||entry.supported!==undefined));
+}
+
+function projectionMatricesForImport(imported){
+  return [
+    imported?.projectionMatrix,
+    imported?.metadata?.projectionMatrix,
+    ...(imported?.projectionMatrices??[]),
+    ...(imported?.metadata?.projectionMatrices??[])
+  ].filter((matrix)=>matrix?.kind==='frontier.lang.projectionTargetLossMatrix'||Array.isArray(matrix?.languages));
+}
+
+export function summarizeParserEvidence(imported,source,losses){
+  const nativeAst=imported?.nativeAst??imported?.nativeSource?.ast;
+  const rootNode=nativeAst?.nodes?.[nativeAst?.rootId];
+  const coverage=imported?.adapter?.coverage
+    ??imported?.metadata?.adapterCoverage
+    ??imported?.nativeSource?.adapter?.coverage
+    ??nativeAst?.metadata?.adapterCoverage;
+  const observed=coverage?.observed;
+  const effective=coverage?.capabilityEvidence?.effective;
+  const diagnostics=[
+    ...(imported?.diagnostics??[]),
+    ...(imported?.nativeSource?.diagnostics??[])
+  ];
+  const parserDiagnosticLosses=(losses??[]).filter((loss)=>
+    loss?.kind==='parserDiagnostic'
+    || loss?.phase==='parse'&&loss?.severity==='error'
+    || loss?.metadata?.parserDiagnostic===true
+  );
+  const parser=source?.parser
+    ??imported?.adapter?.parser
+    ??coverage?.parser
+    ??nativeAst?.parser
+    ??imported?.metadata?.parser
+    ??imported?.nativeSource?.parser;
+  return {
+    parser,
+    astFormat:imported?.metadata?.astFormat??nativeAst?.metadata?.astFormat,
+    exactness:coverage?.exactness??effective?.exactness??observed?.exactness,
+    semanticCoverageLevel:coverage?.semanticCoverage?.level??effective?.semanticCoverage?.level??observed?.semanticCoverage?.level,
+    exactAst:Boolean(coverage?.exactAst??effective?.exactAst??observed?.exactAst),
+    tokens:Boolean(coverage?.tokens??effective?.tokens??observed?.tokens),
+    trivia:Boolean(coverage?.trivia??effective?.trivia??observed?.trivia),
+    diagnostics:Boolean(coverage?.diagnostics??effective?.diagnostics)||(diagnostics.length+parserDiagnosticLosses.length)>0,
+    diagnosticCount:diagnostics.length+parserDiagnosticLosses.length+(observed?.parserDiagnostics??0),
+    sourceRanges:Boolean(coverage?.sourceRanges??effective?.sourceRanges??observed?.sourceRanges),
+    generatedRanges:Boolean(coverage?.generatedRanges??effective?.generatedRanges??observed?.generatedRanges),
+    evidenceRecords:source?.evidenceCount??imported?.evidence?.length??0,
+    missing:Boolean(
+      imported?.metadata?.missingInjectedParser
+      || nativeAst?.metadata?.missingInjectedParser
+      || rootNode?.kind==='MissingInjectedParser'
+      || rootNode?.metadata?.reason==='missing-injected-parser'
+      || parserDiagnosticLosses.some((loss)=>loss?.metadata?.reason==='missing-injected-parser'||loss?.metadata?.missingInjectedParser)
+    )
+  };
+}
+
+export function compactAdmissionSource(imported,index){
+  const semanticIndex=imported?.semanticIndex??imported?.universalAst?.semanticIndex;
+  const nativeAst=imported?.nativeAst??imported?.nativeSource?.ast;
+  const sourceMaps=imported?.sourceMaps??imported?.universalAst?.sourceMaps??[];
+  return {
+    id:imported?.id??`import_${index+1}`,
+    language:imported?.language??imported?.nativeSource?.language??nativeAst?.language,
+    sourcePath:imported?.sourcePath??imported?.nativeSource?.sourcePath??nativeAst?.sourcePath,
+    sourceHash:imported?.nativeSource?.sourceHash??nativeAst?.sourceHash,
+    parser:nativeAst?.parser??imported?.nativeSource?.parser,
+    sourceMapIds:sourceMaps.map((sourceMap)=>sourceMap.id).filter(Boolean),
+    sourceMapMappings:sourceMaps.reduce((sum,sourceMap)=>sum+(sourceMap.mappings?.length??0),0),
+    symbolCount:semanticIndex?.symbols?.length??0,
+    lossCount:imported?.losses?.length??nativeAst?.losses?.length??0,
+    evidenceCount:imported?.evidence?.length??0,
+    readiness:imported?.metadata?.semanticMergeReadiness??imported?.mergeCandidates?.[0]?.readiness
+  };
+}
+
+export function summarizeImportPreservation(imported,source){
+  const nativeAst=imported?.nativeAst??imported?.nativeSource?.ast;
+  const record=imported?.metadata?.sourcePreservation
+    ??imported?.nativeSource?.metadata?.sourcePreservation
+    ??nativeAst?.metadata?.sourcePreservation
+    ??imported?.universalAst?.metadata?.sourcePreservation;
+  const sourceHash=source?.sourceHash??imported?.nativeSource?.sourceHash??nativeAst?.sourceHash;
+  const sourcePreservationLosses=(imported?.losses??nativeAst?.losses??[]).filter((loss)=>loss.kind==='sourcePreservation');
+  const stale=imported?.metadata?.sourceHashVerified===false
+    ||imported?.nativeSource?.metadata?.sourceHashVerified===false
+    ||nativeAst?.metadata?.sourceHashVerified===false
+    ||record?.metadata?.sourceHashVerified===false
+    ||Boolean(record?.sourceHash&&sourceHash&&record.sourceHash!==sourceHash);
+  const missing=!record;
+  const truncated=record?.summary?.truncated===true;
+  const exactSourceAvailable=record?.summary?.exactSourceAvailable===true;
+  const quality=stale?'stale':missing?'missing':truncated||!exactSourceAvailable||sourcePreservationLosses.length?'lossy':'exact';
+  return {quality,missing,stale,truncated,exactSourceAvailable,lossCount:sourcePreservationLosses.length,id:record?.id};
+}
+

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

@@ -0,0 +1,247 @@
+import{countBy,maxSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{candidateRisk,maxPreservationQuality,maxRisk,maxTaskPriority,readinessSort,roundScore,taskPriorityRank}from'./projectImportAdmissionRanks.js';
+
+export function admissionLanguages(importSummaries){
+  const grouped=new Map();
+  for(const entry of importSummaries){
+    const key=entry.language??'unknown';
+    if(!grouped.has(key)) grouped.set(key,emptyLanguageRow(key));
+    const row=grouped.get(key);
+    row.sourceCount+=1;
+    row.sourcePaths.push(entry.sourcePath);
+    row.sources.push(entry);
+    row.readiness=maxSemanticMergeReadiness(row.readiness,entry.readiness);
+    row.semanticSymbols+=entry.semanticCounts.symbols;
+    if(entry.emptySemanticEvidence) row.emptySemanticEvidenceSources+=1;
+    row.sourcePreservationQuality=maxPreservationQuality(row.sourcePreservationQuality,entry.sourcePreservation.quality);
+    if(entry.sourcePreservation.stale&&entry.sourcePath) row.staleSourcePaths.push(entry.sourcePath);
+    row.mergeCandidates+=entry.mergeCandidates.length;
+    row.highestRisk=maxRisk(row.highestRisk,entry.mergeCandidates.reduce((current,candidate)=>maxRisk(current,candidateRisk(candidate)),'low'));
+  }
+  const rows=[...grouped.values()].map((row)=>{
+    const sources=row.sources;
+    return {
+      language:row.language,
+      sourceCount:row.sourceCount,
+      sourcePaths:uniqueStrings(row.sourcePaths.filter(Boolean)),
+      readiness:row.readiness,
+      semanticSymbols:row.semanticSymbols,
+      emptySemanticEvidenceSources:row.emptySemanticEvidenceSources,
+      sourcePreservationQuality:row.sourcePreservationQuality,
+      staleSourcePaths:uniqueStrings(row.staleSourcePaths.filter(Boolean)),
+      mergeCandidates:row.mergeCandidates,
+      highestRisk:row.highestRisk,
+      byReadiness:countBy(sources.map((source)=>source.readiness)),
+      byLossClass:lossClassCounts(sources),
+      parserEvidence:parserEvidenceSummary(sources),
+      semanticMergeScore:semanticMergeScoreSummary(sources),
+      topMissingEvidence:topMissingEvidence(sources),
+      nextMissingTasks:topTaskHints(sources)
+    };
+  }).sort((left,right)=>left.language.localeCompare(right.language));
+  return {
+    total:rows.length,
+    byReadiness:countBy(rows.map((row)=>row.readiness)),
+    bySourceReadiness:countBy(importSummaries.map((entry)=>entry.readiness)),
+    byLossClass:lossClassCounts(importSummaries),
+    bySourcePreservationQuality:countBy(rows.map((row)=>row.sourcePreservationQuality)),
+    parserEvidence:parserEvidenceSummary(importSummaries),
+    semanticMergeScore:semanticMergeScoreSummary(importSummaries),
+    topMissingEvidence:topMissingEvidence(importSummaries),
+    nextMissingTasks:topTaskHints(importSummaries),
+    sourceRows:importSummaries.map(compactAdmissionSourceRow),
+    readinessRows:languageReadinessRows(importSummaries),
+    rows
+  };
+}
+
+function compactAdmissionSourceRow(entry){
+  return {
+    id:entry.id,
+    language:entry.language,
+    sourcePath:entry.sourcePath,
+    sourceHash:entry.sourceHash,
+    readiness:entry.readiness,
+    parser:entry.parserEvidence.parser,
+    parserEvidence:entry.parserEvidence,
+    semanticCounts:entry.semanticCounts,
+    semanticSymbols:entry.semanticCounts.symbols,
+    emptySemanticEvidence:entry.emptySemanticEvidence,
+    sourcePreservationQuality:entry.sourcePreservation.quality,
+    lossClasses:entry.lossClasses,
+    semanticMergeScore:entry.semanticMergeScore,
+    missingEvidence:entry.missingEvidence,
+    nextMissingTask:entry.nextMissingTasks[0],
+    nextMissingTasks:entry.nextMissingTasks
+  };
+}
+
+function languageReadinessRows(importSummaries){
+  const grouped=new Map();
+  for(const entry of importSummaries){
+    const key=`${entry.language??'unknown'}\u0000${entry.readiness??'needs-review'}`;
+    if(!grouped.has(key)) grouped.set(key,{language:entry.language??'unknown',readiness:entry.readiness??'needs-review',sources:[]});
+    grouped.get(key).sources.push(entry);
+  }
+  return [...grouped.values()].map((group)=>sourceGroupSummary(group.language,group.readiness,group.sources))
+    .sort((left,right)=>left.language.localeCompare(right.language)||readinessSort(left.readiness)-readinessSort(right.readiness));
+}
+
+function sourceGroupSummary(language,readiness,sources){
+  return {
+    language,
+    readiness,
+    sourceCount:sources.length,
+    sourcePaths:uniqueStrings(sources.map((source)=>source.sourcePath).filter(Boolean)),
+    byLossClass:lossClassCounts(sources),
+    parserEvidence:parserEvidenceSummary(sources),
+    semanticMergeScore:semanticMergeScoreSummary(sources),
+    topMissingEvidence:topMissingEvidence(sources),
+    nextMissingTasks:topTaskHints(sources)
+  };
+}
+
+function lossClassCounts(sources){
+  return countBy((sources??[]).flatMap((source)=>source.lossClasses?.length?source.lossClasses:['none']));
+}
+
+function parserEvidenceSummary(sources){
+  const records=(sources??[]).map((source)=>source.parserEvidence??{});
+  return {
+    parsers:uniqueStrings(records.map((record)=>record.parser).filter(Boolean)),
+    byParser:countBy(records.map((record)=>record.parser??'unknown')),
+    byExactness:countBy(records.map((record)=>record.exactness??'unknown')),
+    semanticCoverageLevels:uniqueStrings(records.map((record)=>record.semanticCoverageLevel).filter(Boolean)),
+    exactAstSources:records.filter((record)=>record.exactAst).length,
+    tokenSources:records.filter((record)=>record.tokens).length,
+    triviaSources:records.filter((record)=>record.trivia).length,
+    sourceRangeSources:records.filter((record)=>record.sourceRanges).length,
+    generatedRangeSources:records.filter((record)=>record.generatedRanges).length,
+    diagnosticsSources:records.filter((record)=>(record.diagnosticCount??0)>0).length,
+    missingParserSources:records.filter((record)=>record.missing).length,
+    evidenceRecords:records.reduce((sum,record)=>sum+(record.evidenceRecords??0),0)
+  };
+}
+
+function semanticMergeScoreSummary(sources){
+  const scored=(sources??[])
+    .filter((source)=>Number.isFinite(source.semanticMergeScore))
+    .sort((left,right)=>left.semanticMergeScore-right.semanticMergeScore||String(left.sourcePath??'').localeCompare(String(right.sourcePath??'')));
+  const values=scored.map((source)=>source.semanticMergeScore);
+  if(!values.length){
+    return {sourceCount:0,min:0,max:0,average:0,sortKey:0,lowestSourcePaths:[]};
+  }
+  const min=Math.min(...values);
+  const max=Math.max(...values);
+  const average=roundScore(values.reduce((sum,value)=>sum+value,0)/values.length);
+  return {
+    sourceCount:values.length,
+    min,
+    max,
+    average,
+    sortKey:roundScore(average*100-(100-min)),
+    lowestSourcePaths:uniqueStrings(scored.slice(0,5).map((source)=>source.sourcePath).filter(Boolean))
+  };
+}
+
+function topMissingEvidence(sources,limit=5){
+  const grouped=new Map();
+  for(const source of sources??[]){
+    for(const hint of source.missingEvidence??[]){
+      const key=hint.evidenceKey??hint.task;
+      if(!grouped.has(key)){
+        grouped.set(key,{
+          evidenceKey:hint.evidenceKey,
+          task:hint.task,
+          count:0,
+          sourcePaths:[],
+          languages:[],
+          lossIds:[],
+          lossKinds:[],
+          lossClasses:[],
+          readiness:'ready'
+        });
+      }
+      const entry=grouped.get(key);
+      entry.count+=hint.count??1;
+      entry.sourcePaths.push(...(hint.sourcePaths??[]));
+      entry.languages.push(...(hint.languages??[]));
+      entry.lossIds.push(...(hint.lossIds??[]));
+      entry.lossKinds.push(...(hint.lossKinds??[]));
+      entry.lossClasses.push(...(hint.lossClasses??[]));
+      entry.readiness=maxSemanticMergeReadiness(entry.readiness,hint.readiness??source.readiness??'ready');
+    }
+  }
+  return [...grouped.values()].map((entry)=>({
+    ...entry,
+    sourcePaths:uniqueStrings(entry.sourcePaths),
+    languages:uniqueStrings(entry.languages),
+    lossIds:uniqueStrings(entry.lossIds),
+    lossKinds:uniqueStrings(entry.lossKinds),
+    lossClasses:uniqueStrings(entry.lossClasses)
+  })).sort((left,right)=>
+    readinessSort(right.readiness)-readinessSort(left.readiness)
+    || right.count-left.count
+    || String(left.evidenceKey??left.task).localeCompare(String(right.evidenceKey??right.task))
+  ).slice(0,limit);
+}
+
+function topTaskHints(sources,limit=6){
+  const grouped=new Map();
+  for(const source of sources??[]){
+    for(const hint of source.nextMissingTasks??[]){
+      const key=hint.id??hint.task;
+      if(!grouped.has(key)){
+        grouped.set(key,{
+          id:hint.id,
+          task:hint.task,
+          reason:hint.reason,
+          priority:hint.priority??'normal',
+          readiness:'ready',
+          count:0,
+          sourcePaths:[],
+          languages:[],
+          lossClasses:[],
+          evidenceKeys:[]
+        });
+      }
+      const entry=grouped.get(key);
+      entry.count+=hint.count??1;
+      entry.priority=maxTaskPriority(entry.priority,hint.priority??'normal');
+      entry.readiness=maxSemanticMergeReadiness(entry.readiness,hint.readiness??source.readiness??'ready');
+      entry.sourcePaths.push(...(hint.sourcePaths??[]));
+      entry.languages.push(...(hint.languages??[]));
+      entry.lossClasses.push(...(hint.lossClasses??[]));
+      entry.evidenceKeys.push(...(hint.evidenceKeys??[]));
+    }
+  }
+  return [...grouped.values()].map((entry)=>({
+    ...entry,
+    sourcePaths:uniqueStrings(entry.sourcePaths),
+    languages:uniqueStrings(entry.languages),
+    lossClasses:uniqueStrings(entry.lossClasses),
+    evidenceKeys:uniqueStrings(entry.evidenceKeys)
+  })).sort((left,right)=>
+    taskPriorityRank[right.priority]-taskPriorityRank[left.priority]
+    || readinessSort(right.readiness)-readinessSort(left.readiness)
+    || right.count-left.count
+    || String(left.task).localeCompare(String(right.task))
+  ).slice(0,limit);
+}
+
+function emptyLanguageRow(language){
+  return {
+    language,
+    sourceCount:0,
+    sourcePaths:[],
+    sources:[],
+    readiness:'ready',
+    semanticSymbols:0,
+    emptySemanticEvidenceSources:0,
+    sourcePreservationQuality:'exact',
+    staleSourcePaths:[],
+    mergeCandidates:0,
+    highestRisk:'low'
+  };
+}
+

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

@@ -0,0 +1,52 @@
+export const readinessRank=Object.freeze({ready:0,'ready-with-losses':1,'needs-review':2,blocked:3});
+export const sourceScoreByReadiness=Object.freeze({ready:100,'ready-with-losses':75,'needs-review':45,blocked:0});
+export const riskRank=Object.freeze({low:0,medium:1,unknown:2,high:3});
+export const taskPriorityRank=Object.freeze({low:0,normal:1,high:2,critical:3,blocker:4});
+export const preservationRank=Object.freeze({exact:0,lossy:1,missing:2,stale:3,empty:4});
+
+
+export function taskPriorityForReadiness(readiness){
+  if(readiness==='blocked') return 'blocker';
+  if(readiness==='needs-review') return 'high';
+  if(readiness==='ready-with-losses') return 'normal';
+  return 'low';
+}
+
+export function maxTaskPriority(left,right){
+  return taskPriorityRank[left]>=taskPriorityRank[right]?left:right;
+}
+
+export function readinessSort(readiness){
+  return readinessRank[readiness]??readinessRank['needs-review'];
+}
+
+export function clampScore(value){
+  return Math.max(0,Math.min(100,roundScore(value)));
+}
+
+export function roundScore(value){
+  return Math.round(value*100)/100;
+}
+
+export function candidateRisk(candidate,patch){
+  return normalizeRisk(candidate?.risk)??normalizeRisk(patch?.risk)??readinessRisk(candidate?.readiness);
+}
+
+export function maxRisk(left,right){
+  return riskRank[left]>=riskRank[right]?left:right;
+}
+
+export function maxPreservationQuality(left,right){
+  return preservationRank[left]>=preservationRank[right]?left:right;
+}
+
+export function readinessRisk(readiness){
+  if(readiness==='blocked') return 'high';
+  if(readiness==='needs-review'||readiness==='ready-with-losses') return 'medium';
+  return 'low';
+}
+
+export function normalizeRisk(value){
+  const risk=String(value??'').toLowerCase();
+  return Object.prototype.hasOwnProperty.call(riskRank,risk)?risk:undefined;
+}