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

package/dist/declarations/native-project-admission-semantic-evidence.d.ts

@@ -0,0 +1,34 @@
+export type NativeProjectAdmissionSemanticEvidenceWarningCode =
+  | 'missing-ownership-regions'
+  | 'missing-patch-hints'
+  | (string & {});
+
+export interface NativeProjectAdmissionSemanticEvidenceWarning {
+  readonly code: NativeProjectAdmissionSemanticEvidenceWarningCode;
+  readonly reasonCode: NativeProjectAdmissionSemanticEvidenceWarningCode;
+  readonly severity: 'warning' | string;
+  readonly message: string;
+  readonly action: string;
+  readonly sourcePath?: string;
+  readonly sourcePaths: readonly string[];
+  readonly semanticSymbols: number;
+  readonly ownershipRegions: number;
+  readonly patchHints: number;
+  readonly semanticImportExpected: boolean;
+  readonly changedSource: boolean;
+}
+
+export interface NativeProjectAdmissionSemanticEvidence {
+  readonly empty: boolean;
+  readonly emptySourceCount: number;
+  readonly emptySourcePaths: readonly string[];
+  readonly symbols: number;
+  readonly occurrences: number;
+  readonly relations: number;
+  readonly facts: number;
+  readonly evidenceRecords: number;
+  readonly warningCount: number;
+  readonly warningReasonCodes: readonly NativeProjectAdmissionSemanticEvidenceWarningCode[];
+  readonly warningSourcePaths: readonly string[];
+  readonly warnings: readonly NativeProjectAdmissionSemanticEvidenceWarning[];
+}

package/dist/declarations/native-project-admission.d.ts

@@ -2,7 +2,13 @@ import type { FrontierSourceLanguage, SemanticMergeReadiness } from '@shapeshift
 import type { NativeImportLossSummary } from './native-import-losses.js';
 import type { NativeImportResultContract } from './native-import-contracts.js';
 import type { NativeProjectImportResult } from './native-project.js';
+import type { NativeProjectAdmissionSemanticEvidence } from './native-project-admission-semantic-evidence.js';
 import type { SemanticMergeCandidateAdmissionRecord, SemanticMergeCandidateOverlapRecord, SemanticMergeCandidateProjectionRisk } from './semantic-merge-candidates.js';
+export type {
+  NativeProjectAdmissionSemanticEvidence,
+  NativeProjectAdmissionSemanticEvidenceWarning,
+  NativeProjectAdmissionSemanticEvidenceWarningCode
+} from './native-project-admission-semantic-evidence.js';
 export type NativeProjectImportAdmissionAction = 'admit' | 'prioritize' | 'reject';
 export type NativeProjectImportAdmissionPriority = 'low' | 'normal' | 'high' | 'critical' | 'blocker';
 export type NativeProjectImportAdmissionRisk = 'low' | 'medium' | 'high' | 'unknown';
@@ -133,16 +139,6 @@ export interface NativeProjectAdmissionLanguages {
   readonly readinessRows: readonly NativeProjectAdmissionLanguageReadinessSummary[];
   readonly rows: readonly NativeProjectAdmissionLanguageSummary[];
 }
-export interface NativeProjectAdmissionSemanticEvidence {
-  readonly empty: boolean;
-  readonly emptySourceCount: number;
-  readonly emptySourcePaths: readonly string[];
-  readonly symbols: number;
-  readonly occurrences: number;
-  readonly relations: number;
-  readonly facts: number;
-  readonly evidenceRecords: number;
-}
 export type NativeProjectAdmissionSourceStalenessReason =
   | 'source-hash-mismatch'
   | 'content-hash-mismatch'

package/dist/declarations/semantic-edit-script.d.ts

@@ -147,7 +147,10 @@ export interface SemanticEditProjectionEdit {
   readonly replacementBytes: number;
   readonly deletedTextHash?: string;
   readonly replacementTextHash?: string;
+  readonly deletedTextLineEndingStableHash?: string;
+  readonly replacementTextLineEndingStableHash?: string;
   readonly replacementSpanTextHash?: string;
+  readonly replacementSpanTextLineEndingStableHash?: string;
   readonly insertionMode?: string;
   readonly insertionAnchorKey?: string;
   readonly insertionAnchorSymbolName?: string;

package/dist/declarations/semantic-patch-bundle-overlaps.d.ts

@@ -71,6 +71,7 @@ export interface SemanticPatchBundleOverlapRecord {
     readonly sourceSignals: number;
     readonly baseHashMismatch: boolean;
     readonly targetHashMismatch: boolean;
+    readonly replayOutputHashMismatch: boolean;
   };
   readonly metadata?: Record<string, unknown>;
 }

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

@@ -19,7 +19,7 @@ export function createProjectImportAdmissionRecord(projectResult,options={}){
     ...(projectResult?.mergeCandidates??[]),
     ...imports.flatMap((imported)=>imported?.mergeCandidates??[])
   ]);
-  const importSummaries=projectAdmissionImports(imports,contract?.sources??[],mergeCandidates);
+  const importSummaries=projectAdmissionImports(imports,contract?.sources??[],mergeCandidates,projectResult);
   const languages=admissionLanguages(importSummaries);
   const semanticEvidence=admissionSemanticEvidence(projectResult,imports,importSummaries);
   const sourceStaleness=admissionSourceStaleness(imports,importSummaries,contract);
@@ -42,7 +42,10 @@ export function createProjectImportAdmissionRecord(projectResult,options={}){
     failedEvidenceIds,
     blockingLossIds:contract?.readiness?.blockingLossIds??lossSummary?.blockingLossIds??[]
   });
-  const priorityReasons=admissionPriorityReasons({readiness,semanticEvidence,sourcePreservation,ownership,mergeCandidateRisk});
+  const priorityReasons=uniqueStrings([
+    ...admissionPriorityReasons({readiness,semanticEvidence,sourcePreservation,ownership,mergeCandidateRisk}),
+    ...semanticAdmissionWarningReasons(semanticEvidence)
+  ]);
   const action=rejectionReasons.length?'reject':priorityReasons.length?'prioritize':'admit';
   const priority=admissionPriority(action,readiness,sourcePreservation,mergeCandidateRisk);
   const mergeScore=admissionMergeScore({
@@ -221,6 +224,15 @@ function admissionSourcePreservationWithStaleness(sourcePreservation,sourceStale
   };
 }
 
+function semanticAdmissionWarningReasons(semanticEvidence){
+  return (semanticEvidence?.warnings??[]).map((warning)=>{
+    const reasonCode=warning.reasonCode??warning.code;
+    const sourcePaths=warning.sourcePaths?.length?warning.sourcePaths:warning.sourcePath?[warning.sourcePath]:[];
+    const sourceText=sourcePaths.length?` for ${sourcePaths.join(', ')}`:'';
+    return `Project import semantic admission warning ${reasonCode}${sourceText}.`;
+  });
+}
+
 function sourcePaths(records){
   return uniqueStrings(records.map((record)=>record.sourcePath).filter(Boolean));
 }

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

@@ -37,5 +37,86 @@ export function diffNativeSymbols(beforeSymbols, afterSymbols) {
       readiness: maxSemanticMergeReadiness(before?.readiness ?? 'ready', after?.readiness ?? 'ready')
     });
   }
-  return changed;
+  return downgradeCoveredContainerSymbols(changed);
 }
