@shapeshift-labs/frontier-lang-compiler 0.2.60 → 0.2.62

package/README.md

@@ -272,6 +272,7 @@ const sidecar = createSemanticImportSidecar(imported);
 console.log(sidecar.summary.emptySemanticIndex); // false when symbols were found
 console.log(sidecar.ownershipRegions[0].key); // source#src/runtime.ts#type#Runtime
 console.log(sidecar.patchHints[0].supportedOperations); // source-region patch operations
+console.log(sidecar.semanticImpact.records[0].verificationPlan); // dependency/source-map/proof checks for a region
 console.log(sidecar.proofSpec.obligations); // proof/spec obligations when the import carries a universal AST proof layer
 console.log(sidecar.paradigmSemantics.hasLowering); // true when source import preserved lowering/paradigm records
 ```

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

@@ -0,0 +1,55 @@
+import type { SemanticMergeReadiness, SourceSpan } from '@shapeshift-labs/frontier-lang-kernel';
+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 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 SemanticImportImpactRecord {
+  readonly id: string;
+  readonly kind: 'ownership-region-impact' | string;
+  readonly ownershipRegionId: string;
+  readonly ownershipKey: string;
+  readonly regionKind?: NativeImportRegionTaxonomyKind;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly symbolIds: readonly string[];
+  readonly symbolNames: readonly string[];
+  readonly dependencyRelationIds: readonly string[];
+  readonly dependencyPredicates: readonly string[];
+  readonly affectedSymbolIds: readonly string[];
+  readonly sourceMapMappingIds: readonly string[];
+  readonly sourcePreservationRecordIds: readonly string[];
+  readonly patchHintIds: readonly string[];
+  readonly proofSpecIds: readonly string[];
+  readonly proofObligationIds: readonly string[];
+  readonly failedProofObligationIds: readonly string[];
+  readonly openProofObligationIds: readonly string[];
+  readonly paradigmSemanticIds: readonly string[];
+  readonly loweringRecordIds: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly verificationPlan: readonly SemanticImportImpactVerificationStep[];
+  readonly conflictKeys: readonly string[];
+  readonly readiness: SemanticMergeReadiness;
+  readonly risk: SemanticImportImpactRisk;
+  readonly confidence: SemanticImportImpactConfidence;
+}
+
+export interface SemanticImportImpactSummary {
+  readonly kind: 'frontier.lang.semanticImpact';
+  readonly version: 1;
+  readonly records: readonly SemanticImportImpactRecord[];
+  readonly summary: {
+    readonly total: number; readonly byRisk: Readonly<Record<string, number>>; readonly byReadiness: Readonly<Record<string, number>>;
+    readonly conflictKeys: readonly string[]; readonly dependencyRelations: number; readonly affectedSymbols: number;
+    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;
+  };
+}

package/dist/declarations/semantic-sidecar-admission.d.ts

@@ -14,6 +14,7 @@ export interface SemanticImportSidecarProofAdmissionSummary {
   readonly discharged: number;
   readonly pending?: number;
   readonly failed: number;
+  readonly stale?: number;
   readonly assumed?: number;
   readonly externalToolRequired?: number;
   readonly open: number;

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

@@ -26,6 +26,7 @@ import type {
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { SemanticImportSidecarAdmission, SemanticImportSidecarQuality } from './semantic-sidecar-admission.js';
 import type { SemanticMergeConflictClass, SemanticMergeConflictSummary } from './semantic-merge-conflicts.js';
+import type { SemanticImportImpactSummary } from './semantic-impact.js';
 import type { Diagnostic } from '@shapeshift-labs/frontier-lang-checker';
 import type { EmitTypeScriptOptions, TypeScriptAstModule, TypeScriptDocumentSourceMapResult, TypeScriptGeneratedSourceMapResult } from '@shapeshift-labs/frontier-lang-typescript';
 import type { EmitJavaScriptOptions, EmitJavaScriptWithSourceMapResult, JavaScriptAstModule, JavaScriptSourceMapResult } from '@shapeshift-labs/frontier-lang-javascript';
@@ -263,7 +264,7 @@ export interface SemanticImportSidecar {
   readonly universalAstLayers: SemanticImportSidecarUniversalAstLayerSummary;
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
-  readonly dependencies: SemanticImportDependencySummary;
+  readonly dependencies: SemanticImportDependencySummary; readonly semanticImpact: SemanticImportImpactSummary;
   readonly patchHints: readonly SemanticImportPatchHint[];
   readonly quality: SemanticImportSidecarQuality;
   readonly admission: SemanticImportSidecarAdmission;
@@ -302,6 +303,7 @@ export interface SemanticImportSidecar {
     readonly paradigmSemanticsGroups: number;
     readonly paradigmSemanticsLoweringRecords: number;
     readonly dependencyRelations: number; readonly dependencyPredicates: readonly string[];
+    readonly semanticImpactRecords: number; readonly semanticImpactHighRiskRecords: number; readonly semanticImpactRequiredVerificationSteps: number;
     readonly patchHints: number;
     readonly evidenceWarnings: number;
     readonly semanticImportExpected: boolean; readonly semanticImportExpectedSatisfied: boolean; readonly semanticImportExpectedMissingReasonCodes: readonly string[];
@@ -310,10 +312,4 @@ export interface SemanticImportSidecar {
   readonly metadata?: Record<string, unknown>;
 }
 
-export interface SemanticImportSidecarOptions {
-  readonly id?: string;
-  readonly generatedAt?: number;
-  readonly regionPrefix?: string;
-  readonly targetPath?: string; readonly expected?: boolean; readonly semanticImportExpected?: boolean;
-  readonly metadata?: Record<string, unknown>;
-}
+export interface SemanticImportSidecarOptions { readonly id?: string; readonly generatedAt?: number; readonly regionPrefix?: string; readonly targetPath?: string; readonly expected?: boolean; readonly semanticImportExpected?: boolean; readonly metadata?: Record<string, unknown>; }

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export * from './declarations/semantic-sidecar-admission.js';
 export * from './declarations/semantic-merge-conflicts.js';
 export * from './declarations/semantic-history.js';
 export * from './declarations/semantic-patch-bundle.js';
+export * from './declarations/semantic-impact.js';
 export * from './declarations/semantic-sidecar.js';
 export * from './declarations/native-diff.js';
 export * from './declarations/semantic-slice.js';

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

@@ -1,4 +1,4 @@
-import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportDependencies}from'../../semantic-import-dependencies.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
+import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportDependencies}from'../../semantic-import-dependencies.js';import{createSemanticImportImpact}from'../../semantic-import-impact.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
 import{createSemanticImportSidecarAdmission,createSemanticImportSidecarQuality}from'./createSemanticImportSidecarAdmission.js';
 import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
 export function createSemanticImportSidecar(importResult, options = {}) {
@@ -38,6 +38,22 @@ export function createSemanticImportSidecar(importResult, options = {}) {
     readiness
   });
   const admission = createSemanticImportSidecarAdmission(quality, readiness);
+  const semanticImpact = createSemanticImportImpact({
+    imports,
+    symbols,
+    ownershipRegions,
+    sourceMapMappings,
+    sourcePreservation,
+    dependencies,
+    patchHints,
+    proofSpec,
+    evidence: {
+      total: evidence.length,
+      failed: evidence.filter((record) => record.status === 'failed').map((record) => record.id),
+      ids: evidence.map((record) => record.id)
+    },
+    readiness
+  });
   return {
     kind: 'frontier.lang.semanticImportSidecar',
     version: 1,
@@ -58,6 +74,7 @@ export function createSemanticImportSidecar(importResult, options = {}) {
     proofSpec,
     paradigmSemantics,
     dependencies,
+    semanticImpact,
     patchHints,
     quality,
     admission,
@@ -101,6 +118,9 @@ export function createSemanticImportSidecar(importResult, options = {}) {
       paradigmSemanticsLoweringRecords: paradigmSemantics.loweringRecords,
       dependencyRelations: dependencies.total,
       dependencyPredicates: dependencies.predicates,
+      semanticImpactRecords: semanticImpact.summary.total,
+      semanticImpactHighRiskRecords: semanticImpact.summary.byRisk.high ?? 0,
+      semanticImpactRequiredVerificationSteps: semanticImpact.summary.requiredVerificationSteps,
       patchHints: patchHints.length,
       evidenceWarnings: quality.emptyEvidenceWarnings.length,
       semanticImportExpected: quality.expected,

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

@@ -72,6 +72,18 @@ export function createSemanticImportSidecarQuality(input) {
     'review-pending-proof-obligations',
     sourcePaths
   ));
+  if ((proofSpec.byReadinessStatus?.open ?? 0) > 0) warnings.push(sidecarQualityWarning(
+    'open-proof-obligations',
+    'Semantic sidecar has open proof obligations.',
+    'review-open-proof-obligations',
+    sourcePaths
+  ));
+  if (proofSpec.stale > 0) warnings.push(sidecarQualityWarning(
+    'stale-proof-obligations',
+    'Semantic sidecar has stale proof obligations.',
+    'rerun-stale-proof-obligations',
+    sourcePaths
+  ));
   if (proofSpec.assumed > 0) warnings.push(sidecarQualityWarning(
     'assumed-proof-obligations',
     'Semantic sidecar has assumed proof obligations.',
@@ -120,6 +132,7 @@ export function createSemanticImportSidecarQuality(input) {
     discharged: proofSpec.discharged,
     pending: proofSpec.pending,
     failed: proofSpec.failed,
+    stale: proofSpec.stale,
     assumed: proofSpec.assumed,
     externalToolRequired: proofSpec.externalToolRequired,
     open: proofSpec.open,
@@ -186,6 +199,6 @@ function sidecarAdmissionAction(quality, readiness) {
 }
 
 function sidecarProofReviewObligations(proofSummary) {
-  return (proofSummary.pending ?? 0) + (proofSummary.assumed ?? 0) +
+  return (proofSummary.open ?? 0) + (proofSummary.stale ?? 0) + (proofSummary.assumed ?? 0) +
     (proofSummary.externalToolRequired ?? 0) + (proofSummary.unknown ?? 0);
 }

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

@@ -38,8 +38,8 @@ function scanJavaScriptLike(input) {
       declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, declarationLine.includes('{')));
     } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*\(([^)]*)\)/))) {
       declarations.push(nativeDeclaration(input, number, 'ExportDefaultFunctionDeclaration', 'function', match[1] ?? 'default', { parameters: splitParameters(match[2]), exportDefault: true }, trimmed.includes('{')));
-    } else if ((match = declarationLine.match(/^(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/))) {
-      declarations.push(nativeDeclaration(input, number, 'ClassDeclaration', 'class', match[1], {}, declarationLine.includes('{')));
+    } else if ((match = declarationLine.match(/^(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/))) {
+      declarations.push(nativeDeclaration(input, number, declarationLine.startsWith('default ') ? 'ExportDefaultClassDeclaration' : 'ClassDeclaration', 'class', match[1], { exportDefault: declarationLine.startsWith('default ') || undefined }, declarationLine.includes('{')));
       if (declarationLine.includes('{') && !declarationLine.includes('}')) {
         currentClass = match[1];
         classDepth = 0;
@@ -196,6 +196,7 @@ function jsInitializerKind(line) {
   const initializer = String(line ?? '').split('=').slice(1).join('=').trim();
   if (!initializer) return 'unknown';
   if (/^(?:async\s+)?function\b/.test(initializer) || /=>/.test(initializer)) return 'function';
+  if (/^(?:React\.)?(?:forwardRef|memo|lazy|observer)\s*(?:<[^>]+>)?\s*\(/.test(initializer)) return 'function';
   if (initializer.startsWith('{')) return 'object';
   if (initializer.startsWith('[')) return 'array';
   if (/^new\s+/.test(initializer)) return 'instance';

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

@@ -0,0 +1,67 @@
+import type { SemanticMergeReadiness, SourceSpan } from '@shapeshift-labs/frontier-lang-kernel';
+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 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 SemanticImportImpactRecord {
+  readonly id: string;
+  readonly kind: 'ownership-region-impact' | string;
+  readonly ownershipRegionId: string;
+  readonly ownershipKey: string;
+  readonly regionKind?: NativeImportRegionTaxonomyKind;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly symbolIds: readonly string[];
+  readonly symbolNames: readonly string[];
+  readonly dependencyRelationIds: readonly string[];
+  readonly dependencyPredicates: readonly string[];
+  readonly affectedSymbolIds: readonly string[];
+  readonly sourceMapMappingIds: readonly string[];
+  readonly sourcePreservationRecordIds: readonly string[];
+  readonly patchHintIds: readonly string[];
+  readonly proofSpecIds: readonly string[];
+  readonly proofObligationIds: readonly string[];
+  readonly failedProofObligationIds: readonly string[];
+  readonly openProofObligationIds: readonly string[];
+  readonly paradigmSemanticIds: readonly string[];
+  readonly loweringRecordIds: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly verificationPlan: readonly SemanticImportImpactVerificationStep[];
+  readonly conflictKeys: readonly string[];
+  readonly readiness: SemanticMergeReadiness;
+  readonly risk: SemanticImportImpactRisk;
+  readonly confidence: SemanticImportImpactConfidence;
+}
+
+export interface SemanticImportImpactSummary {
+  readonly kind: 'frontier.lang.semanticImpact';
+  readonly version: 1;
+  readonly records: readonly SemanticImportImpactRecord[];
+  readonly summary: {
+    readonly total: number;
+    readonly byRisk: Readonly<Record<string, number>>;
+    readonly byReadiness: Readonly<Record<string, number>>;
+    readonly conflictKeys: readonly string[];
+    readonly dependencyRelations: number;
+    readonly affectedSymbols: number;
+    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;
+  };
+}

package/dist/semantic-import-impact.js

@@ -0,0 +1,317 @@
+import { countBy, idFragment, maxSemanticMergeReadiness, uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
+import { semanticDependencyPredicateKey } from './semantic-import-dependencies.js';
+
+function createSemanticImportImpact(input) {
+  const relations = collectDependencyRelations(input.imports, input.dependencies);
+  const proofRecords = collectProofRecords(input.imports);
+  const paradigmRecords = collectParadigmRecords(input.imports);
+  const symbolsByRegion = groupBy(input.symbols, (symbol) => symbol.ownershipRegionId);
+  const symbolIds = new Set((input.symbols ?? []).map((symbol) => symbol.id).filter(Boolean));
+  const records = [];
+  for (const region of input.ownershipRegions ?? []) {
+    const regionSymbols = symbolsForRegion(region, symbolsByRegion);
+    const record = semanticImpactRecord({
+      region,
+      regionSymbols,
+      relations: relations.filter((relation) => relationTouchesSymbols(relation, regionSymbols, symbolIds)),
+      sourceMapMappings: sourceMapMappingsForSymbols(input.sourceMapMappings, regionSymbols),
+      sourcePreservationRecords: preservationRecordsForSymbols(input.sourcePreservation?.records, regionSymbols),
+      proofRecords: proofRecordsForSymbols(proofRecords, regionSymbols, region),
+      paradigmRecords: paradigmRecordsForSymbols(paradigmRecords, regionSymbols, region),
+      patchHints: (input.patchHints ?? []).filter((hint) => hint.ownershipRegionId === region.id || hint.ownershipKey === region.key),
+      allSymbolIds: symbolIds,
+      evidence: input.evidence ?? { failed: [], ids: [] },
+      readiness: input.readiness
+    });
+    records.push(record);
+  }
+  return {
+    kind: 'frontier.lang.semanticImpact',
+    version: 1,
+    records,
+    summary: summarizeSemanticImpactRecords(records)
+  };
+}
+
+function semanticImpactRecord(input) {
+  const symbolIds = uniqueStrings(input.regionSymbols.map((symbol) => symbol.id).filter(Boolean));
+  const dependencyPredicates = uniqueStrings(input.relations.map((relation) => semanticDependencyPredicateKey(relation.predicate)));
+  const proof = summarizeProofImpact(input.proofRecords);
+  const paradigm = summarizeParadigmImpact(input.paradigmRecords);
+  const evidenceIds = relatedEvidenceIds(input);
+  const readiness = input.regionSymbols.reduce(
+    (current, symbol) => maxSemanticMergeReadiness(current, symbol.readiness),
+    input.readiness
+  );
+  const verificationPlan = semanticImpactVerificationPlan({
+    dependencyPredicates,
+    proof,
+    paradigm,
+    evidenceIds,
+    sourcePreservationRecords: input.sourcePreservationRecords,
+    patchHints: input.patchHints,
+    readiness
+  });
+  const risk = semanticImpactRisk({
+    readiness,
+    proof,
+    failedEvidenceIds: input.evidence.failed ?? [],
+    sourcePreservationRecords: input.sourcePreservationRecords,
+    relationCount: input.relations.length,
+    verificationPlan
+  });
+  return {
+    id: `impact_${idFragment(input.region.id ?? input.region.key)}`,
+    kind: 'ownership-region-impact',
+    ownershipRegionId: input.region.id,
+    ownershipKey: input.region.key,
+    regionKind: input.region.regionKind,
+    sourcePath: input.region.sourcePath,
+    sourceHash: input.region.sourceHash,
+    sourceSpan: input.region.sourceSpan,
+    symbolIds,
+    symbolNames: uniqueStrings(input.regionSymbols.map((symbol) => symbol.name).filter(Boolean)),
+    dependencyRelationIds: input.relations.map((relation) => relation.id).filter(Boolean),
+    dependencyPredicates,
+    affectedSymbolIds: affectedSymbolIds(input.relations, symbolIds, input.allSymbolIds),
+    sourceMapMappingIds: uniqueStrings([
+      ...input.sourceMapMappings.map((mapping) => mapping.id),
+      ...input.sourcePreservationRecords.map((record) => record.sourceMapMappingId)
+    ].filter(Boolean)),
+    sourcePreservationRecordIds: input.sourcePreservationRecords.map((record) => record.id).filter(Boolean),
+    patchHintIds: input.patchHints.map((hint) => hint.id).filter(Boolean),
+    proofSpecIds: proof.specIds,
+    proofObligationIds: proof.obligationIds,
+    failedProofObligationIds: proof.failedObligationIds,
+    openProofObligationIds: proof.openObligationIds,
+    paradigmSemanticIds: paradigm.semanticIds,
+    loweringRecordIds: paradigm.loweringIds,
+    evidenceIds,
+    verificationPlan,
+    conflictKeys: semanticImpactConflictKeys(input.region, symbolIds, input.relations, dependencyPredicates),
+    readiness,
+    risk,
+    confidence: semanticImpactConfidence(input.region, input.sourceMapMappings, input.sourcePreservationRecords)
+  };
+}
+
+function collectDependencyRelations(imports, dependencies) {
+  const dependencyIds = new Set(dependencies?.ids ?? []);
+  return uniqueRecordsById((imports ?? [])
+    .flatMap((imported) => imported?.semanticIndex?.relations ?? imported?.universalAst?.semanticIndex?.relations ?? [])
+    .filter((relation) => dependencyIds.has(relation?.id)));
+}
+
+function collectProofRecords(imports) {
+  const records = [];
+  for (const imported of imports ?? []) {
+    const proof = imported?.universalAst?.proof ?? imported?.proof;
+    if (!proof) continue;
+    const proofGroups = [
+      ['proof-record', proof.contracts, proof.refinements, proof.invariants, proof.termination, proof.temporal],
+      ['obligation', proof.obligations],
+      ['proof-record', proof.artifacts, proof.assumptions]
+    ];
+    for (const [proofRecordKind, ...groups] of proofGroups) for (const record of groups.flatMap((group) => group ?? [])) records.push({ ...record, proofSpecId: proof.id, proofRecordKind });
+  }
+  return records.filter(Boolean);
+}
+
+const ParadigmImpactGroups = Object.freeze([
+  'bindingScopes', 'bindings', 'patterns', 'typeConstraints', 'evaluationModels',
+  'memoryLocations', 'effectRegions', 'controlRegions', 'logicPrograms',
+  'actorSystems', 'stackEffects', 'arrayShapes', 'numericKernels',
+  'dataflowNetworks', 'clockModels', 'objectModels', 'macroExpansions',
+  'reflectionBoundaries', 'loweringRecords'
+]);
+
+function collectParadigmRecords(imports) {
+  const records = [];
+  for (const imported of imports ?? []) {
+    const semantics = imported?.universalAst?.paradigmSemantics ?? imported?.paradigmSemantics;
+    if (!semantics) continue;
+    for (const group of ParadigmImpactGroups) {
+      for (const record of semantics[group] ?? []) records.push({ ...record, paradigmGroup: group, paradigmSpecId: semantics.id });
+    }
+  }
+  return records.filter(Boolean);
+}
+
+function proofRecordsForSymbols(proofRecords, symbols, region) {
+  const ids = new Set(symbols.map((symbol) => symbol.id).filter(Boolean));
+  const mappingIds = new Set(symbols.map((symbol) => symbol.sourceMapMappingId).filter(Boolean));
+  const nativeNodeIds = new Set(symbols.map((symbol) => symbol.nativeAstNodeId).filter(Boolean));
+  const regionIds = new Set([region.id, region.key].filter(Boolean));
+  return proofRecords.filter((record) => isImportWideProofRecord(record) || ids.has(record.subjectId) || ids.has(record.semanticSymbolId) || mappingIds.has(record.sourceMapMappingId) || nativeNodeIds.has(record.nativeAstNodeId) || regionIds.has(record.subjectId) || regionIds.has(record.ownershipRegionId));
+}
+
+function isImportWideProofRecord(record) {
+  const kind = String(record?.subjectKind ?? '').toLowerCase();
+  return (!record?.subjectId && !record?.semanticSymbolId && !record?.sourceMapMappingId && !record?.nativeAstNodeId && !record?.ownershipRegionId) || ['import', 'source', 'nativesource', 'document', 'proofspec'].includes(kind);
+}
+
+function paradigmRecordsForSymbols(records, symbols, region) {
+  const symbolIds = new Set(symbols.map((symbol) => symbol.id).filter(Boolean));
+  const mappingIds = new Set(symbols.map((symbol) => symbol.sourceMapMappingId).filter(Boolean));
+  const nativeNodeIds = new Set(symbols.map((symbol) => symbol.nativeAstNodeId).filter(Boolean));
+  const regionIds = new Set([region.id, region.key].filter(Boolean));
+  return records.filter((record) => symbolIds.has(record.semanticSymbolId)
+    || symbolIds.has(record.symbolId)
+    || symbolIds.has(record.subjectId)
+    || mappingIds.has(record.sourceMapMappingId)
+    || nativeNodeIds.has(record.nativeAstNodeId)
+    || regionIds.has(record.ownershipRegionId)
+    || regionIds.has(record.subjectId));
+}
+
+function summarizeProofImpact(records) {
+  const obligationRecords = records.filter((record) => record.proofRecordKind === 'obligation');
+  const failed = obligationRecords.filter((record) => proofReadinessStatus(record.status) === 'failed');
+  const open = obligationRecords.filter((record) => ['open', 'pending', 'unknown', 'stale', 'assumed', 'external-tool-required'].includes(proofReadinessStatus(record.status)));
+  return {
+    specIds: uniqueStrings(records.map((record) => record.proofSpecId).filter(Boolean)),
+    obligationIds: uniqueStrings(obligationRecords.map((record) => record.id).filter(Boolean)),
+    failedObligationIds: uniqueStrings(failed.map((record) => record.id).filter(Boolean)),
+    openObligationIds: uniqueStrings(open.map((record) => record.id).filter(Boolean)),
+    evidenceIds: uniqueStrings(records.flatMap((record) => record.evidenceIds ?? []).filter(Boolean))
+  };
+}
+
+function summarizeParadigmImpact(records) {
+  const lowering = records.filter((record) => record.paradigmGroup === 'loweringRecords');
+  const semantic = records.filter((record) => record.paradigmGroup !== 'loweringRecords');
+  return {
+    semanticIds: uniqueStrings(semantic.map((record) => record.id).filter(Boolean)),
+    loweringIds: uniqueStrings(lowering.map((record) => record.id).filter(Boolean)),
+    evidenceIds: uniqueStrings(records.flatMap((record) => record.evidenceIds ?? []).filter(Boolean)),
+    lossIds: uniqueStrings(records.flatMap((record) => record.lossIds ?? []).filter(Boolean))
+  };
+}
+
+function proofReadinessStatus(status) {
+  const value = String(status ?? 'unknown').trim().toLowerCase().replace(/[\s_]+/g, '-');
+  if (['accepted', 'checked', 'ok', 'passed', 'proved', 'qed', 'success', 'succeeded', 'valid', 'verified', 'discharged'].includes(value)) return 'discharged';
+  if (['counterexample', 'cex', 'error', 'failed', 'falsified', 'invalid', 'rejected', 'violated'].includes(value)) return 'failed';
+  if (['obsolete', 'outdated', 'stale'].includes(value)) return 'stale';
+  if (['admit', 'admitted', 'assume', 'assumed', 'axiom', 'trusted', 'unchecked'].includes(value)) return 'assumed';
+  if (['solver-required', 'prover-required', 'tool-required', 'external-tool-required'].includes(value)) return 'external-tool-required';
+  if (['pending', 'todo', 'unproved', 'unverified'].includes(value)) return 'pending';
+  if (value === 'open') return 'open';
+  return 'unknown';
+}
+
+function symbolsForRegion(region, symbolsByRegion) {
+  const symbols = [...(symbolsByRegion.get(region.id) ?? [])];
+  if (symbols.length === 0 && region.symbolId) {
+    symbols.push({ id: region.symbolId, name: region.symbolName, ownershipRegionId: region.id, readiness: 'needs-review' });
+  }
+  return symbols;
+}
+
+function relationTouchesSymbols(relation, symbols, allSymbolIds) {
+  const ids = new Set(symbols.map((symbol) => symbol.id).filter(Boolean));
+  if (ids.has(relation.sourceId) || ids.has(relation.targetId)) return true;
+  return allSymbolIds.has(relation.sourceId) && allSymbolIds.has(relation.targetId) && ids.size === 0;
+}
+
+function sourceMapMappingsForSymbols(mappings, symbols) {
+  const ids = new Set(symbols.map((symbol) => symbol.id).filter(Boolean));
+  const mappingIds = new Set(symbols.map((symbol) => symbol.sourceMapMappingId).filter(Boolean));
+  return uniqueRecordsById((mappings ?? []).filter((mapping) => ids.has(mapping.semanticSymbolId) || mappingIds.has(mapping.id)));
+}
+
+function preservationRecordsForSymbols(records, symbols) {
+  const ids = new Set(symbols.map((symbol) => symbol.id).filter(Boolean));
+  const mappingIds = new Set(symbols.map((symbol) => symbol.sourceMapMappingId).filter(Boolean));
+  return uniqueRecordsById((records ?? []).filter((record) => ids.has(record.semanticSymbolId) || mappingIds.has(record.sourceMapMappingId)));
+}
+
+function relatedEvidenceIds(input) {
+  return uniqueStrings([
+    ...input.proofRecords.flatMap((record) => record.evidenceIds ?? []),
+    ...input.paradigmRecords.flatMap((record) => record.evidenceIds ?? []),
+    ...input.sourcePreservationRecords.flatMap((record) => record.evidenceIds ?? []),
+    ...(input.evidence.failed ?? [])
+  ].filter(Boolean));
+}
+
+function semanticImpactVerificationPlan(input) {
+  const plan = [];
+  if (input.dependencyPredicates.length > 0) plan.push({ kind: 'dependency-review', reason: 'region touches semantic dependency relations', required: true });
+  if (input.sourcePreservationRecords.some((record) => record.level === 'estimated' || record.level === 'blocked')) plan.push({ kind: 'source-map-review', reason: 'source preservation is not exact', required: true });
+  if (input.proof.failedObligationIds.length > 0) plan.push({ kind: 'reject-or-reprove', reason: 'failed proof obligations are linked', required: true });
+  else if (input.proof.openObligationIds.length > 0) plan.push({ kind: 'proof-review', reason: 'open proof obligations are linked', required: true });
+  if (input.paradigm.loweringIds.length > 0) plan.push({ kind: 'semantic-lowering-review', reason: 'lowering records are linked to this region', required: input.readiness !== 'ready' });
+  if (input.patchHints.length > 0) plan.push({ kind: 'patch-admission', reason: 'patch hints exist for this region', required: input.readiness !== 'ready' });
+  if (input.evidenceIds.length === 0) plan.push({ kind: 'evidence-review', reason: 'no region-specific evidence ids were linked', required: input.readiness !== 'ready' });
+  return plan;
+}
+
+function semanticImpactRisk(input) {
+  if (input.readiness === 'blocked' || input.proof.failedObligationIds.length > 0 || input.sourcePreservationRecords.some((record) => record.level === 'blocked')) return 'high';
+  if (input.failedEvidenceIds.length > 0 || input.proof.openObligationIds.length > 0) return 'high';
+  if (input.relationCount > 0 || input.verificationPlan.some((step) => step.required)) return 'medium';
+  if (input.sourcePreservationRecords.some((record) => record.level === 'estimated')) return 'medium';
+  return 'low';
+}
+
+function semanticImpactConflictKeys(region, symbolIds, relations, predicates) {
+  return uniqueStrings([
+    region.id ? `region:${region.id}` : undefined,
+    region.key ? `ownership:${region.key}` : undefined,
+    region.sourcePath ? `source:${region.sourcePath}` : undefined,
+    ...symbolIds.map((id) => `symbol:${id}`),
+    ...relations.map((relation) => `dependency:${relation.sourceId}:${semanticDependencyPredicateKey(relation.predicate)}:${relation.targetId}`),
+    ...predicates.map((predicate) => `predicate:${predicate}`)
+  ].filter(Boolean));
+}
+
+function semanticImpactConfidence(region, mappings, sourcePreservationRecords) {
+  if (sourcePreservationRecords.some((record) => record.level === 'exact')) return 'source-exact';
+  if ((mappings ?? []).length > 0 || region.precision === 'declaration') return 'source-addressed';
+  if (region.precision === 'line' || region.precision === 'estimated') return 'estimated-source-region';
+  return 'review-required';
+}
+
+function affectedSymbolIds(relations, ownSymbolIds, allSymbolIds) {
+  const own = new Set(ownSymbolIds);
+  return uniqueStrings(relations
+    .flatMap((relation) => [relation.sourceId, relation.targetId])
+    .filter((id) => id && allSymbolIds.has(id) && !own.has(id)));
+}
+
+function summarizeSemanticImpactRecords(records) {
+  const verificationPlans = records.flatMap((record) => record.verificationPlan.map((step) => step.kind));
+  return {
+    total: records.length,
+    byRisk: countBy(records.map((record) => record.risk)),
+    byReadiness: countBy(records.map((record) => record.readiness)),
+    conflictKeys: uniqueStrings(records.flatMap((record) => record.conflictKeys)),
+    dependencyRelations: uniqueStrings(records.flatMap((record) => record.dependencyRelationIds)).length,
+    affectedSymbols: uniqueStrings(records.flatMap((record) => record.affectedSymbolIds)).length,
+    sourceMapMappings: uniqueStrings(records.flatMap((record) => record.sourceMapMappingIds)).length,
+    sourcePreservationRecords: uniqueStrings(records.flatMap((record) => record.sourcePreservationRecordIds)).length,
+    patchHints: uniqueStrings(records.flatMap((record) => record.patchHintIds)).length,
+    proofObligations: uniqueStrings(records.flatMap((record) => record.proofObligationIds)).length,
+    openProofObligations: uniqueStrings(records.flatMap((record) => record.openProofObligationIds)).length,
+    failedProofObligations: uniqueStrings(records.flatMap((record) => record.failedProofObligationIds)).length,
+    paradigmSemantics: uniqueStrings(records.flatMap((record) => record.paradigmSemanticIds)).length,
+    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
+  };
+}
+
+function groupBy(values, keyFn) {
+  const grouped = new Map();
+  for (const value of values ?? []) {
+    const key = keyFn(value);
+    if (!key) continue;
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key).push(value);
+  }
+  return grouped;
+}
+
+export { createSemanticImportImpact, summarizeSemanticImpactRecords };

package/dist/semantic-import-sidecar-admission-types.d.ts

@@ -14,6 +14,7 @@ export interface SemanticImportSidecarProofAdmissionSummary {
   readonly discharged: number;
   readonly pending?: number;
   readonly failed: number;
+  readonly stale?: number;
   readonly assumed?: number;
   readonly externalToolRequired?: number;
   readonly open: number;
@@ -24,6 +25,9 @@ export interface SemanticImportSidecarProofAdmissionSummary {
 
 export interface SemanticImportSidecarQuality {
   readonly schema: 'frontier.lang.semanticSidecarQuality.v1';
+  readonly expected: boolean;
+  readonly expectedSatisfied: boolean;
+  readonly expectedMissingReasonCodes: readonly string[];
   readonly selected: boolean;
   readonly eligible: boolean;
   readonly imported: boolean;
@@ -40,6 +44,9 @@ export interface SemanticImportSidecarQuality {
 
 export interface SemanticImportSidecarAdmission {
   readonly schema: 'frontier.lang.semanticSidecarAdmission.v1';
+  readonly expected: boolean;
+  readonly expectedSatisfied: boolean;
+  readonly expectedMissingReasonCodes: readonly string[];
   readonly selected: boolean;
   readonly eligible: boolean;
   readonly imported: boolean;

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

@@ -6,6 +6,7 @@ import type {
   SourceSpan
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { NativeImportRegionTaxonomyKind, NativeImportTaxonomyKind } from './index.js';
+import type { SemanticImportImpactSummary } from './semantic-import-impact-types.js';
 import type { SemanticImportSidecarAdmission, SemanticImportSidecarQuality } from './semantic-import-sidecar-admission-types.js';
 import type { SemanticMergeConflictClass, SemanticMergeConflictSummary } from './declarations/semantic-merge-conflicts.js';
 
@@ -237,6 +238,7 @@ export interface SemanticImportSidecar {
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
   readonly dependencies: SemanticImportDependencySummary;
+  readonly semanticImpact: SemanticImportImpactSummary;
   readonly patchHints: readonly SemanticImportPatchHint[];
   readonly quality: SemanticImportSidecarQuality;
   readonly admission: SemanticImportSidecarAdmission;
@@ -280,6 +282,9 @@ export interface SemanticImportSidecar {
     readonly paradigmSemanticsLoweringRecords: number;
     readonly dependencyRelations: number;
     readonly dependencyPredicates: readonly string[];
+    readonly semanticImpactRecords: number;
+    readonly semanticImpactHighRiskRecords: number;
+    readonly semanticImpactRequiredVerificationSteps: number;
     readonly patchHints: number;
     readonly evidenceWarnings: number;
     readonly readiness: SemanticMergeReadiness;
@@ -293,5 +298,7 @@ export interface SemanticImportSidecarOptions {
   readonly generatedAt?: number;
   readonly regionPrefix?: string;
   readonly targetPath?: string;
+  readonly expected?: boolean;
+  readonly semanticImportExpected?: boolean;
   readonly metadata?: Record<string, unknown>;
 }

package/package.json

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