@shapeshift-labs/frontier-lang-compiler 0.2.69 → 0.2.71

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/createLightweightNativeImport.js

@@ -140,14 +140,18 @@ export function createLightweightNativeImport(input) {
       kind: 'import',
       status: 'passed',
       path: input.sourcePath,
-      summary: `Lightweight declaration scan found ${symbols.length} symbol(s) and ${dependencies.summary.total} dependency edge(s).`,
-      metadata: { parser, dependencyRelations: dependencies.summary.total }
+      summary: `Lightweight declaration scan found ${symbols.length} symbol(s), ${dependencies.summary.total} dependency edge(s), and ${dependencies.summary.controlFlow + dependencies.summary.effects + dependencies.summary.mutations} semantic fact(s).`,
+      metadata: { parser, dependencyRelations: dependencies.summary.total, semanticFacts: {
+        controlFlow: dependencies.summary.controlFlow,
+        effects: dependencies.summary.effects,
+        mutations: dependencies.summary.mutations
+      } }
     }],
     metadata: {
       parser,
       coverage: 'declarations-only',
       dependencyRelations: dependencies.summary,
-      unsupported: ['full expression AST', 'type checking', 'control flow', 'comments and formatting preservation']
+      unsupported: ['full expression AST', 'type checking', 'full control-flow graph', 'comments and formatting preservation']
     }
   });
 