+
+function downgradeCoveredContainerSymbols(symbols) {
+  return symbols.filter((symbol) => !nativeDiffContainerCoveredByMorePreciseChange(symbol, symbols));
+}
+
+function nativeDiffContainerCoveredByMorePreciseChange(symbol, symbols) {
+  if (symbol.changeKind !== 'modified') return false;
+  if (!nativeDiffSymbolIsContainer(symbol)) return false;
+  if (nativeDiffSymbolHasOwnChange(symbol)) return false;
+  return symbols.some((candidate) => candidate !== symbol && nativeDiffSymbolIsMorePreciseNestedChange(candidate, symbol));
+}
+
+function nativeDiffSymbolHasOwnChange(symbol) {
+  return ((symbol.beforeSignatureHash ?? '') !== (symbol.afterSignatureHash ?? ''))
+    || ((symbol.beforeOwnershipKey ?? '') !== (symbol.afterOwnershipKey ?? ''))
+    || ((symbol.beforeNativeAstNodeId ?? '') !== (symbol.afterNativeAstNodeId ?? ''));
+}
+
+function nativeDiffSymbolIsMorePreciseNestedChange(candidate, container) {
+  if (candidate.changeKind === 'unchanged') return false;
+  if (nativeDiffSymbolIsContainer(candidate)) return false;
+  if ((candidate.ownershipKey ?? '') === (container.ownershipKey ?? '')) return false;
+  if (!nativeDiffAnySpanContains(container, candidate)) return false;
+  return nativeDiffNestedSymbolName(candidate, container) || nativeDiffSymbolIsMember(candidate);
+}
+
+function nativeDiffSymbolIsContainer(symbol) {
+  return nativeDiffContainerKinds.has(nativeDiffKind(symbol.ownershipRegionKind ?? symbol.kind));
+}
+
+function nativeDiffSymbolIsMember(symbol) {
+  return nativeDiffMemberKinds.has(nativeDiffKind(symbol.ownershipRegionKind ?? symbol.kind));
+}
+
+function nativeDiffNestedSymbolName(candidate, container) {
+  const candidateName = String(candidate.name ?? '');
+  const containerName = String(container.name ?? '');
+  return Boolean(containerName && candidateName && candidateName !== containerName && candidateName.startsWith(`${containerName}.`));
+}
+
+function nativeDiffAnySpanContains(container, candidate) {
+  return nativeDiffSymbolSpans(container).some((containerSpan) => nativeDiffSymbolSpans(candidate).some((candidateSpan) => (
+    nativeDiffSameSourcePath(candidateSpan, containerSpan) && nativeDiffSpanContains(containerSpan, candidateSpan)
+  )));
+}
+
+function nativeDiffSymbolSpans(symbol) {
+  return [symbol.sourceSpan, symbol.beforeSourceSpan, symbol.afterSourceSpan].filter(Boolean);
+}
+
+function nativeDiffSameSourcePath(left, right) {
+  const leftPath = left?.path;
+  const rightPath = right?.path;
+  return !leftPath || !rightPath || leftPath === rightPath;
+}
+
+function nativeDiffSpanContains(containerSpan, candidateSpan) {
+  const container = nativeDiffSpanRange(containerSpan);
+  const candidate = nativeDiffSpanRange(candidateSpan);
+  if (!container || !candidate) return false;
+  return container.start <= candidate.start && candidate.end <= container.end && (container.start !== candidate.start || container.end !== candidate.end);
+}
+
+function nativeDiffSpanRange(span) {
+  const startLine = Number(span?.startLine ?? span?.line ?? span?.start?.line);
+  const endLine = Number(span?.endLine ?? span?.end?.line ?? startLine);
+  if (!Number.isFinite(startLine) || !Number.isFinite(endLine)) return undefined;
+  const startColumn = Number(span?.startColumn ?? span?.column ?? span?.start?.column ?? 0);
+  const endColumn = Number(span?.endColumn ?? span?.end?.column ?? startColumn);
+  return {
+    start: startLine * 100000 + (Number.isFinite(startColumn) ? startColumn : 0),
+    end: endLine * 100000 + Math.max(Number.isFinite(startColumn) ? startColumn : 0, Number.isFinite(endColumn) ? endColumn : 0)
+  };
+}
+
+function nativeDiffKind(value) {
+  return String(value ?? '').toLowerCase();
+}
+
+const nativeDiffContainerKinds = new Set(['type', 'class', 'interface', 'trait', 'protocol', 'struct', 'enum', 'record']);
+const nativeDiffMemberKinds = new Set(['body', 'method', 'function', 'property', 'declaration']);

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

@@ -1,5 +1,6 @@
 import{uniqueStrings}from'../../native-import-utils.js';
 import{nativeImportCategoryForLossKind}from'./nativeImportCategoryForLossKind.js';
