@shapeshift-labs/frontier-lang-compiler 0.2.99 → 0.2.101

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

@@ -0,0 +1,283 @@
+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 = lineContentEndOffset(sourceText, lineStarts[endLine]);
+  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, context = {}) {
+  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 resolved = insertionAnchorResolution(sourceText, insertion, context);
+  if (!resolved?.range) return { ok: false, reasonCodes: ['insertion-anchor-not-resolvable'] };
+  if (resolved.mode === 'before') return { ok: true, offset: resolved.range.start };
+  if (resolved.mode === 'after') return { ok: true, offset: afterLineOffset(sourceText, resolved.range.end) };
+  return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
+}
+
+export function removalRange(sourceText, span) {
+  const range = { ...span };
+  const next = lineBreakEndOffset(sourceText, range.end);
+  if (next !== range.end) range.end = next;
+  else {
+    const previous = previousLineBreakStartOffset(sourceText, range.start);
+    if (previous !== range.start) range.start = previous;
+  }
+  return range;
+}
+
+export function insertionReplacement(text, sourceText, offset) {
+  let replacement = String(text ?? '');
+  const newline = sourceLineEnding(sourceText);
+  if (offset > 0 && !isLineBreak(sourceText[offset - 1])) replacement = `${newline}${replacement}`;
+  if (offset < sourceText.length && !endsWithLineBreak(replacement)) replacement += newline;
+  if (offset === sourceText.length && sourceText && !endsWithLineBreak(sourceText)) replacement = `${newline}${replacement}`;
+  if (offset === sourceText.length && !endsWithLineBreak(replacement)) replacement += newline;
+  return replacement;
+}
+
+export function afterLineOffset(sourceText, offset) {
+  return lineBreakEndOffset(sourceText, 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 };
+  const next = lineBreakEndOffset(sourceText, range.end);
+  if (next !== range.end && next <= container.end) range.end = next;
+  else {
+    const previous = previousLineBreakStartOffset(sourceText, range.start);
+    if (previous !== range.start && previous >= container.start) range.start = previous;
+  }
+  return range;
+}
+
+function lineContentEndOffset(sourceText, nextLineStart) {
+  if (nextLineStart === undefined) return sourceText.length;
+  const lineBreakStart = sourceText[nextLineStart - 2] === '\r' ? nextLineStart - 2 : nextLineStart - 1;
+  return Math.max(0, lineBreakStart);
+}
+
+function lineBreakEndOffset(sourceText, offset) {
+  if (sourceText[offset] === '\r' && sourceText[offset + 1] === '\n') return offset + 2;
+  if (isLineBreak(sourceText[offset])) return offset + 1;
+  return offset;
+}
+
+function previousLineBreakStartOffset(sourceText, offset) {
+  if (sourceText[offset - 1] === '\n') return sourceText[offset - 2] === '\r' ? offset - 2 : offset - 1;
+  if (sourceText[offset - 1] === '\r') return offset - 1;
+  return offset;
+}
+
+function sourceLineEnding(sourceText) {
+  if (sourceText.includes('\r\n')) return '\r\n';
+  return sourceText.includes('\r') ? '\r' : '\n';
+}
+
+function endsWithLineBreak(value) {
+  return isLineBreak(value[value.length - 1]);
+}
+
+function isLineBreak(char) {
+  return char === '\n' || char === '\r';
+}
+
+function isBodyReplacement(operation) {
+  return operation.changeKind === 'modified' && (operation.kind === 'replaceBody' || operation.anchor?.regionKind === 'body');
+}
+
+function insertionAnchorResolution(sourceText, insertion, context) {
+  const candidates = insertionAnchorCandidates(insertion);
+  for (const candidate of candidates) {
+    const symbol = insertionAnchorSymbol(candidate, context.symbols);
+    const range = spanOffsets(sourceText, symbol?.sourceSpan);
+    if (range) return { mode: candidate.mode, range };
+  }
+  for (const candidate of candidates) {
+    const range = spanOffsets(sourceText, candidate.headSpan);
+    if (range) return { mode: candidate.mode, range };
+  }
+  return undefined;
+}
+
+function insertionAnchorCandidates(insertion) {
+  const seen = new Set();
+  const result = [];
+  for (const candidate of [insertion, ...(Array.isArray(insertion?.anchorCandidates) ? insertion.anchorCandidates : [])]) {
+    if (!candidate || (candidate.mode !== 'before' && candidate.mode !== 'after')) continue;
+    const key = [candidate.mode, candidate.anchorKey, candidate.anchorSymbolId, candidate.anchorSymbolName, candidate.anchorSymbolKind].join('\0');
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(candidate);
+  }
+  return result;
+}
+
+function insertionAnchorSymbol(candidate, symbols) {
+  const symbolList = Array.isArray(symbols)
+    ? symbols
+    : symbols?.values
+      ? [...symbols.values()]
+      : [];
+  const keys = [candidate.anchorKey, candidate.anchorSymbolId].filter(Boolean);
+  const exact = symbolList.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && keys.includes(key)));
+  if (exact) return exact;
+  return symbolList.find((symbol) => symbol.name === candidate.anchorSymbolName && (!candidate.anchorSymbolKind || symbol.kind === candidate.anchorSymbolKind));
+}
+
+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
       }
