@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.43

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

@@ -0,0 +1,23 @@
+import{csharpRoslynDeclarationName}from'./csharpRoslynDeclarationName.js';import{csharpRoslynModifierNames}from'./csharpRoslynModifierNames.js';import{csharpRoslynName}from'./csharpRoslynName.js';import{csharpRoslynTypeName}from'./csharpRoslynTypeName.js';import{csharpRoslynUsingPath}from'./csharpRoslynUsingPath.js';
+export function primitiveCSharpRoslynFields(node, kind) {
+  const fields = { kind };
+  const name = csharpRoslynDeclarationName(node);
+  if (name) fields.name = name;
+  const importPath = csharpRoslynUsingPath(node);
+  if (importPath) fields.importPath = importPath;
+  const type = csharpRoslynTypeName(node.type ?? node.Type ?? node.returnType ?? node.ReturnType);
+  if (type) fields.type = type;
+  const modifiers = csharpRoslynModifierNames(node);
+  if (modifiers.length) fields.modifiers = modifiers.join(',');
+  const alias = csharpRoslynName(node.alias ?? node.Alias);
+  if (alias) fields.alias = alias;
+  if (node.static === true || node.isStatic === true) fields.static = true;
+  if (node.global === true || node.isGlobal === true) fields.global = true;
+  if (node.generated === true || node.Generated === true) fields.generated = true;
+  if (node.containsDiagnostics === true || node.ContainsDiagnostics === true) fields.containsDiagnostics = true;
+  if (node.containsSkippedText === true || node.ContainsSkippedText === true) fields.containsSkippedText = true;
+  if (node.isMissing === true || node.IsMissing === true) fields.isMissing = true;
+  if (Array.isArray(node.parameterList?.parameters ?? node.parameters)) fields.parameterCount = (node.parameterList?.parameters ?? node.parameters).length;
+  if (Array.isArray(node.attributeLists)) fields.attributeListCount = node.attributeLists.length;
+  return fields;
+}

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

@@ -0,0 +1,31 @@
+import{clangDeclarationName}from'./clangDeclarationName.js';import{clangIncludePath}from'./clangIncludePath.js';import{clangLiteralValue}from'./clangLiteralValue.js';import{clangTypeName}from'./clangTypeName.js';
+export function primitiveClangAstFields(node, kind) {
+  const fields = { kind };
+  const name = clangDeclarationName(node);
+  if (name) fields.name = name;
+  const type = clangTypeName(node.type ?? node.qualType);
+  if (type) fields.type = type;
+  for (const key of [
+    'mangledName',
+    'storageClass',
+    'tagUsed',
+    'completeDefinition',
+    'isThisDeclarationADefinition',
+    'inline',
+    'isUsed',
+    'isReferenced',
+    'valueCategory',
+    'opcode',
+    'castKind'
+  ]) {
+    const value = node[key];
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) fields[key] = value;
+  }
+  const includePath = clangIncludePath(node);
+  if (includePath) fields.includePath = includePath;
+  const literal = clangLiteralValue(node);
+  if (literal !== undefined) fields.literal = literal;
+  const referenced = clangDeclarationName(node.referencedDecl);
+  if (referenced) fields.referenced = referenced;
+  return fields;
+}

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

@@ -0,0 +1,22 @@
+import{goAstDeclarationName}from'./goAstDeclarationName.js';import{goAstIdentName}from'./goAstIdentName.js';import{goAstImportPath}from'./goAstImportPath.js';import{goAstReceiverName}from'./goAstReceiverName.js';import{goAstTokenName}from'./goAstTokenName.js';import{goAstTypeName}from'./goAstTypeName.js';
+export function primitiveGoAstFields(node, kind) {
+  const fields = { kind };
+  const name = goAstDeclarationName(node);
+  if (name) fields.name = name;
+  const type = goAstTypeName(node.Type ?? node.type);
+  if (type) fields.type = type;
+  const tok = goAstTokenName(node.Tok ?? node.tok);
+  if (tok) fields.token = tok;
+  const importPath = goAstImportPath(node);
+  if (importPath) fields.importPath = importPath;
+  const receiver = goAstReceiverName(node);
+  if (receiver) fields.receiver = receiver;
+  for (const key of ['Incomplete', 'Doc', 'Comment']) {
+    const value = node[key] ?? node[key[0].toLowerCase() + key.slice(1)];
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) fields[key[0].toLowerCase() + key.slice(1)] = value;
+  }
+  if (Array.isArray(node.Names ?? node.names)) {
+    fields.names = (node.Names ?? node.names).map(goAstIdentName).filter(Boolean).join(',');
+  }
+  return fields;
+}

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