+export{summarizeSemanticAdmissionWarnings}from'./projectImportAdmissionSemanticWarnings.js';
 
 export function importLosses(imported){
   const nativeAst=imported?.nativeAst??imported?.nativeSource?.ast;
@@ -157,4 +158,3 @@ export function summarizeImportPreservation(imported,source){
   const quality=stale?'stale':missing?'missing':truncated||!exactSourceAvailable||sourcePreservationLosses.length?'lossy':'exact';
   return {quality,missing,stale,truncated,exactSourceAvailable,lossCount:sourcePreservationLosses.length,id:record?.id};
 }
-

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

@@ -0,0 +1,178 @@
+import { uniqueRecordsById, uniqueStrings } from '../../native-import-utils.js';
+import { semanticOwnershipRegionsFromSemanticIndex } from '../../semantic-import-regions.js';
+
+export function summarizeSemanticAdmissionWarnings(imported, context = {}) {
+  const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
+  const symbols = semanticSymbolsForImport(imported, semanticIndex);
+  const ownershipRegions = semanticOwnershipRegionsForImport(imported, semanticIndex);
+  const patchHints = semanticPatchHintsForImport(imported, semanticIndex);
+  const sourcePath = firstString(context.sourcePath, context.source?.sourcePath, imported?.sourcePath, imported?.nativeSource?.sourcePath, imported?.nativeAst?.sourcePath, semanticIndex?.documents?.[0]?.path);
+  const semanticImportExpected = isSemanticImportExpected(imported, context);
+  const semanticImportExpectedEmpty = isSemanticImportExpectedEmpty(imported, context);
+  const changedSource = isChangedSemanticAdmissionSource(imported, { ...context, sourcePath });
+  const warnings = [];
+  if (semanticImportExpected && !semanticImportExpectedEmpty && changedSource && symbols.length > 0 && ownershipRegions.length === 0) {
+    warnings.push(semanticAdmissionWarning({
+      code: 'missing-ownership-regions',
+      message: 'Semantic import was expected for a changed source and produced symbols, but no ownership regions were available.',
+      action: 'rerun-sidecar-generation-with-ownership-regions',
+      sourcePath,
+      symbols,
+      ownershipRegions,
+      patchHints,
+      semanticImportExpected,
+      changedSource
+    }));
+  }
+  if (semanticImportExpected && !semanticImportExpectedEmpty && changedSource && symbols.length > 0 && patchHints.length === 0) {
+    warnings.push(semanticAdmissionWarning({
+      code: 'missing-patch-hints',
+      message: 'Semantic import was expected for a changed source and produced symbols, but no patch hints were available.',
+      action: 'generate-semantic-patch-hints',
+      sourcePath,
+      symbols,
+      ownershipRegions,
+      patchHints,
+      semanticImportExpected,
+      changedSource
+    }));
+  }
+  return {
+    semanticImportExpected,
+    semanticImportExpectedEmpty,
+    changedSource,
+    symbolCount: symbols.length,
+    ownershipRegionCount: ownershipRegions.length,
+    patchHintCount: patchHints.length,
+    warningCount: warnings.length,
+    reasonCodes: uniqueStrings(warnings.map((warning) => warning.reasonCode)),
+    warnings
+  };
+}
+
+function semanticAdmissionWarning(input) {
+  return {
+    code: input.code,
+    reasonCode: input.code,
+    severity: 'warning',
+    message: input.message,
+    action: input.action,
+    ...(input.sourcePath ? { sourcePath: input.sourcePath } : {}),
+    sourcePaths: uniqueStrings([input.sourcePath].filter(Boolean)),
+    semanticSymbols: input.symbols.length,
+    ownershipRegions: input.ownershipRegions.length,
+    patchHints: input.patchHints.length,
+    semanticImportExpected: input.semanticImportExpected,
+    changedSource: input.changedSource
+  };
+}
+
+function semanticSymbolsForImport(imported, semanticIndex) {
+  if (Array.isArray(semanticIndex?.symbols)) return semanticIndex.symbols;
+  for (const symbols of [
+    imported?.semanticSymbols,
+    imported?.symbols,
+    imported?.metadata?.semanticSymbols,
+    imported?.metadata?.symbols
+  ]) {
+    if (Array.isArray(symbols)) return symbols;
+  }
+  return [];
+}
+
+function semanticOwnershipRegionsForImport(imported, semanticIndex) {
+  return uniqueRecordsById([
+    ...(Array.isArray(imported?.ownershipRegions) ? imported.ownershipRegions : []),
+    ...(Array.isArray(imported?.semanticOwnershipRegions) ? imported.semanticOwnershipRegions : []),
+    ...semanticOwnershipRegionsFromSemanticIndex(semanticIndex),
+    ...(Array.isArray(imported?.universalAst?.ownershipRegions) ? imported.universalAst.ownershipRegions : []),
+    ...(Array.isArray(imported?.metadata?.ownershipRegions) ? imported.metadata.ownershipRegions : [])
+  ]);
+}
+
+function semanticPatchHintsForImport(imported, semanticIndex) {
+  return uniqueRecordsById([
+    ...(Array.isArray(imported?.patchHints) ? imported.patchHints : []),
+    ...(Array.isArray(imported?.semanticPatchHints) ? imported.semanticPatchHints : []),
+    ...(Array.isArray(semanticIndex?.patchHints) ? semanticIndex.patchHints : []),
+    ...(Array.isArray(imported?.universalAst?.patchHints) ? imported.universalAst.patchHints : []),
+    ...(Array.isArray(imported?.metadata?.patchHints) ? imported.metadata.patchHints : [])
+  ]);
+}
+
+function isSemanticImportExpected(imported, context) {
+  return semanticExpectationRecords(imported, context).some((entry) =>
+    entry.semanticImportExpected === true
+    || entry.expectedSemanticImport === true
+    || entry.semanticSidecarExpected === true
+    || entry.expected === true && looksLikeSemanticSidecarQuality(entry)
+  );
+}
+
+function isSemanticImportExpectedEmpty(imported, context) {
+  return semanticExpectationRecords(imported, context).some((entry) =>
+    entry.semanticImportExpectedEmpty === true
+    || entry.expectedSemanticImportEmpty === true
+    || entry.semanticSidecarExpectedEmpty === true
+    || entry.expectedEmpty === true && looksLikeSemanticSidecarQuality(entry)
+  );
+}
+
+function isChangedSemanticAdmissionSource(imported, context) {
+  const sourcePath = context.sourcePath;
+  const changedSourcePaths = uniqueStrings([
+    ...(context.projectResult?.changedSourcePaths ?? []),
+    ...(context.projectResult?.metadata?.changedSourcePaths ?? []),
+    ...(context.projectResult?.metadata?.semanticChangedSourcePaths ?? []),
+    ...(context.projectResult?.metadata?.semanticImportChangedSourcePaths ?? [])
+  ]);
+  return Boolean(
+    (context.candidates?.length ?? 0) > 0
+    || (sourcePath && changedSourcePaths.includes(sourcePath))
+    || semanticExpectationRecords(imported, context).some((entry) =>
+      entry.changedSource === true
+      || entry.sourceChanged === true
+      || entry.semanticSourceChanged === true
+      || entry.semanticImportChangedSource === true
+    )
+  );
+}
+
+function semanticExpectationRecords(imported, context) {
+  const nativeAst = imported?.nativeAst ?? imported?.nativeSource?.ast;
+  const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
+  return [
+    context.projectResult?.metadata,
+    context.source?.metadata,
+    imported?.metadata,
+    imported?.nativeSource?.metadata,
+    nativeAst?.metadata,
+    imported?.universalAst?.metadata,
+    imported?.patch?.metadata,
+    semanticIndex?.metadata,
+    imported?.semanticSidecarQuality,
+    imported?.sidecarQuality,
+    imported?.semanticSidecar?.quality,
+    imported?.sidecar?.quality,
+    imported?.metadata?.semanticSidecarQuality,
+    imported?.metadata?.sidecarQuality,
+    imported?.patch?.metadata?.semanticSidecarQuality
+  ].filter((entry) => entry && typeof entry === 'object');
+}
+
+function looksLikeSemanticSidecarQuality(value) {
+  return value && typeof value === 'object' && (
+    value.schema === 'frontier.lang.semanticSidecarQuality.v1'
+    || value.imported !== undefined
+    || value.expectedSatisfied !== undefined
+    || value.warningCount !== undefined
+    || value.proofSummary !== undefined
+  );
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && String(value)) return String(value);
+  }
+  return undefined;
+}

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

@@ -1,12 +1,12 @@
 import{countBy,maxSemanticMergeReadiness,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
 import{createSemanticMergeCandidateAdmissionRecord,querySemanticMergeCandidateAdmissionOverlaps,sortSemanticMergeCandidateAdmissionRecords}from'./semanticMergeCandidateRecords.js';
-import{compactAdmissionSource,importLosses,sourceLossClasses,summarizeImportPreservation,summarizeParserEvidence}from'./projectImportAdmissionImportEvidence.js';
+import{compactAdmissionSource,importLosses,sourceLossClasses,summarizeImportPreservation,summarizeParserEvidence,summarizeSemanticAdmissionWarnings}from'./projectImportAdmissionImportEvidence.js';
 import{sourceMissingEvidence,sourceMissingTasks,sourceSemanticMergeScore}from'./projectImportAdmissionTasks.js';
 import{candidateRisk,maxPreservationQuality,maxRisk,normalizeRisk}from'./projectImportAdmissionRanks.js';
 
 export{admissionLanguages}from'./projectImportAdmissionLanguageSummaries.js';
 
-export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
+export function projectAdmissionImports(imports,sourceRows,mergeCandidates,projectResult){
   return imports.map((imported,index)=>{
     const source=sourceRows?.[index]??compactAdmissionSource(imported,index);
     const sourcePath=source.sourcePath??imported?.sourcePath;
@@ -22,6 +22,7 @@ export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
     };
     const readiness=source.readiness??imported?.metadata?.semanticMergeReadiness??candidates[0]?.readiness??'ready';
     const emptySemanticEvidence=Object.values(semanticCounts).reduce((sum,value)=>sum+value,0)===0;
+    const semanticAdmission=summarizeSemanticAdmissionWarnings(imported,{source,sourcePath,candidates,projectResult});
     const sourcePreservation=summarizeImportPreservation(imported,source);
     const losses=importLosses(imported);
     const lossClasses=sourceLossClasses(imported,losses);
@@ -55,6 +56,7 @@ export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
       readiness,
       semanticCounts,
       emptySemanticEvidence,
+      semanticAdmission,
       parserEvidence,
       lossClasses,
       missingEvidence,
@@ -90,6 +92,7 @@ export function admissionSemanticEvidence(projectResult,imports,importSummaries)
     .filter((entry)=>entry.emptySemanticEvidence)
     .map((entry)=>entry.sourcePath)
     .filter(Boolean));
+  const warnings=uniqueSemanticAdmissionWarnings(importSummaries.flatMap((entry)=>entry.semanticAdmission?.warnings??[]));
   return {
     empty:Object.values(totals).reduce((sum,value)=>sum+value,0)===0,
     emptySourceCount:importSummaries.filter((entry)=>entry.emptySemanticEvidence).length,
@@ -98,10 +101,26 @@ export function admissionSemanticEvidence(projectResult,imports,importSummaries)
     evidenceRecords:uniqueRecordsById([
       ...(projectResult?.evidence??[]),
       ...imports.flatMap((imported)=>imported?.evidence??[])
-    ]).length
+    ]).length,
+    warningCount:warnings.length,
+    warningReasonCodes:uniqueStrings(warnings.map((warning)=>warning.reasonCode??warning.code)),
+    warningSourcePaths:uniqueStrings(warnings.flatMap((warning)=>warning.sourcePaths??[warning.sourcePath]).filter(Boolean)),
+    warnings
   };
 }
 
