@shapeshift-labs/frontier-lang-compiler 0.2.98 → 0.2.100

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

@@ -0,0 +1,204 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+export function projectionCoveredContainerOperationIds(operations, workerSourceText) {
+  if (typeof workerSourceText !== 'string') return new Set();
+  const result = new Set();
+  for (const operation of operations ?? []) {
+    if (!isProjectionCoverableContainer(operation)) continue;
+    if (workerContainerCoveredByInsertedChildren(operation, operations, workerSourceText)) result.add(operation.id);
+  }
+  return result;
+}
+
+export function spanOffsets(sourceText, span) {
+  if (typeof sourceText !== 'string' || !span) return undefined;
+  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) {
+    return { start: span.start, end: span.end };
+  }
+  if (typeof span.startLine !== 'number') return undefined;
+  const lineStarts = [0];
+  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') lineStarts.push(index + 1);
+  const startLine = Math.max(1, span.startLine);
+  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
+  const start = lineStarts[startLine - 1];
+  const endLineStart = lineStarts[endLine - 1];
+  if (start === undefined || endLineStart === undefined) return undefined;
+  const startColumn = Math.max(1, span.startColumn ?? 1) - 1;
+  const lineEnd = lineStarts[endLine] === undefined ? sourceText.length : lineStarts[endLine] - 1;
+  const endColumn = span.endColumn === undefined ? lineEnd - endLineStart : Math.max(1, span.endColumn) - 1;
+  return { start: start + startColumn, end: endLineStart + endColumn };
+}
+
+export function scopedBodyReplacement(operation, headSourceText, workerSourceText, headOffsets, workerOffsets) {
+  if (!isBodyReplacement(operation)) return undefined;
+  const head = bodyContentRange(headSourceText, headOffsets);
+  const worker = bodyContentRange(workerSourceText, workerOffsets);
+  if (!head || !worker) return undefined;
+  const headPrefix = headSourceText.slice(headOffsets.start, head.start);
+  const workerPrefix = workerSourceText.slice(workerOffsets.start, worker.start);
+  const headSuffix = headSourceText.slice(head.end, headOffsets.end);
+  const workerSuffix = workerSourceText.slice(worker.end, workerOffsets.end);
+  if (headPrefix !== workerPrefix || headSuffix !== workerSuffix) return undefined;
+  return { sourceRangeKind: 'body-content', head, worker };
+}
+
+export function bodyContentRange(sourceText, range) {
+  const pairs = bracePairs(sourceText, range);
+  const close = trailingBodyCloseOffset(sourceText, range);
+  const pair = close === undefined ? undefined : pairs.find((candidate) => candidate.close === close);
+  return pair ? { start: pair.open + 1, end: pair.close } : undefined;
+}
+
+export function insertionOffset(sourceText, insertion) {
+  if (typeof sourceText !== 'string') return { ok: false, reasonCodes: ['missing-head-source-text'] };
+  const mode = insertion?.mode;
+  if (mode === 'file-start') return { ok: true, offset: 0 };
+  if (mode === 'file-end') return { ok: true, offset: sourceText.length };
+  const range = spanOffsets(sourceText, insertion?.headSpan);
+  if (!range) return { ok: false, reasonCodes: ['insertion-anchor-not-resolvable'] };
+  if (mode === 'before') return { ok: true, offset: range.start };
+  if (mode === 'after') return { ok: true, offset: afterLineOffset(sourceText, range.end) };
+  return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
+}
+
+export function removalRange(sourceText, span) {
+  const range = { ...span };
+  if (range.end < sourceText.length && sourceText[range.end] === '\n') range.end += 1;
+  else if (range.start > 0 && sourceText[range.start - 1] === '\n') range.start -= 1;
+  return range;
+}
+
+export function insertionReplacement(text, sourceText, offset) {
+  let replacement = String(text ?? '');
+  if (offset > 0 && sourceText[offset - 1] !== '\n') replacement = `\n${replacement}`;
+  if (offset < sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
+  if (offset === sourceText.length && sourceText && !sourceText.endsWith('\n')) replacement = `\n${replacement}`;
+  if (offset === sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
+  return replacement;
+}
+
+export function afterLineOffset(sourceText, offset) {
+  return sourceText[offset] === '\n' ? offset + 1 : offset;
+}
+
+function isProjectionCoverableContainer(operation) {
+  if (['portable', 'already-applied', 'covered'].includes(operation.status)) return false;
+  if (operation.changeKind !== 'modified') return false;
+  if (!operation.spans?.worker || !operation.hashes?.baseTextHash) return false;
+  const kind = String(operation.anchor?.regionKind ?? operation.regionKind ?? '');
+  return kind === 'type' || kind === 'config' || kind === 'content' || kind === 'route' || kind === 'property';
+}
+
+function workerContainerCoveredByInsertedChildren(container, operations, workerSourceText) {
+  const containerWorker = spanOffsets(workerSourceText, container.spans?.worker);
+  if (!containerWorker) return false;
+  const childRanges = (operations ?? [])
+    .filter((operation) => operation.id !== container.id)
+    .filter((operation) => operation.changeKind === 'added' || String(operation.kind ?? '').startsWith('add'))
+    .filter((operation) => ['portable', 'already-applied'].includes(operation.status))
+    .map((operation) => spanOffsets(workerSourceText, operation.spans?.worker))
+    .filter((range) => containedRange(range, containerWorker))
+    .map((range) => insertionRemovalRange(workerSourceText, range, containerWorker));
+  if (!childRanges.length) return false;
+  const stripped = childRanges
+    .sort((left, right) => right.start - left.start || right.end - left.end)
+    .reduce((text, range) => text.slice(0, range.start - containerWorker.start) + text.slice(range.end - containerWorker.start), workerSourceText.slice(containerWorker.start, containerWorker.end));
+  return hashSemanticValue(stripped) === container.hashes.baseTextHash;
+}
+
+function containedRange(inner, outer) {
+  return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end);
+}
+
+function insertionRemovalRange(sourceText, span, container) {
+  const range = { ...span };
+  if (range.end < container.end && sourceText[range.end] === '\n') range.end += 1;
+  else if (range.start > container.start && sourceText[range.start - 1] === '\n') range.start -= 1;
+  return range;
+}
+
+function isBodyReplacement(operation) {
+  return operation.changeKind === 'modified' && (operation.kind === 'replaceBody' || operation.anchor?.regionKind === 'body');
+}
+
+function trailingBodyCloseOffset(sourceText, range) {
+  if (typeof sourceText !== 'string' || !range) return undefined;
+  let index = range.end - 1;
+  index = previousCodeOffset(sourceText, index, range.start);
+  if (sourceText[index] === ';' || sourceText[index] === ',') {
+    index -= 1;
+    index = previousCodeOffset(sourceText, index, range.start);
+  }
+  return sourceText[index] === '}' ? index : undefined;
+}
+
+function previousCodeOffset(sourceText, index, minIndex) {
+  let cursor = index;
+  while (cursor >= minIndex) {
+    while (cursor >= minIndex && /\s/.test(sourceText[cursor])) cursor -= 1;
+    const blockStart = sourceText.lastIndexOf('/*', cursor);
+    if (sourceText[cursor] === '/' && sourceText[cursor - 1] === '*' && blockStart >= minIndex) {
+      cursor = blockStart - 1;
+      continue;
+    }
+    const lineStart = Math.max(minIndex, sourceText.lastIndexOf('\n', cursor) + 1);
+    const lineComment = sourceText.lastIndexOf('//', cursor);
+    if (lineComment >= lineStart) {
+      cursor = lineComment - 1;
+      continue;
+    }
+    return cursor;
+  }
+  return cursor;
+}
+
+function bracePairs(sourceText, range) {
+  if (typeof sourceText !== 'string' || !range || range.end <= range.start) return [];
+  const stack = [];
+  const pairs = [];
+  let quote;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = range.start; index < range.end; index += 1) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{') stack.push(index);
+    else if (char === '}') {
+      const open = stack.pop();
+      if (open !== undefined) pairs.push({ open, close: index });
+    }
+  }
+  return pairs;
+}

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