@@ -0,0 +1,22 @@
+import{javaAstDeclarationName}from'./javaAstDeclarationName.js';import{javaAstImportPath}from'./javaAstImportPath.js';import{javaAstModifierNames}from'./javaAstModifierNames.js';import{javaAstPackageName}from'./javaAstPackageName.js';import{javaAstTypeName}from'./javaAstTypeName.js';
+export function primitiveJavaAstFields(node, kind) {
+  const fields = { kind };
+  const name = javaAstDeclarationName(node);
+  if (name) fields.name = name;
+  const importPath = javaAstImportPath(node);
+  if (importPath) fields.importPath = importPath;
+  const type = javaAstTypeName(node.type ?? node.typeName ?? node.returnType ?? node.elementType);
+  if (type) fields.type = type;
+  const packageName = javaAstPackageName(node);
+  if (packageName) fields.packageName = packageName;
+  const modifiers = javaAstModifierNames(node);
+  if (modifiers.length) fields.modifiers = modifiers.join(',');
+  if (node.static === true || node.isStatic === true) fields.static = true;
+  if (node.default === true || node.isDefault === true) fields.default = true;
+  if (node.generated === true || node.Generated === true) fields.generated = true;
+  if (typeof node.binaryName === 'string') fields.binaryName = node.binaryName;
+  if (typeof node.qualifiedName === 'string') fields.qualifiedName = node.qualifiedName;
+  if (Array.isArray(node.parameters)) fields.parameterCount = node.parameters.length;
+  if (Array.isArray(node.throws ?? node.thrownExceptions)) fields.throwsCount = (node.throws ?? node.thrownExceptions).length;
+  return fields;
+}

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

@@ -0,0 +1,24 @@
+import{kotlinPsiAnnotationNames}from'./kotlinPsiAnnotationNames.js';import{kotlinPsiDeclarationName}from'./kotlinPsiDeclarationName.js';import{kotlinPsiImportPath}from'./kotlinPsiImportPath.js';import{kotlinPsiModifiers}from'./kotlinPsiModifiers.js';import{kotlinPsiPackageName}from'./kotlinPsiPackageName.js';import{kotlinPsiTypeName}from'./kotlinPsiTypeName.js';
+export function primitiveKotlinPsiFields(node, kind) {
+  const fields = { kind };
+  const name = kotlinPsiDeclarationName(node, kind);
+  if (name) fields.name = name;
+  const importPath = kotlinPsiImportPath(node);
+  if (importPath) fields.importPath = importPath;
+  const packageName = kotlinPsiPackageName(node);
+  if (packageName) fields.packageName = packageName;
+  const type = kotlinPsiTypeName(node.typeReference ?? node.returnTypeRef ?? node.returnType ?? node.type);
+  if (type) fields.type = type;
+  const receiver = kotlinPsiTypeName(node.receiverTypeReference ?? node.receiverTypeRef);
+  if (receiver) fields.receiverType = receiver;
+  const modifiers = kotlinPsiModifiers(node);
+  if (modifiers.length) fields.modifiers = modifiers.join(',');
+  const annotations = kotlinPsiAnnotationNames(node);
+  if (annotations.length) fields.annotations = annotations.join(',');
+  if (node.generated === true || node.isGenerated === true) fields.generated = true;
+  if (node.isScript === true || kind === 'KtScript') fields.script = true;
+  if (Array.isArray(node.typeParameters ?? node.typeParameterList?.parameters)) fields.typeParameterCount = (node.typeParameters ?? node.typeParameterList?.parameters).length;
+  if (Array.isArray(node.valueParameters ?? node.valueParameterList?.parameters ?? node.parameters)) fields.parameterCount = (node.valueParameters ?? node.valueParameterList?.parameters ?? node.parameters).length;
+  if (Array.isArray(node.superTypeListEntries ?? node.superTypes)) fields.superTypeCount = (node.superTypeListEntries ?? node.superTypes).length;
+  return fields;
+}

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