+function uniqueSemanticAdmissionWarnings(warnings){
+  const seen=new Set();
+  const result=[];
+  for(const warning of warnings.filter(Boolean)){
+    const key=[warning.reasonCode??warning.code,(warning.sourcePaths??[warning.sourcePath]).join('|')].join('\u0000');
+    if(seen.has(key)) continue;
+    seen.add(key);
+    result.push(warning);
+  }
+  return result;
+}
+
 export function admissionSourcePreservation(importSummaries,contract){
   const qualities=importSummaries.map((entry)=>entry.sourcePreservation.quality);
   const quality=qualities.length?qualities.reduce(maxPreservationQuality,'exact'):'empty';

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

@@ -3,7 +3,8 @@ import { idFragment, normalizeNativeLanguageId, uniqueStrings } from '../../nati
 import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
 import { mapDiffSymbols } from './mapDiffSymbols.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
-import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+import { alreadyAppliedImportEditForOperation } from './semanticEditImportProjection.js';
+import { projectionEditRecord } from './semanticEditProjectionRecord.js';
 import {
   insertionOffset,
   insertionReplacement,
@@ -40,7 +41,8 @@ export function projectSemanticEditScriptToSource(input = {}) {
     }
     const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, {
       headSourcePath: input.headSourcePath,
-      headSymbols
+      headSymbols,
+      symbolIndexAvailable: isJavaScriptLike(language)
     });
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
@@ -175,14 +177,20 @@ function insertionEditForOperation(operation, identity, workerSourceText, headSo
   const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
   const reasons = [];
   if (!workerOffsets) reasons.push(`worker-span-not-resolvable:${operation.id}`);
-  const insertion = insertionOffset(headSourceText, operation.insertion, { symbols: context.headSymbols });
-  if (!insertion.ok) reasons.push(...insertion.reasonCodes.map((reason) => `${reason}:${operation.id}`));
   if (reasons.length) return { ok: false, reasonCodes: reasons };
   const spanText = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
   if (operation.hashes?.workerTextHash && hashSemanticValue(spanText) !== operation.hashes.workerTextHash) {
     reasons.push(`worker-span-hash-mismatch:${operation.id}`);
   }
   if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const alreadyAppliedImport = alreadyAppliedImportEditForOperation(operation, identity, spanText, headSourceText, workerOffsets, order, context);
+  if (alreadyAppliedImport) return { ok: true, value: alreadyAppliedImport };
+  const insertion = insertionOffset(headSourceText, operation.insertion, {
+    symbols: context.headSymbols,
+    symbolIndexAvailable: context.symbolIndexAvailable
+  });
+  if (!insertion.ok) reasons.push(...insertion.reasonCodes.map((reason) => `${reason}:${operation.id}`));
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
   return {
     ok: true,
     value: {
@@ -212,64 +220,6 @@ function projectionIdentity(operation, headSourcePath) {
     : identity.targetSourcePath;
   return { ...identity, sourcePath, originalSourcePath, targetSourcePath };
 }
-function projectionEditRecord(edit) {
-  const deletedTextHash = hashSemanticValue(edit.current);
-  const replacementTextHash = hashSemanticValue(edit.replacement);
-  const identity = semanticEditIdentityFields(edit);
-  return compactRecord({
-    operationId: edit.operationId,
-    status: edit.alreadyApplied ? 'already-applied' : 'applied',
-    kind: edit.kind,
-    editKind: edit.editKind,
-    changeKind: edit.changeKind,
-    anchorKey: edit.anchorKey,
-    conflictKey: edit.conflictKey,
-    regionId: edit.regionId,
-    regionKind: edit.regionKind,
-    sourcePath: edit.sourcePath,
-    originalSourcePath: edit.originalSourcePath,
-    targetAnchorKey: edit.targetAnchorKey,
-    targetSourcePath: edit.targetSourcePath,
-    targetSymbolName: edit.targetSymbolName,
-    targetSymbolKind: edit.targetSymbolKind,
-    symbolId: edit.symbolId,
-    symbolName: edit.symbolName,
-    symbolKind: edit.symbolKind,
-    ...identity,
-    operationContentHash: edit.operationContentHash,
-    editContentHash: hashSemanticValue(compactRecord({
-      semanticIdentityHash: identity.semanticIdentityHash,
-      sourceRangeKind: edit.sourceRangeKind,
-      deletedTextHash,
-      replacementTextHash,
-      status: edit.alreadyApplied ? 'already-applied' : 'applied'
-    })),
-    sourceRangeKind: edit.sourceRangeKind,
-    headStart: edit.start,
-    headEnd: edit.end,
-    workerStart: edit.workerStart,
-    workerEnd: edit.workerEnd,
-    editOrder: edit.order,
-    headAnchorStart: edit.headAnchorStart,
-    headAnchorEnd: edit.headAnchorEnd,
-    workerAnchorStart: edit.workerAnchorStart,
-    workerAnchorEnd: edit.workerAnchorEnd,
-    deletedBytes: edit.current.length,
-    replacementBytes: edit.replacement.length,
-    deletedTextHash,
-    replacementTextHash,
-    anchorDeletedTextHash: edit.anchorDeletedTextHash,
-    anchorReplacementTextHash: edit.anchorReplacementTextHash,
-    replacementSpanTextHash: hashSemanticValue(edit.replacementSpanText ?? edit.replacement),
-    insertionMode: edit.insertion?.mode,
-    insertionAnchorKey: edit.insertion?.anchorKey,
-    insertionAnchorSymbolName: edit.insertion?.anchorSymbolName,
-    insertionAnchorSymbolKind: edit.insertion?.anchorSymbolKind,
-    insertionAnchorCandidates: edit.insertion?.anchorCandidates,
-    replacementText: edit.replacement
-  });
-}
-
 function sourceSymbolIndex(input) {
   try {
     const imported = normalizeNativeDiffImport({

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

@@ -4,7 +4,14 @@ import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
 import { mapDiffSymbols } from './mapDiffSymbols.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
 import { replayDiagnostics, replayEditDiagnostics, replayEditsWithOverlapDiagnostics } from './semanticEditReplayDiagnostics.js';
-import { afterLineOffset, bodyContentRange, spanOffsets } from './semanticEditSourceRanges.js';
+import {
+  findCurrentSymbol,
+  findInsertionAnchor,
+  hasSymbolAnchorIdentity,
+  insertionAnchorCandidates,
+  insertionRange
+} from './semanticEditReplayAnchors.js';
+import { bodyContentRange, removalRange, spanOffsets } from './semanticEditSourceRanges.js';
 
 export function replaySemanticEditProjection(input = {}) {
   const projection = input.projection ?? input.semanticEditProjection;
@@ -19,7 +26,11 @@ export function replaySemanticEditProjection(input = {}) {
     ? currentSymbolIndex({ currentSourceText, sourcePath, language, parser: input.parser })
     : [];
   const replayedEdits = projection.status === 'projected' && typeof currentSourceText === 'string'
-    ? (projection.edits ?? []).map((edit, index) => replayProjectionEdit(projectionEditWithOrder(edit, index), { currentSourceText, currentSymbols }))
+    ? (projection.edits ?? []).map((edit, index) => replayProjectionEdit(projectionEditWithOrder(edit, index), {
+      currentSourceText,
+      currentSymbols,
+      symbolIndexAvailable: isJavaScriptLike(language)
+    }))
     : [];
   const edits = replayEditsWithOverlapDiagnostics(replayedEdits);
   const status = replayStatus(reasonCodes, edits, projection);
@@ -72,7 +83,7 @@ function replayProjectionEdit(edit, context) {
   const spanRange = currentSymbolEditRange(edit, spanOffsets(context.currentSourceText, symbol?.sourceSpan), context.currentSourceText);
   if (symbol && spanRange && !sameRange(headRange, spanRange)) {
     const moved = checkRange(edit, spanRange, context.currentSourceText, currentSymbolRangeLabel(edit));
-    if (moved) return replayEditRecord(edit, moved.status, moved.range, [moved.reason, 'offset-reanchored-by-symbol'], context.currentSourceText);
+    if (moved) return replayEditRecord(edit, moved.status, replayAppliedRange(edit, moved.range, context.currentSourceText), [moved.reason, 'offset-reanchored-by-symbol'], context.currentSourceText);
     if (edit.editKind === 'delete' && offset && rangesOverlap(headRange, spanRange)) {
       return replayEditRecord(edit, offset.status, offset.range, [offset.reason], context.currentSourceText);
     }
@@ -80,12 +91,17 @@ function replayProjectionEdit(edit, context) {
   }
   if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason], context.currentSourceText);
   const anchored = checkRange(edit, spanRange, context.currentSourceText, currentSymbolRangeLabel(edit));
-  if (anchored) return replayEditRecord(edit, anchored.status, anchored.range, [anchored.reason, 'offset-reanchored-by-symbol'], context.currentSourceText);
+  if (anchored) return replayEditRecord(edit, anchored.status, replayAppliedRange(edit, anchored.range, context.currentSourceText), [anchored.reason, 'offset-reanchored-by-symbol'], context.currentSourceText);
   return replayEditRecord(edit, symbol ? 'conflict' : 'stale', spanRange, [
     symbol ? `${currentSymbolRangeLabel(edit)}-content-mismatch` : 'current-symbol-anchor-missing'
   ], context.currentSourceText);
 }
 
+function replayAppliedRange(edit, range, sourceText) {
+  if (edit.editKind !== 'delete' || !range || typeof sourceText !== 'string') return range;
+  return removalRange(sourceText, range);
+}
+
 function replayInsertionEdit(edit, context) {
   const inserted = findCurrentSymbol(edit, context.currentSymbols);
   const insertedRange = spanOffsets(context.currentSourceText, inserted?.sourceSpan);
@@ -97,7 +113,8 @@ function replayInsertionEdit(edit, context) {
   const anchor = findInsertionAnchor(edit, context.currentSymbols);
   const range = insertionRange(edit, anchor?.candidate, anchor?.symbol, context.currentSourceText);
   if (range) return replayEditRecord(edit, 'applied', range, [anchor ? 'current-insertion-anchor' : `current-${edit.insertionMode}`], context.currentSourceText);
-  return replayEditRecord(edit, anchor ? 'conflict' : 'stale', undefined, [
+  const missingStableAnchor = context.symbolIndexAvailable && insertionAnchorCandidates(edit).some(hasSymbolAnchorIdentity);
+  return replayEditRecord(edit, anchor || missingStableAnchor ? 'conflict' : 'stale', undefined, [
     anchor ? 'current-insertion-anchor-unusable' : 'current-insertion-anchor-missing'
   ], context.currentSourceText);
 }
@@ -106,10 +123,26 @@ function checkRange(edit, range, sourceText, label) {
   if (!range || range.end < range.start) return undefined;
   const current = sourceText.slice(range.start, range.end);
   const currentHash = hashSemanticValue(current);
+  const currentLineEndingStableText = lineEndingStableText(current);
+  const currentLineEndingStableHash = currentLineEndingStableText === undefined
+    ? undefined
+    : hashSemanticValue(currentLineEndingStableText);
   if (edit.replacementSpanTextHash && currentHash === edit.replacementSpanTextHash) return { status: 'already-applied', range, reason: `${label}-matches-replacement-span` };
   if (edit.replacementTextHash && currentHash === edit.replacementTextHash) return { status: 'already-applied', range, reason: `${label}-matches-replacement` };
   if (current === edit.replacementText) return { status: 'already-applied', range, reason: `${label}-matches-replacement-text` };
+  if (edit.replacementSpanTextLineEndingStableHash && currentLineEndingStableHash === edit.replacementSpanTextLineEndingStableHash) {
+    return { status: 'already-applied', range, reason: `${label}-matches-replacement-span-line-ending-stable` };
+  }
+  if (edit.replacementTextLineEndingStableHash && currentLineEndingStableHash === edit.replacementTextLineEndingStableHash) {
+    return { status: 'already-applied', range, reason: `${label}-matches-replacement-line-ending-stable` };
+  }
+  if (typeof edit.replacementText === 'string' && currentLineEndingStableText === lineEndingStableText(edit.replacementText)) {
+    return { status: 'already-applied', range, reason: `${label}-matches-replacement-text-line-ending-stable` };
+  }
   if (edit.deletedTextHash && currentHash === edit.deletedTextHash) return { status: 'applied', range, reason: `${label}-matches-deleted` };
+  if (edit.deletedTextLineEndingStableHash && currentLineEndingStableHash === edit.deletedTextLineEndingStableHash) {
+    return { status: 'applied', range, reason: `${label}-matches-deleted-line-ending-stable` };
+  }
   return undefined;
 }
 
@@ -147,64 +180,6 @@ function currentSymbolIndex(input) {
   return [...mapDiffSymbols(imported, createSemanticImportSidecar(imported)).values()];
 }
 
-function findCurrentSymbol(edit, symbols) {
-  const exact = symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && [
-    edit.anchorKey,
-    edit.targetAnchorKey,
-    edit.symbolId
-  ].includes(key)));
-  if (exact) return exact;
-  const name = edit.targetSymbolName ?? edit.symbolName;
-  const kind = edit.targetSymbolKind ?? edit.symbolKind;
-  return symbols.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
-}
-
-function findInsertionAnchor(edit, symbols) {
-  for (const candidate of insertionAnchorCandidates(edit)) {
-    const symbol = findInsertionAnchorSymbol(candidate, symbols);
-    if (symbol) return { candidate, symbol };
-  }
-  return undefined;
-}
-
-function findInsertionAnchorSymbol(candidate, symbols) {
-  const keys = [candidate.anchorKey, candidate.anchorSymbolId].filter(Boolean);
-  return symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && keys.includes(key)))
-    ?? symbols.find((symbol) => symbol.name === candidate.anchorSymbolName && (!candidate.anchorSymbolKind || symbol.kind === candidate.anchorSymbolKind));
-}
-
-function insertionAnchorCandidates(edit) {
-  const primary = {
-    mode: edit.insertionMode,
-    anchorKey: edit.insertionAnchorKey,
-    anchorSymbolName: edit.insertionAnchorSymbolName,
-    anchorSymbolKind: edit.insertionAnchorSymbolKind
-  };
-  const seen = new Set();
-  const result = [];
-  for (const candidate of [primary, ...(Array.isArray(edit.insertionAnchorCandidates) ? edit.insertionAnchorCandidates : [])]) {
-    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 insertionRange(edit, candidate, anchor, sourceText) {
-  if (edit.insertionMode === 'file-start') return { start: 0, end: 0 };
-  if (edit.insertionMode === 'file-end') return { start: sourceText.length, end: sourceText.length };
-  const mode = candidate?.mode ?? edit.insertionMode;
-  const anchorRange = spanOffsets(sourceText, anchor?.sourceSpan);
-  if (!anchorRange) return undefined;
-  if (mode === 'before') return { start: anchorRange.start, end: anchorRange.start };
-  if (mode === 'after') {
-    return { start: afterLineOffset(sourceText, anchorRange.end), end: afterLineOffset(sourceText, anchorRange.end) };
-  }
-  return undefined;
-}
-
 function currentSymbolEditRange(edit, symbolRange, sourceText) {
   if (!symbolRange) return undefined;
   if (edit.sourceRangeKind === 'body-content') return bodyContentRange(sourceText, symbolRange);
@@ -296,4 +271,9 @@ function rangesOverlap(left, right) {
 
 function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }
 function reasonList(values) { return uniqueStrings((values ?? []).filter(Boolean)); }
+function lineEndingStableText(value) {
+  if (typeof value !== 'string') return undefined;
+  const normalized = value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  return normalized.length > 1 && normalized.endsWith('\n') ? normalized.slice(0, -1) : normalized;
+}
 function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -0,0 +1,53 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { spanOffsets } from './semanticEditSourceRanges.js';
+
+export function alreadyAppliedImportEditForOperation(operation, identity, spanText, headSourceText, workerOffsets, order, context) {
+  if (!isAddImportOperation(operation) || typeof headSourceText !== 'string') return undefined;
+  const match = findHeadImportSymbol(operation, context.headSymbols);
+  const range = spanOffsets(headSourceText, match?.symbol?.sourceSpan);
+  if (!range) return undefined;
+  const current = headSourceText.slice(range.start, range.end);
+  if (!headImportMatchesOperation(operation, spanText, current, match.symbol)) return undefined;
+  return {
+    operationId: operation.id,
+    order,
+    ...identity,
+    start: range.start,
+    end: range.end,
+    workerStart: workerOffsets.start,
+    workerEnd: workerOffsets.end,
+    replacement: current,
+    replacementSpanText: spanText,
+    current,
+    alreadyApplied: true
+  };
+}
+
+function findHeadImportSymbol(operation, symbols) {
+  const symbolList = Array.isArray(symbols) ? symbols : [];
+  const exactKeys = [
+    operation.anchor?.key,
+    operation.anchor?.symbolId,
+    operation.insertion?.insertedSymbolId
+  ].filter(Boolean);
+  const exact = symbolList.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && exactKeys.includes(key)));
+  if (exact) return { symbol: exact, exact: true };
+  const name = operation.insertion?.insertedSymbolName ?? operation.anchor?.symbolName;
+  const kind = operation.insertion?.insertedSymbolKind ?? operation.anchor?.symbolKind;
+  const semantic = symbolList.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
+  return semantic ? { symbol: semantic, exact: false } : undefined;
+}
+
+function headImportMatchesOperation(operation, spanText, current, symbol) {
+  const workerTextHash = operation.hashes?.workerTextHash ?? hashSemanticValue(spanText);
+  const workerSpanHash = operation.hashes?.workerSpanHash ?? workerTextHash;
+  const currentHash = hashSemanticValue(current);
+  if ([workerTextHash, workerSpanHash].includes(currentHash)) return true;
+  if ([workerTextHash, workerSpanHash].includes(symbol?.spanHash)) return true;
+  const signatureHash = operation.hashes?.afterSignatureHash;
+  return Boolean(signatureHash && symbol?.signatureHash === signatureHash);
+}
+
+function isAddImportOperation(operation) {
+  return operation?.kind === 'addImport' || (operation?.changeKind === 'added' && operation?.anchor?.regionKind === 'import');
+}

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

@@ -0,0 +1,79 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+
+export function projectionEditRecord(edit) {
+  const deletedTextHash = hashSemanticValue(edit.current);
+  const replacementTextHash = hashSemanticValue(edit.replacement);
+  const replacementSpanText = edit.replacementSpanText ?? edit.replacement;
+  const identity = semanticEditIdentityFields(edit);
+  return compactRecord({
+    operationId: edit.operationId,
+    status: edit.alreadyApplied ? 'already-applied' : 'applied',
+    kind: edit.kind,
+    editKind: edit.editKind,
+    changeKind: edit.changeKind,
+    anchorKey: edit.anchorKey,
+    conflictKey: edit.conflictKey,
+    regionId: edit.regionId,
+    regionKind: edit.regionKind,
+    sourcePath: edit.sourcePath,
+    originalSourcePath: edit.originalSourcePath,
+    targetAnchorKey: edit.targetAnchorKey,
+    targetSourcePath: edit.targetSourcePath,
+    targetSymbolName: edit.targetSymbolName,
+    targetSymbolKind: edit.targetSymbolKind,
+    symbolId: edit.symbolId,
+    symbolName: edit.symbolName,
+    symbolKind: edit.symbolKind,
+    ...identity,
+    operationContentHash: edit.operationContentHash,
+    editContentHash: hashSemanticValue(compactRecord({
+      semanticIdentityHash: identity.semanticIdentityHash,
+      sourceRangeKind: edit.sourceRangeKind,
+      deletedTextHash,
+      replacementTextHash,
+      status: edit.alreadyApplied ? 'already-applied' : 'applied'
+    })),
+    sourceRangeKind: edit.sourceRangeKind,
+    headStart: edit.start,
+    headEnd: edit.end,
+    workerStart: edit.workerStart,
+    workerEnd: edit.workerEnd,
+    editOrder: edit.order,
+    headAnchorStart: edit.headAnchorStart,
+    headAnchorEnd: edit.headAnchorEnd,
+    workerAnchorStart: edit.workerAnchorStart,
+    workerAnchorEnd: edit.workerAnchorEnd,
+    deletedBytes: edit.current.length,
+    replacementBytes: edit.replacement.length,
+    deletedTextHash,
+    replacementTextHash,
+    deletedTextLineEndingStableHash: lineEndingStableTextHash(edit.current),
+    replacementTextLineEndingStableHash: lineEndingStableTextHash(edit.replacement),
+    anchorDeletedTextHash: edit.anchorDeletedTextHash,
+    anchorReplacementTextHash: edit.anchorReplacementTextHash,
+    replacementSpanTextHash: hashSemanticValue(replacementSpanText),
+    replacementSpanTextLineEndingStableHash: lineEndingStableTextHash(replacementSpanText),
+    insertionMode: edit.insertion?.mode,
+    insertionAnchorKey: edit.insertion?.anchorKey,
+    insertionAnchorSymbolName: edit.insertion?.anchorSymbolName,
+    insertionAnchorSymbolKind: edit.insertion?.anchorSymbolKind,
+    insertionAnchorCandidates: edit.insertion?.anchorCandidates,
+    replacementText: edit.replacement
+  });
+}
+
+function lineEndingStableTextHash(value) {
+  const normalized = lineEndingStableText(value);
+  return normalized === undefined ? undefined : hashSemanticValue(normalized);
+}
+
+function lineEndingStableText(value) {
+  if (typeof value !== 'string') return undefined;
+  const normalized = value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  return normalized.length > 1 && normalized.endsWith('\n') ? normalized.slice(0, -1) : normalized;
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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

@@ -0,0 +1,63 @@
+import { afterLineOffset, spanOffsets } from './semanticEditSourceRanges.js';
+
+export function findCurrentSymbol(edit, symbols) {
+  const exact = symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && [
+    edit.anchorKey,
+    edit.targetAnchorKey,
+    edit.symbolId
+  ].includes(key)));
+  if (exact) return exact;
+  const name = edit.targetSymbolName ?? edit.symbolName;
+  const kind = edit.targetSymbolKind ?? edit.symbolKind;
+  return symbols.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
+}
+
+export function findInsertionAnchor(edit, symbols) {
+  for (const candidate of insertionAnchorCandidates(edit)) {
+    const symbol = findInsertionAnchorSymbol(candidate, symbols);
+    if (symbol) return { candidate, symbol };
+  }
+  return undefined;
+}
+
+export function insertionAnchorCandidates(edit) {
+  const primary = {
+    mode: edit.insertionMode,
+    anchorKey: edit.insertionAnchorKey,
+    anchorSymbolName: edit.insertionAnchorSymbolName,
+    anchorSymbolKind: edit.insertionAnchorSymbolKind
+  };
+  const seen = new Set();
+  const result = [];
+  for (const candidate of [primary, ...(Array.isArray(edit.insertionAnchorCandidates) ? edit.insertionAnchorCandidates : [])]) {
+    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;
+}
+
+export function hasSymbolAnchorIdentity(candidate) {
+  return Boolean(candidate.anchorKey || candidate.anchorSymbolId || candidate.anchorSymbolName);
+}
+
+export function insertionRange(edit, candidate, anchor, sourceText) {
+  if (edit.insertionMode === 'file-start') return { start: 0, end: 0 };
+  if (edit.insertionMode === 'file-end') return { start: sourceText.length, end: sourceText.length };
+  const mode = candidate?.mode ?? edit.insertionMode;
+  const anchorRange = spanOffsets(sourceText, anchor?.sourceSpan);
+  if (!anchorRange) return undefined;
+  if (mode === 'before') return { start: anchorRange.start, end: anchorRange.start };
+  if (mode === 'after') {
+    return { start: afterLineOffset(sourceText, anchorRange.end), end: afterLineOffset(sourceText, anchorRange.end) };
+  }
+  return undefined;
+}
+
+function findInsertionAnchorSymbol(candidate, symbols) {
+  const keys = [candidate.anchorKey, candidate.anchorSymbolId].filter(Boolean);
+  return symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && keys.includes(key)))
+    ?? symbols.find((symbol) => symbol.name === candidate.anchorSymbolName && (!candidate.anchorSymbolKind || symbol.kind === candidate.anchorSymbolKind));
+}

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

@@ -168,6 +168,7 @@ function insertionAnchorResolution(sourceText, insertion, context) {
     const range = spanOffsets(sourceText, symbol?.sourceSpan);
     if (range) return { mode: candidate.mode, range };
   }
+  if (context.symbolIndexAvailable && candidates.some(hasSymbolAnchorIdentity)) return undefined;
   for (const candidate of candidates) {
     const range = spanOffsets(sourceText, candidate.headSpan);
     if (range) return { mode: candidate.mode, range };
@@ -175,6 +176,10 @@ function insertionAnchorResolution(sourceText, insertion, context) {
   return undefined;
 }
 
+function hasSymbolAnchorIdentity(candidate) {
+  return Boolean(candidate.anchorKey || candidate.anchorSymbolId || candidate.anchorSymbolName);
+}
+
 function insertionAnchorCandidates(insertion) {
   const seen = new Set();
   const result = [];

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

@@ -2,7 +2,9 @@ import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-imp
 
 export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
   const transformAdmission = semanticTransformAdmission(context);
-  const semanticEditAdmission = context.semanticEditAdmission ?? { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] };
+  const semanticEditAdmission = semanticEditAdmissionWithReplayRequirement(
+    context.semanticEditAdmission ?? { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] }
+  );
   const evidenceAdmission = autoMergeEvidenceAdmission(context, { transformAdmission, semanticEditAdmission });
   const fallbackReadiness = fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, evidenceAdmission, context.readiness);
   const inputReadiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
@@ -35,7 +37,7 @@ export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
       ...strings(semanticEditAdmission.reasonCodes),
       ...strings(evidenceAdmission.reasonCodes)
     ].filter(Boolean)),
-    conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...context.conflictKeys]),
+    conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...strings(context.conflictKeys)]),
     admittedAt: input.admittedAt,
     reviewerId: input.reviewerId,
     evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(transformAdmission.evidenceIds), ...strings(evidenceAdmission.evidenceIds)]),
