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

package/dist/declarations/source-preservation.d.ts

@@ -54,11 +54,16 @@ export type NativeSourceTokenKind =
   | 'keyword'
   | 'number'
   | 'string'
+  | 'template'
+  | 'regex-like'
+  | 'jsx'
   | 'operator'
   | 'punctuation'
   | 'comment'
+  | 'source-map-comment'
   | 'whitespace'
   | 'newline'
+  | 'shebang'
   | 'directive'
   | 'unknown'
   | string;
@@ -81,6 +86,65 @@ export interface NativeSourcePreservedDirective {
   readonly metadata?: Record<string, unknown>;
 }
 
+export type NativeSourceLedgerSpanRole =
+  | 'token'
+  | 'trivia'
+  | 'comment'
+  | 'directive'
+  | 'module-keyword'
+  | 'brace'
+  | 'protected'
+  | string;
+
+export interface NativeSourceLedgerSpan {
+  readonly id: string;
+  readonly kind: string;
+  readonly role: NativeSourceLedgerSpanRole;
+  readonly text?: string;
+  readonly textHash: string;
+  readonly span: SourceSpan;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface NativeSourceLedgerSummary {
+  readonly spans: number;
+  readonly tokens: number;
+  readonly trivia: number;
+  readonly comments: number;
+  readonly shebangs: number;
+  readonly directives: number;
+  readonly sourceMapComments: number;
+  readonly importExportSpans: number;
+  readonly braces: number;
+  readonly protectedRegions: number;
+  readonly stringRegions: number;
+  readonly templateRegions: number;
+  readonly regexLikeRegions: number;
+  readonly jsxRegions: number;
+  readonly triviaByKind?: Record<string, number>;
+  readonly tokenByKind?: Record<string, number>;
+  readonly directiveByKind?: Record<string, number>;
+  readonly truncated: boolean;
+}
+
+export interface NativeSourceLedger {
+  readonly kind: 'frontier.lang.jsTsSourceLedger';
+  readonly version: 1;
+  readonly language: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash: string;
+  readonly spans: readonly NativeSourceLedgerSpan[];
+  readonly tokens: readonly NativeSourceLedgerSpan[];
+  readonly trivia: readonly NativeSourceLedgerSpan[];
+  readonly comments: readonly NativeSourceLedgerSpan[];
+  readonly shebangs: readonly NativeSourceLedgerSpan[];
+  readonly directives: readonly NativeSourceLedgerSpan[];
+  readonly importExportSpans: readonly NativeSourceLedgerSpan[];
+  readonly braces: readonly NativeSourceLedgerSpan[];
+  readonly protectedRegions: readonly NativeSourceLedgerSpan[];
+  readonly summary: NativeSourceLedgerSummary;
+}
+
 export interface NativeSourcePreservation {
   readonly kind: 'frontier.lang.nativeSourcePreservation';
   readonly version: 1;
@@ -96,12 +160,18 @@ export interface NativeSourcePreservation {
   readonly tokens: readonly NativeSourcePreservedToken[];
   readonly trivia: readonly NativeSourcePreservedToken[];
   readonly directives: readonly NativeSourcePreservedDirective[];
+  readonly ledger?: NativeSourceLedger;
   readonly summary: {
     readonly tokens: number;
     readonly trivia: number;
     readonly directives: number;
     readonly comments: number;
     readonly whitespace: number;
+    readonly ledger?: NativeSourceLedgerSummary;
+    readonly sourceMapComments?: number;
+    readonly protectedRegions?: number;
+    readonly importExportSpans?: number;
+    readonly braces?: number;
     readonly exactSourceAvailable: boolean;
     readonly truncated: boolean;
   };
@@ -119,8 +189,10 @@ export interface CreateNativeSourcePreservationOptions {
   readonly includeTokens?: boolean;
   readonly includeTrivia?: boolean;
   readonly includeDirectives?: boolean;
+  readonly includeSourceLedger?: boolean;
   readonly maxTokens?: number;
   readonly maxTrivia?: number;
   readonly maxDirectives?: number;
+  readonly maxLedgerSpans?: number;
   readonly metadata?: Record<string, unknown>;
 }

package/dist/declarations/universal-capability.d.ts

@@ -49,6 +49,7 @@ import type { JavaAstNativeImporterAdapterOptions, KotlinPsiNativeImporterAdapte
 import type { NativeTargetProjectionAdapterCoverageInput, NativeTargetProjectionAdapterSummary, NativeTargetProjectionAdapterInput, NativeTargetProjectionAdapterResult, NativeTargetProjectionAdapter, NativeTargetProjectionAdapterResolverInput, NativeTargetProjectionResult } from './target-adapters.js';
 import type { NativeProjectSourceInput, ImportNativeProjectOptions, NativeProjectImportResult, NativeSourceProjectionMode, ProjectNativeImportToSourceOptions, NativeSourceProjectionDeclaration, NativeSourceProjectionResult, NativeSourceCompileOutputMode, CompileNativeSourceOptions, NativeSourceCompileResult } from './native-project.js';
 import type { NativeImportRoundtripReadinessStatus, NativeImportRoundtripReadinessOptions, NativeImportRoundtripReadinessClassification } from './roundtrip.js';
+import type { UniversalRepresentationCoverage } from './universal-representation-coverage.js';
 
 export interface UniversalCapabilityLanguageRow {
   readonly language: FrontierSourceLanguage | string;
@@ -89,6 +90,7 @@ export interface UniversalCapabilityLanguageRow {
     readonly knownLossKinds: readonly NativeImportKnownLossKind[];
     readonly sourceMapMappings: number;
   };
+  readonly representation: UniversalRepresentationCoverage;
   readonly blockers: readonly string[];
   readonly review: readonly string[];
 }
@@ -111,6 +113,8 @@ export interface UniversalCapabilityMatrix {
     readonly unsupportedTargetFeatures: number;
     readonly exactSourceProjection: number;
     readonly nativeSourceStubs: number;
+    readonly representationConstructs: number;
+    readonly representationMissing: number;
     readonly blockers: number;
     readonly reviewReasons: number;
     readonly readyLanguages: number;

package/dist/declarations/universal-conversion-artifacts.d.ts

@@ -6,6 +6,7 @@ import type {
 import type { FrontierCompileTarget } from './compile.js';
 import type { SemanticHistoryRecord } from './semantic-history.js';
 import type { SemanticPatchBundleRecord } from './semantic-patch-bundle.js';
+import type { UniversalConversionArtifactCompactCounts } from './universal-conversion-compact-counts.js';
 import type {
   UniversalConversionAdmissionAction,
   UniversalConversionPlan,
@@ -17,6 +18,7 @@ import type {
   UniversalConversionMergeScore,
   UniversalConversionRisk
 } from './universal-conversion-plan.js';
+import type { UniversalRepresentationCoverageQuery } from './universal-representation-coverage.js';
 
 export type UniversalConversionArtifactAdmissionStatus = 'queued' | 'needs-review' | 'blocked' | string;
 export type UniversalConversionArtifactAdmissionBucket =
@@ -151,6 +153,27 @@ export interface UniversalConversionArtifactIndex {
   readonly proofIds: readonly string[];
   readonly semanticOperationIds: readonly string[];
   readonly semanticOperationKinds: readonly string[];
+  readonly semanticEditStatuses: readonly string[];
+  readonly semanticEditScriptIds: readonly string[];
+  readonly semanticEditProjectionIds: readonly string[];
+  readonly semanticEditReplayIds: readonly string[];
+  readonly semanticEditReplayStatuses: readonly string[];
+  readonly semanticEditReplayActions: readonly string[];
+  readonly semanticEditAdmissionStatuses: readonly string[];
+  readonly semanticEditAdmissionActions: readonly string[];
+  readonly semanticEditAdmissionReadinesses: readonly string[];
+  readonly semanticEditReplayCurrentHashes: readonly string[];
+  readonly semanticEditReplayOutputHashes: readonly string[];
+  readonly semanticEditKeys: readonly string[];
+  readonly semanticEditHashes: readonly string[];
+  readonly semanticIdentityHashes: readonly string[];
+  readonly sourceIdentityHashes: readonly string[];
+  readonly operationContentHashes: readonly string[];
+  readonly editContentHashes: readonly string[];
+  readonly representationConstructKinds: readonly string[];
+  readonly runtimeCapabilities: readonly string[];
+  readonly sourceMapPrecisions: readonly string[];
+  readonly transformIdentityHashes: readonly string[];
 }
 
 export interface UniversalConversionArtifacts {
@@ -171,6 +194,7 @@ export interface UniversalConversionArtifacts {
     readonly patchBundles: number;
     readonly admissionRecords: number;
     readonly semanticOperations: number;
+    readonly compactCounts: UniversalConversionArtifactCompactCounts;
     readonly mergeReady: number;
     readonly needsEvidence: number;
     readonly needsAdapter: number;
@@ -217,7 +241,7 @@ export type CreateUniversalConversionArtifactsInput =
   | UniversalConversionRoute
   | UniversalConversionPlanOptions;
 
-export interface UniversalConversionArtifactQuery {
+export interface UniversalConversionArtifactQuery extends UniversalRepresentationCoverageQuery {
   readonly routeId?: string | readonly string[];
   readonly historyId?: string | readonly string[];
   readonly patchBundleId?: string | readonly string[];
@@ -240,6 +264,42 @@ export interface UniversalConversionArtifactQuery {
   readonly proofId?: string | readonly string[];
   readonly semanticOperationId?: string | readonly string[];
   readonly semanticOperationKind?: string | readonly string[];
+  readonly semanticEditStatus?: string | readonly string[];
+  readonly semanticEditStatuses?: readonly string[];
+  readonly semanticEditScriptId?: string | readonly string[];
+  readonly semanticEditScriptIds?: readonly string[];
+  readonly semanticEditProjectionId?: string | readonly string[];
+  readonly semanticEditProjectionIds?: readonly string[];
+  readonly semanticEditReplayId?: string | readonly string[];
+  readonly semanticEditReplayIds?: readonly string[];
+  readonly semanticEditReplayStatus?: string | readonly string[];
+  readonly semanticEditReplayStatuses?: readonly string[];
+  readonly semanticEditReplayAction?: string | readonly string[];
+  readonly semanticEditReplayActions?: readonly string[];
+  readonly semanticEditAdmission?: string | readonly string[];
+  readonly semanticEditAdmissionStatus?: string | readonly string[];
+  readonly semanticEditAdmissionStatuses?: readonly string[];
+  readonly semanticEditAdmissionAction?: string | readonly string[];
+  readonly semanticEditAdmissionActions?: readonly string[];
+  readonly semanticEditAdmissionReadiness?: string | readonly string[];
+  readonly semanticEditAdmissionReadinesses?: readonly string[];
+  readonly semanticEditReplayCurrentHash?: string | readonly string[];
+  readonly semanticEditReplayCurrentHashes?: readonly string[];
+  readonly semanticEditReplayOutputHash?: string | readonly string[];
+  readonly semanticEditReplayOutputHashes?: readonly string[];
+  readonly semanticEditKey?: string | readonly string[];
+  readonly semanticEditKeys?: readonly string[];
+  readonly semanticEditHash?: string | readonly string[];
+  readonly semanticEditHashes?: readonly string[];
+  readonly semanticIdentityHash?: string | readonly string[];
+  readonly semanticIdentityHashes?: readonly string[];
+  readonly sourceIdentityHash?: string | readonly string[];
+  readonly sourceIdentityHashes?: readonly string[];
+  readonly operationContentHash?: string | readonly string[];
+  readonly operationContentHashes?: readonly string[];
+  readonly editContentHash?: string | readonly string[];
+  readonly editContentHashes?: readonly string[];
+  readonly representationConstructKind?: string | readonly string[];
 }
 
 export declare function createUniversalConversionArtifacts(

package/dist/declarations/universal-conversion-compact-counts.d.ts

@@ -0,0 +1,51 @@
+export interface UniversalConversionRepresentationCompactCounts {
+  readonly total: number;
+  readonly byKind: Readonly<Record<string, number>>;
+}
+
+export interface UniversalConversionPlanRepresentationCompactCounts extends UniversalConversionRepresentationCompactCounts {
+  readonly represented: number;
+  readonly missing: number;
+  readonly review: number;
+  readonly blocked: number;
+  readonly byStatus: Readonly<Record<string, number>>;
+}
+
+export interface UniversalConversionArtifactRepresentationCompactCounts extends UniversalConversionRepresentationCompactCounts {
+  readonly routeArtifacts: number;
+}
+
+export interface UniversalConversionMissingConstructCompactCounts {
+  readonly total: number;
+  readonly byKind: Readonly<Record<string, number>>;
+}
+
+export interface UniversalConversionArtifactMissingConstructCompactCounts extends UniversalConversionMissingConstructCompactCounts {
+  readonly routeArtifacts: number;
+}
+
+export interface UniversalConversionPlanCompactCounts {
+  readonly representationConstructs: UniversalConversionPlanRepresentationCompactCounts;
+  readonly missingConstructs: UniversalConversionMissingConstructCompactCounts;
+  readonly semanticEditReadiness: { readonly routes: Readonly<Record<string, number>> };
+  readonly admissionStatuses: {
+    readonly byAction: Readonly<Record<string, number>>;
+    readonly byRouteStatus: Readonly<Record<string, number>>;
+    readonly byRisk: Readonly<Record<string, number>>;
+  };
+}
+
+export interface UniversalConversionArtifactCompactCounts {
+  readonly representationConstructs: UniversalConversionArtifactRepresentationCompactCounts;
+  readonly missingConstructs: UniversalConversionArtifactMissingConstructCompactCounts;
+  readonly semanticEditReadiness: {
+    readonly routeArtifacts: Readonly<Record<string, number>>;
+    readonly semanticOperations: Readonly<Record<string, number>>;
+  };
+  readonly admissionStatuses: {
+    readonly byStatus: Readonly<Record<string, number>>;
+    readonly byBucket: Readonly<Record<string, number>>;
+    readonly byAction: Readonly<Record<string, number>>;
+    readonly byRisk: Readonly<Record<string, number>>;
+  };
+}

package/dist/declarations/universal-conversion-plan.d.ts

@@ -9,6 +9,8 @@ import type { NativeParserFeatureCategory } from './native-parser-features.js';
 import type { ProjectionSourceProjectionCoverage, ProjectionTargetCoverageEntry } from './projection-coverage.js';
 import type { ProjectionReadinessTargetCell } from './projection-readiness.js';
 import type { UniversalCapabilityMatrix, UniversalCapabilityMatrixOptions } from './universal-capability.js';
+import type { UniversalRepresentationCoverage, UniversalRepresentationCoverageQuery } from './universal-representation-coverage.js';
+import type { UniversalConversionPlanCompactCounts } from './universal-conversion-compact-counts.js';
 import type {
   UniversalRuntimeAdapterRequirement,
   UniversalRuntimeCapabilityKind,
@@ -40,6 +42,7 @@ export type UniversalConversionScoreComponentKey =
   | 'importEvidence'
   | 'parserEvidence'
   | 'semanticIndex'
+  | 'representationCoverage'
   | 'projectionPath'
   | 'proofEvidence';
 
@@ -145,6 +148,7 @@ export interface UniversalConversionRoute {
   readonly runtime: UniversalConversionRouteRuntime;
   readonly runtimeAdapterRequirements: readonly UniversalRuntimeAdapterRequirement[];
   readonly evidence: UniversalConversionRouteEvidence;
+  readonly representation: UniversalRepresentationCoverage;
   readonly missingEvidence: readonly string[];
   readonly blockers: readonly string[];
   readonly review: readonly string[];
@@ -167,6 +171,7 @@ export interface UniversalConversionPlan {
     readonly byMode: Readonly<Record<UniversalConversionRouteMode, number>>;
     readonly byReadiness: Readonly<Record<SemanticMergeReadiness, number>>;
     readonly byAdmissionAction: Readonly<Record<UniversalConversionAdmissionAction, number>>;
+    readonly compactCounts: UniversalConversionPlanCompactCounts;
     readonly readyRoutes: number;
     readonly reviewRoutes: number;
     readonly blockedRoutes: number;
@@ -237,7 +242,7 @@ export interface UniversalConversionPlanOptions extends UniversalCapabilityMatri
   readonly evidence?: readonly EvidenceRecord[];
 }
 
-export interface UniversalConversionPlanQuery {
+export interface UniversalConversionPlanQuery extends UniversalRepresentationCoverageQuery {
   readonly sourceLanguage?: FrontierSourceLanguage | string;
   readonly language?: FrontierSourceLanguage | string;
   readonly target?: FrontierCompileTarget | string;

package/dist/declarations/universal-representation-coverage.d.ts

@@ -0,0 +1,90 @@
+import type { FrontierSourceLanguage } from '@shapeshift-labs/frontier-lang-kernel';
+import type { FrontierCompileTarget } from './compile.js';
+import type { UniversalRuntimeCapabilityKind } from './universal-runtime-capabilities.js';
+
+export type UniversalRepresentationConstructKind =
+  | 'source-import'
+  | 'semantic-symbol'
+  | 'source-map'
+  | 'parser-feature'
+  | 'source-preservation'
+  | 'declaration-stub'
+  | 'target-adapter'
+  | 'runtime-capability'
+  | 'semantic-ownership'
+  | 'proof-evidence'
+  | string;
+
+export type UniversalRepresentationConstructStatus = 'represented' | 'missing' | 'review' | 'blocked' | string;
+
+export interface UniversalRepresentationConstructRecord {
+  readonly kind: UniversalRepresentationConstructKind;
+  readonly status: UniversalRepresentationConstructStatus;
+  readonly surface: string;
+  readonly count: number;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}
+
+export interface UniversalRepresentationCoverage {
+  readonly kind: 'frontier.lang.universalRepresentationCoverage';
+  readonly version: 1;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly target?: FrontierCompileTarget | string;
+  readonly constructKinds: readonly UniversalRepresentationConstructKind[];
+  readonly constructs: readonly UniversalRepresentationConstructRecord[];
+  readonly surfaces: {
+    readonly sourceImport: { readonly total: number; readonly readiness?: string };
+    readonly semanticIndex: { readonly symbols: number; readonly sourceMapMappings: number };
+    readonly sourceMaps: { readonly mappings: number; readonly precisions: readonly string[] };
+    readonly parser: { readonly rows: number; readonly mergeReadyParsers: readonly string[] };
+    readonly projection: {
+      readonly targetEntries: number;
+      readonly missingTargets: readonly string[];
+      readonly unsupportedTargets: readonly string[];
+    };
+    readonly runtime: {
+      readonly requiredCapabilities: readonly UniversalRuntimeCapabilityKind[];
+      readonly satisfiedCapabilities: readonly UniversalRuntimeCapabilityKind[];
+      readonly missingCapabilities: readonly UniversalRuntimeCapabilityKind[];
+      readonly adapterRequirements: readonly string[];
+    };
+    readonly mergeRefs: {
+      readonly ownershipKeys: readonly string[];
+      readonly conflictKeys: readonly string[];
+      readonly sourceMapIds: readonly string[];
+      readonly sourceMapMappingIds: readonly string[];
+      readonly transformIdentityHashes: readonly string[];
+    };
+    readonly evidence: { readonly records: number; readonly proofRecords: number };
+  };
+  readonly missing: readonly string[];
+  readonly blockers: readonly string[];
+  readonly review: readonly string[];
+  readonly summary: {
+    readonly constructs: number;
+    readonly representedConstructs: number;
+    readonly reviewConstructs: number;
+    readonly blockedConstructs: number;
+    readonly missing: number;
+    readonly blockers: number;
+    readonly review: number;
+  };
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}
+
+export interface UniversalRepresentationCoverageQuery {
+  readonly constructKind?: UniversalRepresentationConstructKind | readonly UniversalRepresentationConstructKind[];
+  readonly construct?: UniversalRepresentationConstructKind | readonly UniversalRepresentationConstructKind[];
+  readonly runtimeCapability?: UniversalRuntimeCapabilityKind | readonly UniversalRuntimeCapabilityKind[];
+  readonly sourceMapPrecision?: string | readonly string[];
+  readonly transformIdentityHash?: string | readonly string[];
+}
+
+export declare const UniversalRepresentationConstructKinds: readonly UniversalRepresentationConstructKind[];
+export declare function createUniversalRepresentationCoverage(input?: Record<string, unknown>): UniversalRepresentationCoverage;
+export declare function representationCoverageMatches(
+  coverage?: UniversalRepresentationCoverage,
+  query?: UniversalRepresentationCoverageQuery
+): boolean;

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from './declarations/native-import-coverage.js';
 export * from './declarations/projection-coverage.js';
 export * from './declarations/projection-readiness.js';
 export * from './declarations/universal-capability.js';
+export * from './declarations/universal-representation-coverage.js';
 export * from './declarations/universal-conversion-artifacts.js';
 export * from './declarations/universal-conversion-plan.js';
 export * from './declarations/universal-runtime-capabilities.js';
@@ -25,8 +26,11 @@ export * from './declarations/semantic-patch-bundle.js';
 export * from './declarations/semantic-patch-bundle-overlaps.js';
 export * from './declarations/semantic-transform-identity.js';
 export * from './declarations/bidirectional-target-change.js';
+export * from './declarations/bidirectional-target-change-source-edit.js';
 export * from './declarations/semantic-impact.js';
 export * from './declarations/semantic-sidecar.js';
+export * from './declarations/semantic-sidecar-example.js';
+export * from './declarations/js-ts-semantic-merge.js';
 export * from './declarations/native-diff.js';
 export * from './declarations/semantic-slice.js';
 export * from './declarations/semantic-slice-admission.js';

package/dist/index.js

@@ -23,6 +23,8 @@ export { createProjectionTargetLossMatrix } from './internal/index-impl/createPr
 export { createPythonAstNativeImporterAdapter } from './internal/index-impl/createPythonAstNativeImporterAdapter.js';
 export { createRustSynNativeImporterAdapter } from './internal/index-impl/createRustSynNativeImporterAdapter.js';
 export { createSemanticImportSidecar } from './internal/index-impl/createSemanticImportSidecar.js';
+export { compactSemanticSidecarExample } from './semantic-sidecar-example.js';
+export * from './js-ts-semantic-merge.js';
 export { createSemanticSlice } from './internal/index-impl/createSemanticSlice.js';
 export { createSemanticSliceAdmissionRecord } from './internal/index-impl/createSemanticSliceAdmissionRecord.js';
 export { createSwiftSyntaxNativeImporterAdapter } from './internal/index-impl/createSwiftSyntaxNativeImporterAdapter.js';
@@ -30,6 +32,7 @@ export { createTreeSitterNativeImporterAdapter } from './internal/index-impl/cre
 export { createTypeScriptCompilerNativeImporterAdapter } from './internal/index-impl/createTypeScriptCompilerNativeImporterAdapter.js';
 export { createUniversalAstFromDocument } from './internal/index-impl/createUniversalAstFromDocument.js';
 export { createUniversalCapabilityMatrix } from './internal/index-impl/createUniversalCapabilityMatrix.js';
+export { createUniversalRepresentationCoverage, representationCoverageMatches, UniversalRepresentationConstructKinds } from './universal-representation-coverage.js';
 export { createUniversalConversionArtifacts } from './internal/index-impl/createUniversalConversionArtifacts.js';
 export { queryUniversalConversionArtifacts } from './universal-conversion-artifacts.js';
 export { createUniversalConversionPlan } from './internal/index-impl/createUniversalConversionPlan.js';

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

@@ -0,0 +1,199 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { normalizeNativeLanguageId } from '../../native-import-utils.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { spanOffsets } from './semanticEditSourceRanges.js';
+
+export function exactSourceBackprojectionForMatch(match, context) {
+  if (!sameLanguage(context.source?.language, context.targetChangeSet?.language)) {
+    return explicitSourceReplacementBackprojection(match, context);
+  }
+  const anchor = match.sourceAnchors[0];
+  const link = match.sourceMapLinks.find((entry) => entry.precision === 'exact');
+  const region = targetRegionForMatch(match, context);
+  if (!anchor || !link || !['added', 'modified', 'removed'].includes(region?.changeKind)) return undefined;
+  const sourceText = nativeImportSourceText(context.source);
+  const targetBeforeText = nativeImportSourceText(context.targetChangeSet.before);
+  const targetAfterText = nativeImportSourceText(context.targetChangeSet.after);
+  const beforeSpan = region.metadata?.changedRegionProjection?.before?.sourceSpan ?? region.sourceSpan;
+  const afterSpan = region.metadata?.changedRegionProjection?.after?.sourceSpan;
+  const ranges = {
+    source: spanOffsets(sourceText, link.sourceSpan ?? anchor.sourceSpan),
+    generated: spanOffsets(targetBeforeText, link.generatedSpan),
+    before: spanOffsets(targetBeforeText, beforeSpan),
+    after: spanOffsets(targetAfterText, afterSpan)
+  };
+  if (region.changeKind === 'added') return addedSourceBackprojection({ anchor, link, region, sourceText, targetAfterText, ranges, context });
+  if (!validRanges(ranges, region.changeKind)) return undefined;
+  const sourceMappedText = sourceText.slice(ranges.source.start, ranges.source.end);
+  const targetBeforeMappedText = targetBeforeText.slice(ranges.generated.start, ranges.generated.end);
+  const targetBeforeEditText = targetBeforeText.slice(ranges.before.start, ranges.before.end);
+  const targetAfterEditText = region.changeKind === 'removed'
+    ? ''
+    : targetAfterText.slice(ranges.after.start, ranges.after.end);
+  const targetAfterMappedText = afterMappedText(targetBeforeMappedText, targetAfterEditText, ranges);
+  const matchesBefore = sourceMappedText === targetBeforeMappedText;
+  const matchesAfter = sourceMappedText === targetAfterMappedText;
+  const lineEndingStableBefore = !matchesBefore && sameLineEndingStable(sourceMappedText, targetBeforeMappedText);
+  const lineEndingStableAfter = !matchesBefore && sameLineEndingStable(sourceMappedText, targetAfterMappedText);
+  if (!matchesBefore && !matchesAfter && !lineEndingStableBefore && !lineEndingStableAfter) return undefined;
+  const alreadyApplied = matchesAfter && !matchesBefore;
+  const lineEndingStable = lineEndingStableBefore || lineEndingStableAfter;
+  const sourceEditRange = lineEndingStable
+    ? lineEndingStableSourceEditRange(sourceMappedText, lineEndingStableAfter ? targetAfterMappedText : targetBeforeMappedText, ranges, lineEndingStableAfter ? targetAfterEditText : targetBeforeEditText)
+    : sourceEditRangeForMatch(ranges, alreadyApplied ? targetAfterEditText : targetBeforeEditText);
+  if (!sourceEditRange) return undefined;
+  const sourceEditText = sourceText.slice(sourceEditRange.start, sourceEditRange.end);
+  const expectedSourceEditText = alreadyApplied || lineEndingStableAfter ? targetAfterEditText : targetBeforeEditText;
+  if (sourceEditText !== expectedSourceEditText && !sameLineEndingStable(sourceEditText, expectedSourceEditText)) return undefined;
+  return compactRecord({
+    mode: 'same-language-exact-source-map',
+    alreadyApplied: alreadyApplied || lineEndingStableAfter,
+    lineEndingStable,
+    sourceMapLinkId: link.id,
+    sourceMapMappingId: link.sourceMapMappingId,
+    sourceEditSpan: { start: sourceEditRange.start, end: sourceEditRange.end, path: anchor.sourcePath },
+    targetBeforeEditSpan: { start: ranges.before.start, end: ranges.before.end, path: region.sourcePath },
+    targetAfterEditSpan: ranges.after ? { start: ranges.after.start, end: ranges.after.end, path: region.sourcePath } : undefined,
+    sourceEditTextHash: hashSemanticValue(sourceEditText),
+    targetBeforeEditTextHash: hashSemanticValue(targetBeforeEditText),
+    targetAfterEditTextHash: hashSemanticValue(targetAfterEditText),
+    targetAfterSourceHash: context.targetChangeSet.afterHash
+  });
+}
+
+function explicitSourceReplacementBackprojection(match, context) {
+  const anchor = match.sourceAnchors[0];
+  const link = match.sourceMapLinks.find((entry) => typeof sourceReplacementText(entry) === 'string');
+  const replacement = sourceReplacementText(link);
+  const sourceText = nativeImportSourceText(context.source);
+  const targetAfterText = nativeImportSourceText(context.targetChangeSet?.after);
+  const region = targetRegionForMatch(match, context);
+  const ranges = {
+    source: spanOffsets(sourceText, link?.sourceSpan ?? anchor?.sourceSpan),
+    after: spanOffsets(targetAfterText, region?.metadata?.changedRegionProjection?.after?.sourceSpan ?? region?.sourceSpan)
+  };
+  if (!anchor || !link || link.precision !== 'exact' || typeof replacement !== 'string' || !ranges.source) return undefined;
+  const sourceEditText = sourceText.slice(ranges.source.start, ranges.source.end);
+  const replacementHash = sourceReplacementHash(link) ?? hashSemanticValue(replacement);
+  if (replacementHash !== hashSemanticValue(replacement)) return undefined;
+  const targetAfterEditText = ranges.after ? targetAfterText.slice(ranges.after.start, ranges.after.end) : undefined;
+  return compactRecord({
+    mode: 'cross-language-explicit-source-replacement',
+    alreadyApplied: sourceEditText === replacement,
+    sourceMapLinkId: link.id,
+    sourceMapMappingId: link.sourceMapMappingId,
+    sourceEditSpan: { start: ranges.source.start, end: ranges.source.end, path: anchor.sourcePath },
+    targetAfterEditSpan: ranges.after ? { start: ranges.after.start, end: ranges.after.end, path: region.sourcePath } : undefined,
+    sourceEditTextHash: hashSemanticValue(sourceEditText),
+    sourceReplacementText: replacement,
+    sourceReplacementTextHash: replacementHash,
+    targetAfterEditTextHash: targetAfterEditText === undefined ? undefined : hashSemanticValue(targetAfterEditText),
+    targetAfterSourceHash: context.targetChangeSet.afterHash
+  });
+}
+
+function addedSourceBackprojection(input) {
+  const { anchor, link, region, sourceText, targetAfterText, ranges, context } = input;
+  const generated = spanOffsets(targetAfterText, link.generatedSpan);
+  if (!ranges.source || !ranges.after || !generated) return undefined;
+  const sourceMappedText = sourceText.slice(ranges.source.start, ranges.source.end);
+  const targetAfterMappedText = targetAfterText.slice(generated.start, generated.end);
+  const targetAfterEditText = targetAfterText.slice(ranges.after.start, ranges.after.end);
+  const exact = sourceMappedText === targetAfterMappedText && sourceMappedText === targetAfterEditText;
+  const lineEndingStable = !exact && sameLineEndingStable(sourceMappedText, targetAfterMappedText) && sameLineEndingStable(sourceMappedText, targetAfterEditText);
+  if (!exact && !lineEndingStable) return undefined;
+  const sourceEditRange = lineEndingStable
+    ? lineEndingStableSourceEditRange(sourceMappedText, targetAfterMappedText, { ...ranges, before: generated, generated }, targetAfterEditText)
+    : { start: ranges.source.start, end: ranges.source.start + targetAfterEditText.length };
+  if (!sourceEditRange) return undefined;
+  return compactRecord({
+    mode: 'same-language-exact-source-map',
+    alreadyApplied: true,
+    lineEndingStable,
+    sourceMapLinkId: link.id,
+    sourceMapMappingId: link.sourceMapMappingId,
+    sourceEditSpan: { start: sourceEditRange.start, end: sourceEditRange.end, path: anchor.sourcePath },
+    targetAfterEditSpan: { start: ranges.after.start, end: ranges.after.end, path: region.sourcePath },
+    sourceEditTextHash: hashSemanticValue(sourceText.slice(sourceEditRange.start, sourceEditRange.end)),
+    targetBeforeEditTextHash: hashSemanticValue(''),
+    targetAfterEditTextHash: hashSemanticValue(targetAfterEditText),
+    targetAfterSourceHash: context.targetChangeSet.afterHash
+  });
+}
+
+function validRanges(ranges, changeKind) {
+  const hasAfter = changeKind === 'removed' || ranges.after;
+  return ranges.source && ranges.generated && ranges.before && hasAfter && containedRange(ranges.before, ranges.generated);
+}
+
+function afterMappedText(targetBeforeMappedText, targetAfterEditText, ranges) {
+  const start = ranges.before.start - ranges.generated.start;
+  const end = ranges.before.end - ranges.generated.start;
+  return targetBeforeMappedText.slice(0, start) + targetAfterEditText + targetBeforeMappedText.slice(end);
+}
+
+function sourceEditRangeForMatch(ranges, editText) {
+  const start = ranges.source.start + ranges.before.start - ranges.generated.start;
+  return { start, end: start + editText.length };
+}
+
+function lineEndingStableSourceEditRange(sourceMappedText, targetAfterMappedText, ranges, targetAfterEditText) {
+  const targetStart = ranges.before.start - ranges.generated.start;
+  const targetEnd = targetStart + targetAfterEditText.length;
+  const normalizedStart = normalizedPrefixLength(targetAfterMappedText, targetStart);
+  const normalizedEnd = normalizedPrefixLength(targetAfterMappedText, targetEnd);
+  const sourceStart = rawOffsetForNormalizedPrefix(sourceMappedText, normalizedStart);
+  const sourceEnd = rawOffsetForNormalizedPrefix(sourceMappedText, normalizedEnd);
+  if (sourceStart < 0 || sourceEnd < sourceStart) return undefined;
+  return {
+    start: ranges.source.start + sourceStart,
+    end: ranges.source.start + sourceEnd
+  };
+}
+
+function targetRegionForMatch(match, context) {
+  return context.targetChangeSet.changedRegions.find((region) => region.id === match.targetRegion?.id)
+    ?? match.targetRegion;
+}
+
+function sameLanguage(left, right) {
+  return normalizeNativeLanguageId(left) && normalizeNativeLanguageId(left) === normalizeNativeLanguageId(right);
+}
+
+function sourceReplacementText(link) {
+  return link?.sourceReplacementText ?? link?.sourceEditText ?? link?.metadata?.sourceReplacementText;
+}
+
+function sourceReplacementHash(link) {
+  return link?.sourceReplacementTextHash ?? link?.sourceReplacementHash ?? link?.metadata?.sourceReplacementTextHash;
+}
+
+function containedRange(inner, outer) {
+  return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end);
+}
+
+function sameLineEndingStable(left, right) {
+  return normalizeLineEndings(left) === normalizeLineEndings(right);
+}
+
+function normalizeLineEndings(value) {
+  return String(value ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+function normalizedPrefixLength(value, rawOffset) {
+  return normalizeLineEndings(String(value ?? '').slice(0, rawOffset)).length;
+}
+
+function rawOffsetForNormalizedPrefix(value, normalizedOffset) {
+  let normalized = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (normalized === normalizedOffset) return index;
+    if (value[index] === '\r' && value[index + 1] === '\n') index += 1;
+    normalized += 1;
+  }
+  return normalized === normalizedOffset ? value.length : -1;
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}