@@ -22,7 +22,11 @@ export function resolveSemanticHistoryRecordLineage(record = {}, eventsOrMap = [
     semanticAnchorKeys: resolveIndexKeys(sourceIndex.semanticAnchorKeys, byAnchorKey, options),
     sourcePaths: uniqueStrings([
       ...array(sourceIndex.sourcePaths),
-      ...resolutions.flatMap((resolution) => resolution.currentAnchors.map((anchor) => anchor.sourcePath))
+      ...resolutions.flatMap((resolution) => resolutionSourcePaths(resolution))
+    ]),
+    lineageResolutionIds: uniqueStrings([
+      ...array(sourceIndex.lineageResolutionIds),
+      ...resolutions.map((resolution) => resolution.id)
     ]),
     lineageEventIds: uniqueStrings([
       ...array(sourceIndex.lineageEventIds),
@@ -105,6 +109,13 @@ function createResolvedHistoryRecord(record, index, resolution) {
           inactiveAnchorKeys: resolution.summary.inactiveAnchorKeys,
           blockedAnchorKeys: resolution.summary.blockedAnchorKeys
         },
+        lineageResolutionIds: resolution.summary.lineageResolutionIds,
+        lineageEventIds: resolution.summary.traversedEventIds,
+        terminalEventIds: resolution.summary.terminalEventIds,
+        sourcePaths: resolution.summary.sourcePaths,
+        evidenceIds: resolution.summary.evidenceIds,
+        proofIds: resolution.summary.proofIds,
+        reasonCodes: resolution.summary.reasonCodes,
         autoMergeClaim: false,
         semanticEquivalenceClaim: false
       }
@@ -159,8 +170,11 @@ function summarizeSemanticHistoryLineageResolutions(resolutions, index, anchorIn
     deletedAnchorKeys: uniqueStrings(anchorInventory.deleted.map((anchor) => anchor.key)),
     unresolvedAnchorKeys: uniqueStrings(anchorInventory.unresolved.map((anchor) => anchor.key)),
     blockedAnchorKeys: uniqueStrings(anchorInventory.blocked.map((anchor) => anchor.key)),
+    lineageResolutionIds: uniqueStrings(resolutions.map((resolution) => resolution.id)),
     traversedEventIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.traversedEventIds)),
     terminalEventIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.terminalEventIds)),