@@ -126,12 +137,17 @@ function resolveIndexKeys(values, resolutions, options) {
     const key = String(value);
     const resolution = resolutions.get(key);
     if (!resolution) return [key];
+    const current = resolution.currentAnchors.map((anchor) => anchor.key).filter(Boolean);
     if (resolution.status === 'deleted' && options.keepDeletedAnchors !== true) return [];
     if (resolution.status === 'cycle' && options.keepBlockedAnchors !== true) return [];
     if (resolution.status === 'max-depth' && options.keepBlockedAnchors !== true) return [];
     if (resolution.status === 'not-found' && options.keepUnresolvedAnchors !== true) return [];
+    if (resolution.status === 'ambiguous' && resolutionHasInactiveTerminal(resolution)) {
+      if (options.keepCandidateAnchors === true) return current.length ? current : [key];
+      if (options.keepDeletedAnchors === true || options.keepInactiveAnchors === true) return [key];
+      return [];
+    }
     if (resolution.status === 'ambiguous' && options.keepCandidateAnchors === false) return [];
-    const current = resolution.currentAnchors.map((anchor) => anchor.key).filter(Boolean);
     return current.length ? current : [key];
   }));
 }
@@ -159,8 +175,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))
   };
 }
@@ -179,7 +198,10 @@ function createAnchorInventory(resolutions) {
     const current = resolution.currentAnchors.map((anchor) => anchorEntry(anchor, resolution));
     if (resolution.status === 'ambiguous') {
       inventory.candidate.push(...current);
-      if (start) inventory.inactive.push(start);
+      if (start) {
+        inventory.inactive.push(start);
+        if (resolutionHasDeletedTerminal(resolution)) inventory.deleted.push(start);
+      }
       continue;
     }
     if (resolution.status === 'deleted') {
@@ -225,12 +247,32 @@ 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)
   });
 }
 
