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

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

@@ -1,3 +1,5 @@
+import { semanticImportSidecarQualityRecord } from '../../semantic-import-sidecar-entry.js';
+
 function sidecarSourcePaths(importEntries) {
   return [...new Set(importEntries.map((entry) => entry.sourcePath).filter(Boolean))];
 }
@@ -15,10 +17,19 @@ function sidecarQualityWarning(code, message, action, sourcePaths) {
 export function createSemanticImportSidecarQuality(input) {
   const { importEntries, symbols, ownershipRegions, patchHints, proofSpec, evidence, readiness } = input;
   const expected = input.expected === true;
+  const expectedEmpty = input.expectedEmpty === true || input.semanticImportExpectedEmpty === true;
   const sourcePaths = sidecarSourcePaths(importEntries);
   const importCount = importEntries.length;
+  const record = semanticImportSidecarQualityRecord({
+    expected,
+    expectedEmpty,
+    importCount,
+    symbolCount: symbols.length,
+    sourcePaths
+  });
+  const expectedEmptySatisfied = record.classification === 'expected-empty';
   const warnings = [];
-  if (expected && importCount === 0) warnings.push(sidecarQualityWarning(
+  if ((expected || expectedEmpty) && importCount === 0) warnings.push(sidecarQualityWarning(
     'expected-semantic-import-missing',
     'Semantic import was expected but no import entries were selected.',
     'check-semantic-import-include-globs-and-workspace-paths',
@@ -30,31 +41,31 @@ export function createSemanticImportSidecarQuality(input) {
     'run-native-import',
     sourcePaths
   ));
-  if (expected && importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && expected && importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
     'expected-semantic-import-empty',
     'Semantic import was expected but selected imports produced zero semantic symbols.',
     'rerun-importer-with-semantic-source-selection',
     sourcePaths
   ));
-  if (importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
     'empty-semantic-index',
     'Semantic sidecar has import entries but no semantic symbols.',
     'rerun-importer-with-semantic-index',
     sourcePaths
   ));
-  if (importCount > 0 && ownershipRegions.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && importCount > 0 && ownershipRegions.length === 0) warnings.push(sidecarQualityWarning(
     'missing-ownership-regions',
     'Semantic sidecar has no ownership regions for safe merge ownership.',
     'rerun-sidecar-generation-with-ownership-regions',
     sourcePaths
   ));
-  if (importCount > 0 && patchHints.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && importCount > 0 && patchHints.length === 0) warnings.push(sidecarQualityWarning(
     'missing-patch-hints',
     'Semantic sidecar has no patch hints.',
     'generate-semantic-patch-hints',
     sourcePaths
   ));
-  if (importCount > 0 && evidence.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && importCount > 0 && evidence.length === 0) warnings.push(sidecarQualityWarning(
     'empty-evidence',
     'Semantic sidecar has no evidence records.',
     'attach-semantic-import-evidence',
@@ -116,16 +127,18 @@ export function createSemanticImportSidecarQuality(input) {
     warning.code === 'missing-ownership-regions' ||
     warning.code === 'missing-patch-hints'
   ));
-  const expectedMissingReasonCodes = expected
-    ? emptyEvidenceWarnings.map((warning) => warning.code)
-    : [];
-  const expectedSatisfied = !expected || (
+  const expectedSatisfied = expectedEmpty
+    ? expectedEmptySatisfied
+    : !expected || (
     importCount > 0 &&
     symbols.length > 0 &&
     ownershipRegions.length > 0 &&
     patchHints.length > 0 &&
     evidence.length > 0
   );
+  const expectedMissingReasonCodes = (expected || expectedEmpty) && !expectedSatisfied
+    ? emptyEvidenceWarnings.map((warning) => warning.code)
+    : [];
   const proofSummary = {
     total: proofSpec.total,
     obligations: proofSpec.obligations,
@@ -143,12 +156,14 @@ export function createSemanticImportSidecarQuality(input) {
   return {
     schema: 'frontier.lang.semanticSidecarQuality.v1',
     expected,
+    expectedEmpty,
     expectedSatisfied,
     expectedMissingReasonCodes,
     selected: importCount > 0,
-    eligible: importCount > 0 && emptyEvidenceWarnings.length === 0 && proofSpec.failed === 0 && readiness !== 'blocked',
+    eligible: record.classification === 'useful' && emptyEvidenceWarnings.length === 0 && proofSpec.failed === 0 && readiness !== 'blocked',
     imported: importCount > 0,
     importCount,
+    record,
     symbolCount: symbols.length,
     ownershipRegionCount: ownershipRegions.length,
     patchHintCount: patchHints.length,
@@ -164,6 +179,7 @@ export function createSemanticImportSidecarAdmission(quality, readiness) {
   return {
     schema: 'frontier.lang.semanticSidecarAdmission.v1',
     expected: quality.expected,
+    expectedEmpty: quality.expectedEmpty,
     expectedSatisfied: quality.expectedSatisfied,
     expectedMissingReasonCodes: quality.expectedMissingReasonCodes,
     selected: quality.selected,
@@ -172,6 +188,7 @@ export function createSemanticImportSidecarAdmission(quality, readiness) {
     importCount: quality.importCount,
     readiness,
     action: sidecarAdmissionAction(quality, readiness),
+    record: quality.record,
     counts: {
       symbols: quality.symbolCount,
       ownershipRegions: quality.ownershipRegionCount,
@@ -191,6 +208,7 @@ function sidecarAdmissionAction(quality, readiness) {
   if (!quality.imported) return 'reject-missing-imports';
   if (readiness === 'blocked') return 'reject-blocked';
   if (quality.proofSummary.failed > 0) return 'reject-failed-proof';
+  if (quality.record?.classification === 'expected-empty') return 'skip-expected-empty';
   if (quality.emptyEvidenceWarnings.length > 0) return 'reject-empty-evidence';
   if (!quality.eligible) return 'reject-quality';
   if (sidecarProofReviewObligations(quality.proofSummary) > 0) return 'review-proof-obligations';

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

@@ -1,4 +1,4 @@
-import{nativeChangeMappingTouchesRegion}from'./nativeChangeMappingTouchesRegion.js';import{nativeImportSourcePreservationRecord}from'./nativeImportSourcePreservationRecord.js';
+import{uniqueStrings}from'../../native-import-utils.js';import{nativeChangeMappingTouchesRegion}from'./nativeChangeMappingTouchesRegion.js';import{nativeImportSourcePreservationRecord}from'./nativeImportSourcePreservationRecord.js';
 export function nativeChangeProjectionEndpoint(imported, sidecar, region, side) {
   if (!imported && !region) return undefined;
   const preservation = nativeImportSourcePreservationRecord(imported);
@@ -6,23 +6,63 @@ export function nativeChangeProjectionEndpoint(imported, sidecar, region, side)
   const regionMappings = sourceMaps
     .flatMap((sourceMap) => (sourceMap?.mappings ?? []).map((mapping) => ({ sourceMap, mapping })))
     .filter(({ mapping }) => nativeChangeMappingTouchesRegion(mapping, region, []));
+  const sourceMapIds = uniqueStrings(sourceMaps.map((sourceMap) => sourceMap?.id));
+  const sourceMapMappingIds = uniqueStrings(regionMappings.map(({ mapping }) => mapping?.id));
+  const importId = imported?.id;
+  const nativeSourceId = imported?.nativeSource?.id;
+  const nativeAstId = imported?.nativeAst?.id;
+  const semanticIndexId = imported?.semanticIndex?.id;
+  const universalAstId = imported?.universalAst?.id;
+  const sourcePath = imported?.sourcePath ?? region?.sourcePath;
+  const sourceHash = imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? region?.sourceHash;
+  const sourcePreservationId = preservation?.id;
+  const exactSourceAvailable = preservation?.summary?.exactSourceAvailable === true;
+  const ownershipRegionId = region?.id;
+  const ownershipKey = region?.key;
+  const ownershipRegionKind = region?.regionKind;
+  const sourceSpan = region?.sourceSpan;
+  const identity = compactRecord({
+    schema: 'frontier.lang.nativeChangeProjectionEndpointIdentity.v1',
+    version: 1,
+    side,
+    importId,
+    nativeSourceId,
+    nativeAstId,
+    semanticIndexId,
+    universalAstId,
+    sourcePath,
+    sourceHash,
+    sourcePreservationId,
+    exactSourceAvailable,
+    ownershipRegionId,
+    ownershipKey,
+    ownershipRegionKind,
+    sourceSpan,
+    sourceMapIds,
+    sourceMapMappingIds
+  });
   return {
     side,
-    importId: imported?.id,
+    importId,
     sidecarId: sidecar?.id,
-    nativeSourceId: imported?.nativeSource?.id,
-    nativeAstId: imported?.nativeAst?.id,
-    semanticIndexId: imported?.semanticIndex?.id,
-    universalAstId: imported?.universalAst?.id,
-    sourcePath: imported?.sourcePath ?? region?.sourcePath,
-    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? region?.sourceHash,
-    sourcePreservationId: preservation?.id,
-    exactSourceAvailable: preservation?.summary?.exactSourceAvailable === true,
-    ownershipRegionId: region?.id,
-    ownershipKey: region?.key,
-    ownershipRegionKind: region?.regionKind,
-    sourceSpan: region?.sourceSpan,
-    sourceMapIds: sourceMaps.map((sourceMap) => sourceMap?.id).filter(Boolean),
-    sourceMapMappingIds: regionMappings.map(({ mapping }) => mapping?.id).filter(Boolean)
+    nativeSourceId,
+    nativeAstId,
+    semanticIndexId,
+    universalAstId,
+    sourcePath,
+    sourceHash,
+    sourcePreservationId,
+    exactSourceAvailable,
+    ownershipRegionId,
+    ownershipKey,
+    ownershipRegionKind,
+    sourceSpan,
+    sourceMapIds,
+    sourceMapMappingIds,
+    identity
   };
 }
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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

@@ -1,4 +1,5 @@
 import{uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
+import{targetProjectionCoverageSignals}from'./projectImportAdmissionProjectionCoverage.js';
 
 const scoreWeights=Object.freeze({
   semanticEvidence:22,
@@ -95,15 +96,35 @@ function sourcePreservationScore(input){
 
 function sourceFreshnessScore(input){
   const sourceCount=Math.max(input.sourceCount??0,input.sourcePreservation.total,1);
-  const fresh=Math.max(0,sourceCount-input.sourcePreservation.stale);
+  const sourceStaleness=input.sourceStaleness??{};
+  const stale=sourceStaleness.stale??input.sourcePreservation.stale;
+  const contentHashStale=sourceStaleness.contentHashStale??input.sourcePreservation.contentHashStale??0;
+  const baseHashStale=sourceStaleness.baseHashStale??input.sourcePreservation.baseHashStale??0;
+  const dirtyWorkspace=sourceStaleness.dirtyWorkspace??input.sourcePreservation.dirtyWorkspace??0;
+  const fresh=Math.max(0,sourceCount-stale);
   const score=roundScore(fresh*100/sourceCount);
   return scoreComponent('sourceFreshness',score,[
-    ...(input.sourcePreservation.stale?[
-      `Project import has stale source hashes for ${input.sourcePreservation.stale} source(s).`
+    ...(contentHashStale?[
+      `Project import has stale content hashes for ${contentHashStale} source(s).`
+    ]:[]),
+    ...(baseHashStale?[
+      `Project import has stale base hashes for ${baseHashStale} source(s).`
+    ]:[]),
+    ...(!contentHashStale&&!baseHashStale&&stale?[
+      `Project import has stale source hashes for ${stale} source(s).`
+    ]:[]),
+    ...(dirtyWorkspace&&!stale?[
+      `Project workspace is marked dirty for ${dirtyWorkspace} source(s), but no content or base hash staleness was detected.`
     ]:[])
   ],{
-    stale:input.sourcePreservation.stale,
-    staleSourcePaths:input.sourcePreservation.staleSourcePaths,
+    stale,
+    contentHashStale,
+    baseHashStale,
+    dirtyWorkspace,
+    staleSourcePaths:sourceStaleness.staleSourcePaths??input.sourcePreservation.staleSourcePaths,
+    contentHashStaleSourcePaths:sourceStaleness.contentHashStaleSourcePaths??input.sourcePreservation.contentHashStaleSourcePaths??[],
+    baseHashStaleSourcePaths:sourceStaleness.baseHashStaleSourcePaths??input.sourcePreservation.baseHashStaleSourcePaths??[],
+    dirtyWorkspaceSourcePaths:sourceStaleness.dirtyWorkspaceSourcePaths??input.sourcePreservation.dirtyWorkspaceSourcePaths??[],
     checkedSources:sourceCount
   });
 }
@@ -186,75 +207,6 @@ function targetProjectionCoverageScore(input){
   ],coverage);
 }
 
-function targetProjectionCoverageSignals(input){
-  const entries=targetProjectionEntries(input.projectResult,input.imports);
-  const matrices=projectionMatrices(input.projectResult,input.imports);
-  for(const matrix of matrices){
-    for(const language of matrix?.languages??[]) entries.push(...(language?.targets??[]));
-  }
-  const sourceMapSummary=input.contract?.sourceMaps??{};
-  const summary=matrices.reduce((current,matrix)=>{
-    current.exactSourceProjection+=matrix?.summary?.exactSourceProjection??0;
-    current.targetAdapterProjection+=matrix?.summary?.targetAdapterProjection??0;
-    current.missingAdapters+=matrix?.summary?.missingAdapters??0;
-    current.unsupportedTargetFeatures+=matrix?.summary?.unsupportedTargetFeatures??0;
-    return current;
-  },{exactSourceProjection:0,targetAdapterProjection:0,missingAdapters:0,unsupportedTargetFeatures:0});
-  const targetEntries=entries.length;
-  const supportedTargets=entries.filter((entry)=>entry?.supported===true).length;
-  const adapterProjectionTargets=entries.filter((entry)=>
-    entry?.lossClass==='targetAdapterProjection'||entry?.lossClass==='exactSourceProjection'||entry?.adapter||entry?.adapterKind==='targetProjection'
-  ).length+summary.targetAdapterProjection+summary.exactSourceProjection;
-  const readinessValues=entries.map((entry)=>readinessScore[entry?.readiness]??45);
-  const readinessAverage=readinessValues.length?readinessValues.reduce((sum,value)=>sum+value,0)/readinessValues.length:0;
-  return {
-    targetEntries,
-    supportedTargets,
-    adapterProjectionTargets,
-    exactSourceProjection:Math.max(summary.exactSourceProjection,input.sourcePreservation.exactSourceAvailable??0),
-    targetAdapterProjection:summary.targetAdapterProjection,
-    missingAdapters:summary.missingAdapters+entries.filter((entry)=>entry?.lossClass==='missingAdapter'||entry?.supported===false).length,
-    unsupportedTargetFeatures:summary.unsupportedTargetFeatures+entries.filter((entry)=>entry?.lossClass==='unsupportedTargetFeatures').length,
-    readinessScore:roundScore(readinessAverage),
-    sourceMapMappings:sourceMapSummary.mappingCount??0,
-    generatedRangeMappings:sourceMapSummary.generatedRangeMappings??0,
-    targetPaths:sourceMapSummary.targetPaths?.length??0,
-    adapterGeneratedRanges:input.contract?.adapterCoverage?.generatedRanges??0
-  };
-}
-
-function targetProjectionEntries(projectResult,imports){
-  return [
-    projectResult?.targetCoverage,
-    projectResult?.metadata?.targetCoverage,
-    projectResult?.metadata?.targetProjectionCoverage,
-    ...(projectResult?.targetCoverages??[]),
-    ...(projectResult?.metadata?.targetCoverages??[]),
-    ...(imports??[]).flatMap((imported)=>[
-      imported?.targetCoverage,
-      imported?.metadata?.targetCoverage,
-      imported?.metadata?.targetProjectionCoverage,
-      ...(imported?.targetCoverages??[]),
-      ...(imported?.metadata?.targetCoverages??[])
-    ])
-  ].flatMap((entry)=>Array.isArray(entry)?entry:[entry]).filter((entry)=>entry&&typeof entry==='object'&&(entry.target||entry.lossClass||entry.supported!==undefined));
-}
-
-function projectionMatrices(projectResult,imports){
-  return [
-    projectResult?.projectionMatrix,
-    projectResult?.metadata?.projectionMatrix,
-    ...(projectResult?.projectionMatrices??[]),
-    ...(projectResult?.metadata?.projectionMatrices??[]),
-    ...(imports??[]).flatMap((imported)=>[
-      imported?.projectionMatrix,
-      imported?.metadata?.projectionMatrix,
-      ...(imported?.projectionMatrices??[]),
-      ...(imported?.metadata?.projectionMatrices??[])
-    ])
-  ].filter((matrix)=>matrix?.kind==='frontier.lang.projectionTargetLossMatrix'||Array.isArray(matrix?.languages));
-}
-
 function admissionEvidenceRecords(projectResult,imports){
   return uniqueRecordsById([
     ...(projectResult?.evidence??[]),

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

@@ -0,0 +1,74 @@
+const readinessScore = Object.freeze({ ready: 100, 'ready-with-losses': 75, 'needs-review': 45, blocked: 0 });
+
+export function targetProjectionCoverageSignals(input) {
+  const entries = targetProjectionEntries(input.projectResult, input.imports);
+  const matrices = projectionMatrices(input.projectResult, input.imports);
+  for (const matrix of matrices) {
+    for (const language of matrix?.languages ?? []) entries.push(...(language?.targets ?? []));
+  }
+  const sourceMapSummary = input.contract?.sourceMaps ?? {};
+  const summary = matrices.reduce((current, matrix) => {
+    current.exactSourceProjection += matrix?.summary?.exactSourceProjection ?? 0;
+    current.targetAdapterProjection += matrix?.summary?.targetAdapterProjection ?? 0;
+    current.missingAdapters += matrix?.summary?.missingAdapters ?? 0;
+    current.unsupportedTargetFeatures += matrix?.summary?.unsupportedTargetFeatures ?? 0;
+    return current;
+  }, { exactSourceProjection: 0, targetAdapterProjection: 0, missingAdapters: 0, unsupportedTargetFeatures: 0 });
+  const targetEntries = entries.length;
+  const supportedTargets = entries.filter((entry) => entry?.supported === true).length;
+  const adapterProjectionTargets = entries.filter((entry) =>
+    entry?.lossClass === 'targetAdapterProjection' || entry?.lossClass === 'exactSourceProjection' || entry?.adapter || entry?.adapterKind === 'targetProjection'
+  ).length + summary.targetAdapterProjection + summary.exactSourceProjection;
+  const readinessValues = entries.map((entry) => readinessScore[entry?.readiness] ?? 45);
+  const readinessAverage = readinessValues.length ? readinessValues.reduce((sum, value) => sum + value, 0) / readinessValues.length : 0;
+  return {
+    targetEntries,
+    supportedTargets,
+    adapterProjectionTargets,
+    exactSourceProjection: Math.max(summary.exactSourceProjection, input.sourcePreservation.exactSourceAvailable ?? 0),
+    targetAdapterProjection: summary.targetAdapterProjection,
+    missingAdapters: summary.missingAdapters + entries.filter((entry) => entry?.lossClass === 'missingAdapter' || entry?.supported === false).length,
+    unsupportedTargetFeatures: summary.unsupportedTargetFeatures + entries.filter((entry) => entry?.lossClass === 'unsupportedTargetFeatures').length,
+    readinessScore: roundScore(readinessAverage),
+    sourceMapMappings: sourceMapSummary.mappingCount ?? 0,
+    generatedRangeMappings: sourceMapSummary.generatedRangeMappings ?? 0,
+    targetPaths: sourceMapSummary.targetPaths?.length ?? 0,
+    adapterGeneratedRanges: input.contract?.adapterCoverage?.generatedRanges ?? 0
+  };
+}
+
+function targetProjectionEntries(projectResult, imports) {
+  return [
+    projectResult?.targetCoverage,
+    projectResult?.metadata?.targetCoverage,
+    projectResult?.metadata?.targetProjectionCoverage,
+    ...(projectResult?.targetCoverages ?? []),
+    ...(projectResult?.metadata?.targetCoverages ?? []),
+    ...(imports ?? []).flatMap((imported) => [
+      imported?.targetCoverage,
+      imported?.metadata?.targetCoverage,
+      imported?.metadata?.targetProjectionCoverage,
+      ...(imported?.targetCoverages ?? []),
+      ...(imported?.metadata?.targetCoverages ?? [])
+    ])
+  ].flatMap((entry) => Array.isArray(entry) ? entry : [entry]).filter((entry) => entry && typeof entry === 'object' && (entry.target || entry.lossClass || entry.supported !== undefined));
+}
+
+function projectionMatrices(projectResult, imports) {
+  return [
+    projectResult?.projectionMatrix,
+    projectResult?.metadata?.projectionMatrix,
+    ...(projectResult?.projectionMatrices ?? []),
+    ...(projectResult?.metadata?.projectionMatrices ?? []),
+    ...(imports ?? []).flatMap((imported) => [
+      imported?.projectionMatrix,
+      imported?.metadata?.projectionMatrix,
+      ...(imported?.projectionMatrices ?? []),
+      ...(imported?.metadata?.projectionMatrices ?? [])
+    ])
+  ].filter((matrix) => matrix?.kind === 'frontier.lang.projectionTargetLossMatrix' || Array.isArray(matrix?.languages));
+}
+
+function roundScore(value) {
+  return Math.round((Number.isFinite(value) ? value : 0) * 100) / 100;
+}

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

@@ -1,5 +1,8 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
-import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { idFragment, normalizeNativeLanguageId, uniqueStrings } from '../../native-import-utils.js';
+import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
+import { mapDiffSymbols } from './mapDiffSymbols.js';
+import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
 import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
 import {
   insertionOffset,
@@ -10,7 +13,6 @@ import {
   spanOffsets
 } from './semanticEditSourceRanges.js';
 import { applySourceEdits, dedupeSourceEdits, validateSourceEdits } from './semanticSourceEditDedupe.js';
-
 export function projectSemanticEditScriptToSource(input = {}) {
   const script = input.script;
   const workerSourceText = input.workerSourceText;
@@ -19,6 +21,15 @@ export function projectSemanticEditScriptToSource(input = {}) {
   if (!script) throw new Error('projectSemanticEditScriptToSource requires a script');
   if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
   if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
+  const language = normalizeNativeLanguageId(script.language);
+  const headSymbols = typeof headSourceText === 'string' && isJavaScriptLike(language)
+    ? sourceSymbolIndex({
+      sourceText: headSourceText,
+      sourcePath: input.headSourcePath ?? script.sourcePath,
+      language,
+      parser: input.parser
+    })
+    : [];
   const edits = [];
   const coveredOperationIds = [];
   const projectionCoveredOperationIds = projectionCoveredContainerOperationIds(script.operations ?? [], workerSourceText);
@@ -27,7 +38,10 @@ export function projectSemanticEditScriptToSource(input = {}) {
       coveredOperationIds.push(operation.id);
       continue;
     }
-    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, input.headSourcePath);
+    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, {
+      headSourcePath: input.headSourcePath,
+      headSymbols
+    });
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
   }
@@ -67,20 +81,20 @@ export function projectSemanticEditScriptToSource(input = {}) {
       appliedEditCount: deduped.edits.filter((edit) => !edit.alreadyApplied).length,
       alreadyAppliedEditCount: deduped.edits.filter((edit) => edit.alreadyApplied).length,
       dedupedEditCount: deduped.skippedOperationIds.length,
+      anchorMode: headSymbols.length ? 'javascript-like-symbols' : 'offsets',
       ...input.metadata
     })
   };
   return { ...core, hash: hashSemanticValue(core) };
 }
-
-function sourceEditForOperation(operation, workerSourceText, headSourceText, order, headSourcePath) {
-  const identity = projectionIdentity(operation, headSourcePath);
+function sourceEditForOperation(operation, workerSourceText, headSourceText, order, context) {
+  const identity = projectionIdentity(operation, context.headSourcePath);
   if (operation.status === 'already-applied') {
     return { ok: true, value: { ...identity, operationId: operation.id, order, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
   }
   if (operation.status !== 'portable') return { ok: false, reasonCodes: [`operation-not-portable:${operation.id}`] };
   if (operation.changeKind === 'added' || String(operation.kind ?? '').startsWith('add')) {
-    return insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order);
+    return insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order, context);
   }
   if (operation.changeKind === 'removed' || String(operation.kind ?? '').startsWith('remove')) {
     return removalEditForOperation(operation, identity, headSourceText, order);
@@ -131,7 +145,6 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
     }
   };
 }
-
 function removalEditForOperation(operation, identity, headSourceText, order) {
   const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
   const reasons = [];
@@ -158,12 +171,11 @@ function removalEditForOperation(operation, identity, headSourceText, order) {
     }
   };
 }
-
-function insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order) {
+function insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order, context) {
   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);
+  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);
@@ -189,7 +201,6 @@ function insertionEditForOperation(operation, identity, workerSourceText, headSo
     }
   };
 }
-
 function projectionIdentity(operation, headSourcePath) {
   const identity = semanticEditIdentity(operation);
   const sourcePath = operation.reanchor?.toSourcePath ?? headSourcePath ?? operation.insertion?.sourcePath ?? identity.sourcePath;
@@ -201,7 +212,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);
@@ -255,10 +265,25 @@ function projectionEditRecord(edit) {
     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({
+      language: input.language,
+      sourcePath: input.sourcePath,
+      sourceText: input.sourceText,
+      parser: input.parser
+    }, input, 'head');
+    return [...mapDiffSymbols(imported, createSemanticImportSidecar(imported)).values()];
+  } catch {
+    return [];
+  }
+}
+
 function semanticEditIdentity(operation) {
   const anchor = operation.anchor ?? {};
   return compactRecord({
@@ -288,6 +313,7 @@ function projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
 
+function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }
 function compactRecord(value) {
   return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
 }