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

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

@@ -24,7 +24,7 @@ export function spanOffsets(sourceText, span) {
   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 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 };
 }
@@ -49,36 +49,41 @@ export function bodyContentRange(sourceText, range) {
   return pair ? { start: pair.open + 1, end: pair.close } : undefined;
 }
 
-export function insertionOffset(sourceText, insertion) {
+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 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) };
+  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 };
-  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;
+  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 ?? '');
-  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';
+  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 sourceText[offset] === '\n' ? offset + 1 : offset;
+  return lineBreakEndOffset(sourceText, offset);
 }
 
 function isProjectionCoverableContainer(operation) {
@@ -112,15 +117,89 @@ function containedRange(inner, outer) {
 
 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;
+  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;

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

@@ -137,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];
   }));
 }
@@ -193,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') {
@@ -254,6 +262,17 @@ function anchorEntry(anchor, resolution) {
   });
 }
 
+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,

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);
+}

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

@@ -1,4 +1,5 @@
 import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { addIdentityHashEvidence, addSourceHashEvidence, hashEvidenceSummary } from './semanticLineageHashEvidence.js';
 import { createSemanticLineageEvent } from './semanticLineageRecords.js';
 
 export function matchExactAnchors(beforeSymbols, afterSymbols) {
@@ -88,6 +89,9 @@ export function symbolSummary(symbol) {
     language: symbol.language,
     sourcePath: symbol.anchor.sourcePath,
     sourceHash: symbol.anchor.sourceHash,
+    identityHash: firstString(symbol.identityHash, symbol.anchor.metadata?.identityHash),
+    semanticIdentityHash: firstString(symbol.semanticIdentityHash, symbol.anchor.metadata?.semanticIdentityHash),
+    sourceIdentityHash: firstString(symbol.sourceIdentityHash, symbol.anchor.metadata?.sourceIdentityHash),
     sourceSpan: symbol.anchor.sourceSpan,
     signatureHash: symbol.signatureHash,
     bodyHash: symbol.spanHash,
@@ -144,6 +148,7 @@ function inferredEvent(before, after, score, input) {
       inferred: true,
       algorithm: 'frontier.semantic-lineage-inference.v1',
       reasonCodes: score.reasons,
+      hashEvidence: hashEvidenceSummary(score.reasons),
       moved: pathChanged || spanMoved,
       renamed: nameChanged,
       recreated,
@@ -190,6 +195,7 @@ function inferredSplitEvent(before, candidates, input) {
       inferred: true,
       algorithm: 'frontier.semantic-lineage-inference.v1',
       reasonCodes: reasons,
+      hashEvidence: hashEvidenceSummary(reasons),
       split: true,
       targetCount: targets.length,
       candidateConfidences: candidates.map((candidate) => candidate.score.confidence),
@@ -210,10 +216,12 @@ function scoreLineagePair(before, after) {
   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');
+  addIdentityHashEvidence(before, after, add, note);
   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');
+  addSourceHashEvidence(before, after, add, note, reasons, sameSymbolSurface);
   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');

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

@@ -36,7 +36,12 @@ export function resolveSemanticLineage(eventsOrMap = [], query = {}, options = {
     state.status = 'max-depth';
     state.reasonCodes.push('max-depth');
   }
-  if (!state.cycle && !state.maxDepthHit) state.status = classifyResolutionStatus(state);
+  if (!state.cycle && !state.maxDepthHit) {
+    state.status = classifyResolutionStatus(state);
+    if (state.status === 'ambiguous' && state.terminal.length > 0 && state.current.length > 0) {
+      state.reasonCodes.push('inactive-anchor-has-active-candidates');
+    }
+  }
   return buildResolutionRecord(state, start, maxDepth, resolutionQuery, options);
 }
 
@@ -105,6 +110,7 @@ function applyLineageEvent(state, event, visitedEvents) {
   state.operationIds.push(event.crdt?.operationId);
   state.heads.push(...(event.crdt?.heads ?? []));
   state.eventKinds.push(event.eventKind);
+  state.reasonCodes.push(...lineageEventReasonCodes(event));
   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));
@@ -142,6 +148,7 @@ function nextLineageEvents(anchors, byFromKey, byFromId) {
 
 function classifyResolutionStatus(state) {
   if (state.current.length === 0 && state.traversed.length > 0) return 'deleted';
+  if (state.terminal.length > 0 && state.current.length > 0) return 'ambiguous';
   if (state.eventKinds.includes('recreated')) return 'recreated';
   if (state.current.length > 1 || state.eventKinds.includes('split') || state.eventKinds.includes('merged')) return 'ambiguous';
   if (state.traversed.length > 0) return 'resolved';
@@ -205,6 +212,16 @@ function lineageSourcePaths(state, start, query, anchors = []) {
     ...array(anchors).flatMap((anchor) => anchor?.lineageSourcePaths ?? [])
   ]);
 }
+function lineageEventReasonCodes(event) {
+  return uniqueStrings([
+    ...array(event.reasonCodes),
+    ...array(event.metadata?.reasonCodes),
+    event.evidence?.signatureHashMatch ? 'signature-hash-match' : undefined,
+    event.evidence?.bodyHashMatch ? 'body-hash-match' : undefined,
+    event.evidence?.pathMatch ? 'source-path-match' : undefined,
+    event.evidence?.sourceSpanMoved ? 'source-span-moved' : undefined
+  ]);
+}
 function positiveInteger(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;

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

@@ -1,6 +1,7 @@
 import{idFragment,normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
 import{semanticMergeConflictRiskScore}from'./semanticMergeConflicts.js';
 import{inferProjectionRisk,internalOverlaps,normalizeChangedSemanticRegions,normalizeProjectionRisk,projectionRiskRank,queryAdmissionOverlaps,summarizeOverlaps}from'./semanticMergeCandidateRecordInternals.js';
+import{semanticMergeCandidateScoreFacets}from'./semanticMergeCandidateScoreFacets.js';
 
 export const SemanticMergeCandidateProjectionRisks=Object.freeze(['low','medium','high','unknown']);
 
@@ -74,6 +75,21 @@ export function createSemanticMergeCandidateAdmissionRecord(input={},options={})
   const projectionRisk=normalizeProjectionRisk(options.projectionRisk??candidate.projectionRisk??candidate.risk)
     ??inferProjectionRisk({readiness,candidate,patch,changedSemanticRegions,conflictKeys});
   const overlaps=internalOverlaps(changedSemanticRegions);
+  const conflictRiskScore=semanticMergeConflictRiskScore(candidate);
+  const scoreFacets=semanticMergeCandidateScoreFacets({
+    source,
+    candidate,
+    patch,
+    readiness,
+    projectionRisk,
+    evidenceRecords,
+    evidenceIds,
+    proofIds,
+    changedSemanticRegions,
+    conflictKeys,
+    overlaps,
+    conflictRiskScore
+  });
   const readinessSortKey=semanticMergeCandidateReadinessSortKey({
     readiness,
     projectionRisk,
@@ -106,11 +122,13 @@ export function createSemanticMergeCandidateAdmissionRecord(input={},options={})
     evidenceIds,
     proofIds,
     overlapSummary:summarizeOverlaps(overlaps),
+    scoreFacets,
     admission:{
       readiness,
       reviewRequired:readiness!=='ready'||projectionRisk!=='low'||overlaps.length>0,
       action:admissionAction({readiness,projectionRisk,overlaps}),
       sortKey:readinessSortKey,
+      scoreFacets,
       reasonCodes:uniqueStrings([
         ...strings(options.reasonCodes),
         ...strings(source.reasons),
@@ -145,11 +163,12 @@ export function createSemanticMergeCandidateAdmissionRecord(input={},options={})
       overlaps:overlaps.length,
       readiness,
       projectionRisk,
-      reviewRequired:readiness!=='ready'||projectionRisk!=='low'||overlaps.length>0
+      reviewRequired:readiness!=='ready'||projectionRisk!=='low'||overlaps.length>0,
+      scoreFacets:scoreFacets.summary
     },
     metadata:compactRecord({
       sourceChangeSetId:source.kind==='frontier.lang.nativeSourceChangeSet'?source.id:undefined,
-      conflictRiskScore:semanticMergeConflictRiskScore(candidate),
+      conflictRiskScore,
       conflictSummary:candidate.conflictSummary??candidate.metadata?.conflictSummary??source.metadata?.semanticMergeConflictSummary,
       changedRegionProjectionSummary:source.metadata?.changedRegionProjectionSummary??candidate.metadata?.changedRegionProjectionSummary,
       compact:true,
@@ -170,6 +189,7 @@ export function decorateSemanticMergeCandidateForAdmission(input={},options={}){
     proofIds:admissionRecord.proofIds,
     projectionRisk:admissionRecord.projectionRisk,
     readinessSortKey:admissionRecord.readinessSortKey,
+    scoreFacets:admissionRecord.scoreFacets,
     mergeAdmission:admissionRecord
   };
 }