+function resolutionHasInactiveTerminal(resolution) {
+  return array(resolution.terminalEventIds).length > 0
+    || resolutionHasDeletedTerminal(resolution)
+    || array(resolution.reasonCodes).some((code) => code === 'lineage-event-without-target-anchor' || code === 'inactive-anchor-has-active-candidates');
+}
+
+function resolutionHasDeletedTerminal(resolution) {
+  return array(resolution.lineageEventKinds).includes('deleted')
+    || array(resolution.reasonCodes).includes('anchor-deleted');
+}
+
 function queryAnchor(resolution) {
   return compactRecord({
     key: resolution.query?.anchorKey,
@@ -250,6 +292,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/semanticLineageHashEvidence.js

@@ -0,0 +1,97 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+
+export function addIdentityHashEvidence(before, after, add, note) {
+  const matches = matchingIdentityHashReasons(before, after);
+  if (matches.length === 0) return;
+  if (!compatibleLineageSurface(before, after)) {
+    note('identity-hash-match-surface-mismatch');
+    return;
+  }
+  const primary = matches.includes('semantic-identity-hash-match')
+    ? 'semantic-identity-hash-match'
+    : matches.includes('source-identity-hash-match')
+      ? 'source-identity-hash-match'
+      : 'identity-hash-match';
+  add(0.62, primary);
+  for (const reason of matches) {
+    if (reason !== primary) note(reason);
+  }
+}
+
+export function addSourceHashEvidence(before, after, add, note, reasons, sameSymbolSurface) {
+  const beforeHash = firstString(before.anchor.sourceHash, before.sourceHash);
+  const afterHash = firstString(after.anchor.sourceHash, after.sourceHash);
+  if (!beforeHash || !afterHash) return;
+  if (beforeHash !== afterHash) {
+    note('source-hash-changed');
+    return;
+  }
+  if (!hasSourceHashSupport(before, after, reasons, sameSymbolSurface)) {
+    note('source-hash-match-without-lineage-support');
+    return;
+  }
+  add(0.04, 'source-hash-match');
+  if (before.anchor.sourcePath && after.anchor.sourcePath && before.anchor.sourcePath !== after.anchor.sourcePath) {
+    note('source-hash-preserved-across-path');
+  }
+}
+
+export function hashEvidenceSummary(reasons) {
+  return {
+    semanticIdentityHashMatch: reasons.includes('semantic-identity-hash-match'),
+    sourceIdentityHashMatch: reasons.includes('source-identity-hash-match'),
+    identityHashMatch: reasons.includes('identity-hash-match'),
+    sourceHashMatch: reasons.includes('source-hash-match'),
+    signatureHashMatch: reasons.includes('signature-hash-match'),
+    bodyHashMatch: reasons.includes('body-hash-match')
+  };
+}
+
+function matchingIdentityHashReasons(before, after) {
+  const beforeHashes = identityHashEntries(before);
+  const afterHashes = new Map(identityHashEntries(after).map((entry) => [entry.value, entry.reason]));
+  const reasons = [];
+  for (const entry of beforeHashes) {
+    const afterReason = afterHashes.get(entry.value);
+    if (!afterReason) continue;
+    reasons.push(identityHashMatchReason(entry.reason, afterReason));
+  }
+  return uniqueStrings(reasons);
+}
+
+function identityHashEntries(symbol) {
+  return [
+    { reason: 'semantic-identity-hash-match', value: firstString(symbol.semanticIdentityHash, symbol.anchor.metadata?.semanticIdentityHash) },
+    { reason: 'source-identity-hash-match', value: firstString(symbol.sourceIdentityHash, symbol.anchor.metadata?.sourceIdentityHash) },
+    { reason: 'identity-hash-match', value: firstString(symbol.identityHash, symbol.anchor.metadata?.identityHash) }
+  ].filter((entry) => entry.value);
+}
+
+function identityHashMatchReason(beforeReason, afterReason) {
+  if (beforeReason === afterReason) return beforeReason;
+  if (beforeReason === 'semantic-identity-hash-match' || afterReason === 'semantic-identity-hash-match') return 'semantic-identity-hash-match';
+  if (beforeReason === 'source-identity-hash-match' || afterReason === 'source-identity-hash-match') return 'source-identity-hash-match';
+  return 'identity-hash-match';
+}
+
+function compatibleLineageSurface(before, after) {
+  return (!before.language || !after.language || before.language === after.language)
+    && (!before.kind || !after.kind || before.kind === after.kind)
+    && (!before.anchor.kind || !after.anchor.kind || before.anchor.kind === after.anchor.kind);
+}
+
+function hasSourceHashSupport(before, after, reasons, sameSymbolSurface) {
+  return reasons.some((reason) => [
+    'semantic-identity-hash-match',
+    'source-identity-hash-match',
+    'identity-hash-match',
+    'signature-hash-match',
+    'body-hash-match',
+    'symbol-name-match'
+  ].includes(reason))
+    || sameSymbolSurface(before, after);
+}
+
+function firstString(...values) {
+  return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
+}