@@ -155,6 +157,7 @@ function fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, e
   if ([transformAdmission.readiness, semanticEditAdmission.readiness, evidenceAdmission.readiness].includes('blocked')) return 'blocked';
   if (hasSkipReadyAction(semanticEditAdmission)) return 'ready';
   if (hasPositiveApplyAction(transformAdmission, semanticEditAdmission)) return evidenceAdmission.action === 'admit' ? 'ready' : evidenceAdmission.readiness;
+  if (semanticEditAdmission.action === 'review' || semanticEditAdmission.status === 'needs-review') return 'needs-review';
   return fallback;
 }
 
@@ -183,6 +186,51 @@ function hasSkipReadyAction(semanticEditAdmission) {
   return semanticEditAdmission.action === 'skip' && semanticEditAdmission.readiness === 'ready' && semanticEditAdmission.reviewRequired === false;
 }
 
+function semanticEditAdmissionWithReplayRequirement(admission) {
+  if (!requiresSemanticEditReplay(admission) || hasAcceptedCleanSemanticEditReplay(admission)) return admission;
+  return compactRecord({
+    ...admission,
+    status: 'needs-review',
+    action: 'review',
+    readiness: 'needs-review',
+    reviewRequired: true,
+    autoApplyCandidate: false,
+    reasonCodes: uniqueStrings([
+      ...strings(admission.reasonCodes).filter((reason) => reason !== 'semantic-edit-positive-auto-merge-proof'),
+      ...semanticEditReplayRequirementReasonCodes(admission)
+    ])
+  });
+}
+
+function requiresSemanticEditReplay(admission) {
+  return admission.action === 'admit' ||
+    admission.autoApplyCandidate === true ||
+    admission.status === 'ready' ||
+    strings(admission.reasonCodes).includes('semantic-edit-positive-auto-merge-proof');
+}
+
+function hasAcceptedCleanSemanticEditReplay(admission) {
+  const summary = admission.summary ?? {};
+  const acceptedClean = count(summary.acceptedClean);
+  const alreadyApplied = count(summary.alreadyApplied);
+  const replays = count(summary.replays);
+  return acceptedClean > 0 && replays > 0 && acceptedClean + alreadyApplied === replays;
+}
+
+function semanticEditReplayRequirementReasonCodes(admission) {
+  const summary = admission.summary ?? {};
+  const scripts = count(summary.scripts);
+  const projections = count(summary.projections);
+  const replays = count(summary.replays);
+  const acceptedClean = count(summary.acceptedClean);
+  return [
+    scripts > 0 && projections === 0 ? 'semantic-edit-projection-missing' : undefined,
+    (scripts > 0 || projections > 0) && replays === 0 ? 'semantic-edit-replay-missing' : undefined,
+    replays > 0 && acceptedClean === 0 ? 'semantic-edit-replay-accepted-clean-missing' : undefined,
+    'semantic-edit-replay-required'
+  ].filter(Boolean);
+}
+
 function hasCrossLanguageTransform(index) {
   const source = new Set(strings(index.transformSourceLanguages));
   return strings(index.transformTargetLanguages).some((target) => !source.has(target));
@@ -211,6 +259,7 @@ function uniqueEvidenceRecords(records) {
 }
 
 function evidenceIds(evidence) { return uniqueStrings(evidence.map((record) => record.id)); }
+function count(value) { const number = Number(value ?? 0); return Number.isFinite(number) ? number : 0; }
 function array(value) { if (value === undefined || value === null) return []; return Array.isArray(value) ? value : [value]; }
 function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
 function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -65,7 +65,8 @@ export function compareSemanticPatchBundleRecords(left={},right={},options={}){
       semanticSignals:shared.semanticEditKeys.length+shared.semanticIdentityHashes.length+shared.sourceIdentityHashes.length+shared.semanticTransformIdentityHashes.length+shared.projectionIdentityHashes.length,
       sourceSignals:shared.regionKeys.length+shared.conflictKeys.length+shared.sourcePaths.length+shared.semanticEditReplayCurrentHashes.length,
       baseHashMismatch:admission.reasonCodes.includes('base-hash-mismatch'),
-      targetHashMismatch:admission.reasonCodes.includes('target-hash-mismatch')
+      targetHashMismatch:admission.reasonCodes.includes('target-hash-mismatch'),
+      replayOutputHashMismatch:admission.reasonCodes.includes('replay-output-hash-mismatch')
     },
     metadata:compactRecord(options.metadata)
   };