+    evidenceIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.evidenceIds)),
+    proofIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.proofIds)),
     reasonCodes: uniqueStrings(resolutions.flatMap((resolution) => resolution.reasonCodes))
   };
 }
@@ -225,8 +239,17 @@ function anchorEntry(anchor, resolution) {
     sourcePath: anchor.sourcePath,
     symbolId: anchor.symbolId,
     symbolName: anchor.symbolName,
+    sourcePaths: resolutionSourcePaths(resolution, anchor),
+    lineageEventIds: uniqueStrings(resolution.traversedEventIds),
+    terminalEventIds: uniqueStrings(resolution.terminalEventIds),
+    evidenceIds: uniqueStrings(resolution.evidenceIds),
+    proofIds: uniqueStrings(resolution.proofIds),
+    crdtOperationIds: uniqueStrings(resolution.crdtOperationIds),
+    crdtHeads: uniqueStrings(resolution.crdtHeads),
+    lineageEventKinds: uniqueStrings(resolution.lineageEventKinds),
     status: resolution.status,
     resolutionId: resolution.id,
+    confidence: resolution.confidence,
     reasonCodes: uniqueStrings(resolution.reasonCodes)
   });
 }
@@ -250,6 +273,17 @@ function uniqueAnchorEntries(entries) {
   });
 }
 
+function resolutionSourcePaths(resolution, anchor) {
+  return uniqueStrings([
+    anchor?.sourcePath,
+    ...array(anchor?.lineageSourcePaths),
+    resolution.query?.sourcePath,
+    resolution.startAnchor?.sourcePath,
+    ...array(resolution.sourcePaths),
+    ...resolution.currentAnchors.flatMap((entry) => [entry.sourcePath, ...array(entry.lineageSourcePaths)])
+  ]);
+}
+
 function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
 function uniqueStrings(values) { return uniqueRawStrings(array(values).map((value) => String(value ?? '')).filter(Boolean)); }
 function firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean); }

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

