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

package/README.md

@@ -487,6 +487,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,6 +110,10 @@ 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,
   bidirectionalTargetChangeBlocked: sourceChangeMetrics.bidirectionalTargetChangeBlocked,

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({

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/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.77",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",