@@ -110,21 +111,32 @@ function sharedIndex(left,right,options){
     baseHashes:intersect(left.baseHashes,right.baseHashes),
     targetHashes:intersect(left.targetHashes,right.targetHashes)
   };
-  const scopedEdit=hasSharedEditScope(shared);
-  const scopedSource=hasSharedSourceScope(shared);
-  return{
+  const semanticKeyIndependent=hasDisjointSemanticEditScope(left,right,shared);
+  const scopedShared={
     ...shared,
-    operationContentHashes:scopedEdit?shared.operationContentHashes:[],
-    editContentHashes:scopedEdit?shared.editContentHashes:[],
-    semanticEditKeys:scopedSource?shared.semanticEditKeys:[],
-    semanticIdentityHashes:scopedSource?shared.semanticIdentityHashes:[],
-    semanticEditReplayCurrentHashes:scopedSource?shared.semanticEditReplayCurrentHashes:[],
-    semanticEditReplayOutputHashes:scopedEdit?shared.semanticEditReplayOutputHashes:[],
-    semanticTransformContentHashes:shared.projectionIdentityHashes.length?shared.semanticTransformContentHashes:[],
-    semanticTransformIdentityHashes:shared.projectionIdentityHashes.length?shared.semanticTransformIdentityHashes:[]
+    sourcePaths:semanticKeyIndependent?[]:shared.sourcePaths
+  };
+  const scopedEdit=hasSharedEditScope(scopedShared);
+  const scopedSource=hasSharedSourceScope(scopedShared);
+  return{
+    ...scopedShared,
+    operationContentHashes:scopedEdit?scopedShared.operationContentHashes:[],
+    editContentHashes:scopedEdit?scopedShared.editContentHashes:[],
+    semanticEditKeys:scopedSource?scopedShared.semanticEditKeys:[],
+    semanticIdentityHashes:scopedSource?scopedShared.semanticIdentityHashes:[],
+    semanticEditReplayCurrentHashes:scopedSource?scopedShared.semanticEditReplayCurrentHashes:[],
+    semanticEditReplayOutputHashes:scopedEdit?scopedShared.semanticEditReplayOutputHashes:[],
+    semanticTransformContentHashes:scopedShared.projectionIdentityHashes.length?scopedShared.semanticTransformContentHashes:[],
+    semanticTransformIdentityHashes:scopedShared.projectionIdentityHashes.length?scopedShared.semanticTransformIdentityHashes:[]
   };
 }
 
