@shapeshift-labs/frontier-lang-compiler 0.2.76 → 0.2.78

package/README.md

@@ -422,6 +422,22 @@ console.log(targetChange.metadata.semanticEquivalenceClaim); // false
 
 Bidirectional target-change records are merge-admission evidence, not transpiler proof. They keep target diffs, source anchor matches, optional lineage resolutions, source patch-bundle records, semantic history records, evidence IDs, readiness, and reason codes. They always keep `autoMergeClaim: false` and `semanticEquivalenceClaim: false`; unmatched or deleted anchors block the source-port route, while matched and ambiguous anchors still require human or verifier review.
 
+When the target source came from a Frontier/native projection, pass the generated-output `sourceMaps` back into `createBidirectionalTargetChangeRecord`. The record will match target changed regions by generated span or generated name, emit `sourceMapLinks`, include `sourceMapBackedMatches` in the summary/evidence, and carry source-map mapping IDs into the source patch bundle index:
+
+```js
+const sourceMapBacked = createBidirectionalTargetChangeRecord({
+  source,
+  targetLanguage: 'rust',
+  targetPath: 'src/counter.rs',
+  baseTarget,
+  editedTarget,
+  sourceMaps: [projection.sourceMap]
+});
+
+console.log(sourceMapBacked.summary.sourceMapBackedMatches);
+console.log(sourceMapBacked.sourcePatchBundle.index.sourceMapMappingIds);
+```
+
 Store worker outputs as compact semantic history records when a coordinator needs to compare distributed changes without merging whole files:
 
 ```js
@@ -487,6 +503,38 @@ console.log(resolution.currentAnchors[0].key); // current semantic anchor
 console.log(resolution.traversedEventIds); // compact history path
 ```
 
+Infer conservative lineage events from two native imports when a file was moved,
+a parser reports a rename, or an anchor disappeared:
+
+```js
+import {
+  importNativeSource,
+  inferSemanticLineageEvents
+} from '@shapeshift-labs/frontier-lang-compiler';
+
+const before = importNativeSource({
+  language: 'typescript',
+  sourcePath: 'src/runtime.ts',
+  sourceText: 'export function step(value) { return value + 1; }\n'
+});
+const after = importNativeSource({
+  language: 'typescript',
+  sourcePath: 'src/runtime-core.ts',
+  sourceText: 'export function step(value) { return value + 1; }\n'
+});
+
+const inference = inferSemanticLineageEvents({ before, after });
+
+console.log(inference.summary.moved); // 1
+console.log(inference.events[0].metadata.autoMergeClaim); // false
+console.log(inference.lineageMap.byAnchorKey); // old/current anchor index
+```
+
+The inference API is intentionally conservative. Ambiguous matches are reported
+as blocked, additions are kept separate from recreated lineage, and inferred
+events always require review; richer parser adapters can improve confidence by
+supplying stable signature hashes and source-map spans.
+
 Resolver output is merge-admission evidence: it helps a swarm compare old worker bundles against current semantic anchors after code moved, split, or was deleted. It is not proof that the projected code is correct or semantically equivalent; admission still needs tests, source evidence, review status, and conflict scoring.
 
 Extract a surgical semantic slice when a worker only needs one symbol, region, native AST node, or source path:

package/bench/smoke.mjs

