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

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

@@ -1,4 +1,4 @@
-import type { SemanticMergeReadiness } from '@shapeshift-labs/frontier-lang-kernel';
+import type { EvidenceRecord, SemanticMergeReadiness } from '@shapeshift-labs/frontier-lang-kernel';
 import type { SemanticEditProjection, SemanticEditReplay, SemanticEditScript } from './semantic-edit-script.js';
 
 export type SemanticEditBundleAdmissionStatus =
@@ -16,6 +16,8 @@ export interface SemanticEditBundleAdmissionSummary {
   readonly projections: number;
   readonly replays: number;
   readonly files: number;
+  readonly portableScripts: number;
+  readonly portableProjections: number;
   readonly acceptedClean: number;
   readonly alreadyApplied: number;
   readonly conflicts: number;
@@ -32,6 +34,11 @@ export interface SemanticEditBundleAdmissionSummary {
   readonly scriptIds: readonly string[];
   readonly projectionIds: readonly string[];
   readonly replayIds: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly passedTestEvidence: number;
+  readonly failedTestEvidence: number;
+  readonly conflictEvidence: number;
+  readonly staleEvidence: number;
   readonly reasonCodes: readonly string[];
 }
 
@@ -68,6 +75,11 @@ export interface CreateSemanticEditBundleAdmissionInput {
   readonly semanticEditReplay?: SemanticEditReplay;
   readonly semanticEditReplays?: readonly SemanticEditReplay[] | SemanticEditReplay;
   readonly replays?: readonly SemanticEditReplay[] | SemanticEditReplay;
+  readonly evidence?: readonly EvidenceRecord[] | EvidenceRecord;
+  readonly testEvidence?: readonly EvidenceRecord[] | EvidenceRecord;
+  readonly testResults?: readonly EvidenceRecord[] | EvidenceRecord;
+  readonly gateEvidence?: readonly EvidenceRecord[] | EvidenceRecord;
+  readonly proofEvidence?: readonly EvidenceRecord[] | EvidenceRecord;
   readonly metadata?: Record<string, unknown>;
 }
 

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

@@ -1,28 +1,8 @@
-import type {
-  EvidenceRecord,
-  FrontierSourceLanguage,
-  SemanticMergeReadiness,
-  SourceSpan
-} from '@shapeshift-labs/frontier-lang-kernel';
+import type { EvidenceRecord, FrontierSourceLanguage, SemanticMergeReadiness, SourceSpan } from '@shapeshift-labs/frontier-lang-kernel';
 import type { ImportNativeSourceOptions, NativeSourceImportResult } from './import-adapter-core.js';
 
-export type SemanticEditScriptOperationStatus =
-  | 'candidate'
-  | 'portable'
-  | 'already-applied'
-  | 'covered'
-  | 'needs-port'
-  | 'conflict'
-  | 'stale'
-  | 'blocked';
-
-export type SemanticEditScriptAdmissionStatus =
-  | 'auto-merge-candidate'
-  | 'needs-port'
-  | 'conflict'
-  | 'stale'
-  | 'blocked'
-  | 'evidence-only';
+export type SemanticEditScriptOperationStatus = 'candidate' | 'portable' | 'already-applied' | 'covered' | 'needs-port' | 'conflict' | 'stale' | 'blocked';
+export type SemanticEditScriptAdmissionStatus = 'auto-merge-candidate' | 'needs-port' | 'conflict' | 'stale' | 'blocked' | 'evidence-only';
 
 export interface SemanticEditScriptOperation {
   readonly id: string;
@@ -130,7 +110,7 @@ export interface SemanticEditProjectionEdit {
   readonly operationId?: string;
   readonly status: 'applied' | 'already-applied';
   readonly kind?: string;
-  readonly editKind?: 'replace' | 'insert' | string;
+  readonly editKind?: 'replace' | 'insert' | 'delete' | string;
   readonly changeKind?: string;
   readonly anchorKey?: string;
   readonly conflictKey?: string;
@@ -192,14 +172,7 @@ export interface SemanticEditProjection {
   readonly metadata?: Record<string, unknown>;
 }
 
-export type SemanticEditReplayStatus =
-  | 'accepted-clean'
-  | 'already-applied'
-  | 'conflict'
-  | 'stale'
-  | 'blocked'
-  | 'needs-port'
-  | 'evidence-only';
+export type SemanticEditReplayStatus = 'accepted-clean' | 'already-applied' | 'conflict' | 'stale' | 'blocked' | 'needs-port' | 'evidence-only';
 
 export interface SemanticEditReplayEdit {
   readonly operationId?: string;
@@ -207,7 +180,7 @@ export interface SemanticEditReplayEdit {
   readonly semanticIdentityHash?: string;
   readonly sourceIdentityHash?: string;
   readonly editContentHash?: string;
-  readonly editKind?: 'replace' | 'insert' | string;
+  readonly editKind?: 'replace' | 'insert' | 'delete' | string;
   readonly sourcePath?: string;
   readonly symbolName?: string;
   readonly symbolKind?: string;
@@ -269,9 +242,12 @@ export interface ProjectSemanticEditScriptToSourceOptions {
 
 export interface ReplaySemanticEditProjectionOptions {
   readonly id?: string;
-  readonly projection: SemanticEditProjection;
-  readonly currentSourceText: string;
+  readonly projection?: SemanticEditProjection;
+  readonly semanticEditProjection?: SemanticEditProjection;
+  readonly currentSourceText?: string;
+  readonly headSourceText?: string;
   readonly currentSourcePath?: string;
+  readonly headSourcePath?: string;
   readonly currentSourceHash?: string;
   readonly language?: FrontierSourceLanguage | string;
   readonly parser?: string;
@@ -294,17 +270,38 @@ export interface CreateSemanticEditScriptOptions {
   readonly workerSourceText?: string;
   readonly afterSourceText?: string;
   readonly headSourceText?: string;
+  readonly baseSourcePath?: string;
+  readonly beforeSourcePath?: string;
+  readonly workerSourcePath?: string;
+  readonly afterSourcePath?: string;
   readonly headSourcePath?: string;
   readonly currentSourceText?: string;
+  readonly currentSourcePath?: string;
   readonly baseSourceHash?: string;
+  readonly beforeSourceHash?: string;
   readonly workerSourceHash?: string;
+  readonly afterSourceHash?: string;
   readonly headSourceHash?: string;
-  readonly generatedAt?: number;
+  readonly currentSourceHash?: string;
+  readonly baseMetadata?: Record<string, unknown>;
+  readonly beforeMetadata?: Record<string, unknown>;
+  readonly workerMetadata?: Record<string, unknown>;
+  readonly afterMetadata?: Record<string, unknown>;
+  readonly headMetadata?: Record<string, unknown>;
+  readonly currentMetadata?: Record<string, unknown>;
+  readonly workerChangeSetId?: string;
+  readonly headChangeSetId?: string;
+  readonly lineageInferenceId?: string;
+  readonly generatedAt?: number | string;
   readonly evidenceId?: string;
   readonly metadata?: Record<string, unknown>;
 }
 
+export interface CreateSemanticEditScriptRuntimeOptions {
+  readonly metadata?: Record<string, unknown>;
+}
+
 export declare const SemanticEditScriptAdmissionStatuses: readonly SemanticEditScriptAdmissionStatus[];
-export declare function createSemanticEditScript(input?: CreateSemanticEditScriptOptions): SemanticEditScript;
+export declare function createSemanticEditScript(input?: CreateSemanticEditScriptOptions, options?: CreateSemanticEditScriptRuntimeOptions): SemanticEditScript;
 export declare function projectSemanticEditScriptToSource(input: ProjectSemanticEditScriptToSourceOptions): SemanticEditProjection;
 export declare function replaySemanticEditProjection(input: ReplaySemanticEditProjectionOptions): SemanticEditReplay;

package/dist/declarations/semantic-lineage.d.ts

@@ -1,26 +1,36 @@
-import type { FrontierSourceLanguage, SourceSpan } from '@shapeshift-labs/frontier-lang-kernel';
-import type { EvidenceRecord, SemanticMergeReadiness } from '@shapeshift-labs/frontier-lang-kernel';
+import type { EvidenceRecord, FrontierSourceLanguage, SemanticMergeReadiness, SourceSpan } from '@shapeshift-labs/frontier-lang-kernel';
 import type { ImportNativeSourceOptions, NativeSourceImportResult } from './import-adapter-core.js';
 
 export type SemanticLineageEventKind = 'unchanged' | 'moved' | 'renamed' | 'split' | 'merged' | 'deleted' | 'recreated' | 'unknown' | string;
 export type SemanticLineageResolutionStatus = 'unchanged' | 'resolved' | 'ambiguous' | 'deleted' | 'recreated' | 'cycle' | 'max-depth' | 'not-found' | string;
 
 export interface SemanticAnchor {
-  readonly id?: string;
-  readonly key?: string;
-  readonly kind?: string;
-  readonly language?: FrontierSourceLanguage | string;
-  readonly sourcePath?: string;
-  readonly sourceHash?: string;
-  readonly symbolId?: string;
-  readonly symbolName?: string;
+  readonly id?: string; readonly key?: string; readonly kind?: string;
+  readonly language?: FrontierSourceLanguage | string; readonly sourcePath?: string; readonly sourceHash?: string;
+  readonly symbolId?: string; readonly symbolName?: string;
   readonly semanticPath?: readonly string[];
-  readonly signatureHash?: string;
-  readonly bodyHash?: string;
+  readonly signatureHash?: string; readonly bodyHash?: string;
   readonly sourceSpan?: SourceSpan;
+  readonly lineageEventIds?: readonly string[]; readonly terminalLineageEventIds?: readonly string[];
+  readonly lineageSourcePaths?: readonly string[]; readonly evidenceIds?: readonly string[];
+  readonly proofIds?: readonly string[]; readonly crdtOperationIds?: readonly string[]; readonly crdtHeads?: readonly string[];
+  readonly lineageEventKinds?: readonly SemanticLineageEventKind[]; readonly lineageReasonCodes?: readonly string[];
   readonly metadata?: Record<string, unknown>;
 }
 
+export interface CreateSemanticAnchorInput extends SemanticAnchor {
+  readonly ownershipKey?: string;
+  readonly conflictKey?: string;
+  readonly semanticKey?: string;
+  readonly anchorKind?: string;
+  readonly regionKind?: string;
+  readonly symbolKind?: string;
+  readonly pathSegments?: readonly string[];
+  readonly name?: string;
+  readonly hash?: string;
+  readonly span?: SourceSpan;
+}
+
 export interface SemanticLineageCrdtClock {
   readonly operationId?: string;
   readonly actor?: string;
@@ -31,6 +41,19 @@ export interface SemanticLineageCrdtClock {
   readonly versionFrame?: Record<string, unknown>;
 }
 
+export interface SemanticLineageCrdtClockInput {
+  readonly operationId?: string;
+  readonly id?: string;
+  readonly actor?: string;
+  readonly actorId?: string;
+  readonly seq?: number;
+  readonly deps?: readonly string[] | string;
+  readonly heads?: readonly string[] | string;
+  readonly stateVector?: Record<string, number>;
+  readonly versionFrame?: Record<string, unknown>;
+  readonly frame?: Record<string, unknown>;
+}
+
 export interface SemanticLineageEvidence {
   readonly pathMatch?: boolean;
   readonly signatureHashMatch?: boolean;
@@ -41,6 +64,10 @@ export interface SemanticLineageEvidence {
   readonly command?: string;
 }
 
+export interface SemanticLineageEvidenceInput extends SemanticLineageEvidence {
+  readonly id?: string;
+}
+
 export interface SemanticLineageActor {
   readonly id?: string;
   readonly role?: string;
@@ -50,6 +77,10 @@ export interface SemanticLineageActor {
   readonly metadata?: Record<string, unknown>;
 }
 
+export interface SemanticLineageActorInput extends SemanticLineageActor {
+  readonly actorId?: string;
+}
+
 export interface SemanticLineageEvent {
   readonly kind: 'frontier.lang.semanticLineageEvent';
   readonly version: 1;
@@ -71,32 +102,27 @@ export interface SemanticLineageEvent {
 }
 
 export interface CreateSemanticLineageEventInput {
-  readonly id?: string;
-  readonly hash?: string;
-  readonly createdAt?: number | string;
-  readonly eventKind?: SemanticLineageEventKind;
-  readonly event?: SemanticLineageEventKind;
-  readonly kind?: SemanticLineageEventKind;
-  readonly from?: SemanticAnchor | string;
-  readonly fromAnchor?: SemanticAnchor | string;
-  readonly before?: SemanticAnchor | string;
-  readonly to?: readonly (SemanticAnchor | string)[] | SemanticAnchor | string;
-  readonly toAnchors?: readonly (SemanticAnchor | string)[] | SemanticAnchor | string;
-  readonly after?: readonly (SemanticAnchor | string)[] | SemanticAnchor | string;
-  readonly confidence?: number;
-  readonly actor?: SemanticLineageActor | string;
-  readonly actorId?: string;
-  readonly actorRole?: string;
-  readonly crdt?: SemanticLineageCrdtClock;
-  readonly clock?: SemanticLineageCrdtClock;
-  readonly operation?: SemanticLineageCrdtClock;
+  readonly id?: string; readonly hash?: string; readonly createdAt?: number | string;
+  readonly eventKind?: SemanticLineageEventKind; readonly event?: SemanticLineageEventKind; readonly kind?: SemanticLineageEventKind;
+  readonly from?: CreateSemanticAnchorInput | string;
+  readonly fromAnchor?: CreateSemanticAnchorInput | string;
+  readonly before?: CreateSemanticAnchorInput | string;
+  readonly to?: readonly (CreateSemanticAnchorInput | string)[] | CreateSemanticAnchorInput | string;
+  readonly toAnchors?: readonly (CreateSemanticAnchorInput | string)[] | CreateSemanticAnchorInput | string;
+  readonly after?: readonly (CreateSemanticAnchorInput | string)[] | CreateSemanticAnchorInput | string;
+  readonly confidence?: number; readonly actor?: SemanticLineageActorInput | string;
+  readonly actorId?: string; readonly actorRole?: string;
+  readonly crdt?: SemanticLineageCrdtClockInput;
+  readonly clock?: SemanticLineageCrdtClockInput;
+  readonly operation?: SemanticLineageCrdtClockInput;
   readonly operationId?: string;
   readonly seq?: number;
   readonly deps?: readonly string[] | string;
   readonly heads?: readonly string[] | string;
   readonly stateVector?: Record<string, number>;
   readonly versionFrame?: Record<string, unknown>;
-  readonly evidence?: SemanticLineageEvidence | readonly { readonly id?: string }[];
+  readonly frame?: Record<string, unknown>;
+  readonly evidence?: SemanticLineageEvidenceInput | readonly SemanticLineageEvidenceInput[];
   readonly pathMatch?: boolean;
   readonly signatureHashMatch?: boolean;
   readonly bodyHashMatch?: boolean;
@@ -161,6 +187,7 @@ export interface SemanticLineageResolution {
   readonly currentAnchors: readonly SemanticAnchor[];
   readonly traversedEventIds: readonly string[];
   readonly terminalEventIds: readonly string[];
+  readonly sourcePaths: readonly string[];
   readonly status: SemanticLineageResolutionStatus;
   readonly confidence?: number;
   readonly conflictKeys: readonly string[];
@@ -236,6 +263,8 @@ export interface SemanticLineageInferenceResult {
     readonly inferredEvents: number;
     readonly moved: number;
     readonly renamed: number;
+    readonly split: number;
+    readonly recreated: number;
     readonly deleted: number;
     readonly ambiguous: number;
     readonly unmatchedAdded: number;
@@ -280,8 +309,8 @@ export interface InferSemanticLineageEventsOptions {
 
 export declare const SemanticLineageEventKinds: readonly SemanticLineageEventKind[];
 export declare const SemanticLineageResolutionStatuses: readonly SemanticLineageResolutionStatus[];
-export declare function createSemanticAnchor(input?: SemanticAnchor | string, defaults?: Partial<SemanticAnchor>): SemanticAnchor | undefined;
-export declare function createSemanticLineageEvent(input?: CreateSemanticLineageEventInput, options?: { readonly id?: string; readonly createdAt?: number | string; readonly actor?: SemanticLineageActor | string; readonly actorId?: string; readonly actorRole?: string }): SemanticLineageEvent;
+export declare function createSemanticAnchor(input?: CreateSemanticAnchorInput | string, defaults?: Partial<SemanticAnchor>): SemanticAnchor | undefined;
+export declare function createSemanticLineageEvent(input?: CreateSemanticLineageEventInput, options?: { readonly id?: string; readonly createdAt?: number | string; readonly actor?: SemanticLineageActorInput | string; readonly actorId?: string; readonly actorRole?: string }): SemanticLineageEvent;
 export declare function createSemanticLineageMap(events?: readonly (SemanticLineageEvent | CreateSemanticLineageEventInput)[], options?: { readonly id?: string; readonly generatedAt?: number | string }): SemanticLineageMap;
 export declare function inferSemanticLineageEvents(input?: InferSemanticLineageEventsOptions, options?: { readonly metadata?: Record<string, unknown>; readonly deletedConfidence?: number }): SemanticLineageInferenceResult;
 export declare function querySemanticLineageEvents(events: SemanticLineageEvent | readonly SemanticLineageEvent[], query?: SemanticLineageQuery): readonly SemanticLineageEvent[];

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

@@ -90,6 +90,7 @@ export interface SemanticPatchBundleAdmission {
   readonly autoApplyCandidate?: boolean;
   readonly transformAdmission?: SemanticPatchBundleTransformAdmission;
   readonly semanticEditAdmission?: SemanticEditBundleAdmission;
+  readonly evidenceAdmission?: SemanticPatchBundleEvidenceAdmission;
   readonly reasonCodes?: readonly string[];
   readonly conflictKeys?: readonly string[];
   readonly admittedAt?: number | string;
@@ -98,6 +99,18 @@ export interface SemanticPatchBundleAdmission {
   readonly metadata?: Record<string, unknown>;
 }
 
+export interface SemanticPatchBundleEvidenceAdmission {
+  readonly status: 'none' | 'ready' | 'needs-review' | 'stale' | 'blocked' | string;
+  readonly action: 'none' | 'admit' | 'review' | 'rerun-semantic-import' | 'block' | string;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly reasonCodes?: readonly string[];
+  readonly evidenceIds?: readonly string[];
+  readonly passed?: number;
+  readonly failed?: number;
+  readonly conflict?: number;
+  readonly stale?: number;
+}
+
 export interface SemanticPatchBundleTransformAdmission {
   readonly status: 'none' | 'ready' | 'needs-review' | 'blocked' | string;
   readonly action: 'none' | 'admit' | 'review' | 'block' | string;

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

@@ -1,11 +1,11 @@
-import{idFragment}from'../../native-import-utils.js';
+import{idFragment,caseSensitiveIdFragment}from'../../native-import-utils.js';
 import{nativeNodeId}from'./nativeNodeId.js';
 export function declarationRecord(input, nativeNodeId, name, symbolKind, role = 'definition') {
   return {
     name: String(name),
     symbolKind,
     role,
-    symbolId: `symbol:${input.language}:${role === 'import' ? 'import:' : ''}${idFragment(name)}`,
+    symbolId: `symbol:${input.language}:${role === 'import' ? 'import:' : ''}${caseSensitiveIdFragment(name)}`,
     nativeNodeId
   };
 }

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

@@ -74,6 +74,8 @@ export function inferSemanticLineageEvents(input = {}, options = {}) {
       inferredEvents: events.length,
       moved: events.filter((event) => event.eventKind === 'moved').length,
       renamed: events.filter((event) => event.eventKind === 'renamed').length,
+      split: events.filter((event) => event.eventKind === 'split').length,
+      recreated: events.filter((event) => event.eventKind === 'recreated').length,
       deleted: deleted.length,
       ambiguous: candidates.ambiguous.length,
       unmatchedAdded: candidates.unmatchedAfter.length,
@@ -169,6 +171,10 @@ function lineageInferenceEvidence(input) {
       language: input.language,
       unchangedAnchors: input.exact.matched.length,
       inferredEvents: input.events.length,
+      moved: input.events.filter((event) => event.eventKind === 'moved').length,
+      renamed: input.events.filter((event) => event.eventKind === 'renamed').length,
+      split: input.events.filter((event) => event.eventKind === 'split').length,
+      recreated: input.events.filter((event) => event.eventKind === 'recreated').length,
       deleted: input.deleted.length,
       ambiguous: input.candidates.ambiguous.length,
       unmatchedAdded: input.candidates.unmatchedAfter.length,
@@ -188,6 +194,8 @@ function inferenceReadiness(input, options) {
 function inferenceReasons(input) {
   return uniqueStrings([
     input.events.length ? 'semantic-lineage-inferred' : undefined,
+    input.events.some((event) => event.eventKind === 'split') ? 'split-anchor-lineage-inferred' : undefined,
+    input.events.some((event) => event.eventKind === 'recreated') ? 'recreated-anchor-lineage-inferred' : undefined,
     input.deleted.length ? 'deleted-anchor-lineage-inferred' : undefined,
     input.added.length ? 'unmatched-added-anchor-review' : undefined,
     input.ambiguous.length ? 'ambiguous-lineage-candidates' : undefined,

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

@@ -1,6 +1,14 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { idFragment, uniqueStrings } from '../../native-import-utils.js';
 import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+import {
+  insertionOffset,
+  insertionReplacement,
+  projectionCoveredContainerOperationIds,
+  removalRange,
+  scopedBodyReplacement,
+  spanOffsets
+} from './semanticEditSourceRanges.js';
 import { applySourceEdits, dedupeSourceEdits, validateSourceEdits } from './semanticSourceEditDedupe.js';
 
 export function projectSemanticEditScriptToSource(input = {}) {
@@ -9,22 +17,25 @@ export function projectSemanticEditScriptToSource(input = {}) {
   const headSourceText = input.headSourceText;
   const reasonCodes = [];
   if (!script) throw new Error('projectSemanticEditScriptToSource requires a script');
-  if (script.admission?.status !== 'auto-merge-candidate') reasonCodes.push('script-not-auto-merge-candidate');
   if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
   if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
   const edits = [];
   const coveredOperationIds = [];
+  const projectionCoveredOperationIds = projectionCoveredContainerOperationIds(script.operations ?? [], workerSourceText);
   for (const [index, operation] of (script.operations ?? []).entries()) {
-    if (operation.status === 'covered') {
+    if (operation.status === 'covered' || projectionCoveredOperationIds.has(operation.id)) {
       coveredOperationIds.push(operation.id);
       continue;
     }
-    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index);
+    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, input.headSourcePath);
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
   }
   const deduped = dedupeSourceEdits(edits);
   reasonCodes.push(...validateSourceEdits(deduped.edits));
+  if (script.admission?.status !== 'auto-merge-candidate' && (reasonCodes.length > 0 || (!edits.length && !coveredOperationIds.length))) {
+    reasonCodes.push('script-not-auto-merge-candidate');
+  }
   const blocked = reasonCodes.length > 0;
   const sourceText = blocked ? undefined : applySourceEdits(headSourceText, deduped.edits);
   const core = {
@@ -62,8 +73,8 @@ export function projectSemanticEditScriptToSource(input = {}) {
   return { ...core, hash: hashSemanticValue(core) };
 }
 
-function sourceEditForOperation(operation, workerSourceText, headSourceText, order) {
-  const identity = projectionIdentity(operation);
+function sourceEditForOperation(operation, workerSourceText, headSourceText, order, headSourcePath) {
+  const identity = projectionIdentity(operation, headSourcePath);
   if (operation.status === 'already-applied') {
     return { ok: true, value: { ...identity, operationId: operation.id, order, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
   }
@@ -80,16 +91,23 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
   if (!workerOffsets) reasons.push(`worker-span-not-resolvable:${operation.id}`);
   if (!headOffsets) reasons.push(`head-span-not-resolvable:${operation.id}`);
   if (reasons.length) return { ok: false, reasonCodes: reasons };
-  const replacement = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
-  const current = headSourceText.slice(headOffsets.start, headOffsets.end);
-  if (operation.hashes?.workerTextHash && hashSemanticValue(replacement) !== operation.hashes.workerTextHash) {
+  const anchorReplacement = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
+  const anchorCurrent = headSourceText.slice(headOffsets.start, headOffsets.end);
+  if (operation.hashes?.workerTextHash && hashSemanticValue(anchorReplacement) !== operation.hashes.workerTextHash) {
     reasons.push(`worker-span-hash-mismatch:${operation.id}`);
   }
   const expectedHeadHash = operation.hashes?.headTextHash ?? operation.hashes?.baseTextHash;
-  if (expectedHeadHash && hashSemanticValue(current) !== expectedHeadHash) {
+  if (expectedHeadHash && hashSemanticValue(anchorCurrent) !== expectedHeadHash) {
     reasons.push(`head-span-hash-mismatch:${operation.id}`);
   }
   if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const scoped = scopedBodyReplacement(operation, headSourceText, workerSourceText, headOffsets, workerOffsets);
+  const replacement = scoped
+    ? workerSourceText.slice(scoped.worker.start, scoped.worker.end)
+    : anchorReplacement;
+  const current = scoped
+    ? headSourceText.slice(scoped.head.start, scoped.head.end)
+    : anchorCurrent;
   return {
     ok: true,
     value: {
@@ -97,10 +115,17 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
       order,
       ...identity,
       editKind: 'replace',
-      start: headOffsets.start,
-      end: headOffsets.end,
-      workerStart: workerOffsets.start,
-      workerEnd: workerOffsets.end,
+      sourceRangeKind: scoped?.sourceRangeKind,
+      start: scoped?.head.start ?? headOffsets.start,
+      end: scoped?.head.end ?? headOffsets.end,
+      workerStart: scoped?.worker.start ?? workerOffsets.start,
+      workerEnd: scoped?.worker.end ?? workerOffsets.end,
+      headAnchorStart: scoped ? headOffsets.start : undefined,
+      headAnchorEnd: scoped ? headOffsets.end : undefined,
+      workerAnchorStart: scoped ? workerOffsets.start : undefined,
+      workerAnchorEnd: scoped ? workerOffsets.end : undefined,
+      anchorDeletedTextHash: scoped ? hashSemanticValue(anchorCurrent) : undefined,
+      anchorReplacementTextHash: scoped ? hashSemanticValue(anchorReplacement) : undefined,
       replacement,
       current
     }
@@ -165,9 +190,16 @@ function insertionEditForOperation(operation, identity, workerSourceText, headSo
   };
 }
 
-function projectionIdentity(operation) {
+function projectionIdentity(operation, headSourcePath) {
   const identity = semanticEditIdentity(operation);
-  return { ...identity, sourcePath: operation.reanchor?.toSourcePath ?? identity.sourcePath };
+  const sourcePath = operation.reanchor?.toSourcePath ?? headSourcePath ?? operation.insertion?.sourcePath ?? identity.sourcePath;
+  const originalSourcePath = sourcePath && identity.sourcePath && sourcePath !== identity.sourcePath
+    ? identity.sourcePath
+    : identity.originalSourcePath;
+  const targetSourcePath = sourcePath && sourcePath !== identity.sourcePath
+    ? sourcePath
+    : identity.targetSourcePath;
+  return { ...identity, sourcePath, originalSourcePath, targetSourcePath };
 }
 
 function projectionEditRecord(edit) {
@@ -197,18 +229,27 @@ function projectionEditRecord(edit) {
     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,
@@ -247,55 +288,6 @@ function projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
 
-function spanOffsets(sourceText, span) {
-  if (typeof sourceText !== 'string' || !span) return undefined;
-  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) return { start: span.start, end: span.end };
-  if (typeof span.startLine !== 'number') return undefined;
-  const lineStarts = [0];
-  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') lineStarts.push(index + 1);
-  const startLine = Math.max(1, span.startLine);
-  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
-  const start = lineStarts[startLine - 1];
-  const endLineStart = lineStarts[endLine - 1];
-  if (start === undefined || endLineStart === undefined) return undefined;
-  const startColumn = Math.max(1, span.startColumn ?? 1) - 1;
-  const lineEnd = lineStarts[endLine] === undefined ? sourceText.length : lineStarts[endLine] - 1;
-  const endColumn = span.endColumn === undefined ? lineEnd - endLineStart : Math.max(1, span.endColumn) - 1;
-  return { start: start + startColumn, end: endLineStart + endColumn };
-}
-
-function insertionOffset(sourceText, insertion) {
-  if (typeof sourceText !== 'string') return { ok: false, reasonCodes: ['missing-head-source-text'] };
-  const mode = insertion?.mode;
-  if (mode === 'file-start') return { ok: true, offset: 0 };
-  if (mode === 'file-end') return { ok: true, offset: sourceText.length };
-  const range = spanOffsets(sourceText, insertion?.headSpan);
-  if (!range) return { ok: false, reasonCodes: ['insertion-anchor-not-resolvable'] };
-  if (mode === 'before') return { ok: true, offset: range.start };
-  if (mode === 'after') return { ok: true, offset: afterLineOffset(sourceText, range.end) };
-  return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
-}
-
-function removalRange(sourceText, span) {
-  const range = { ...span };
-  if (range.end < sourceText.length && sourceText[range.end] === '\n') range.end += 1;
-  else if (range.start > 0 && sourceText[range.start - 1] === '\n') range.start -= 1;
-  return range;
-}
-
-function insertionReplacement(text, sourceText, offset) {
-  let replacement = String(text ?? '');
-  if (offset > 0 && sourceText[offset - 1] !== '\n') replacement = `\n${replacement}`;
-  if (offset < sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
-  if (offset === sourceText.length && sourceText && !sourceText.endsWith('\n')) replacement = `\n${replacement}`;
-  if (offset === sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
-  return replacement;
-}
-
-function afterLineOffset(sourceText, offset) {
-  return sourceText[offset] === '\n' ? offset + 1 : offset;
-}
-
 function compactRecord(value) {
   return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
 }