@@ -0,0 +1,18 @@
+import{pythonAliasName}from'./pythonAliasName.js';import{pythonAstLiteralValue}from'./pythonAstLiteralValue.js';
+export function primitivePythonAstFields(node, kind) {
+  const fields = { kind };
+  for (const key of ['name', 'id', 'arg', 'module', 'level', 'attr', 'asname', 'type_comment']) {
+    if (typeof node[key] === 'string' || typeof node[key] === 'number' || typeof node[key] === 'boolean' || node[key] === null) {
+      fields[key] = node[key];
+    }
+  }
+  if (Array.isArray(node.names)) {
+    fields.names = node.names
+      .map((entry) => pythonAliasName(entry))
+      .filter(Boolean)
+      .join(',');
+  }
+  const literal = pythonAstLiteralValue(node);
+  if (literal !== undefined) fields.literal = literal;
+  return fields;
+}

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

@@ -0,0 +1,16 @@
+import{rustSynIdentName}from'./rustSynIdentName.js';import{rustSynPathName}from'./rustSynPathName.js';import{rustSynVisibility}from'./rustSynVisibility.js';
+export function primitiveRustSynFields(node, kind) {
+  const fields = { kind };
+  const ident = rustSynIdentName(node.ident ?? node.name ?? node.sig?.ident);
+  if (ident) fields.ident = ident;
+  const path = rustSynPathName(node.path ?? node.trait_ ?? node.self_ty ?? node.selfType ?? node.ty);
+  if (path) fields.path = path;
+  const visibility = rustSynVisibility(node.vis ?? node.visibility);
+  if (visibility) fields.visibility = visibility;
+  for (const key of ['mutability', 'defaultness', 'constness', 'asyncness', 'unsafety', 'abi']) {
+    const value = node[key];
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) fields[key] = value;
+  }
+  if (Array.isArray(node.attrs) && node.attrs.length) fields.attributeCount = node.attrs.length;
+  return fields;
+}

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

@@ -0,0 +1,21 @@
+import{swiftSyntaxAttributeNames}from'./swiftSyntaxAttributeNames.js';import{swiftSyntaxDeclarationName}from'./swiftSyntaxDeclarationName.js';import{swiftSyntaxImportPath}from'./swiftSyntaxImportPath.js';import{swiftSyntaxModifierNames}from'./swiftSyntaxModifierNames.js';import{swiftSyntaxTypeName}from'./swiftSyntaxTypeName.js';
+export function primitiveSwiftSyntaxFields(node, kind) {
+  const fields = { kind };
+  const name = swiftSyntaxDeclarationName(node, kind);
+  if (name) fields.name = name;
+  const importPath = swiftSyntaxImportPath(node);
+  if (importPath) fields.importPath = importPath;
+  const type = swiftSyntaxTypeName(node.type ?? node.typeAnnotation?.type ?? node.returnClause?.type ?? node.extendedType);
+  if (type) fields.type = type;
+  const modifiers = swiftSyntaxModifierNames(node);
+  if (modifiers.length) fields.modifiers = modifiers.join(',');
+  const attributes = swiftSyntaxAttributeNames(node);
+  if (attributes.length) fields.attributes = attributes.join(',');
+  if (node.generated === true || node.isGenerated === true) fields.generated = true;
+  if (node.isMissing === true || node.presence === 'missing') fields.isMissing = true;
+  if (node.hasError === true || node.containsDiagnostics === true) fields.hasError = true;
+  if (Array.isArray(node.genericParameterClause?.parameters ?? node.genericParameters)) fields.genericParameterCount = (node.genericParameterClause?.parameters ?? node.genericParameters).length;
+  if (Array.isArray(node.inheritanceClause?.inheritedTypes ?? node.inheritedTypes)) fields.inheritedTypeCount = (node.inheritanceClause?.inheritedTypes ?? node.inheritedTypes).length;
+  if (Array.isArray(node.signature?.parameterClause?.parameters ?? node.parameters)) fields.parameterCount = (node.signature?.parameterClause?.parameters ?? node.parameters).length;
+  return fields;
+}

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