@@ -110,8 +110,13 @@ console.log(JSON.stringify({
   changedRegionProjections: sourceChangeMetrics.changedRegionProjections,
   changedRegionProjectionSourceMapLinks: sourceChangeMetrics.changedRegionProjectionSourceMapLinks,
   changeProjectionDurationMs: Number(sourceChangeMetrics.changeProjectionDurationMs.toFixed(2)),
+  semanticLineageInferences: sourceChangeMetrics.semanticLineageInferences,
+  semanticLineageEvents: sourceChangeMetrics.semanticLineageEvents,
+  semanticLineageDeleted: sourceChangeMetrics.semanticLineageDeleted,
+  semanticLineageInferenceDurationMs: Number(sourceChangeMetrics.semanticLineageInferenceDurationMs.toFixed(2)),
   bidirectionalTargetChanges: sourceChangeMetrics.bidirectionalTargetChanges,
   bidirectionalTargetChangeMatches: sourceChangeMetrics.bidirectionalTargetChangeMatches,
+  bidirectionalTargetChangeSourceMapBacked: sourceChangeMetrics.bidirectionalTargetChangeSourceMapBacked,
   bidirectionalTargetChangeBlocked: sourceChangeMetrics.bidirectionalTargetChangeBlocked,
   bidirectionalTargetChangeDurationMs: Number(sourceChangeMetrics.bidirectionalTargetChangeDurationMs.toFixed(2)),
   externalSemanticImports: sourceChangeMetrics.externalSemanticImports,

package/bench/source-change-suite.mjs

@@ -4,6 +4,7 @@ import {
   createSemanticImportSidecar,
   createSemanticLineageEvent,
   diffNativeSources,
+  inferSemanticLineageEvents,
   importExternalSemanticIndex,
   importNativeSource
 } from '../dist/index.js';
@@ -12,6 +13,7 @@ export function measureSourceChangeSuites() {
   return {
     ...measureRegionScan(),
     ...measureChangeProjection(),
+    ...measureSemanticLineageInference(),
     ...measureBidirectionalTargetChanges(),
     ...measureExternalSemanticImports()
   };
@@ -75,6 +77,34 @@ function measureChangeProjection() {
   };
 }
 
+function measureSemanticLineageInference() {
+  const start = performance.now();
+  const inferences = [];
+  for (let index = 0; index < 80; index += 1) {
+    inferences.push(inferSemanticLineageEvents({
+      id: `bench_semantic_lineage_inference_${index}`,
+      before: {
+        language: 'typescript',
+        sourcePath: `src/lineage-before-${index}.ts`,
+        sourceText: `export function lineageBench${index}(value) { return value + ${index}; }\n`
+      },
+      after: {
+        language: 'typescript',
+        sourcePath: index % 5 === 0 ? `src/lineage-before-${index}.ts` : `src/lineage-after-${index}.ts`,
+        sourceText: index % 6 === 0
+          ? `export const lineageBenchDeleted${index} = true;\n`
+          : `export function lineageBench${index}(value) { return value + ${index}; }\n`
+      }
+    }));
+  }
+  return {
+    semanticLineageInferences: inferences.length,
+    semanticLineageEvents: inferences.reduce((sum, inference) => sum + inference.events.length, 0),
+    semanticLineageDeleted: inferences.reduce((sum, inference) => sum + inference.summary.deleted, 0),
+    semanticLineageInferenceDurationMs: performance.now() - start
+  };
+}
+
 function measureBidirectionalTargetChanges() {
   const start = performance.now();
   const source = importNativeSource({
@@ -82,6 +112,8 @@ function measureBidirectionalTargetChanges() {
     sourcePath: 'src/bidirectional-source.ts',
     sourceText: 'export function advance(frame: number): number { return frame + 1; }\n'
   });
+  const sourceSymbol = source.semanticIndex.symbols.find((symbol) => symbol.name === 'advance');
+  const sourceMapping = source.sourceMaps[0].mappings.find((mapping) => mapping.semanticSymbolId === sourceSymbol.id);
   const lineage = [createSemanticLineageEvent({
     eventKind: 'moved',
     from: { key: 'source#src/bidirectional-source.ts#body#advance', symbolName: 'advance' },
@@ -104,18 +136,45 @@ function measureBidirectionalTargetChanges() {
         sourcePath: `src/bidirectional-${index}.rs`,
         sourceText: `pub fn advance(frame: i32, delta: i32) -> i32 { frame + delta + ${index} }\n`
       },
-      sourceAnchorMappings: [{ targetSymbolName: 'advance', sourceSymbolName: 'advance' }],
+      ...(index % 2 === 0
+        ? { sourceMaps: [rustSourceMap(source, sourceSymbol, sourceMapping, index)] }
+        : { sourceAnchorMappings: [{ targetSymbolName: 'advance', sourceSymbolName: 'advance' }] }),
       lineage: index % 4 === 0 ? lineage : []
     }));
   }
   return {
     bidirectionalTargetChanges: records.length,
     bidirectionalTargetChangeMatches: records.reduce((sum, record) => sum + record.summary.sourceAnchorMatches, 0),
+    bidirectionalTargetChangeSourceMapBacked: records.reduce((sum, record) => sum + record.summary.sourceMapBackedMatches, 0),
     bidirectionalTargetChangeBlocked: records.filter((record) => record.readiness === 'blocked').length,
     bidirectionalTargetChangeDurationMs: performance.now() - start
   };
 }
 
+function rustSourceMap(source, sourceSymbol, sourceMapping, index) {
+  const targetPath = `src/bidirectional-${index}.rs`;
+  return {
+    kind: 'frontier.lang.sourceMap',
+    version: 1,
+    id: `bench_source_map_bidirectional_${index}`,
+    sourcePath: source.sourcePath,
+    sourceHash: source.nativeSource.sourceHash,
+    target: 'rust',
+    targetPath,
+    mappings: [{
+      id: `bench_map_advance_${index}`,
+      semanticSymbolId: sourceSymbol.id,
+      nativeAstNodeId: sourceSymbol.nativeAstNodeId,
+      sourceSpan: sourceMapping.sourceSpan,
+      generatedSpan: { path: targetPath, target: 'rust', targetPath, startLine: 1, startColumn: 1, endLine: 1, endColumn: 80, generatedName: 'advance' },
+      target: 'rust',
+      generatedName: 'advance',
+      precision: 'declaration',
+      preservation: 'declaration'
+    }]
+  };
+}
+
 function measureExternalSemanticImports() {
   const externalSemanticStart = performance.now();
   const externalSemanticImports = [];

package/dist/declarations/bidirectional-target-change.d.ts

@@ -2,6 +2,8 @@ import type {
   EvidenceRecord,
   FrontierSourceLanguage,
   SemanticMergeReadiness,
+  SourceMapMappingRecord,
+  SourceMapRecord,
   SourceSpan
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { ImportNativeSourceOptions, NativeSourceImportResult } from './import-adapter-core.js';
@@ -27,6 +29,26 @@ export interface BidirectionalTargetChangeSourceAnchorMapping {
   readonly sourceSymbolId?: string;
 }
 
+export interface BidirectionalTargetChangeSourceMapLink {
+  readonly id: string;
+  readonly sourceMapId?: string;
+  readonly sourceMapMappingId?: string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly targetPath?: string;
+  readonly targetHash?: string;
+  readonly semanticSymbolId?: string;
+  readonly semanticOccurrenceId?: string;
+  readonly semanticNodeId?: string;
+  readonly nativeSourceId?: string;
+  readonly nativeAstNodeId?: string;
+  readonly precision?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly generatedSpan?: SourceMapMappingRecord['generatedSpan'];
+  readonly regionKey?: string;
+  readonly regionKind?: string;
+}
+
 export interface BidirectionalTargetChangeAnchor {
   readonly id?: string;
   readonly key?: string;
@@ -47,6 +69,7 @@ export interface BidirectionalTargetChangeSourceAnchorMatch {
   readonly targetRegion: Partial<NativeSourceChangeRegion>;
   readonly sourceAnchors: readonly BidirectionalTargetChangeAnchor[];
   readonly lineageResolutions: readonly SemanticLineageResolution[];
+  readonly sourceMapLinks: readonly BidirectionalTargetChangeSourceMapLink[];
   readonly status: BidirectionalTargetChangeAnchorStatus;
   readonly confidence?: number;
   readonly reasonCodes: readonly string[];
@@ -77,6 +100,11 @@ export interface CreateBidirectionalTargetChangeRecordOptions {
   readonly after?: NativeSourceImportResult | ImportNativeSourceOptions;
   readonly sourceAnchorMappings?: readonly BidirectionalTargetChangeSourceAnchorMapping[];
   readonly anchorMappings?: readonly BidirectionalTargetChangeSourceAnchorMapping[];
+  readonly sourceMaps?: readonly SourceMapRecord[];
+  readonly projectionSourceMaps?: readonly SourceMapRecord[];
+  readonly targetSourceMaps?: readonly SourceMapRecord[];
+  readonly targetProjectionSourceMaps?: readonly SourceMapRecord[];
+  readonly targetCompileResult?: { readonly sourceMaps?: readonly SourceMapRecord[]; readonly sourceMap?: SourceMapRecord };
   readonly lineage?: readonly SemanticLineageEvent[];
   readonly lineageEvents?: readonly SemanticLineageEvent[];
   readonly lineageMap?: unknown;
@@ -114,6 +142,7 @@ export interface BidirectionalTargetChangeRecord {
     readonly unmatchedTargetRegions: number;
     readonly deletedSourceAnchors: number;
     readonly sourceChangedRegions: number;
+    readonly sourceMapBackedMatches: number;
   };
   readonly metadata: {
     readonly autoMergeClaim: false;

package/dist/declarations/native-diff.d.ts

@@ -40,6 +40,7 @@ import type { UniversalCapabilityLanguageRow, UniversalCapabilityMatrix, Univers
 import type { NativeImportContractSource, NativeImportSourcePreservationRecordSummary, NativeImportSourcePreservationContract, NativeImportAdapterCoverageRecordSummary, NativeImportAdapterCoverageContract, NativeImportRegionSummary, NativeImportSourceMapSummary, NativeImportReadinessContract, NativeImportResultContract, NativeImportResultContractOptions } from './native-import-contracts.js';
 import type { NativeSourceTokenKind, NativeSourcePreservedToken, NativeSourcePreservedDirective, NativeSourcePreservation, CreateNativeSourcePreservationOptions } from './source-preservation.js';
 import type { SemanticImportOwnershipRegion, SemanticImportSidecarSymbol, SemanticImportRegionTaxonomySummary, SemanticImportPatchHint, SemanticImportSidecarImportEntry, SemanticImportSidecarSourcePreservationRecord, SemanticImportSidecarUniversalAstLayerSummary, SemanticImportSidecarProofSpecSummary, SemanticImportSidecarParadigmSemanticsSummary, SemanticImportSidecar, SemanticImportSidecarOptions } from './semantic-sidecar.js';
+import type { SemanticLineageInferenceResult } from './semantic-lineage.js';
 import type { SemanticMergeCandidateWithConflicts, SemanticMergeConflictSummary } from './semantic-merge-conflicts.js';
 import type { SemanticSliceInput, CreateSemanticSliceOptions, SemanticSliceSourceMapLink, SemanticSliceSourceFile, SemanticSliceExpectedAssertion, SemanticSlice, TestSemanticSliceOptions, SemanticSliceTestAssertion, SemanticSliceTestResult } from './semantic-slice.js';
 import type { NativeImporterAdapterExactness, NativeImporterAdapterSemanticCoverage, NativeImporterAdapterCoverageSnapshot, NativeImporterAdapterCoverageObserved, NativeImporterAdapterCoverageCapabilityRow, NativeImporterAdapterCoverageCapabilityEvidence, NativeImporterAdapterCoverageSummary, NativeImporterAdapterCoverageInput } from './adapter-coverage.js';
@@ -227,6 +228,7 @@ export interface NativeSourceChangeSet {
   readonly patch: SemanticPatchBundle;
   readonly mergeCandidate: SemanticMergeCandidateWithConflicts;
   readonly evidence: readonly EvidenceRecord[];
+  readonly lineageInference?: SemanticLineageInferenceResult;
   readonly readiness: SemanticMergeReadiness;
   readonly reasons: readonly string[];
   readonly sourceMaps: readonly SourceMapRecord[];
@@ -236,5 +238,6 @@ export interface NativeSourceChangeSet {
   readonly metadata?: Record<string, unknown> & {
     readonly changedRegionProjectionSummary?: NativeSourceChangeProjectionSummary;
     readonly semanticMergeConflictSummary?: SemanticMergeConflictSummary;
+    readonly semanticLineageInferenceSummary?: SemanticLineageInferenceResult['summary'];
   };
 }

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

@@ -1,4 +1,6 @@
 import type { FrontierSourceLanguage, SourceSpan } from '@shapeshift-labs/frontier-lang-kernel';
+import type { EvidenceRecord, SemanticMergeReadiness } from '@shapeshift-labs/frontier-lang-kernel';
+import type { ImportNativeSourceOptions, NativeSourceImportResult } from './import-adapter-core.js';
 
 export type SemanticLineageEventKind = 'unchanged' | 'moved' | 'renamed' | 'split' | 'merged' | 'deleted' | 'recreated' | 'unknown' | string;
 export type SemanticLineageResolutionStatus = 'unchanged' | 'resolved' | 'ambiguous' | 'deleted' | 'recreated' | 'cycle' | 'max-depth' | 'not-found' | string;
@@ -183,11 +185,105 @@ export interface SemanticLineageQuery {
   readonly evidenceId?: string | readonly string[];
 }
 
+export interface SemanticLineageInferredAnchorSummary {
+  readonly key?: string;
+  readonly id?: string;
+  readonly name?: string;
+  readonly kind?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly signatureHash?: string;
+  readonly bodyHash?: string;
+  readonly ownershipRegionKind?: string;
+}
+
+export interface SemanticLineageAmbiguousCandidate {
+  readonly after: SemanticLineageInferredAnchorSummary;
+  readonly confidence: number;
+  readonly reasons: readonly string[];
+}
+
+export interface SemanticLineageAmbiguousMatch {
+  readonly before: SemanticLineageInferredAnchorSummary;
+  readonly candidates: readonly SemanticLineageAmbiguousCandidate[];
+  readonly reasonCodes: readonly string[];
+}
+
+export interface SemanticLineageInferenceResult {
+  readonly kind: 'frontier.lang.semanticLineageInference';
+  readonly version: 1;
+  readonly id: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly beforeImportId?: string;
+  readonly afterImportId?: string;
+  readonly beforeHash?: string;
+  readonly afterHash?: string;
+  readonly events: readonly SemanticLineageEvent[];
+  readonly lineageMap: SemanticLineageMap;
+  readonly evidence: readonly EvidenceRecord[];
+  readonly unmatched: {
+    readonly removed: readonly SemanticLineageInferredAnchorSummary[];
+    readonly added: readonly SemanticLineageInferredAnchorSummary[];
+    readonly ambiguous: readonly SemanticLineageAmbiguousMatch[];
+  };
+  readonly summary: {
+    readonly beforeSymbols: number;
+    readonly afterSymbols: number;
+    readonly unchangedAnchors: number;
+    readonly inferredEvents: number;
+    readonly moved: number;
+    readonly renamed: number;
+    readonly deleted: number;
+    readonly ambiguous: number;
+    readonly unmatchedAdded: number;
+    readonly minConfidence: number;
+    readonly ambiguityMargin: number;
+  };
+  readonly readiness: SemanticMergeReadiness;
+  readonly reasons: readonly string[];
+  readonly metadata: {
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+    readonly reviewRequired: true;
+    readonly [key: string]: unknown;
+  };
+}
+
+export interface InferSemanticLineageEventsOptions {
+  readonly id?: string;
+  readonly before?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly after?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly parser?: string;
+  readonly generatedAt?: number | string;
+  readonly regionPrefix?: string;
+  readonly evidenceId?: string;
+  readonly lineageMapId?: string;
+  readonly minConfidence?: number;
+  readonly ambiguityMargin?: number;
+  readonly includeDeleted?: boolean;
+  readonly deletedConfidence?: number;
+  readonly readiness?: SemanticMergeReadiness;
+  readonly actor?: SemanticLineageActor | string;
+  readonly actorId?: string;
+  readonly actorRole?: string;
+  readonly operationId?: string;
+  readonly deps?: readonly string[] | string;
+  readonly heads?: readonly string[] | string;
+  readonly stateVector?: Record<string, number>;
+  readonly metadata?: Record<string, unknown>;
+}
+
 export declare const SemanticLineageEventKinds: readonly SemanticLineageEventKind[];
 export declare const SemanticLineageResolutionStatuses: readonly SemanticLineageResolutionStatus[];
 export declare function createSemanticAnchor(input?: SemanticAnchor | string, defaults?: Partial<SemanticAnchor>): SemanticAnchor | undefined;
 export declare function createSemanticLineageEvent(input?: CreateSemanticLineageEventInput, options?: { readonly id?: string; readonly createdAt?: number | string; readonly actor?: SemanticLineageActor | string; readonly actorId?: string; readonly actorRole?: string }): SemanticLineageEvent;
 export declare function createSemanticLineageMap(events?: readonly (SemanticLineageEvent | CreateSemanticLineageEventInput)[], options?: { readonly id?: string; readonly generatedAt?: number | string }): SemanticLineageMap;
+export declare function inferSemanticLineageEvents(input?: InferSemanticLineageEventsOptions, options?: { readonly metadata?: Record<string, unknown>; readonly deletedConfidence?: number }): SemanticLineageInferenceResult;
 export declare function querySemanticLineageEvents(events: SemanticLineageEvent | readonly SemanticLineageEvent[], query?: SemanticLineageQuery): readonly SemanticLineageEvent[];
 export declare function resolveSemanticLineage(eventsOrMap?: SemanticLineageMap | readonly (SemanticLineageEvent | CreateSemanticLineageEventInput)[], query?: SemanticLineageResolutionQuery | SemanticAnchor | string, options?: { readonly id?: string; readonly generatedAt?: number | string; readonly maxDepth?: number; readonly metadata?: Record<string, unknown> }): SemanticLineageResolution;
 export declare function resolveSemanticLineageBatch(eventsOrMap?: SemanticLineageMap | readonly (SemanticLineageEvent | CreateSemanticLineageEventInput)[], queries?: readonly (SemanticLineageResolutionQuery | SemanticAnchor | string)[], options?: { readonly generatedAt?: number | string; readonly maxDepth?: number; readonly metadata?: Record<string, unknown> }): readonly SemanticLineageResolution[];

package/dist/index.js

@@ -46,6 +46,7 @@ export { getNativeParserAstFormatProfile } from './internal/index-impl/getNative
 export { importExternalSemanticIndex } from './internal/index-impl/importExternalSemanticIndex.js';
 export { importNativeProject } from './internal/index-impl/importNativeProject.js';
 export { importNativeSource } from './internal/index-impl/importNativeSource.js';
+export { inferSemanticLineageEvents } from './internal/index-impl/inferSemanticLineageEvents.js';
 export { createLanguageAdapterPackageContract, getLanguageAdapterPackageContract, LanguageAdapterPackageContracts, LanguageAdapterPackageReleaseReadinessStatuses, queryLanguageAdapterPackageContracts, summarizeLanguageAdapterPackageContracts } from './language-adapter-package-contracts.js';
 export { NativeImportFeatureEvidencePolicies } from './internal/index-impl/NativeImportFeatureEvidencePolicies.js';
 export { NativeImportLanguageProfiles } from './coverage-matrix-profiles.js';

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

@@ -8,13 +8,14 @@ import { resolveSemanticLineage } from './semanticLineageResolutionRecords.js';
 
 export function matchTargetRegion(context) {
   const explicit = explicitMappingForRegion(context.region, context.mappings);
-  const candidateAnchors = explicit
-    ? sourceAnchorsForMapping(explicit, context.sourceAnchors)
-    : sourceAnchorsByName(context.region, context.sourceAnchors);
+  const mapped = explicit ? { anchors: sourceAnchorsForMapping(explicit, context.sourceAnchors), links: [] }
+    : sourceMapAnchorsForRegion(context.region, context.sourceMaps, context.sourceAnchors);
+  const candidateAnchors = mapped.anchors.length ? mapped.anchors : sourceAnchorsByName(context.region, context.sourceAnchors);
   const resolvedAnchors = candidateAnchors.flatMap((anchor) => resolveAnchor(anchor, context.lineage));
   const status = matchStatus(candidateAnchors, resolvedAnchors);
   const reasonCodes = uniqueStrings([
-    explicit ? 'explicit-anchor-mapping' : 'inferred-by-symbol-name',
+    explicit ? 'explicit-anchor-mapping' : mapped.links.length ? 'source-map-generated-anchor' : 'inferred-by-symbol-name',
+    mapped.links.length ? 'mapped-by-generated-source-map' : undefined,
     status === 'unmatched' ? 'source-anchor-not-found' : undefined,
     status === 'ambiguous' ? 'source-anchor-ambiguous' : undefined,
     status === 'deleted' ? 'source-anchor-deleted' : undefined,
@@ -27,8 +28,9 @@ export function matchTargetRegion(context) {
     targetRegion: compactRegion(context.region),
     sourceAnchors: resolvedAnchors.map((entry) => entry.anchor),
     lineageResolutions: uniqueRecordsById(resolvedAnchors.map((entry) => entry.resolution).filter(Boolean)),
+    sourceMapLinks: mapped.links,
     status,
-    confidence: status === 'matched' && explicit ? 0.8 : status === 'matched' ? 0.58 : undefined,
+    confidence: status === 'matched' && explicit ? 0.8 : status === 'matched' && mapped.links.length ? 0.72 : status === 'matched' ? 0.58 : undefined,
     reasonCodes,
     reviewRequired: true,
     autoMergeClaim: false,
@@ -37,6 +39,7 @@ export function matchTargetRegion(context) {
       context.region.conflictKey,
       context.region.key,
       ...resolvedAnchors.map((entry) => entry.anchor?.key),
+      ...mapped.links.map((link) => link.sourceMapMappingId && `source-map:${link.sourceMapMappingId}`),
       status === 'unmatched' ? `target:${context.region.sourcePath ?? context.region.language ?? 'unknown'}` : undefined
     ])
   };
@@ -65,6 +68,7 @@ export function sourceRegionsForMatch(match, readiness) {
     symbolId: anchor?.symbolId,
     symbolName: anchor?.symbolName,
     sourceSpan: anchor?.sourceSpan,
+    sourceMapLinks: match.sourceMapLinks,
     admission: {
       readiness,
       action: 'review-port-from-target-change',
@@ -75,6 +79,7 @@ export function sourceRegionsForMatch(match, readiness) {
       bidirectionalTargetChange: {
         matchId: match.id,
         targetRegion: match.targetRegion,
+        sourceMapLinkIds: match.sourceMapLinks.map((link) => link.id),
         lineageResolutionIds: match.lineageResolutions.map((resolution) => resolution.id),
         reviewRequired: true,
         autoMergeClaim: false,
@@ -97,6 +102,8 @@ export function createBidirectionalEvidence(context) {
       targetChangeSetId: context.targetChangeSet.id,
       targetPatchId: context.targetChangeSet.patch?.id,
       sourceAnchorMatchIds: context.sourceAnchorMatches.map((match) => match.id),
+      sourceMapBackedMatches: context.sourceAnchorMatches.filter((match) => match.sourceMapLinks.length > 0).length,
+      sourceMapLinkIds: context.sourceAnchorMatches.flatMap((match) => match.sourceMapLinks.map((link) => link.id)),
       readiness: context.readiness,
       reasons: context.reasons,
       autoMergeClaim: false,
@@ -105,6 +112,77 @@ export function createBidirectionalEvidence(context) {
   };
 }
 
+function sourceMapAnchorsForRegion(region, sourceMaps, sourceAnchors) {
+  const links = [];
+  const anchors = [];
+  for (const sourceMap of sourceMaps ?? []) {
+    for (const mapping of sourceMap?.mappings ?? []) {
+      if (!mappingMatchesTargetRegion(mapping, sourceMap, region)) continue;
+      const link = sourceMapLinkForMapping(sourceMap, mapping);
+      links.push(link);
+      anchors.push(...anchorsForSourceMapMapping(mapping, link, sourceAnchors));
+    }
+  }
+  return { anchors: uniqueRecordsById(anchors), links: uniqueRecordsById(links) };
+}
+
+function anchorsForSourceMapMapping(mapping, link, sourceAnchors) {
+  const matches = sourceAnchors.filter((anchor) =>
+    (mapping.semanticSymbolId && anchor.symbolId === mapping.semanticSymbolId)
+    || (mapping.semanticNodeId && anchor.id === mapping.semanticNodeId)
+    || (mapping.nativeAstNodeId && anchor.metadata?.nativeAstNodeId === mapping.nativeAstNodeId)
+    || (mapping.ownershipRegionKey && anchor.key === mapping.ownershipRegionKey)
+  );
+  if (matches.length) return matches;
+  return [compactRecord({
+    id: mapping.semanticSymbolId ?? mapping.semanticNodeId ?? mapping.nativeAstNodeId ?? link.id,
+    key: mapping.ownershipRegionKey ?? mapping.semanticSymbolId ?? mapping.semanticNodeId ?? link.id,
+    kind: mapping.ownershipRegionKind ?? 'source-map',
+    language: link.sourceSpan?.language,
+    sourcePath: link.sourcePath,
+    sourceHash: link.sourceHash,
+    symbolId: mapping.semanticSymbolId,
+    symbolName: mapping.generatedName ?? mapping.generatedSpan?.generatedName,
+    sourceSpan: mapping.sourceSpan,
+    metadata: { sourceMapId: link.sourceMapId, sourceMapMappingId: link.sourceMapMappingId }
+  })];
+}
+
+function mappingMatchesTargetRegion(mapping, sourceMap, region) {
+  if (!targetPathMatches(mapping, sourceMap, region)) return false;
+  if (mapping.generatedName && namesForRegion(region).includes(mapping.generatedName)) return true;
+  if (mapping.generatedSpan?.generatedName && namesForRegion(region).includes(mapping.generatedSpan.generatedName)) return true;
+  return spansOverlap(mapping.generatedSpan, region.sourceSpan);
+}
+
+function targetPathMatches(mapping, sourceMap, region) {
+  const targetPaths = uniqueStrings([mapping.generatedSpan?.targetPath, mapping.generatedSpan?.path, sourceMap?.targetPath]);
+  const regionPath = region.sourcePath ?? region.sourceSpan?.path;
+  return !regionPath || targetPaths.length === 0 || targetPaths.includes(regionPath);
+}
+
+function sourceMapLinkForMapping(sourceMap, mapping) {
+  return compactRecord({
+    id: `source_map_link_${idFragment(sourceMap?.id ?? 'map')}_${idFragment(mapping.id ?? mapping.semanticSymbolId ?? 'mapping')}`,
+    sourceMapId: sourceMap?.id,
+    sourceMapMappingId: mapping.id,
+    sourcePath: mapping.sourceSpan?.path ?? sourceMap?.sourcePath,
+    sourceHash: mapping.sourceSpan?.sourceId ?? sourceMap?.sourceHash,
+    targetPath: mapping.generatedSpan?.targetPath ?? sourceMap?.targetPath,
+    targetHash: mapping.generatedSpan?.targetHash ?? sourceMap?.targetHash,
+    semanticSymbolId: mapping.semanticSymbolId,
+    semanticOccurrenceId: mapping.semanticOccurrenceId,
+    semanticNodeId: mapping.semanticNodeId,
+    nativeSourceId: mapping.nativeSourceId,
+    nativeAstNodeId: mapping.nativeAstNodeId,
+    precision: mapping.precision,
+    sourceSpan: mapping.sourceSpan,
+    generatedSpan: mapping.generatedSpan,
+    regionKey: mapping.ownershipRegionKey,
+    regionKind: mapping.ownershipRegionKind
+  });
+}
+
 export function anchorsFromSourceSidecar(sidecar, source) {
   return uniqueRecordsById((sidecar.ownershipRegions ?? []).map((region) => compactRecord({
     id: region.id,
@@ -148,11 +226,15 @@ function sourceAnchorsForMapping(mapping, sourceAnchors) {
 }
 
 function sourceAnchorsByName(region, sourceAnchors) {
-  const names = uniqueStrings([region.symbolName, region.name, region.metadata?.changedRegionProjection?.region?.symbolName]);
+  const names = namesForRegion(region);
   if (names.length === 0) return [];
   return sourceAnchors.filter((anchor) => names.includes(anchor.symbolName));
 }
 
+function namesForRegion(region) {
+  return uniqueStrings([region.symbolName, region.name, region.metadata?.changedRegionProjection?.region?.symbolName]);
+}
+
 function resolveAnchor(anchor, lineage) {
   if (!anchor) return [];
   const resolution = array(lineage).length ? resolveSemanticLineage(lineage, { anchorKey: anchor.key }) : undefined;
@@ -189,6 +271,23 @@ function compactRegion(region) {
   });
 }
 
+function spansOverlap(left, right) {
+  if (!left || !right) return false;
+  if (!sourcePathsCompatible(left, right)) return false;
+  const leftStart = Number(left.startLine ?? 0);
+  const leftEnd = Number(left.endLine ?? left.startLine ?? 0);
+  const rightStart = Number(right.startLine ?? 0);
+  const rightEnd = Number(right.endLine ?? right.startLine ?? 0);
+  if (!leftStart || !rightStart) return false;
+  return leftStart <= rightEnd && rightStart <= leftEnd;
+}
+
+function sourcePathsCompatible(left, right) {
+  const leftPath = left.targetPath ?? left.path;
+  const rightPath = right.targetPath ?? right.path;
+  return !leftPath || !rightPath || leftPath === rightPath;
+}
+
 function array(value) {
   return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value];
 }

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

@@ -1,5 +1,6 @@
 import {
   idFragment,
+  uniqueRecordsById,
   uniqueStrings
 } from '../../native-import-utils.js';
 import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
@@ -45,6 +46,14 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
   }) : undefined;
   const sourceAnchors = sourceSidecar ? anchorsFromSourceSidecar(sourceSidecar, source) : [];
   const mappings = array(input.sourceAnchorMappings ?? input.anchorMappings);
+  const sourceMaps = uniqueRecordsById([
+    ...array(input.sourceMaps),
+    ...array(input.projectionSourceMaps),
+    ...array(input.targetSourceMaps),
+    ...array(input.targetProjectionSourceMaps),
+    ...array(input.targetCompileResult?.sourceMaps),
+    input.targetCompileResult?.sourceMap
+  ]);
   const lineage = input.lineage ?? input.lineageEvents ?? input.lineageMap ?? [];
   const sourceAnchorMatches = targetChangeSet.changedRegions.map((region, index) => matchTargetRegion({
     id,
@@ -53,6 +62,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     source,
     sourceAnchors,
     mappings,
+    sourceMaps,
     lineage
   }));
   const readiness = classifyBidirectionalReadiness(targetChangeSet, source, sourceAnchorMatches);
@@ -86,7 +96,8 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       projectionOnly: true,
       targetChangeSetId: targetChangeSet.id,
       targetPatchId: targetChangeSet.patch?.id,
-      targetMergeCandidateId: targetChangeSet.mergeCandidate?.id
+      targetMergeCandidateId: targetChangeSet.mergeCandidate?.id,
+      sourceMapBackprojection: summarizeSourceMapBackprojection(sourceAnchorMatches)
     }
   }, {
     id: input.sourcePatchBundleId ?? `semantic_patch_bundle_${idFragment(id)}_source_port`,
@@ -127,6 +138,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       bidirectionalTargetChangeId: id,
       sourcePatchBundleId: sourcePatchBundle.id,
       targetChangeSetId: targetChangeSet.id,
+      sourceMapBackprojection: summarizeSourceMapBackprojection(sourceAnchorMatches),
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
@@ -153,7 +165,8 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       ambiguousMatches: sourceAnchorMatches.filter((match) => match.status === 'ambiguous').length,
       unmatchedTargetRegions: sourceAnchorMatches.filter((match) => match.status === 'unmatched').length,
       deletedSourceAnchors: sourceAnchorMatches.filter((match) => match.status === 'deleted').length,
-      sourceChangedRegions: sourceChangedRegions.length
+      sourceChangedRegions: sourceChangedRegions.length,
+      sourceMapBackedMatches: sourceAnchorMatches.filter((match) => match.sourceMapLinks.length > 0).length
     },
     metadata: {
       autoMergeClaim: false,
@@ -164,6 +177,16 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
   };
 }
 
+function summarizeSourceMapBackprojection(matches) {
+  const links = matches.flatMap((match) => match.sourceMapLinks ?? []);
+  return {
+    sourceMapBackedMatches: matches.filter((match) => (match.sourceMapLinks ?? []).length > 0).length,
+    sourceMapLinks: links.length,
+    sourceMapIds: uniqueStrings(links.map((link) => link.sourceMapId)),
+    sourceMapMappingIds: uniqueStrings(links.map((link) => link.sourceMapMappingId))
+  };
+}
+
 function array(value) {
   return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value];
 }

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

@@ -1,5 +1,6 @@
 import{idFragment,maxSemanticMergeReadiness,uniqueByLossId,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';import{createPatch,createSemanticMergeCandidateRecord}from'@shapeshift-labs/frontier-lang-kernel';
 import{attachNativeChangeRegionProjectionMetadata}from'./attachNativeChangeRegionProjectionMetadata.js';import{classifyNativeSourceMergeConflicts}from'./semanticMergeConflicts.js';import{createSemanticImportSidecar}from'./createSemanticImportSidecar.js';import{diffNativeOwnershipRegions}from'./diffNativeOwnershipRegions.js';import{diffNativeSymbols}from'./diffNativeSymbols.js';import{fileLevelNativeChangeRegion}from'./fileLevelNativeChangeRegion.js';import{mapDiffSymbols}from'./mapDiffSymbols.js';import{nativeChangeSpans}from'./nativeChangeSpans.js';import{nativeChangeTouchedSymbol}from'./nativeChangeTouchedSymbol.js';import{nativeImportReadiness}from'./nativeImportReadiness.js';import{nativeSourceChangeReasons}from'./nativeSourceChangeReasons.js';import{nativeSourceChangeSummary}from'./nativeSourceChangeSummary.js';import{normalizeNativeDiffImport}from'./normalizeNativeDiffImport.js';import{summarizeNativeChangedRegionProjections}from'./summarizeNativeChangedRegionProjections.js';
+import{inferSemanticLineageEvents}from'./inferSemanticLineageEvents.js';
 import{decorateSemanticMergeCandidateForAdmission}from'./semanticMergeCandidateRecords.js';
 export function diffNativeSourceImports(input) {
   const before = normalizeNativeDiffImport(input.before, input, 'before');
@@ -39,6 +40,17 @@ export function diffNativeSourceImports(input) {
     reasons
   });
   const changedRegionProjectionSummary = summarizeNativeChangedRegionProjections(changedRegions);
+  const lineageInference = inferSemanticLineageEvents({
+    before,
+    after,
+    id: `${idPart}_native_source_diff`,
+    language,
+    sourcePath,
+    generatedAt: input.generatedAt,
+    regionPrefix: input.regionPrefix,
+    evidenceId: `evidence_${idPart}_semantic_lineage_inference`,
+    metadata: { source: 'diffNativeSourceImports' }
+  });
   const evidence = [{
     id: input.evidenceId ?? `evidence_${idPart}_native_source_diff`,
     kind: 'import',
@@ -54,7 +66,8 @@ export function diffNativeSourceImports(input) {
       addedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'added').length,
       removedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'removed').length,
       modifiedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'modified').length,
-      changedRegionProjectionSummary
+      changedRegionProjectionSummary,
+      semanticLineageInferenceSummary: lineageInference.summary
     }
   }];
   const conflictKeys = uniqueStrings([
@@ -148,6 +161,7 @@ export function diffNativeSourceImports(input) {
     patch,
     mergeCandidate,
     evidence,
+    lineageInference,
     readiness,
     reasons,
     sourceMaps: uniqueRecordsById([...(before?.sourceMaps ?? []), ...(after?.sourceMaps ?? [])]),
@@ -160,6 +174,7 @@ export function diffNativeSourceImports(input) {
       beforeImportContract: before?.metadata?.importResultContract,
       afterImportContract: after?.metadata?.importResultContract,
       changedRegionProjectionSummary,
+      semanticLineageInferenceSummary: lineageInference.summary,
       semanticMergeConflictSummary: mergeConflictProfile.conflictSummary,
       ...input.metadata
     }

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

@@ -0,0 +1,214 @@
+import { idFragment, maxSemanticMergeReadiness, uniqueStrings } from '../../native-import-utils.js';
+import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
+import { createSemanticAnchor, createSemanticLineageEvent, createSemanticLineageMap } from './semanticLineageRecords.js';
+import { matchExactAnchors, matchLineageCandidates, symbolSummary } from './semanticLineageInferenceMatching.js';
+import { mapDiffSymbols } from './mapDiffSymbols.js';
+import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
+
+const DEFAULT_MIN_CONFIDENCE = 0.74;
+const DEFAULT_AMBIGUITY_MARGIN = 0.08;
+
+export function inferSemanticLineageEvents(input = {}, options = {}) {
+  const before = normalizeNativeDiffImport(input.before, input, 'before');
+  const after = normalizeNativeDiffImport(input.after, input, 'after');
+  if (!before && !after) throw new Error('inferSemanticLineageEvents requires before or after native source input');
+  const language = input.language ?? after?.language ?? before?.language;
+  const sourcePath = input.sourcePath ?? after?.sourcePath ?? before?.sourcePath;
+  const beforeHash = before?.nativeSource?.sourceHash ?? before?.nativeAst?.sourceHash ?? before?.sourceHash;
+  const afterHash = after?.nativeSource?.sourceHash ?? after?.nativeAst?.sourceHash ?? after?.sourceHash;
+  const idPart = idFragment(input.id ?? sourcePath ?? language ?? 'semantic_lineage_inference');
+  const beforeSidecar = before ? createSemanticImportSidecar(before, { id: `lineage_sidecar_before_${idPart}`, generatedAt: input.generatedAt, regionPrefix: input.regionPrefix }) : undefined;
+  const afterSidecar = after ? createSemanticImportSidecar(after, { id: `lineage_sidecar_after_${idPart}`, generatedAt: input.generatedAt, regionPrefix: input.regionPrefix }) : undefined;
+  const beforeSymbols = [...mapDiffSymbols(before, beforeSidecar).values()].map((symbol) => lineageSymbol(symbol, before)).filter((symbol) => symbol.anchor?.key);
+  const afterSymbols = [...mapDiffSymbols(after, afterSidecar).values()].map((symbol) => lineageSymbol(symbol, after)).filter((symbol) => symbol.anchor?.key);
+  const exact = matchExactAnchors(beforeSymbols, afterSymbols);
+  const candidates = matchLineageCandidates(exact.unmatchedBefore, exact.unmatchedAfter, input, {
+    minConfidence: minConfidence(input),
+    ambiguityMargin: ambiguityMargin(input)
+  });
+  const deleted = input.includeDeleted === false
+    ? []
+    : candidates.unmatchedBefore.map((symbol) => deletedEvent(symbol, input, options, { before, after }));
+  const events = [...candidates.events, ...deleted].filter(Boolean);
+  const evidence = [lineageInferenceEvidence({
+    input,
+    idPart,
+    sourcePath,
+    language,
+    before,
+    after,
+    beforeHash,
+    afterHash,
+    exact,
+    candidates,
+    deleted,
+    events
+  })];
+  const lineageMap = createSemanticLineageMap(events, {
+    id: input.lineageMapId ?? `semantic_lineage_map_${idPart}`,
+    generatedAt: input.generatedAt
+  });
+  const readiness = inferenceReadiness({ events, deleted, ambiguous: candidates.ambiguous, added: candidates.unmatchedAfter }, input);
+  return {
+    kind: 'frontier.lang.semanticLineageInference',
+    version: 1,
+    id: input.id ?? `semantic_lineage_inference_${idPart}`,
+    language,
+    sourcePath,
+    beforeImportId: before?.id,
+    afterImportId: after?.id,
+    beforeHash,
+    afterHash,
+    events,
+    lineageMap,
+    evidence,
+    unmatched: {
+      removed: candidates.unmatchedBefore.map(symbolSummary),
+      added: candidates.unmatchedAfter.map(symbolSummary),
+      ambiguous: candidates.ambiguous
+    },
+    summary: {
+      beforeSymbols: beforeSymbols.length,
+      afterSymbols: afterSymbols.length,
+      unchangedAnchors: exact.matched.length,
+      inferredEvents: events.length,
+      moved: events.filter((event) => event.eventKind === 'moved').length,
+      renamed: events.filter((event) => event.eventKind === 'renamed').length,
+      deleted: deleted.length,
+      ambiguous: candidates.ambiguous.length,
+      unmatchedAdded: candidates.unmatchedAfter.length,
+      minConfidence: minConfidence(input),
+      ambiguityMargin: ambiguityMargin(input)
+    },
+    readiness,
+    reasons: inferenceReasons({ events, deleted, ambiguous: candidates.ambiguous, added: candidates.unmatchedAfter, readiness }),
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reviewRequired: true,
+      beforeSidecarId: beforeSidecar?.id,
+      afterSidecarId: afterSidecar?.id,
+      note: 'Inferred lineage is refactoring-aware merge evidence, not proof of semantic equivalence.',
+      ...input.metadata,
+      ...options.metadata
+    }
+  };
+}
+
+function deletedEvent(symbol, input, options, context) {
+  return createSemanticLineageEvent({
+    id: `lineage_deleted_${idFragment(firstString(input.id, symbol.anchor.key))}`,
+    createdAt: input.generatedAt,
+    eventKind: 'deleted',
+    from: symbol.anchor,
+    confidence: deletedConfidence(input, options, context),
+    actor: input.actor,
+    actorId: input.actorId,
+    actorRole: input.actorRole ?? 'semantic-lineage-inference',
+    evidenceIds: [input.evidenceId ?? `evidence_${idFragment(input.id ?? symbol.anchor.key)}_lineage_inference`],
+    conflictKeys: [symbol.anchor.key],
+    metadata: {
+      inferred: true,
+      algorithm: 'frontier.semantic-lineage-inference.v1',
+      reasonCodes: ['anchor-removed-from-after-import'],
+      deletionEvidenceScope: deletionEvidenceScope(context),
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  });
+}
+
+function deletedConfidence(input, options, context) {
+  if (options.deletedConfidence !== undefined) return options.deletedConfidence;
+  if (input.deletedConfidence !== undefined) return input.deletedConfidence;
+  return deletionEvidenceScope(context) === 'same-source-file' ? 0.8 : 0.55;
+}
+
+function deletionEvidenceScope(context) {
+  const beforePath = context.before?.sourcePath ?? context.before?.nativeSource?.sourcePath;
+  const afterPath = context.after?.sourcePath ?? context.after?.nativeSource?.sourcePath;
+  return beforePath && afterPath && beforePath === afterPath ? 'same-source-file' : 'partial-or-moved-scope';
+}
+
+function lineageSymbol(symbol, imported) {
+  const anchor = createSemanticAnchor({
+    key: symbol.ownershipKey ?? symbol.key ?? symbol.id,
+    kind: symbol.ownershipRegionKind ?? symbol.kind,
+    language: symbol.language ?? imported?.language,
+    sourcePath: symbol.sourcePath ?? imported?.sourcePath,
+    sourceHash: symbol.sourceHash ?? imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash,
+    symbolId: symbol.id,
+    symbolName: symbol.name,
+    signatureHash: symbol.signatureHash,
+    bodyHash: symbol.spanHash,
+    sourceSpan: symbol.sourceSpan,
+    metadata: {
+      nativeAstNodeId: symbol.nativeAstNodeId,
+      semanticOccurrenceId: symbol.semanticOccurrenceId,
+      sourceMapMappingId: symbol.sourceMapMappingId,
+      ownershipRegionId: symbol.ownershipRegionId,
+      ownershipRegionKind: symbol.ownershipRegionKind
+    }
+  }, { language: imported?.language, sourcePath: imported?.sourcePath });
+  return { ...symbol, anchor };
+}
+
+function lineageInferenceEvidence(input) {
+  return {
+    id: input.input.evidenceId ?? `evidence_${input.idPart}_lineage_inference`,
+    kind: 'import',
+    status: 'passed',
+    path: input.sourcePath,
+    summary: `Inferred ${input.events.length} semantic lineage event(s) from ${input.before?.id ?? 'before'} to ${input.after?.id ?? 'after'}.`,
+    metadata: {
+      algorithm: 'frontier.semantic-lineage-inference.v1',
+      beforeImportId: input.before?.id,
+      afterImportId: input.after?.id,
+      beforeHash: input.beforeHash,
+      afterHash: input.afterHash,
+      language: input.language,
+      unchangedAnchors: input.exact.matched.length,
+      inferredEvents: input.events.length,
+      deleted: input.deleted.length,
+      ambiguous: input.candidates.ambiguous.length,
+      unmatchedAdded: input.candidates.unmatchedAfter.length,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  };
+}
+
+function inferenceReadiness(input, options) {
+  if (input.ambiguous.length) return 'blocked';
+  let readiness = 'ready';
+  if (input.events.length || input.added.length) readiness = maxSemanticMergeReadiness(readiness, 'needs-review');
+  return maxSemanticMergeReadiness(readiness, options.readiness ?? 'ready');
+}
+
+function inferenceReasons(input) {
+  return uniqueStrings([
+    input.events.length ? 'semantic-lineage-inferred' : undefined,
+    input.deleted.length ? 'deleted-anchor-lineage-inferred' : undefined,
+    input.added.length ? 'unmatched-added-anchor-review' : undefined,
+    input.ambiguous.length ? 'ambiguous-lineage-candidates' : undefined,
+    input.readiness === 'blocked' ? 'lineage-inference-blocked' : undefined,
+    'no-auto-merge-claim'
+  ].filter(Boolean));
+}
+
+function minConfidence(input) {
+  return numeric(input.minConfidence, DEFAULT_MIN_CONFIDENCE);
+}
+
+function ambiguityMargin(input) {
+  return numeric(input.ambiguityMargin, DEFAULT_AMBIGUITY_MARGIN);
+}
+
+function numeric(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function firstString(...values) {
+  return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
+}

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

@@ -0,0 +1,167 @@
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { createSemanticLineageEvent } from './semanticLineageRecords.js';
+
+export function matchExactAnchors(beforeSymbols, afterSymbols) {
+  const afterByKey = new Map(afterSymbols.map((symbol) => [symbol.anchor.key, symbol]));
+  const matched = [];
+  const unmatchedBefore = [];
+  const matchedAfterKeys = new Set();
+  for (const before of beforeSymbols) {
+    const after = afterByKey.get(before.anchor.key);
+    if (after && anchorsSameLocation(before.anchor, after.anchor)) {
+      matched.push({ before: symbolSummary(before), after: symbolSummary(after) });
+      matchedAfterKeys.add(after.anchor.key);
+    } else {
+      unmatchedBefore.push(before);
+    }
+  }
+  return {
+    matched,
+    unmatchedBefore,
+    unmatchedAfter: afterSymbols.filter((symbol) => !matchedAfterKeys.has(symbol.anchor.key))
+  };
+}
+
+export function matchLineageCandidates(beforeSymbols, afterSymbols, input, options) {
+  const claimedAfter = new Set();
+  const events = [];
+  const ambiguous = [];
+  const unmatchedBefore = [];
+  for (const before of beforeSymbols) {
+    const ranked = afterSymbols
+      .filter((after) => !claimedAfter.has(after.anchor.key))
+      .map((after) => ({ after, score: scoreLineagePair(before, after) }))
+      .filter((candidate) => candidate.score.confidence >= options.minConfidence)
+      .sort(compareCandidateScores);
+    const best = ranked[0];
+    const runnerUp = ranked[1];
+    if (!best) {
+      unmatchedBefore.push(before);
+      continue;
+    }
+    if (runnerUp && best.score.confidence - runnerUp.score.confidence < options.ambiguityMargin) {
+      ambiguous.push(ambiguousMatch(before, ranked));
+      unmatchedBefore.push(before);
+      continue;
+    }
+    claimedAfter.add(best.after.anchor.key);
+    events.push(inferredEvent(before, best.after, best.score, input));
+  }
+  return {
+    events,
+    ambiguous,
+    unmatchedBefore,
+    unmatchedAfter: afterSymbols.filter((symbol) => !claimedAfter.has(symbol.anchor.key))
+  };
+}
+
+export function symbolSummary(symbol) {
+  return {
+    key: symbol.anchor.key,
+    id: symbol.id,
+    name: symbol.name,
+    kind: symbol.kind,
+    language: symbol.language,
+    sourcePath: symbol.anchor.sourcePath,
+    sourceHash: symbol.anchor.sourceHash,
+    sourceSpan: symbol.anchor.sourceSpan,
+    signatureHash: symbol.signatureHash,
+    bodyHash: symbol.spanHash,
+    ownershipRegionKind: symbol.ownershipRegionKind
+  };
+}
+
+function ambiguousMatch(before, ranked) {
+  return {
+    before: symbolSummary(before),
+    candidates: ranked.slice(0, 4).map((candidate) => ({
+      after: symbolSummary(candidate.after),
+      confidence: candidate.score.confidence,
+      reasons: candidate.score.reasons
+    })),
+    reasonCodes: ['ambiguous-lineage-candidates']
+  };
+}
+
+function compareCandidateScores(left, right) {
+  return right.score.confidence - left.score.confidence
+    || String(left.after.anchor.key).localeCompare(String(right.after.anchor.key));
+}
+
+function inferredEvent(before, after, score, input) {
+  const nameChanged = before.anchor.symbolName
+    && after.anchor.symbolName
+    && before.anchor.symbolName !== after.anchor.symbolName;
+  const pathChanged = before.anchor.sourcePath !== after.anchor.sourcePath;
+  const spanMoved = JSON.stringify(before.anchor.sourceSpan ?? null) !== JSON.stringify(after.anchor.sourceSpan ?? null);
+  const eventKind = nameChanged ? 'renamed' : 'moved';
+  return createSemanticLineageEvent({
+    id: `lineage_inferred_${idFragment(firstString(input.id, before.anchor.key))}_${idFragment(after.anchor.key)}`,
+    createdAt: input.generatedAt,
+    eventKind,
+    from: before.anchor,
+    to: after.anchor,
+    confidence: score.confidence,
+    actor: input.actor,
+    actorId: input.actorId,
+    actorRole: input.actorRole ?? 'semantic-lineage-inference',
+    operationId: input.operationId,
+    deps: input.deps,
+    heads: input.heads,
+    stateVector: input.stateVector,
+    evidenceIds: [input.evidenceId ?? `evidence_${idFragment(input.id ?? before.anchor.key)}_lineage_inference`],
+    signatureHashMatch: score.reasons.includes('signature-hash-match'),
+    bodyHashMatch: score.reasons.includes('body-hash-match'),
+    pathMatch: !pathChanged,
+    sourceSpanMoved: pathChanged || spanMoved,
+    conflictKeys: uniqueStrings([before.anchor.key, after.anchor.key]),
+    metadata: {
+      inferred: true,
+      algorithm: 'frontier.semantic-lineage-inference.v1',
+      reasonCodes: score.reasons,
+      moved: pathChanged || spanMoved,
+      renamed: nameChanged,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  });
+}
+
+function scoreLineagePair(before, after) {
+  const reasons = [];
+  let score = 0;
+  const add = (value, reason) => {
+    score += value;
+    reasons.push(reason);
+  };
+  if (before.anchor.key && before.anchor.key === after.anchor.key) add(0.4, 'anchor-key-match');
+  if (before.name && before.name === after.name) add(0.28, 'symbol-name-match');
+  if (before.kind && before.kind === after.kind) add(0.12, 'symbol-kind-match');
+  if (before.signatureHash && before.signatureHash === after.signatureHash) add(0.52, 'signature-hash-match');
+  if (before.spanHash && before.spanHash === after.spanHash) add(0.22, 'body-hash-match');
+  if (before.anchor.kind && before.anchor.kind === after.anchor.kind) add(0.06, 'anchor-kind-match');
+  if (before.anchor.sourcePath && before.anchor.sourcePath === after.anchor.sourcePath) add(0.04, 'source-path-match');
+  if (sourceSpanRangeSame(before.anchor.sourceSpan, after.anchor.sourceSpan)) add(0.18, 'source-span-range-match');
+  if (before.ownershipRegionKind && before.ownershipRegionKind === after.ownershipRegionKind) add(0.04, 'ownership-kind-match');
+  if (before.nativeAstNodeId && before.nativeAstNodeId === after.nativeAstNodeId) add(0.06, 'native-node-id-match');
+  if (before.anchor.sourcePath !== after.anchor.sourcePath && (before.name === after.name || before.signatureHash === after.signatureHash)) add(0.04, 'source-path-moved');
+  return { confidence: Math.max(0, Math.min(1, Number(score.toFixed(3)))), reasons };
+}
+
+function anchorsSameLocation(before, after) {
+  return (before.sourcePath ?? '') === (after.sourcePath ?? '')
+    && JSON.stringify(before.sourceSpan ?? null) === JSON.stringify(after.sourceSpan ?? null);
+}
+
+function sourceSpanRangeSame(before, after) {
+  return before
+    && after
+    && before.startLine === after.startLine
+    && before.startColumn === after.startColumn
+    && before.endLine === after.endLine
+    && before.endColumn === after.endColumn;
+}
+
+function firstString(...values) {
+  return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
+}

package/package.json

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