+function hasDisjointSemanticEditScope(left,right,shared){
+  return Boolean(shared.sourcePaths.length&&left.semanticEditKeys.length&&right.semanticEditKeys.length
+    &&shared.semanticEditKeys.length===0&&shared.regionKeys.length===0&&shared.conflictKeys.length===0
+    &&shared.semanticIdentityHashes.length===0&&shared.sourceIdentityHashes.length===0);
+}
+
 function hasSharedEditScope(shared){
   return Boolean(shared.regionKeys.length||shared.conflictKeys.length||shared.sourceIdentityHashes.length
     ||(shared.sourcePaths.length&&(shared.semanticEditKeys.length||shared.semanticIdentityHashes.length)));
@@ -135,7 +147,10 @@ function hasSharedSourceScope(shared){
 }
 
 function overlapAdmission(shared,{leftIndex,rightIndex,options}){
-  const hashMismatch=disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)||disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes);
+  const baseHashMismatch=disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes);
+  const targetHashMismatch=disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes);
+  const replayOutputHashMismatch=disjointNonEmpty(leftIndex.semanticEditReplayOutputHashes,rightIndex.semanticEditReplayOutputHashes);
+  const hashMismatch=baseHashMismatch||targetHashMismatch||replayOutputHashMismatch;
   const sourceRelated=shared.sourcePaths.length||shared.regionKeys.length||shared.conflictKeys.length||shared.sourceIdentityHashes.length;
   const editContent=shared.operationContentHashes.length||shared.editContentHashes.length||shared.semanticEditReplayOutputHashes.length;
   const transformContent=shared.semanticTransformContentHashes.length&&shared.projectionIdentityHashes.length;