@@ -0,0 +1,13 @@
+import{literalSyntaxValue}from'./literalSyntaxValue.js';
+export function primitiveSyntaxFields(node) {
+  const fields = {};
+  for (const key of ['name', 'operator', 'sourceType', 'async', 'generator', 'computed', 'static', 'exportKind', 'importKind', 'optional']) {
+    if (typeof node[key] === 'string' || typeof node[key] === 'number' || typeof node[key] === 'boolean' || node[key] === null) {
+      fields[key] = node[key];
+    }
+  }
+  const literal = literalSyntaxValue(node);
+  if (literal !== undefined) fields.literal = literal;
+  if (node.source && typeof node.source === 'object' && typeof node.source.value === 'string') fields.source = node.source.value;
+  return fields;
+}

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

@@ -0,0 +1,9 @@
+import{identifierName}from'./identifierName.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
+export function primitiveTypeScriptFields(node, kind) {
+  const fields = { kind };
+  const name = identifierName(node.name);
+  if (name) fields.name = name;
+  const moduleSpecifier = stringFromTsExpression(node.moduleSpecifier);
+  if (moduleSpecifier) fields.moduleSpecifier = moduleSpecifier;
+  return fields;
+}

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

@@ -0,0 +1,6 @@
+import{normalizeCompileTarget}from'./normalizeCompileTarget.js';import{projectors}from'./projectors.js';
+export function projectFrontierAst(document, target = 'typescript', options = {}) {
+  const normalized = normalizeCompileTarget(target);
+  const projector = projectors[normalized];
+  return projector(document, options);
+}

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

@@ -0,0 +1,27 @@
+export function admissionRejectionReasons(input){
+  const reasons=[];
+  if(input.readiness==='blocked') reasons.push('Project import readiness is blocked.');
+  if(input.failedEvidenceIds.length) reasons.push(`Project import has failed evidence: ${input.failedEvidenceIds.join(', ')}`);
+  if((input.blockingLossIds??[]).length) reasons.push(`Project import has blocking losses: ${input.blockingLossIds.join(', ')}`);
+  if(input.semanticEvidence.empty) reasons.push('Project import has no semantic symbols, occurrences, relations, or facts.');
+  if(input.sourcePreservation.stale>0) reasons.push(`Project import has stale source preservation for ${input.sourcePreservation.stale} source(s).`);
+  return reasons;
+}
+
+export function admissionPriorityReasons(input){
+  const reasons=[];
+  if(input.readiness==='needs-review'||input.readiness==='ready-with-losses') reasons.push(`Project import readiness is ${input.readiness}.`);
+  if(input.semanticEvidence.emptySourceCount>0) reasons.push(`${input.semanticEvidence.emptySourceCount} source(s) have empty semantic evidence.`);
+  if(input.sourcePreservation.quality==='lossy'||input.sourcePreservation.quality==='missing') reasons.push(`Project source preservation quality is ${input.sourcePreservation.quality}.`);
+  if(input.mergeCandidateRisk.highestRisk!=='low') reasons.push(`Highest merge-candidate risk is ${input.mergeCandidateRisk.highestRisk}.`);
+  if(input.ownership.changed>0) reasons.push(`Project import changes ${input.ownership.changed} ownership region(s) or region conflict key(s).`);
+  return reasons;
+}
+
+export function admissionPriority(action,readiness,sourcePreservation,mergeCandidateRisk){
+  if(action==='reject') return 'blocker';
+  if(mergeCandidateRisk.highestRisk==='high'||readiness==='blocked') return 'critical';
+  if(readiness==='needs-review'||sourcePreservation.quality==='stale') return 'high';
+  if(readiness==='ready-with-losses'||sourcePreservation.quality==='lossy'||mergeCandidateRisk.highestRisk==='medium'||mergeCandidateRisk.highestRisk==='unknown') return 'normal';
+  return 'low';
+}

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

