@shapeshift-labs/frontier-lang-compiler 0.2.69 → 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/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/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.69",
+  "version": "0.2.70",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",