@@ -164,6 +168,12 @@ export function createLightweightNativeImport(input) {
       declarationCount: declarations.length,
       dependencyRelationCount: dependencies.summary.total,
       dependencyOccurrenceCount: dependencies.occurrences.length,
+      semanticFactCount: dependencies.summary.controlFlow + dependencies.summary.effects + dependencies.summary.mutations,
+      semanticFactSummary: {
+        controlFlow: dependencies.summary.controlFlow,
+        effects: dependencies.summary.effects,
+        mutations: dependencies.summary.mutations
+      },
       ...(input.sourcePreservation ? {
         sourcePreservationId: input.sourcePreservation.id,
         sourcePreservationSummary: input.sourcePreservation.summary

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/observeNativeImporterSemanticEvidence.js

@@ -11,6 +11,7 @@ export function observeNativeImporterSemanticEvidence(semanticIndex = {}) {
     ...relations.filter((relation) => semanticPredicateMatches(relation?.predicate, ['controlflow', 'cfg', 'flow'])),
     ...facts.filter((fact) => semanticPredicateMatches(fact?.predicate, ['controlflow', 'cfg', 'flow']))
   ];
+  const effectRecords = facts.filter((fact) => semanticPredicateMatches(fact?.predicate, ['effect', 'mutation', 'sideeffect']));
   return {
     declarations: occurrences.filter((occurrence) => occurrence?.role === 'definition' || occurrence?.role === 'declaration').length,
     references: occurrences.filter((occurrence) => {
@@ -18,6 +19,7 @@ export function observeNativeImporterSemanticEvidence(semanticIndex = {}) {
       return role && role !== 'definition' && role !== 'declaration';
     }).length + referenceRelations.length,
     types: typeFacts.length + typedSymbols.length,
-    controlFlow: controlFlowRecords.length
+    controlFlow: controlFlowRecords.length,
+    effects: effectRecords.length
   };
 }

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/lightweight-dependency-relations.js

@@ -24,7 +24,10 @@ export function lightweightDependencyRelations(input, declarations, documentId)
     summary: {
       total: records.relations.length,
       calls: records.relations.filter((relation) => relation.predicate === 'calls').length,
-      uses: records.relations.filter((relation) => relation.predicate === 'uses').length
+      uses: records.relations.filter((relation) => relation.predicate === 'uses').length,
+      controlFlow: records.facts.filter((fact) => fact.predicate === 'controlFlow').length,
+      effects: records.facts.filter((fact) => fact.predicate === 'effect').length,
+      mutations: records.facts.filter((fact) => fact.predicate === 'mutation').length
     }
   };
 }
@@ -67,6 +70,7 @@ function scanDeclarationDependencies(input, documentId, scan, identifiers, lines
   const state = { inBlockComment: false };
   for (let lineNumber = scan.startLine; lineNumber <= scan.endLine; lineNumber += 1) {
     const scanLine = maskDependencyLine(input, lines[lineNumber - 1]?.line ?? '', state);
+    addLightweightSemanticFacts(input, documentId, scan.declaration, scanLine, lineNumber, records);
     for (const match of scanLine.matchAll(/[A-Za-z_$][\w$]*/g)) {
       const name = match[0];
       if (!isDependencyIdentifier(name) || !identifiers.has(name)) continue;
@@ -83,6 +87,68 @@ function scanDeclarationDependencies(input, documentId, scan, identifiers, lines
   }
 }
 
+function addLightweightSemanticFacts(input, documentId, declaration, line, lineNumber, records) {
+  const text = String(line ?? '').trim();
+  if (!text) return;
+  for (const item of lightweightControlFlowKinds(text)) {
+    addFactRecord(input, documentId, declaration, 'controlFlow', item, lineNumber, records);
+  }
+  for (const item of lightweightEffectKinds(text)) {
+    addFactRecord(input, documentId, declaration, 'effect', item, lineNumber, records);
+  }
+  for (const item of lightweightMutationKinds(text)) {
+    addFactRecord(input, documentId, declaration, 'mutation', item, lineNumber, records);
+  }
+}
+
+function lightweightControlFlowKinds(line) {
+  const kinds = [];
+  if (/\b(if|else|switch|case|default)\b/.test(line)) kinds.push('branch');
+  if (/\b(for|while|do)\b/.test(line)) kinds.push('loop');
+  if (/\b(return|yield)\b/.test(line)) kinds.push('exit');
+  if (/\b(throw|catch|finally|try)\b/.test(line)) kinds.push('exception');
+  if (/\b(await|async)\b/.test(line)) kinds.push('async');
+  return kinds;
+}
+
+function lightweightEffectKinds(line) {
+  const kinds = [];
+  if (/\bawait\b|import\s*\(/.test(line)) kinds.push('async');
+  if (/\b(fetch|XMLHttpRequest|WebSocket|EventSource)\s*\(/.test(line)) kinds.push('network');
+  if (/\b(localStorage|sessionStorage|indexedDB|caches|cookie)\b/.test(line)) kinds.push('storage');
+  if (/\b(setTimeout|setInterval|requestAnimationFrame|queueMicrotask)\s*\(/.test(line)) kinds.push('scheduler');
+  if (/\b(console|process|Deno|Bun)\s*\./.test(line)) kinds.push('host');
+  if (/\b(document|window|navigator|location|history)\s*\./.test(line)) kinds.push('browser');
+  return kinds;
+}
+
+function lightweightMutationKinds(line) {
+  const kinds = [];
+  if (/\bdelete\s+[A-Za-z_$][\w$.[\]]*/.test(line)) kinds.push('delete');
+  if (/(?:^|[^=!<>])=(?!=|>)/.test(line)) kinds.push('assignment');
+  if (/\+\+|--|(?:\+=|-=|\*=|\/=|%=|\|\|=|&&=|\?\?=)/.test(line)) kinds.push('update');
+  if (/\.(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\s*\(/.test(line)) kinds.push('mutating-call');
+  return kinds;
+}
+
+function addFactRecord(input, documentId, declaration, predicate, factKind, lineNumber, records) {
+  const key = `${declaration.symbolId}|${predicate}|${factKind}|${lineNumber}`;
+  if (records.seen.has(key)) return;
+  records.seen.add(key);
+  records.facts.push({
+    id: `fact_${idFragment(declaration.symbolId)}_${predicate}_${idFragment(factKind)}_${lineNumber}`,
+    predicate,
+    subjectId: declaration.symbolId,
+    value: {
+      kind: factKind,
+      line: lineNumber,
+      sourcePath: input.sourcePath,
+      documentId,
+      confidence: 'lexical-source-scan'
+    }
+  });
+}
+
 function addDependencyRecord(input, documentId, caller, target, occurrence, records) {
   const predicate = isCallReference(occurrence.line, occurrence.startColumn + occurrence.name.length - 1) ? 'calls' : 'uses';
   const key = `${caller.symbolId}|${predicate}|${target.symbolId}|${occurrence.lineNumber}|${occurrence.startColumn}`;

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/dist/semantic-import-sidecar-entry.js

@@ -11,6 +11,7 @@ import {
 function semanticImportSidecarEntry(imported, index, options) {
   const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
   const nativeAst = imported?.nativeAst ?? imported?.nativeSource?.ast;
+  const semanticFacts = semanticIndex?.facts ?? [];
   const sourceMaps = imported?.sourceMaps ?? imported?.universalAst?.sourceMaps ?? [];
   const sourceMapMappings = sourceMaps.flatMap((sourceMap) => sourceMap?.mappings ?? []);
   const sourcePreservationRecords = collectKernelSourcePreservationFromImport(imported);
@@ -18,6 +19,7 @@ function semanticImportSidecarEntry(imported, index, options) {
   const proofSpec = summarizeProofSpecLayer(imported?.universalAst?.proof ?? imported?.proof);
   const paradigmSemantics = summarizeParadigmSemanticsLayer(imported?.universalAst?.paradigmSemantics ?? imported?.paradigmSemantics);
   const dependencies = summarizeSemanticImportDependencyRelations(semanticIndex?.relations ?? []);
+  const factSummary = summarizeSemanticFacts(semanticFacts);
   const readiness = semanticImportEntryReadiness(imported);
   const mappingsBySymbolId = new Map();
   for (const mapping of sourceMapMappings) {
@@ -72,6 +74,9 @@ function semanticImportSidecarEntry(imported, index, options) {
     paradigmSemantics,
     dependencyRelationCount: dependencies.total,
     dependencyPredicates: dependencies.predicates,
+    semanticFactCount: semanticFacts.length,
+    semanticFactPredicates: factSummary.predicates,
+    semanticFactSummary: factSummary.byPredicate,
     readiness,
     emptySemanticIndex: symbols.length === 0,
     regionTaxonomy,
@@ -90,4 +95,14 @@ function semanticImportEntryReadiness(imported) {
   return readiness ?? 'needs-review';
 }
 
+function summarizeSemanticFacts(facts) {
+  const byPredicate = {};
+  for (const fact of facts ?? []) {
+    const predicate = String(fact?.predicate ?? '').trim();
+    if (!predicate) continue;
+    byPredicate[predicate] = (byPredicate[predicate] ?? 0) + 1;
+  }
+  return { byPredicate, predicates: Object.keys(byPredicate).sort() };
+}
+
 export { semanticImportSidecarEntry };

package/package.json

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