@@ -1,4 +1,4 @@
-import{idFragment}from'../../native-import-utils.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{idFragment,caseSensitiveIdFragment}from'../../native-import-utils.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 import{relationPredicateForDeclaration}from'./relationPredicateForDeclaration.js';
 export function semanticIndexFromNativeDeclarations(declarations, input, options) {
   const documentId = `doc_${idFragment(input.sourcePath ?? input.language)}_${idFragment(input.sourceHash)}`;
@@ -9,7 +9,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
   const facts = [];
   const mappings = [];
   for (const declaration of declarations) {
-    const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${idFragment(declaration.name)}`;
+    const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${caseSensitiveIdFragment(declaration.name)}`;
     const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${declaration.role ?? 'definition'}`;
     const ownershipRegion = semanticOwnershipRegionForDeclaration(input, {
       ...declaration,

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

@@ -8,8 +8,12 @@ export function matchExactAnchors(beforeSymbols, afterSymbols) {
   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) });
+    if (after) {
+      matched.push({
+        before: symbolSummary(before),
+        after: symbolSummary(after),
+        sourceSpanMoved: !anchorsSameLocation(before.anchor, after.anchor)
+      });
       matchedAfterKeys.add(after.anchor.key);
     } else {
       unmatchedBefore.push(before);
@@ -27,21 +31,33 @@ export function matchLineageCandidates(beforeSymbols, afterSymbols, input, optio
   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 rankedByBefore = beforeSymbols.map((before) => ({
+    before,
+    ranked: rankLineageCandidates(before, afterSymbols, options)
+  }));
+  const contendersByAfter = afterContenderIndex(rankedByBefore);
+  for (const entry of rankedByBefore) {
+    const before = entry.before;
+    const ranked = entry.ranked.filter((candidate) => !claimedAfter.has(candidate.after.anchor.key));
     const best = ranked[0];
     const runnerUp = ranked[1];
     if (!best) {
       unmatchedBefore.push(before);
       continue;
     }
+    const splitTargets = splitLineageCandidates(before, ranked, contendersByAfter, options);
+    if (splitTargets.length > 1) {
+      for (const candidate of splitTargets) claimedAfter.add(candidate.after.anchor.key);
+      events.push(inferredSplitEvent(before, splitTargets, input));
+      continue;
+    }
+    const targetContention = ambiguousTargetContention(before, best, contendersByAfter, options);
+    if (targetContention.length > 0) {
+      ambiguous.push(ambiguousMatch(before, ranked, ['ambiguous-lineage-candidates', 'ambiguous-target-lineage-candidates']));
+      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);
@@ -55,6 +71,14 @@ export function matchLineageCandidates(beforeSymbols, afterSymbols, input, optio
   };
 }
 
+function rankLineageCandidates(before, afterSymbols, options) {
+  return afterSymbols
+    .filter((after) => before.anchor.key !== after.anchor.key)
+    .map((after) => ({ before, after, score: scoreLineagePair(before, after) }))
+    .filter((candidate) => candidate.score.confidence >= options.minConfidence)
+    .sort(compareCandidateScores);
+}
+
 export function symbolSummary(symbol) {
   return {
     key: symbol.anchor.key,
@@ -71,7 +95,7 @@ export function symbolSummary(symbol) {
   };
 }
 
-function ambiguousMatch(before, ranked) {
+function ambiguousMatch(before, ranked, reasonCodes = ['ambiguous-lineage-candidates']) {
   return {
     before: symbolSummary(before),
     candidates: ranked.slice(0, 4).map((candidate) => ({
@@ -79,7 +103,7 @@ function ambiguousMatch(before, ranked) {
       confidence: candidate.score.confidence,
       reasons: candidate.score.reasons
     })),
-    reasonCodes: ['ambiguous-lineage-candidates']
+    reasonCodes: uniqueStrings(reasonCodes)
   };
 }
 
@@ -94,7 +118,8 @@ function inferredEvent(before, after, score, input) {
     && 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';
+  const recreated = !nameChanged && score.reasons.includes('delete-recreate-candidate');
+  const eventKind = nameChanged ? 'renamed' : recreated ? 'recreated' : 'moved';
   return createSemanticLineageEvent({
     id: `lineage_inferred_${idFragment(firstString(input.id, before.anchor.key))}_${idFragment(after.anchor.key)}`,
     createdAt: input.generatedAt,
@@ -121,6 +146,53 @@ function inferredEvent(before, after, score, input) {
       reasonCodes: score.reasons,
       moved: pathChanged || spanMoved,
       renamed: nameChanged,
+      recreated,
+      anchorKeyChanged: before.anchor.key !== after.anchor.key,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  });
+}
+
+function inferredSplitEvent(before, candidates, input) {
+  const targets = candidates.map((candidate) => candidate.after);
+  const reasons = uniqueStrings([
+    ...candidates.flatMap((candidate) => candidate.score.reasons),
+    'split-lineage-candidate'
+  ]);
+  const confidence = Math.min(...candidates.map((candidate) => candidate.score.confidence));
+  const pathMatch = targets.every((target) => before.anchor.sourcePath === target.anchor.sourcePath);
+  const spanMoved = targets.some((target) => (
+    before.anchor.sourcePath !== target.anchor.sourcePath
+    || JSON.stringify(before.anchor.sourceSpan ?? null) !== JSON.stringify(target.anchor.sourceSpan ?? null)
+  ));
+  return createSemanticLineageEvent({
+    id: `lineage_split_${idFragment(firstString(input.id, before.anchor.key))}_${idFragment(targets.map((target) => target.anchor.key).join('_'))}`,
+    createdAt: input.generatedAt,
+    eventKind: 'split',
+    from: before.anchor,
+    to: targets.map((target) => target.anchor),
+    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: candidates.every((candidate) => candidate.score.reasons.includes('signature-hash-match')),
+    bodyHashMatch: candidates.every((candidate) => candidate.score.reasons.includes('body-hash-match')),
+    pathMatch,
+    sourceSpanMoved: spanMoved,
+    conflictKeys: uniqueStrings([before.anchor.key, ...targets.map((target) => target.anchor.key)]),
+    metadata: {
+      inferred: true,
+      algorithm: 'frontier.semantic-lineage-inference.v1',
+      reasonCodes: reasons,
+      split: true,
+      targetCount: targets.length,
+      candidateConfidences: candidates.map((candidate) => candidate.score.confidence),
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
@@ -134,6 +206,7 @@ function scoreLineagePair(before, after) {
     score += value;
     reasons.push(reason);
   };
+  const note = (reason) => 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');
@@ -145,7 +218,67 @@ function scoreLineagePair(before, after) {
   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 };
+  if (before.anchor.key && after.anchor.key && before.anchor.key !== after.anchor.key) note('anchor-key-changed');
+  if (sameSymbolSurface(before, after)) note('same-symbol-surface');
+  if (deleteRecreateCandidate(before, after, reasons)) note('delete-recreate-candidate');
+  return { confidence: Math.max(0, Math.min(1, Number(score.toFixed(3)))), reasons: uniqueStrings(reasons) };
+}
+
+function afterContenderIndex(rankedByBefore) {
+  const contenders = new Map();
+  for (const entry of rankedByBefore) {
+    for (const candidate of entry.ranked) {
+      const key = candidate.after.anchor.key;
+      if (!key) continue;
+      contenders.set(key, [...(contenders.get(key) ?? []), candidate]);
+    }
+  }
+  return contenders;
+}
+
+function ambiguousTargetContention(before, candidate, contendersByAfter, options) {
+  return (contendersByAfter.get(candidate.after.anchor.key) ?? []).filter((contender) => (
+    contender.before.anchor.key !== before.anchor.key
+    && candidate.score.confidence - contender.score.confidence < options.ambiguityMargin
+  ));
+}
+
+function splitLineageCandidates(before, ranked, contendersByAfter, options) {
+  const best = ranked[0];
+  if (!best) return [];
+  const close = ranked.filter((candidate) => best.score.confidence - candidate.score.confidence < options.ambiguityMargin);
+  if (close.length < 2 || close.length > 4) return [];
+  if (!close.every((candidate) => hasStrongLineageEvidence(candidate.score))) return [];
+  if (!close.every((candidate) => splitNameEvidence(before, candidate.after))) return [];
+  if (close.some((candidate) => ambiguousTargetContention(before, candidate, contendersByAfter, options).length > 0)) return [];
+  return close;
+}
+
+function hasStrongLineageEvidence(score) {
+  return score.reasons.includes('signature-hash-match') || score.reasons.includes('body-hash-match');
+}
+
+function splitNameEvidence(before, after) {
+  const beforeName = normalizedName(before.name);
+  const afterName = normalizedName(after.name);
+  return Boolean(beforeName && afterName && beforeName !== afterName && afterName.includes(beforeName));
+}
+
+function deleteRecreateCandidate(before, after, reasons) {
+  return before.anchor.key !== after.anchor.key
+    && sameSymbolSurface(before, after)
+    && (reasons.includes('signature-hash-match') || reasons.includes('body-hash-match'));
+}
+
+function sameSymbolSurface(before, after) {
+  return Boolean(
+    before.name
+    && before.name === after.name
+    && before.kind
+    && before.kind === after.kind
+    && before.anchor.sourcePath
+    && before.anchor.sourcePath === after.anchor.sourcePath
+  );
 }
 
 function anchorsSameLocation(before, after) {
@@ -162,6 +295,10 @@ function sourceSpanRangeSame(before, after) {
     && before.endColumn === after.endColumn;
 }
 
+function normalizedName(value) {
+  return String(value ?? '').replace(/[^A-Za-z0-9_$]+/g, '').toLowerCase();
+}
+
 function firstString(...values) {
   return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
 }

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

@@ -49,6 +49,7 @@ function createResolutionState(start) {
     current: start ? [start] : [],
     traversed: [],
     terminal: [],
+    sourcePaths: strings(start?.sourcePath),
     conflictKeys: [],
     evidenceIds: [],
     proofIds: [],
@@ -64,14 +65,16 @@ function createResolutionState(start) {
 }
 
 function buildResolutionRecord(state, start, maxDepth, query, options) {
+  const currentAnchors = uniqueAnchors(state.current).map((anchor) => anchorWithLineageLinks(anchor, state, start, query));
   const core = {
     kind: 'frontier.lang.semanticLineageResolution',
     version: 1,
     query: compactRecord({ anchorKey: start?.key, anchorId: start?.id, sourcePath: start?.sourcePath, symbolName: start?.symbolName, maxDepth }),
     startAnchor: start,
-    currentAnchors: uniqueAnchors(state.current),
+    currentAnchors,
     traversedEventIds: uniqueStrings(state.traversed),
     terminalEventIds: uniqueStrings(state.terminal),
+    sourcePaths: lineageSourcePaths(state, start, query, currentAnchors),
     status: state.status,
     confidence: clampConfidence(state.confidence),
     conflictKeys: uniqueStrings(state.conflictKeys),
@@ -102,6 +105,7 @@ function applyLineageEvent(state, event, visitedEvents) {
   state.operationIds.push(event.crdt?.operationId);
   state.heads.push(...(event.crdt?.heads ?? []));
   state.eventKinds.push(event.eventKind);
+  state.sourcePaths.push(event.from?.sourcePath, ...event.to.map((anchor) => anchor.sourcePath));
   if (event.confidence !== undefined) state.confidence = state.confidence === undefined ? event.confidence : Math.min(state.confidence, event.confidence);
   const matched = state.current.filter((anchor) => anchorsMatch(anchor, event.from));
   const unmatched = state.current.filter((anchor) => !anchorsMatch(anchor, event.from));
@@ -178,6 +182,29 @@ function uniqueEvents(events) {
     return true;
   });
 }
+function anchorWithLineageLinks(anchor, state, start, query) {
+  return compactRecord({
+    ...anchor,
+    lineageEventIds: uniqueStrings(state.traversed),
+    terminalLineageEventIds: uniqueStrings(state.terminal),
+    lineageSourcePaths: lineageSourcePaths(state, start, query, [anchor]),
+    evidenceIds: uniqueStrings(state.evidenceIds),
+    proofIds: uniqueStrings(state.proofIds),
+    crdtOperationIds: uniqueStrings(state.operationIds),
+    crdtHeads: uniqueStrings(state.heads),
+    lineageEventKinds: uniqueStrings(state.eventKinds),
+    lineageReasonCodes: uniqueStrings(state.reasonCodes)
+  });
+}
+function lineageSourcePaths(state, start, query, anchors = []) {
+  return uniqueStrings([
+    query?.sourcePath,
+    start?.sourcePath,
+    ...state.sourcePaths,
+    ...array(anchors).map((anchor) => anchor?.sourcePath),
+    ...array(anchors).flatMap((anchor) => anchor?.lineageSourcePaths ?? [])
+  ]);
+}
 function positiveInteger(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;