@@ -0,0 +1,316 @@
+import{uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
+
+const scoreWeights=Object.freeze({
+  semanticEvidence:22,
+  sourcePreservation:18,
+  sourceFreshness:14,
+  ownershipChange:14,
+  proofReadiness:20,
+  targetProjectionCoverage:12
+});
+const readinessScore=Object.freeze({ready:100,'ready-with-losses':75,'needs-review':45,blocked:0});
+const readinessSortRank=Object.freeze({ready:3,'ready-with-losses':2,'needs-review':1,blocked:0});
+const riskSortRank=Object.freeze({low:3,medium:2,unknown:1,high:0});
+const actionSortRank=Object.freeze({admit:2,prioritize:1,reject:0});
+const preservationScore=Object.freeze({exact:100,lossy:62,missing:30,stale:0,empty:20});
+const proofEvidenceKind=/proof|test|trace|verify|verification|benchmark|behavior|contract/i;
+
+export function admissionMergeScore(input){
+  const components={
+    semanticEvidence:semanticEvidenceScore(input),
+    sourcePreservation:sourcePreservationScore(input),
+    sourceFreshness:sourceFreshnessScore(input),
+    ownershipChange:ownershipChangeScore(input),
+    proofReadiness:proofReadinessScore(input),
+    targetProjectionCoverage:targetProjectionCoverageScore(input)
+  };
+  const weightedTotal=Object.values(components).reduce((sum,component)=>sum+component.weightedScore,0);
+  const weightTotal=Object.values(components).reduce((sum,component)=>sum+component.weight,0);
+  const uncappedValue=roundScore(weightTotal?weightedTotal*100/weightTotal:0);
+  const value=admissionScoreValue(uncappedValue,input);
+  return {
+    schema:'frontier.lang.semanticMergeScore.v1',
+    version:1,
+    value,
+    uncappedValue,
+    sortKey:mergeScoreSortKey(value,input),
+    higherIsBetter:true,
+    readiness:input.readiness,
+    risk:input.mergeCandidateRisk.highestRisk,
+    action:input.action,
+    priority:input.priority,
+    components,
+    penalties:uniqueStrings([
+      ...(input.action==='reject'?['Admission action is reject.']:[]),
+      ...Object.values(components).flatMap((component)=>component.score<100?component.reasons:[])
+    ])
+  };
+}
+
+function semanticEvidenceScore(input){
+  const sourceCount=Math.max(1,input.sourceCount??0);
+  const semanticTotal=input.semanticEvidence.symbols+input.semanticEvidence.occurrences+input.semanticEvidence.relations+input.semanticEvidence.facts;
+  const nonEmptySources=Math.max(0,(input.sourceCount??0)-input.semanticEvidence.emptySourceCount);
+  const sourceCoverage=(input.sourceCount??0)>0?nonEmptySources/sourceCount:(semanticTotal>0?1:0);
+  const symbolDensity=Math.min(1,input.semanticEvidence.symbols/sourceCount);
+  const evidenceDensity=Math.min(1,input.semanticEvidence.evidenceRecords/sourceCount);
+  const score=input.semanticEvidence.empty?0:roundScore(sourceCoverage*68+symbolDensity*22+evidenceDensity*10);
+  return scoreComponent('semanticEvidence',score,[
+    ...(input.semanticEvidence.empty?['No semantic evidence was imported.']:[]),
+    ...(input.semanticEvidence.emptySourceCount?[
+      `${input.semanticEvidence.emptySourceCount} source(s) have no semantic evidence.`
+    ]:[])
+  ],{
+    symbols:input.semanticEvidence.symbols,
+    occurrences:input.semanticEvidence.occurrences,
+    relations:input.semanticEvidence.relations,
+    facts:input.semanticEvidence.facts,
+    evidenceRecords:input.semanticEvidence.evidenceRecords,
+    emptySourceCount:input.semanticEvidence.emptySourceCount,
+    emptySourcePaths:input.semanticEvidence.emptySourcePaths
+  });
+}
+
+function sourcePreservationScore(input){
+  const base=preservationScore[input.sourcePreservation.quality]??35;
+  const exactRatio=input.sourcePreservation.total?input.sourcePreservation.exactSourceAvailable/input.sourcePreservation.total:0;
+  const score=roundScore(Math.min(base,base*0.8+exactRatio*20));
+  return scoreComponent('sourcePreservation',score,[
+    ...(input.sourcePreservation.quality!=='exact'?[`Project source preservation is ${input.sourcePreservation.quality}.`]:[]),
+    ...(input.sourcePreservation.truncated?['Project source preservation is truncated.']:[]),
+    ...(input.sourcePreservation.lossySourcePaths.length?[`Lossy or missing source preservation: ${input.sourcePreservation.lossySourcePaths.join(', ')}`]:[])
+  ],{
+    quality:input.sourcePreservation.quality,
+    total:input.sourcePreservation.total,
+    exactSourceAvailable:input.sourcePreservation.exactSourceAvailable,
+    sourceBytes:input.sourcePreservation.sourceBytes,
+    tokens:input.sourcePreservation.tokens,
+    trivia:input.sourcePreservation.trivia,
+    directives:input.sourcePreservation.directives,
+    comments:input.sourcePreservation.comments,
+    truncated:input.sourcePreservation.truncated,
+    lossySourcePaths:input.sourcePreservation.lossySourcePaths
+  });
+}
+
+function sourceFreshnessScore(input){
+  const sourceCount=Math.max(input.sourceCount??0,input.sourcePreservation.total,1);
+  const fresh=Math.max(0,sourceCount-input.sourcePreservation.stale);
+  const score=roundScore(fresh*100/sourceCount);
+  return scoreComponent('sourceFreshness',score,[
+    ...(input.sourcePreservation.stale?[
+      `Project import has stale source hashes for ${input.sourcePreservation.stale} source(s).`
+    ]:[])
+  ],{
+    stale:input.sourcePreservation.stale,
+    staleSourcePaths:input.sourcePreservation.staleSourcePaths,
+    checkedSources:sourceCount
+  });
+}
+
+function ownershipChangeScore(input){
+  const changed=input.ownership.changed;
+  const total=input.ownership.total;
+  const candidateConflictKeys=input.ownership.candidateRegionConflictKeys.length;
+  let score=total===0&&changed===0?70:100;
+  if(changed>0){
+    score=total>0
+      ? Math.max(0,100-(changed/Math.max(total,changed))*75-candidateConflictKeys*5)
+      : Math.max(10,85-changed*12-candidateConflictKeys*5);
+  }
+  return scoreComponent('ownershipChange',roundScore(score),[
+    ...(total===0&&changed===0?['No ownership-region evidence was available for this project import.']:[]),
+    ...(changed?[`Project import changes ${changed} ownership region(s) or region conflict key(s).`]:[])
+  ],{
+    total,
+    changed,
+    changedIds:input.ownership.changedIds,
+    changedKeys:input.ownership.changedKeys,
+    candidateRegionConflictKeys:input.ownership.candidateRegionConflictKeys,
+    byKind:input.ownership.byKind,
+    byGranularity:input.ownership.byGranularity,
+    byPrecision:input.ownership.byPrecision,
+    byLanguage:input.ownership.byLanguage
+  });
+}
+
+function proofReadinessScore(input){
+  const evidence=admissionEvidenceRecords(input.projectResult,input.imports);
+  const proofRecords=evidence.filter((record)=>proofEvidenceKind.test(String(record?.kind??record?.metadata?.kind??record?.type??''))||record?.kind==='proof');
+  const failedEvidence=uniqueStrings([
+    ...input.failedEvidenceIds,
+    ...evidence.filter((record)=>record?.status==='failed').map((record)=>record.id).filter(Boolean)
+  ]);
+  const passedProofRecords=proofRecords.filter((record)=>record?.status==='passed'||record?.status==='ok'||record?.status==='success');
+  const pendingProofRecords=proofRecords.filter((record)=>record?.status==='pending'||record?.status==='assumed'||record?.status==='unknown');
+  const blockingLossIds=input.contract?.readiness?.blockingLossIds??input.lossSummary?.blockingLossIds??[];
+  const reviewLossIds=input.contract?.readiness?.reviewLossIds??input.lossSummary?.reviewLossIds??[];
+  const base=readinessScore[input.readiness]??45;
+  const score=clampScore(base+Math.min(16,passedProofRecords.length*8+proofRecords.length*3)-failedEvidence.length*25-blockingLossIds.length*12-Math.min(18,reviewLossIds.length*3));
+  return scoreComponent('proofReadiness',score,[
+    ...(input.readiness!=='ready'?[`Project import readiness is ${input.readiness}.`]:[]),
+    ...(failedEvidence.length?[`Failed evidence: ${failedEvidence.join(', ')}`]:[]),
+    ...(blockingLossIds.length?[`Blocking losses: ${blockingLossIds.join(', ')}`]:[]),
+    ...(pendingProofRecords.length?[`${pendingProofRecords.length} proof/readiness evidence record(s) are pending or assumed.`]:[])
+  ],{
+    readiness:input.readiness,
+    evidenceRecords:evidence.length,
+    proofRecords:proofRecords.length,
+    passedProofRecords:passedProofRecords.length,
+    pendingProofRecords:pendingProofRecords.length,
+    failedEvidenceIds:failedEvidence,
+    blockingLossIds,
+    reviewLossIds
+  });
+}
+
+function targetProjectionCoverageScore(input){
+  const coverage=targetProjectionCoverageSignals(input);
+  let score;
+  if(coverage.targetEntries>0){
+    const supportedRatio=coverage.supportedTargets/coverage.targetEntries;
+    const adapterRatio=Math.min(1,coverage.adapterProjectionTargets/coverage.targetEntries);
+    const readinessRatio=coverage.readinessScore/100;
+    score=roundScore(supportedRatio*55+readinessRatio*25+adapterRatio*20);
+  }else{
+    score=coverage.sourceMapMappings>0||coverage.generatedRangeMappings>0||coverage.targetPaths>0
+      ? 62
+      : coverage.exactSourceProjection>0?55:45;
+  }
+  if(coverage.missingAdapters>0) score=clampScore(score-Math.min(40,coverage.missingAdapters*10));
+  if(coverage.unsupportedTargetFeatures>0) score=clampScore(score-Math.min(35,coverage.unsupportedTargetFeatures*10));
+  return scoreComponent('targetProjectionCoverage',score,[
+    ...(coverage.targetEntries===0?['No explicit target projection coverage was supplied; score uses source-map and exact-source fallback signals.']:[]),
+    ...(coverage.missingAdapters?[`${coverage.missingAdapters} target projection adapter(s) are missing.`]:[]),
+    ...(coverage.unsupportedTargetFeatures?[`${coverage.unsupportedTargetFeatures} target projection target(s) have unsupported features.`]:[])
+  ],coverage);
+}
+
+function targetProjectionCoverageSignals(input){
+  const entries=targetProjectionEntries(input.projectResult,input.imports);
+  const matrices=projectionMatrices(input.projectResult,input.imports);
+  for(const matrix of matrices){
+    for(const language of matrix?.languages??[]) entries.push(...(language?.targets??[]));
+  }
+  const sourceMapSummary=input.contract?.sourceMaps??{};
+  const summary=matrices.reduce((current,matrix)=>{
+    current.exactSourceProjection+=matrix?.summary?.exactSourceProjection??0;
+    current.targetAdapterProjection+=matrix?.summary?.targetAdapterProjection??0;
+    current.missingAdapters+=matrix?.summary?.missingAdapters??0;
+    current.unsupportedTargetFeatures+=matrix?.summary?.unsupportedTargetFeatures??0;
+    return current;
+  },{exactSourceProjection:0,targetAdapterProjection:0,missingAdapters:0,unsupportedTargetFeatures:0});
+  const targetEntries=entries.length;
+  const supportedTargets=entries.filter((entry)=>entry?.supported===true).length;
+  const adapterProjectionTargets=entries.filter((entry)=>
+    entry?.lossClass==='targetAdapterProjection'||entry?.lossClass==='exactSourceProjection'||entry?.adapter||entry?.adapterKind==='targetProjection'
+  ).length+summary.targetAdapterProjection+summary.exactSourceProjection;
+  const readinessValues=entries.map((entry)=>readinessScore[entry?.readiness]??45);
+  const readinessAverage=readinessValues.length?readinessValues.reduce((sum,value)=>sum+value,0)/readinessValues.length:0;
+  return {
+    targetEntries,
+    supportedTargets,
+    adapterProjectionTargets,
+    exactSourceProjection:Math.max(summary.exactSourceProjection,input.sourcePreservation.exactSourceAvailable??0),
+    targetAdapterProjection:summary.targetAdapterProjection,
+    missingAdapters:summary.missingAdapters+entries.filter((entry)=>entry?.lossClass==='missingAdapter'||entry?.supported===false).length,
+    unsupportedTargetFeatures:summary.unsupportedTargetFeatures+entries.filter((entry)=>entry?.lossClass==='unsupportedTargetFeatures').length,
+    readinessScore:roundScore(readinessAverage),
+    sourceMapMappings:sourceMapSummary.mappingCount??0,
+    generatedRangeMappings:sourceMapSummary.generatedRangeMappings??0,
+    targetPaths:sourceMapSummary.targetPaths?.length??0,
+    adapterGeneratedRanges:input.contract?.adapterCoverage?.generatedRanges??0
+  };
+}
+
+function targetProjectionEntries(projectResult,imports){
+  return [
+    projectResult?.targetCoverage,
+    projectResult?.metadata?.targetCoverage,
+    projectResult?.metadata?.targetProjectionCoverage,
+    ...(projectResult?.targetCoverages??[]),
+    ...(projectResult?.metadata?.targetCoverages??[]),
+    ...(imports??[]).flatMap((imported)=>[
+      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 projectionMatrices(projectResult,imports){
+  return [
+    projectResult?.projectionMatrix,
+    projectResult?.metadata?.projectionMatrix,
+    ...(projectResult?.projectionMatrices??[]),
+    ...(projectResult?.metadata?.projectionMatrices??[]),
+    ...(imports??[]).flatMap((imported)=>[
+      imported?.projectionMatrix,
+      imported?.metadata?.projectionMatrix,
+      ...(imported?.projectionMatrices??[]),
+      ...(imported?.metadata?.projectionMatrices??[])
+    ])
+  ].filter((matrix)=>matrix?.kind==='frontier.lang.projectionTargetLossMatrix'||Array.isArray(matrix?.languages));
+}
+
+function admissionEvidenceRecords(projectResult,imports){
+  return uniqueRecordsById([
+    ...(projectResult?.evidence??[]),
+    ...(projectResult?.patch?.evidence??[]),
+    ...(projectResult?.universalAst?.evidence??[]),
+    ...(imports??[]).flatMap((imported)=>[
+      ...(imported?.evidence??[]),
+      ...(imported?.patch?.evidence??[]),
+      ...(imported?.universalAst?.evidence??[])
+    ])
+  ]);
+}
+
+function scoreComponent(key,score,reasons,signals){
+  const normalizedScore=clampScore(score);
+  const weight=scoreWeights[key];
+  return {
+    key,
+    score:normalizedScore,
+    weight,
+    weightedScore:roundWeighted(normalizedScore*weight/100),
+    status:componentStatus(normalizedScore),
+    reasons:uniqueStrings(reasons),
+    signals
+  };
+}
+
+function componentStatus(score){
+  if(score<=0) return 'blocked';
+  if(score<50) return 'weak';
+  if(score<80) return 'partial';
+  return 'strong';
+}
+
+function mergeScoreSortKey(value,input){
+  return Math.round(value*1000)
+    +(readinessSortRank[input.readiness]??1)*100
+    +(riskSortRank[input.mergeCandidateRisk.highestRisk]??1)*10
+    +(actionSortRank[input.action]??0);
+}
+
+function admissionScoreValue(value,input){
+  if(input.action==='reject') return Math.min(value,35);
+  if(input.readiness==='blocked') return Math.min(value,25);
+  if(input.mergeCandidateRisk.highestRisk==='high') return Math.min(value,60);
+  return value;
+}
+
+function clampScore(value){
+  return Math.max(0,Math.min(100,roundScore(value)));
+}
+
+function roundScore(value){
+  return Math.round((Number.isFinite(value)?value:0)*100)/100;
+}
+
+function roundWeighted(value){
+  return Math.round((Number.isFinite(value)?value:0)*1000)/1000;
+}