@@ -158,8 +173,9 @@ function overlapAdmission(shared,{leftIndex,rightIndex,options}){
     shared.regionKeys.length?'same-region-key':undefined,
     shared.conflictKeys.length?'same-conflict-key':undefined,
     shared.sourcePaths.length?'same-source-path':undefined,
-    status!=='independent'&&disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)?'base-hash-mismatch':undefined,
-    status!=='independent'&&disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes)?'target-hash-mismatch':undefined
+    status!=='independent'&&baseHashMismatch?'base-hash-mismatch':undefined,
+    status!=='independent'&&targetHashMismatch?'target-hash-mismatch':undefined,
+    status!=='independent'&&replayOutputHashMismatch?'replay-output-hash-mismatch':undefined
   ]);
   return{
     status,
@@ -223,7 +239,8 @@ function matchesOverlap(overlap,query){
 function overlapScore(status,shared,reasonCodes){
   const base=status==='duplicate'?100:status==='semantic-overlap'?75:status==='source-overlap'?35:0;
   const sharedBonus=Math.min(20,countShared(shared));
-  const stalePenalty=reasonCodes.includes('base-hash-mismatch')||reasonCodes.includes('target-hash-mismatch')?15:0;
+  const stalePenalty=reasonCodes.includes('base-hash-mismatch')||reasonCodes.includes('target-hash-mismatch')
+    ||reasonCodes.includes('replay-output-hash-mismatch')?15:0;
   return Math.max(0,base+sharedBonus-stalePenalty);
 }
 

package/package.json

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