@shapeshift-labs/frontier-lang-compiler 0.2.59 → 0.2.61

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

@@ -109,6 +109,18 @@ export function createLightweightNativeImport(input) {
   occurrences.push(...dependencies.occurrences);
   relations.push(...dependencies.relations);
   facts.push(...dependencies.facts);
+  for (const occurrence of dependencies.occurrences) {
+    mappings.push({
+      id: `map_${idFragment(occurrence.id)}`,
+      nativeAstNodeId: occurrence.nativeAstNodeId,
+      semanticSymbolId: occurrence.symbolId,
+      semanticOccurrenceId: occurrence.id,
+      sourceSpan: occurrence.span,
+      evidenceIds: [evidenceId],
+      lossIds: [],
+      precision: 'line'
+    });
+  }
   losses.push(...lightweightCoverageLosses(input, declarations, input.sourcePreservation));
 
   const semanticIndex = createSemanticIndexRecord({

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

@@ -48,7 +48,7 @@ export function createLightweightSemanticLayers(input) {
     })),
     evaluationModels: [evaluationModel(input, evidenceIds)],
     effectRegions: effectRegions(input, evidenceIds),
-    loweringRecords: mappings.slice(0, 40).map((mapping) => ({
+    loweringRecords: mappings.map((mapping) => ({
       id: `lowering_${mapping.id}`,
       kind: 'nativeSourceToFrontierSemanticIndex',
       sourceMapId: mapping.sourceMapId,

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

@@ -0,0 +1,223 @@
+const ignoredIdentifiers = new Set([
+  'abstract', 'alias', 'and', 'as', 'async', 'await', 'break', 'case', 'catch',
+  'class', 'const', 'continue', 'def', 'default', 'defer', 'delete', 'do',
+  'else', 'enum', 'export', 'extends', 'false', 'finally', 'fn', 'for', 'from',
+  'func', 'function', 'if', 'impl', 'import', 'in', 'interface', 'let', 'match',
+  'mod', 'module', 'namespace', 'new', 'nil', 'none', 'not', 'null', 'or',
+  'package', 'pass', 'protocol', 'pub', 'public', 'return', 'self', 'static',
+  'struct', 'super', 'switch', 'this', 'throw', 'trait', 'true', 'try', 'type',
+  'undefined', 'use', 'using', 'var', 'void', 'while', 'with', 'yield'
+]);
+
+export function dependencyIdentifiers(input, declaration, line) {
+  const identifiers = new Set();
+  addIdentifier(identifiers, declaration.name);
+  for (const part of splitIdentifierPath(declaration.name)) addIdentifier(identifiers, part);
+  for (const field of ['methodName', 'propertyName', 'owner']) addIdentifier(identifiers, declaration.fields?.[field]);
+  if (declaration.role === 'import') {
+    for (const identifier of importLineIdentifiers(input, line)) addIdentifier(identifiers, identifier);
+    for (const identifier of importPathIdentifiers(declaration.importPath ?? declaration.name)) addIdentifier(identifiers, identifier);
+  }
+  return [...identifiers];
+}
+
+export function addIdentifier(set, value) {
+  if (isDependencyIdentifier(value)) set.add(String(value));
+}
+
+export function isDependencyIdentifier(value) {
+  const text = String(value ?? '');
+  return /^[A-Za-z_$][\w$]*$/.test(text) && !ignoredIdentifiers.has(text.toLowerCase());
+}
+
+export function dependencyScanRanges(input, declarations, lines) {
+  const ordered = [...(declarations ?? [])].sort((left, right) => (left.span?.startLine ?? 0) - (right.span?.startLine ?? 0));
+  return ordered
+    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import')
+    .map((declaration, index) => ({
+      declaration,
+      startLine: declaration.span?.startLine ?? 1,
+      endLine: dependencyScanEndLine(input, declaration, lines, ordered[index + 1]?.span?.startLine)
+    }));
+}
+
+export function maskDependencyLine(input, line, state) {
+  const language = String(input.language ?? '').toLowerCase();
+  const text = String(line ?? '');
+  let output = '';
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (state.inBlockComment) {
+      output += ' ';
+      if (char === '*' && next === '/') {
+        output += ' ';
+        index += 1;
+        state.inBlockComment = false;
+      }
+      continue;
+    }
+    if (quote) {
+      output += ' ';
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      output += '  ';
+      index += 1;
+      state.inBlockComment = true;
+      continue;
+    }
+    if (startsLineComment(language, char, next, text, index)) break;
+    if (char === '\'' || char === '"' || char === '`') {
+      output += ' ';
+      quote = char;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+export function emptyDependencySummary() {
+  return { total: 0, calls: 0, uses: 0 };
+}
+
+function importLineIdentifiers(input, line) {
+  const language = String(input.language ?? '').toLowerCase();
+  const source = String(line ?? '').trim();
+  if (language === 'python') return pythonImportIdentifiers(source);
+  if (language === 'rust') return rustImportIdentifiers(source);
+  if (language === 'go') return aliasedPathImportIdentifiers(source);
+  if (language === 'javascript' || language === 'typescript') return jsImportIdentifiers(source);
+  if (language === 'haskell') return haskellImportIdentifiers(source);
+  return aliasedPathImportIdentifiers(source);
+}
+
+function jsImportIdentifiers(source) {
+  const identifiers = [];
+  let match = source.match(/^import\s+([A-Za-z_$][\w$]*)\s+from\b/);
+  if (match) identifiers.push(match[1]);
+  match = source.match(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
+  if (match) identifiers.push(match[1]);
+  match = source.match(/^import\s+[^,{]+,\s*\{([^}]+)\}\s+from\b|^import\s+\{([^}]+)\}\s+from\b/);
+  if (match) identifiers.push(...namedImportIdentifiers(match[1] ?? match[2]));
+  return identifiers;
+}
+
+function pythonImportIdentifiers(source) {
+  const identifiers = [];
+  const importMatch = source.match(/^import\s+(.+)$/);
+  if (importMatch) identifiers.push(...commaParts(importMatch[1]).map((part) => part.split(/\s+as\s+/i).pop()));
+  const fromMatch = source.match(/^from\s+\S+\s+import\s+(.+)$/);
+  if (fromMatch) identifiers.push(...namedImportIdentifiers(fromMatch[1]));
+  return identifiers;
+}
+
+function rustImportIdentifiers(source) {
+  const match = source.match(/^use\s+(.+?);?$/);
+  if (!match) return [];
+  const raw = match[1].replace(/[{}]/g, ' ');
+  return raw.split(/::|,|\s+as\s+/i).map((part) => part.trim()).filter(Boolean);
+}
+
+function haskellImportIdentifiers(source) {
+  const match = source.match(/^import\s+(?:qualified\s+)?([A-Za-z_][\w.]*)(?:\s+as\s+([A-Za-z_]\w*))?/);
+  return match ? [match[2], ...splitIdentifierPath(match[1])].filter(Boolean) : [];
+}
+
+function aliasedPathImportIdentifiers(source) {
+  const alias = source.match(/^(?:import|using|use)\s+([A-Za-z_$][\w$]*)\s*=/)?.[1]
+    ?? source.match(/^(?:import|using|use)\s+([A-Za-z_$][\w$]*)\s+["']/)?.[1]
+    ?? source.match(/\bas\s+([A-Za-z_$][\w$]*)\b/)?.[1];
+  return alias ? [alias] : [];
+}
+
+function namedImportIdentifiers(raw) {
+  return commaParts(raw).map((part) => part.trim().split(/\s+as\s+/i).pop()?.trim()).filter(Boolean);
+}
+
+function importPathIdentifiers(value) {
+  return splitIdentifierPath(String(value ?? '').replace(/['";]/g, ''));
+}
+
+function splitIdentifierPath(value) {
+  return String(value ?? '').split(/[^A-Za-z0-9_$]+/).filter(isDependencyIdentifier);
+}
+
+function commaParts(raw) {
+  return String(raw ?? '').split(',').map((part) => part.trim()).filter(Boolean);
+}
+
+function dependencyScanEndLine(input, declaration, lines, nextStartLine) {
+  const startLine = declaration.span?.startLine ?? 1;
+  if (!declaration.metadata?.hasBody) return startLine;
+  if (usesIndentationBlocks(input)) {
+    return indentationRegionEndLine(lines, startLine);
+  }
+  const balancedEnd = balancedRegionEndLine(lines, startLine);
+  const fallbackEnd = nextStartLine ? nextStartLine - 1 : lines.length;
+  return Math.max(startLine, Math.min(balancedEnd > startLine ? balancedEnd : fallbackEnd, lines.length));
+}
+
+function usesIndentationBlocks(input) {
+  return ['python'].includes(String(input.language ?? '').toLowerCase());
+}
+
+function indentationRegionEndLine(lines, startLine) {
+  const header = lines[startLine - 1]?.line ?? '';
+  const baseIndent = indentationWidth(header);
+  let lastBodyLine = startLine;
+  let sawBodyLine = false;
+  for (let index = startLine; index < lines.length; index += 1) {
+    const line = lines[index]?.line ?? '';
+    if (!line.trim()) {
+      if (sawBodyLine) lastBodyLine = index + 1;
+      continue;
+    }
+    const indent = indentationWidth(line);
+    if (indent <= baseIndent) return Math.max(startLine, lastBodyLine);
+    sawBodyLine = true;
+    lastBodyLine = index + 1;
+  }
+  return lastBodyLine;
+}
+
+function indentationWidth(line) {
+  let width = 0;
+  for (const char of String(line ?? '')) {
+    if (char === ' ') width += 1;
+    else if (char === '\t') width += 4;
+    else break;
+  }
+  return width;
+}
+
+function balancedRegionEndLine(lines, startLine) {
+  const state = { inBlockComment: false };
+  let depth = 0;
+  let opened = false;
+  for (let index = Math.max(0, startLine - 1); index < lines.length; index += 1) {
+    for (const char of maskDependencyLine({ language: 'javascript' }, lines[index].line, state)) {
+      if (char === '{' || char === '[' || char === '(') {
+        depth += 1;
+        opened = true;
+      } else if (char === '}' || char === ']' || char === ')') {
+        depth -= 1;
+      }
+    }
+    if (opened && depth <= 0) return lines[index].number;
+  }
+  return startLine;
+}
+
+function startsLineComment(language, char, next, text, index) {
+  if (char === '/' && next === '/') return true;
+  if (char === '#' && !['csharp'].includes(language)) return true;
+  if (char === '-' && next === '-' && ['sql', 'haskell', 'lua'].includes(language)) return true;
+  return text.startsWith('rem ', index) && language === 'shell';
+}

package/dist/lightweight-dependency-relations.js

@@ -1,23 +1,20 @@
 import { idFragment } from './native-import-utils.js';
+import {
+  addIdentifier,
+  dependencyIdentifiers,
+  dependencyScanRanges,
+  emptyDependencySummary,
+  isDependencyIdentifier,
+  maskDependencyLine
+} from './lightweight-dependency-language.js';
 import { sourceLines } from './native-region-scanner-core.js';
 
-const jsLikeLanguages = new Set(['javascript', 'typescript']);
-const ignoredIdentifiers = new Set([
-  'async', 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'default',
-  'delete', 'do', 'else', 'export', 'extends', 'false', 'finally', 'for', 'from',
-  'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'null', 'of',
-  'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof',
-  'undefined', 'var', 'void', 'while', 'with', 'yield'
-]);
-
 export function lightweightDependencyRelations(input, declarations, documentId) {
-  if (!jsLikeLanguages.has(String(input.language ?? '').toLowerCase())) {
-    return { relations: [], occurrences: [], facts: [], summary: emptySummary() };
-  }
+  if (typeof input.sourceText !== 'string') return { relations: [], occurrences: [], facts: [], summary: emptyDependencySummary() };
   const lines = sourceLines(input.sourceText);
   const identifiers = declarationIdentifierMap(input, declarations, lines);
   const records = { relations: [], occurrences: [], facts: [], seen: new Set() };
-  for (const scan of declarationScanRanges(declarations, lines)) {
+  for (const scan of dependencyScanRanges(input, declarations, lines)) {
     scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records);
   }
   return {
@@ -52,101 +49,27 @@ function declarationIdentifierMap(input, declarations, lines) {
 
 function identifiersForDeclaration(input, declaration, lines) {
   const identifiers = new Set();
-  addIdentifier(identifiers, declaration.name);
-  const parts = String(declaration.name ?? '').split('.');
-  addIdentifier(identifiers, parts[parts.length - 1]);
-  if (declaration.role === 'import') {
-    const line = lines[(declaration.span?.startLine ?? 1) - 1]?.line ?? '';
-    for (const identifier of importLocalIdentifiers(line)) addIdentifier(identifiers, identifier);
-    addIdentifier(identifiers, packageIdentifier(declaration.importPath ?? declaration.name));
+  const line = lines[(declaration.span?.startLine ?? 1) - 1]?.line ?? '';
+  for (const identifier of dependencyIdentifiers(input, declaration, line)) {
+    addIdentifier(identifiers, identifier);
   }
   return [...identifiers];
 }
 
-function importLocalIdentifiers(line) {
-  const source = String(line ?? '');
-  const identifiers = [];
-  let match = source.match(/^import\s+([A-Za-z_$][\w$]*)\s+from\b/);
-  if (match) identifiers.push(match[1]);
-  match = source.match(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
-  if (match) identifiers.push(match[1]);
-  match = source.match(/^import\s+[^,{]+,\s*\{([^}]+)\}\s+from\b/);
-  if (match) identifiers.push(...namedImportIdentifiers(match[1]));
-  match = source.match(/^import\s+\{([^}]+)\}\s+from\b/);
-  if (match) identifiers.push(...namedImportIdentifiers(match[1]));
-  return identifiers;
-}
-
-function namedImportIdentifiers(raw) {
-  return String(raw ?? '')
-    .split(',')
-    .map((part) => part.trim().split(/\s+as\s+/i).pop()?.trim())
-    .filter(Boolean);
-}
-
-function packageIdentifier(value) {
-  const parts = String(value ?? '').split('/').filter(Boolean);
-  const last = parts[parts.length - 1] ?? value;
-  return String(last).replace(/[^A-Za-z0-9_$]/g, '');
-}
-
 function addIdentifierTarget(map, identifier, target) {
-  if (!isIdentifier(identifier)) return;
+  if (!isDependencyIdentifier(identifier)) return;
   const existing = map.get(identifier) ?? [];
   if (!existing.some((entry) => entry.symbolId === target.symbolId)) existing.push(target);
   map.set(identifier, existing);
 }
 
-function addIdentifier(set, value) {
-  if (isIdentifier(value)) set.add(value);
-}
-
-function isIdentifier(value) {
-  const text = String(value ?? '');
-  return /^[A-Za-z_$][\w$]*$/.test(text) && !ignoredIdentifiers.has(text);
-}
-
-function declarationScanRanges(declarations, lines) {
-  return (declarations ?? [])
-    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import')
-    .map((declaration) => ({
-      declaration,
-      startLine: declaration.span?.startLine ?? 1,
-      endLine: declarationScanEndLine(declaration, lines)
-    }));
-}
-
-function declarationScanEndLine(declaration, lines) {
-  const startLine = declaration.span?.startLine ?? 1;
-  if (!declaration.metadata?.hasBody || declaration.kind === 'ClassDeclaration') return startLine;
-  return balancedRegionEndLine(lines, startLine);
-}
-
-function balancedRegionEndLine(lines, startLine) {
-  const state = { inBlockComment: false, inTemplateString: false };
-  let depth = 0;
-  let opened = false;
-  for (let index = Math.max(0, startLine - 1); index < lines.length; index += 1) {
-    for (const char of maskReferenceLine(lines[index].line, state)) {
-      if (char === '{' || char === '[' || char === '(') {
-        depth += 1;
-        opened = true;
-      } else if (char === '}' || char === ']' || char === ')') {
-        depth -= 1;
-      }
-    }
-    if (opened && depth <= 0) return lines[index].number;
-  }
-  return startLine;
-}
-
 function scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records) {
-  const state = { inBlockComment: false, inTemplateString: false };
+  const state = { inBlockComment: false };
   for (let lineNumber = scan.startLine; lineNumber <= scan.endLine; lineNumber += 1) {
-    const scanLine = maskReferenceLine(lines[lineNumber - 1]?.line ?? '', state);
+    const scanLine = maskDependencyLine(input, lines[lineNumber - 1]?.line ?? '', state);
     for (const match of scanLine.matchAll(/[A-Za-z_$][\w$]*/g)) {
       const name = match[0];
-      if (ignoredIdentifiers.has(name) || !identifiers.has(name)) continue;
+      if (!isDependencyIdentifier(name) || !identifiers.has(name)) continue;
       const targets = identifiers.get(name).filter((target) => target.symbolId !== scan.declaration.symbolId);
       for (const target of targets) {
         addDependencyRecord(input, documentId, scan.declaration, target, {
@@ -197,7 +120,7 @@ function addDependencyRecord(input, documentId, caller, target, occurrence, reco
     nativeAstNodeId: caller.nodeId
   });
   records.facts.push({
-    id: `fact_${idFragment(relationId)}_lightweight_dependency`,
+    id: `fact_${idFragment(relationId)}_${records.facts.length + 1}_lightweight_dependency`,
     predicate: 'lightweightDependency',
     subjectId: caller.symbolId,
     value: {
@@ -213,59 +136,3 @@ function addDependencyRecord(input, documentId, caller, target, occurrence, reco
 function isCallReference(line, afterIdentifierIndex) {
   return /^\s*\(/.test(String(line ?? '').slice(afterIdentifierIndex));
 }
-
-function maskReferenceLine(line, state) {
-  const text = String(line ?? '');
-  let output = '';
-  let quote;
-  let escaped = false;
-  for (let index = 0; index < text.length; index += 1) {
-    const char = text[index];
-    const next = text[index + 1];
-    if (state.inBlockComment) {
-      output += ' ';
-      if (char === '*' && next === '/') {
-        output += ' ';
-        index += 1;
-        state.inBlockComment = false;
-      }
-      continue;
-    }
-    if (state.inTemplateString) {
-      output += ' ';
-      if (char === '`' && !escaped) state.inTemplateString = false;
-      escaped = char === '\\' && !escaped;
-      continue;
-    }
-    if (quote) {
-      output += ' ';
-      if (escaped) escaped = false;
-      else if (char === '\\') escaped = true;
-      else if (char === quote) quote = undefined;
-      continue;
-    }
-    if (char === '/' && next === '/') break;
-    if (char === '/' && next === '*') {
-      output += '  ';
-      index += 1;
-      state.inBlockComment = true;
-      continue;
-    }
-    if (char === '\'' || char === '"') {
-      output += ' ';
-      quote = char;
-      continue;
-    }
-    if (char === '`') {
-      output += ' ';
-      state.inTemplateString = true;
-      continue;
-    }
-    output += char;
-  }
-  return output;
-}
-
-function emptySummary() {
-  return { total: 0, calls: 0, uses: 0 };
-}

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/dist/semantic-import-source-preservation.js

@@ -46,9 +46,9 @@ function createKernelSourcePreservationRecords(input) {
   }
 
   for (const sourceMap of input.sourceMaps ?? []) {
-    for (const mapping of sourceMap.mappings ?? []) {
+    for (const [index, mapping] of (sourceMap.mappings ?? []).entries()) {
       records.push(explainSourcePreservation({
-        id: `source_preservation_${idFragment(sourceMap.id)}_${idFragment(mapping.id)}`,
+        id: `source_preservation_${idFragment(sourceMap.id)}_${index + 1}_${idFragment(mapping.id)}`,
         sourceMap,
         mapping,
         level: mapping.preservation,

package/package.json

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