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

package/dist/declarations/semantic-impact.d.ts

@@ -3,12 +3,21 @@ import type { NativeImportRegionTaxonomyKind } from './native-import-losses.js';
 
 export type SemanticImportImpactRisk = 'low' | 'medium' | 'high' | string;
 export type SemanticImportImpactConfidence = 'source-exact' | 'source-addressed' | 'estimated-source-region' | 'review-required' | string;
+export type SemanticImportMergeSignalStatus = 'strong' | 'partial' | 'weak' | 'blocked' | string;
 
 export interface SemanticImportImpactVerificationStep {
   readonly kind: 'dependency-review' | 'source-map-review' | 'reject-or-reprove' | 'proof-review' | 'patch-admission' | 'evidence-review' | string;
   readonly reason: string;
   readonly required: boolean;
 }
+export interface SemanticImportMergeSignal {
+  readonly status: SemanticImportMergeSignalStatus;
+  readonly score: number;
+  readonly missing: readonly string[];
+  readonly reviewRequired: boolean;
+  readonly queryKeys: readonly string[];
+}
+export interface SemanticImportMergeSignalScoreSummary { readonly min: number; readonly max: number; readonly average: number; }
 
 export interface SemanticImportImpactRecord {
   readonly id: string;
@@ -39,6 +48,7 @@ export interface SemanticImportImpactRecord {
   readonly readiness: SemanticMergeReadiness;
   readonly risk: SemanticImportImpactRisk;
   readonly confidence: SemanticImportImpactConfidence;
+  readonly mergeSignal: SemanticImportMergeSignal;
 }
 
 export interface SemanticImportImpactSummary {
@@ -51,5 +61,7 @@ export interface SemanticImportImpactSummary {
     readonly sourceMapMappings: number; readonly sourcePreservationRecords: number; readonly patchHints: number;
     readonly proofObligations: number; readonly openProofObligations: number; readonly failedProofObligations: number; readonly paradigmSemantics: number; readonly loweringRecords: number;
     readonly evidenceIds: number; readonly verificationPlans: readonly string[]; readonly requiredVerificationSteps: number;
+    readonly byMergeSignal: Readonly<Record<string, number>>; readonly weakMergeSignals: number; readonly reviewRequiredMergeSignals: number;
+    readonly mergeSignalQueryKeys: readonly string[]; readonly mergeSignalScores: SemanticImportMergeSignalScoreSummary;
   };
 }

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

@@ -1,5 +1,5 @@
 import{nativeLanguageCompileTarget}from'../../coverage-matrix-profiles.js';import{idFragment,uniqueByEvidenceId,uniqueByLossId}from'../../native-import-utils.js';
-import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{createNativeRoundtripEvidence}from'./createNativeRoundtripEvidence.js';import{createProjectionTargetLossMatrix}from'./createProjectionTargetLossMatrix.js';import{importNativeSource}from'./importNativeSource.js';import{isNativeSourceImportResult}from'./isNativeSourceImportResult.js';import{nativeCompileSourceLanguage}from'./nativeCompileSourceLanguage.js';import{nativeCompileTarget}from'./nativeCompileTarget.js';import{nativeSourceCompileEvidence}from'./nativeSourceCompileEvidence.js';import{nativeSourceCompileSourceMaps}from'./nativeSourceCompileSourceMaps.js';import{nativeSourceCompileTargetCoverage}from'./nativeSourceCompileTargetCoverage.js';import{nativeSourceCompileTargetLosses}from'./nativeSourceCompileTargetLosses.js';import{projectNativeImportToSource}from'./projectNativeImportToSource.js';import{resolveNativeTargetProjectionAdapter}from'./resolveNativeTargetProjectionAdapter.js';import{runNativeTargetProjectionAdapter}from'./runNativeTargetProjectionAdapter.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{createNativeRoundtripEvidence}from'./createNativeRoundtripEvidence.js';import{createProjectionTargetLossMatrix}from'./createProjectionTargetLossMatrix.js';import{importNativeSource}from'./importNativeSource.js';import{isNativeSourceImportResult}from'./isNativeSourceImportResult.js';import{nativeCompileSourceLanguage}from'./nativeCompileSourceLanguage.js';import{nativeCompileTarget}from'./nativeCompileTarget.js';import{nativeProjectionReview}from'./nativeProjectionReview.js';import{nativeSourceCompileEvidence}from'./nativeSourceCompileEvidence.js';import{nativeSourceCompileSourceMaps}from'./nativeSourceCompileSourceMaps.js';import{nativeSourceCompileTargetCoverage}from'./nativeSourceCompileTargetCoverage.js';import{nativeSourceCompileTargetLosses}from'./nativeSourceCompileTargetLosses.js';import{projectNativeImportToSource}from'./projectNativeImportToSource.js';import{resolveNativeTargetProjectionAdapter}from'./resolveNativeTargetProjectionAdapter.js';import{runNativeTargetProjectionAdapter}from'./runNativeTargetProjectionAdapter.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
 export function compileNativeSource(input, options = {}) {
   const importResult = isNativeSourceImportResult(input) ? input : importNativeSource(input);
   const sourceLanguage = nativeCompileSourceLanguage(importResult, input);
@@ -124,6 +124,17 @@ export function compileNativeSource(input, options = {}) {
       compileResultId: id
     });
   const sourceMap = sourceMaps[0];
+  const projectionReview = nativeProjectionReview({
+    mode: projection.mode, outputMode, language: projection.language, sourceLanguage, target,
+    sourcePath: importResult.sourcePath ?? importResult.nativeSource?.sourcePath,
+    exactSourceAvailable: projection.metadata?.exactSourceAvailable === true,
+    sourceTextAvailable: projection.metadata?.sourceTextAvailable === true,
+    sourceHashVerified: projection.metadata?.sourceHashVerified === true,
+    declarationCount: projection.declarations.length, sourceMapCount: sourceMaps.length,
+    losses, targetLosses, readiness: readiness.readiness, targetCoverage, targetProjection
+  });
+  compileEvidence.metadata.projectionReview = projectionReview;
+  for (const record of sourceMaps) record.metadata = { ...(record.metadata ?? {}), projectionReview };
   const roundtripEvidence = createNativeRoundtripEvidence(importResult, {
     id: `evidence_${idPart}_${idFragment(target)}_native_roundtrip`,
     projection,
@@ -179,6 +190,7 @@ export function compileNativeSource(input, options = {}) {
       targetLossClass: targetCoverage.lossClass,
       targetReadiness: targetCoverage.readiness,
       targetSupported: targetCoverage.supported,
+      projectionReview,
       ...options.metadata,
       roundtripEvidence: roundtripEvidence.metadata.roundtripEvidence
     }

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

@@ -9,6 +9,10 @@ export function createUniversalAstFromDocument(document, input = {}) {
     losses: input.losses,
     evidence: input.evidence ?? [],
     mergeCandidates: input.mergeCandidates,
+    semanticOperations: input.semanticOperations,
+    proof: input.proof ?? input.universalAstProof,
+    paradigmSemantics: input.paradigmSemantics ?? input.universalAstParadigmSemantics,
+    replayLinks: input.replayLinks,
     layers: input.layers,
     metadata: input.metadata
   }), input);

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

@@ -0,0 +1,73 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+
+export function nativeProjectionReview(input) {
+  const lossIds = (input.losses ?? []).map((loss) => loss.id).filter(Boolean);
+  const blockingLossIds = (input.losses ?? []).filter((loss) => loss.severity === 'error').map((loss) => loss.id).filter(Boolean);
+  const targetLossIds = (input.targetLosses ?? []).map((loss) => loss.id).filter(Boolean);
+  const fallbackReasons = nativeProjectionFallbackReasons(input, blockingLossIds, targetLossIds);
+  const reviewRequired = input.readiness !== 'ready' || fallbackReasons.length > 0 || blockingLossIds.length > 0;
+  const status = nativeProjectionReviewStatus(input, blockingLossIds);
+  return {
+    kind: 'frontier.lang.nativeProjectionReview',
+    version: 1,
+    status,
+    reviewRequired,
+    projectionMode: input.mode,
+    outputMode: input.outputMode ?? input.mode,
+    language: input.language,
+    sourceLanguage: input.sourceLanguage ?? input.language,
+    target: input.target,
+    sourcePath: input.sourcePath,
+    exactSourceAvailable: input.exactSourceAvailable === true,
+    sourceTextAvailable: input.sourceTextAvailable === true,
+    sourceHashVerified: input.sourceHashVerified === true,
+    declarationCount: input.declarationCount ?? 0,
+    sourceMapCount: input.sourceMapCount ?? 0,
+    readiness: input.readiness,
+    targetLossClass: input.targetCoverage?.lossClass,
+    targetReadiness: input.targetCoverage?.readiness,
+    targetSupported: input.targetCoverage?.supported,
+    targetProjectionAdapterId: input.targetProjection?.adapter?.id,
+    fallbackReasons,
+    lossIds: uniqueStrings(lossIds),
+    blockingLossIds: uniqueStrings(blockingLossIds),
+    targetLossIds: uniqueStrings(targetLossIds),
+    queryKeys: nativeProjectionReviewQueryKeys(input, status, fallbackReasons, reviewRequired)
+  };
+}
+
+function nativeProjectionFallbackReasons(input, blockingLossIds, targetLossIds) {
+  const reasons = [];
+  if (input.exactSourceAvailable !== true) reasons.push('no-exact-source');
+  if (input.sourceHashVerified !== true) reasons.push('source-hash-unverified');
+  if (input.mode === 'native-source-stubs') reasons.push('declaration-stubs');
+  if (input.outputMode === 'target-stubs') reasons.push('target-stubs');
+  if (input.targetCoverage?.supported === false) reasons.push('target-unsupported');
+  if (input.targetCoverage?.lossClass === 'missingAdapter') reasons.push('missing-target-adapter');
+  if (blockingLossIds.length > 0) reasons.push('blocking-losses');
+  if (targetLossIds.length > 0) reasons.push('target-losses');
+  return uniqueStrings(reasons);
+}
+
+function nativeProjectionReviewStatus(input, blockingLossIds) {
+  if (blockingLossIds.length > 0 || input.readiness === 'blocked' || input.targetCoverage?.readiness === 'blocked') return 'blocked';
+  if (input.outputMode === 'target-adapter') return 'target-adapter';
+  if (input.outputMode === 'target-stubs' || input.mode === 'native-source-stubs') return 'stub-only';
+  if (input.sourceHashVerified === true && input.exactSourceAvailable === true) return 'preserved-source';
+  return 'needs-review';
+}
+
+function nativeProjectionReviewQueryKeys(input, status, fallbackReasons, reviewRequired) {
+  return uniqueStrings([
+    `projection-review:${status}`,
+    reviewRequired ? 'review-required' : 'review-not-required',
+    input.language ? `language:${input.language}` : undefined,
+    input.sourceLanguage ? `source-language:${input.sourceLanguage}` : undefined,
+    input.target ? `target:${input.target}` : undefined,
+    input.sourcePath ? `source:${input.sourcePath}` : undefined,
+    input.mode ? `projection-mode:${input.mode}` : undefined,
+    input.outputMode ? `output-mode:${input.outputMode}` : undefined,
+    input.targetCoverage?.lossClass ? `target-loss-class:${input.targetCoverage.lossClass}` : undefined,
+    ...fallbackReasons.map((reason) => `fallback:${reason}`)
+  ].filter(Boolean));
+}

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

@@ -1,5 +1,5 @@
 import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
-import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{createNativeRoundtripEvidence}from'./createNativeRoundtripEvidence.js';import{nativeImportProjectionContext}from'./nativeImportProjectionContext.js';import{nativeProjectionDeclarations}from'./nativeProjectionDeclarations.js';import{nativeProjectionSourceCandidate}from'./nativeProjectionSourceCandidate.js';import{nativeProjectionStubLosses}from'./nativeProjectionStubLosses.js';import{renderNativeProjectionStubs}from'./renderNativeProjectionStubs.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{createNativeRoundtripEvidence}from'./createNativeRoundtripEvidence.js';import{nativeImportProjectionContext}from'./nativeImportProjectionContext.js';import{nativeProjectionDeclarations}from'./nativeProjectionDeclarations.js';import{nativeProjectionReview}from'./nativeProjectionReview.js';import{nativeProjectionSourceCandidate}from'./nativeProjectionSourceCandidate.js';import{nativeProjectionStubLosses}from'./nativeProjectionStubLosses.js';import{renderNativeProjectionStubs}from'./renderNativeProjectionStubs.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
 export function projectNativeImportToSource(importResult, options = {}) {
   if (!importResult || typeof importResult !== 'object') {
     throw new Error('projectNativeImportToSource requires a native import result');
@@ -49,6 +49,14 @@ export function projectNativeImportToSource(importResult, options = {}) {
     parser: context.parser,
     semanticStatus: context.semanticStatus
   });
+  const projectionReview = nativeProjectionReview({
+    mode, language: context.language, sourcePath: context.sourcePath,
+    exactSourceAvailable: candidateSource?.exact === true,
+    sourceTextAvailable: typeof candidateSource?.sourceText === 'string',
+    sourceHashVerified: candidateSource?.hashVerified ?? false,
+    declarationCount: declarations.length, losses, readiness: readiness.readiness
+  });
+  evidence[0].metadata.projectionReview = projectionReview;
   const result = {
     kind: 'frontier.lang.nativeSourceProjection',
     version: 1,
@@ -75,6 +83,7 @@ export function projectNativeImportToSource(importResult, options = {}) {
       sourcePreservationId: candidateSource?.sourcePreservationId,
       sourceHashVerified: candidateSource?.hashVerified ?? false,
       nativeImportLossSummary,
+      projectionReview,
       ...options.metadata
     }
   };

package/dist/native-region-scanner-js-imports.js

@@ -30,6 +30,14 @@ export function jsImportDeclarations(input, lineNumber, trimmed) {
         : [];
     return jsImportModuleDeclarations(input, lineNumber, importPath, 'ExportFromDeclaration', bindings, { typeOnly, reexport: true, exportStar: Boolean(exportMatch[2]) });
   }
+  const destructuredRequireMatch = trimmed.match(/^(?:const|let|var)\s+\{([^}]+)\}\s*=\s*(?:await\s+)?(require|import)\s*\(\s*(['"])([^'"]+)\3\s*\)/);
+  if (destructuredRequireMatch) {
+    const importKind = destructuredRequireMatch[2] === 'import' ? 'dynamic-import-binding' : 'commonjs-require';
+    const bindings = jsDestructuredImportBindings(destructuredRequireMatch[1], importKind);
+    if (bindings.length) {
+      return jsImportModuleDeclarations(input, lineNumber, destructuredRequireMatch[4], 'DestructuredRequireDeclaration', bindings, { destructured: true });
+    }
+  }
   const requireMatch = trimmed.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:await\s+)?(?:require|import)\s*\(\s*(['"])([^'"]+)\2\s*\)/);
   if (requireMatch) return jsImportModuleDeclarations(input, lineNumber, requireMatch[3], 'CommonJsRequireDeclaration', [{
     localName: requireMatch[1],
@@ -39,6 +47,23 @@ export function jsImportDeclarations(input, lineNumber, trimmed) {
   return [];
 }
 
+function jsDestructuredImportBindings(raw, importKind) {
+  return String(raw ?? '')
+    .split(',')
+    .map((part) => {
+      const text = part.trim();
+      if (!text || text.startsWith('...')) return undefined;
+      const match = text.match(/^([A-Za-z_$][\w$]*|\*)\s*(?::\s*([A-Za-z_$][\w$]*))?$/);
+      if (!match) return undefined;
+      return {
+        localName: match[2] ?? match[1],
+        importedName: match[1],
+        importKind
+      };
+    })
+    .filter(Boolean);
+}
+
 function jsImportModuleDeclarations(input, lineNumber, importPath, languageKind, bindings = [], metadata = {}) {
   const bindingSummaries = bindings.map((binding) => ({
     localName: binding.localName,
@@ -55,7 +80,8 @@ function jsImportModuleDeclarations(input, lineNumber, importPath, languageKind,
         ...(metadata.typeOnly ? { typeOnly: true } : {}),
         ...(metadata.sideEffectOnly ? { sideEffectOnly: true } : {}),
         ...(metadata.reexport ? { reexport: true } : {}),
-        ...(metadata.exportStar ? { exportStar: true } : {})
+        ...(metadata.exportStar ? { exportStar: true } : {}),
+        ...(metadata.destructured ? { destructured: true } : {})
       },
       metadata: {
         moduleOnly: true,

package/dist/native-region-scanner-js.js

@@ -33,6 +33,7 @@ function scanJavaScriptLike(input) {
   let currentClass;
   let classDepth = 0;
   let currentObject;
+  let currentType;
   const lexicalState = { inBlockComment: false, inTemplateString: false };
   for (const { line, number } of lines) {
     const scanLine = jsDeclarationScanLine(line, lexicalState);
@@ -40,6 +41,9 @@ function scanJavaScriptLike(input) {
     if (!trimmed || jsCommentOnlyLine(trimmed)) continue;
     const declarationLine = trimmed.replace(/^(?:export\s+)?(?:declare\s+)?/, '');
     let match;
+    if (currentType && number !== currentType.startLine) {
+      pushDeclaration(jsTypeMemberDeclaration(input, number, declarationLine, currentType));
+    }
     if (currentObject) {
       const routeRecord = jsRouteRecordDeclaration(input, number, trimmed, currentObject);
       if (routeRecord) {
@@ -66,13 +70,18 @@ function scanJavaScriptLike(input) {
         classDepth = 0;
       }
     } else if ((match = declarationLine.match(/^interface\s+([A-Za-z_$][\w$]*)/))) {
-      pushDeclaration(nativeDeclaration(input, number, 'InterfaceDeclaration', 'interface', match[1], {}, declarationLine.includes('{')));
+      const regionKind = 'type';
+      pushDeclaration(nativeDeclaration(input, number, 'InterfaceDeclaration', 'interface', match[1], {}, declarationLine.includes('{'), { regionKind }));
+      currentType = jsTypeRegionContext(match[1], declarationLine, number, regionKind, 'interface');
     } else if ((match = declarationLine.match(/^(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/))) {
       pushDeclaration(nativeDeclaration(input, number, 'EnumDeclaration', 'type', match[1], {}, declarationLine.includes('{')));
     } else if ((match = declarationLine.match(/^(?:namespace|module)\s+([A-Za-z_$][\w$.]*)/))) {
       pushDeclaration(nativeDeclaration(input, number, 'ModuleDeclaration', 'module', match[1], {}, declarationLine.includes('{')));
-    } else if ((match = declarationLine.match(/^type\s+([A-Za-z_$][\w$]*)\s*=/))) {
-      pushDeclaration(nativeDeclaration(input, number, 'TypeAliasDeclaration', 'type', match[1], {}, false));
+    } else if ((match = declarationLine.match(/^type\s+([A-Za-z_$][\w$]*)(?:\s*<[^=]+>)?\s*=/))) {
+      const regionKind = 'type';
+      const hasTypeBody = declarationLine.includes('{');
+      pushDeclaration(nativeDeclaration(input, number, 'TypeAliasDeclaration', 'type', match[1], {}, hasTypeBody, { regionKind }));
+      currentType = jsTypeRegionContext(match[1], declarationLine, number, regionKind, 'type');
     } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::\s*[^=]+)?=\s*(?:async\s*)?(?:<[^=]+>\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/))) {
       pushDeclaration(nativeDeclaration(input, number, 'VariableFunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, true));
     } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\b/))) {
@@ -113,6 +122,10 @@ function scanJavaScriptLike(input) {
         classDepth = 0;
       }
     }
+    if (currentType) {
+      if (number !== currentType.startLine) currentType.depth += jsStructureDelta(trimmed).value;
+      if (currentType.depth <= 0) currentType = undefined;
+    }
     if (currentObject) {
       if (number !== currentObject.startLine) currentObject.depth += jsContainerDelta(trimmed);
       if (currentObject.depth <= 0) currentObject = undefined;
@@ -179,6 +192,53 @@ function jsStructureDelta(source) {
   return { value, opened };
 }
 
+function jsTypeRegionContext(name, declarationLine, lineNumber, regionKind, typeKind) {
+  const depth = jsStructureDelta(declarationLine).value;
+  if (depth <= 0) return undefined;
+  return {
+    name,
+    typeKind,
+    regionKind,
+    depth,
+    startLine: lineNumber
+  };
+}
+
+function jsTypeMemberDeclaration(input, lineNumber, declarationLine, context) {
+  const text = String(declarationLine ?? '').trim();
+  if (!text || /^[}\])]/.test(text) || text.startsWith('//')) return undefined;
+  let match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*([^;,]+))?[;,]?$/);
+  if (match && !jsControlKeyword(match[2])) {
+    return nativeDeclaration(input, lineNumber, 'TypeMethodSignature', 'method', `${context.name}.${match[2]}`, {
+      owner: context.name,
+      propertyName: match[2],
+      parameters: splitParameters(match[3]),
+      returnType: match[4]?.trim(),
+      typeKind: context.typeKind
+    }, false, {
+      regionKind: jsTypeMemberRegionKind(context, match[2], text),
+      metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
+    });
+  }
+  match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*:\s*(.+?)[;,]?$/);
+  if (!match || jsControlKeyword(match[2])) return undefined;
+  const valueType = match[3].trim();
+  const functionLike = /=>/.test(valueType) || /^\([^)]*\)\s*=>/.test(valueType);
+  return nativeDeclaration(input, lineNumber, functionLike ? 'TypeFunctionPropertySignature' : 'TypePropertySignature', functionLike ? 'function' : 'property', `${context.name}.${match[2]}`, {
+    owner: context.name,
+    propertyName: match[2],
+    valueType,
+    typeKind: context.typeKind
+  }, false, {
+    regionKind: jsTypeMemberRegionKind(context, match[2], text),
+    metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
+  });
+}
+
+function jsTypeMemberRegionKind(context, propertyName, source) {
+  return jsRegionKindForDeclarationName(propertyName, source) ?? (context.regionKind === 'type' ? 'property' : context.regionKind) ?? 'property';
+}
+
 function jsInlineClassMemberDeclarations(input, lineNumber, declarationLine, className) {
   const open = declarationLine.indexOf('{');
   const close = declarationLine.lastIndexOf('}');

package/dist/semantic-import-impact-types.d.ts

@@ -3,6 +3,7 @@ import type { NativeImportRegionTaxonomyKind } from './index.js';
 
 export type SemanticImportImpactRisk = 'low' | 'medium' | 'high' | string;
 export type SemanticImportImpactConfidence = 'source-exact' | 'source-addressed' | 'estimated-source-region' | 'review-required' | string;
+export type SemanticImportMergeSignalStatus = 'strong' | 'partial' | 'weak' | 'blocked' | string;
 
 export interface SemanticImportImpactVerificationStep {
   readonly kind: 'dependency-review' | 'source-map-review' | 'reject-or-reprove' | 'proof-review' | 'patch-admission' | 'evidence-review' | string;
@@ -10,6 +11,20 @@ export interface SemanticImportImpactVerificationStep {
   readonly required: boolean;
 }
 
+export interface SemanticImportMergeSignal {
+  readonly status: SemanticImportMergeSignalStatus;
+  readonly score: number;
+  readonly missing: readonly string[];
+  readonly reviewRequired: boolean;
+  readonly queryKeys: readonly string[];
+}
+
+export interface SemanticImportMergeSignalScoreSummary {
+  readonly min: number;
+  readonly max: number;
+  readonly average: number;
+}
+
 export interface SemanticImportImpactRecord {
   readonly id: string;
   readonly kind: 'ownership-region-impact' | string;
@@ -39,6 +54,7 @@ export interface SemanticImportImpactRecord {
   readonly readiness: SemanticMergeReadiness;
   readonly risk: SemanticImportImpactRisk;
   readonly confidence: SemanticImportImpactConfidence;
+  readonly mergeSignal: SemanticImportMergeSignal;
 }
 
 export interface SemanticImportImpactSummary {
@@ -63,5 +79,10 @@ export interface SemanticImportImpactSummary {
     readonly evidenceIds: number;
     readonly verificationPlans: readonly string[];
     readonly requiredVerificationSteps: number;
+    readonly byMergeSignal: Readonly<Record<string, number>>;
+    readonly weakMergeSignals: number;
+    readonly reviewRequiredMergeSignals: number;
+    readonly mergeSignalQueryKeys: readonly string[];
+    readonly mergeSignalScores: SemanticImportMergeSignalScoreSummary;
   };
 }

package/dist/semantic-import-impact.js

@@ -1,5 +1,6 @@
 import { countBy, idFragment, maxSemanticMergeReadiness, uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
 import { semanticDependencyPredicateKey } from './semantic-import-dependencies.js';
+import { semanticImpactMergeSignal, summarizeSemanticImpactMergeSignals } from './semantic-import-merge-signal.js';
 
 function createSemanticImportImpact(input) {
   const relations = collectDependencyRelations(input.imports, input.dependencies);
@@ -60,7 +61,7 @@ function semanticImpactRecord(input) {
     relationCount: input.relations.length,
     verificationPlan
   });
-  return {
+  const record = {
     id: `impact_${idFragment(input.region.id ?? input.region.key)}`,
     kind: 'ownership-region-impact',
     ownershipRegionId: input.region.id,
@@ -93,6 +94,7 @@ function semanticImpactRecord(input) {
     risk,
     confidence: semanticImpactConfidence(input.region, input.sourceMapMappings, input.sourcePreservationRecords)
   };
+  return { ...record, mergeSignal: semanticImpactMergeSignal(record) };
 }
 
 function collectDependencyRelations(imports, dependencies) {
@@ -299,7 +301,8 @@ function summarizeSemanticImpactRecords(records) {
     loweringRecords: uniqueStrings(records.flatMap((record) => record.loweringRecordIds)).length,
     evidenceIds: uniqueStrings(records.flatMap((record) => record.evidenceIds)).length,
     verificationPlans: uniqueStrings(verificationPlans),
-    requiredVerificationSteps: records.flatMap((record) => record.verificationPlan).filter((step) => step.required).length
+    requiredVerificationSteps: records.flatMap((record) => record.verificationPlan).filter((step) => step.required).length,
+    ...summarizeSemanticImpactMergeSignals(records)
   };
 }
 

package/dist/semantic-import-merge-signal.js

@@ -0,0 +1,86 @@
+import { countBy, uniqueStrings } from './native-import-utils.js';
+
+export function semanticImpactMergeSignal(record) {
+  const missing = semanticImpactMissingSignals(record);
+  const requiredSteps = (record.verificationPlan ?? []).filter((step) => step.required).length;
+  const blocked = record.readiness === 'blocked' || (record.failedProofObligationIds ?? []).length > 0;
+  const reviewRequired = blocked || record.readiness !== 'ready' || record.risk !== 'low' || requiredSteps > 0 || missing.length > 0;
+  const score = semanticImpactMergeScore(record, missing, requiredSteps, blocked);
+  const status = semanticImpactMergeStatus(record, score, blocked);
+  return {
+    status,
+    score,
+    missing,
+    reviewRequired,
+    queryKeys: semanticImpactMergeQueryKeys(record, status, missing, reviewRequired)
+  };
+}
+
+export function summarizeSemanticImpactMergeSignals(records) {
+  const signals = (records ?? []).map((record) => record.mergeSignal).filter(Boolean);
+  return {
+    byMergeSignal: countBy(signals.map((signal) => signal.status)),
+    weakMergeSignals: signals.filter((signal) => signal.status === 'weak' || signal.status === 'blocked').length,
+    reviewRequiredMergeSignals: signals.filter((signal) => signal.reviewRequired).length,
+    mergeSignalQueryKeys: uniqueStrings(signals.flatMap((signal) => signal.queryKeys)),
+    mergeSignalScores: semanticImpactMergeScoreSummary(signals)
+  };
+}
+
+function semanticImpactMissingSignals(record) {
+  const missing = [];
+  if ((record.evidenceIds ?? []).length === 0) missing.push('evidence');
+  if ((record.sourceMapMappingIds ?? []).length === 0) missing.push('source-map');
+  if ((record.sourcePreservationRecordIds ?? []).length === 0) missing.push('source-preservation');
+  if (record.readiness !== 'ready' && (record.patchHintIds ?? []).length === 0) missing.push('patch-hint');
+  if ((record.openProofObligationIds ?? []).length > 0) missing.push('proof-obligations');
+  if (record.confidence === 'estimated-source-region' || record.confidence === 'review-required') missing.push('source-confidence');
+  return uniqueStrings(missing);
+}
+
+function semanticImpactMergeScore(record, missing, requiredSteps, blocked) {
+  let score = 100;
+  if (blocked) score -= 70;
+  else if (record.risk === 'high') score -= 35;
+  else if (record.risk === 'medium') score -= 18;
+  if (record.readiness === 'blocked') score -= 30;
+  else if (record.readiness === 'needs-review') score -= 18;
+  else if (record.readiness === 'ready-with-losses') score -= 8;
+  score -= Math.min(requiredSteps * 8, 32);
+  score -= Math.min(missing.length * 7, 35);
+  if ((record.failedProofObligationIds ?? []).length > 0) score -= 30;
+  if ((record.openProofObligationIds ?? []).length > 0) score -= 12;
+  if (record.confidence === 'source-exact') score += 5;
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+
+function semanticImpactMergeStatus(record, score, blocked) {
+  if (blocked || score < 25) return 'blocked';
+  if (score < 50 || record.risk === 'high') return 'weak';
+  if (score < 80 || record.risk === 'medium' || record.readiness !== 'ready') return 'partial';
+  return 'strong';
+}
+
+function semanticImpactMergeQueryKeys(record, status, missing, reviewRequired) {
+  return uniqueStrings([
+    `merge-signal:${status}`,
+    `risk:${record.risk ?? 'unknown'}`,
+    `readiness:${record.readiness ?? 'unknown'}`,
+    reviewRequired ? 'review-required' : 'review-not-required',
+    ...missing.map((item) => `missing:${item}`),
+    record.sourcePath ? `source:${record.sourcePath}` : undefined,
+    record.ownershipKey ? `ownership:${record.ownershipKey}` : undefined,
+    ...(record.symbolNames ?? []).map((name) => `symbol-name:${name}`),
+    ...(record.dependencyPredicates ?? []).map((predicate) => `predicate:${predicate}`)
+  ].filter(Boolean));
+}
+
+function semanticImpactMergeScoreSummary(signals) {
+  if (!signals.length) return { min: 0, max: 0, average: 0 };
+  const scores = signals.map((signal) => signal.score);
+  return {
+    min: Math.min(...scores),
+    max: Math.max(...scores),
+    average: Math.round(scores.reduce((sum, score) => sum + score, 0) / scores.length)
+  };
+}

package/package.json

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