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

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

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

@@ -0,0 +1,112 @@
+import { idFragment, normalizeNativeLanguageId } from '../../native-import-utils.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { createSemanticEditScript } from './semanticEditScripts.js';
+import { projectSemanticEditScriptToSource } from './projectSemanticEditScriptToSource.js';
+import { replaySemanticEditProjection } from './replaySemanticEditProjection.js';
+
+const backprojectionMode = 'same-language-target-source-edit';
+
+export function createSameLanguageTargetSourceProjection(context = {}) {
+  if (!sameLanguageSamePath(context.source, context.targetChangeSet)) return {};
+  const sourceText = nativeImportSourceText(context.source);
+  const workerSourceText = nativeImportSourceText(context.targetChangeSet?.after);
+  if (typeof sourceText !== 'string' || typeof workerSourceText !== 'string') return {};
+  const script = createSemanticEditScript({
+    id: `semantic_edit_script_${idFragment(context.id)}_same_language_target`,
+    language: context.source.language,
+    sourcePath: context.source.sourcePath,
+    base: context.targetChangeSet.before,
+    worker: context.targetChangeSet.after,
+    head: context.source,
+    generatedAt: context.generatedAt,
+    metadata: {
+      sourceBackprojectionMode: backprojectionMode,
+      bidirectionalTargetChangeId: context.id,
+      targetChangeSetId: context.targetChangeSet.id
+    }
+  });
+  const projection = projectSemanticEditScriptToSource({
+    id: `semantic_edit_projection_${idFragment(context.id)}_same_language_target`,
+    script,
+    workerSourceText,
+    headSourceText: sourceText,
+    headSourcePath: context.source.sourcePath,
+    metadata: { sourceBackprojectionMode: backprojectionMode }
+  });
+  const replay = projection.status === 'projected'
+    ? replaySemanticEditProjection({
+      id: `semantic_edit_replay_${idFragment(context.id)}_same_language_target`,
+      projection,
+      currentSourceText: sourceText
+    })
+    : undefined;
+  const sourceProjectionHint = projectionHint(context, script, projection, replay);
+  return {
+    sourceEditScript: script,
+    sourceProjectionHint,
+    sourceEditProjection: projection,
+    sourceEditReplay: replay,
+    evidence: [sameLanguageEvidence(context, script, projection, replay)]
+  };
+}
+
+function projectionHint(context, script, projection, replay) {
+  const replayReady = ['accepted-clean', 'already-applied'].includes(replay?.status);
+  const ready = script.admission?.status === 'auto-merge-candidate' && projection?.status === 'projected' && replayReady;
+  return {
+    schema: 'frontier.lang.bidirectionalTargetChangeSourceEditProjectionHint.v1',
+    version: 1,
+    id: `source_projection_hint_${idFragment(context.id)}_same_language_target`,
+    scriptId: script.id,
+    status: ready ? 'auto-merge-candidate' : script.admission?.status ?? 'needs-port',
+    action: ready ? sourceAction(replay) : 'reanchor-or-human-port',
+    readiness: ready ? 'ready' : script.admission?.readiness ?? 'needs-review',
+    sourcePath: context.source.sourcePath,
+    sourceHash: script.headHash,
+    targetPath: context.targetChangeSet.sourcePath,
+    targetHash: context.targetChangeSet.afterHash,
+    targetChangeSetId: context.targetChangeSet.id,
+    targetPatchId: context.targetChangeSet.patch?.id,
+    targetMergeCandidateId: context.targetChangeSet.mergeCandidate?.id,
+    operationIds: (script.operations ?? []).map((operation) => operation.id),
+    reviewRequired: !ready,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: ready ? ['same-language-target-source-edit-replayed'] : script.admission?.reasonCodes,
+    sourceBackprojectionMode: backprojectionMode
+  };
+}
+
+function sameLanguageEvidence(context, script, projection, replay) {
+  const passed = projection?.status === 'projected' && ['accepted-clean', 'already-applied'].includes(replay?.status);
+  return {
+    id: `evidence_${idFragment(context.id)}_same_language_target_replay`,
+    kind: 'verification',
+    status: passed ? 'passed' : 'failed',
+    path: script.sourcePath,
+    summary: passed
+      ? 'Verified same-language target change by projecting and replaying it onto the source file.'
+      : 'Same-language target change did not project and replay cleanly onto the source file.',
+    metadata: {
+      schema: 'frontier.lang.bidirectionalSameLanguageTargetSourceEvidence.v1',
+      bidirectionalTargetChangeId: context.id,
+      sourceEditScriptId: script.id,
+      sourceEditProjectionId: projection?.id,
+      sourceEditReplayId: replay?.id,
+      projectionStatus: projection?.status,
+      replayStatus: replay?.status,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  };
+}
+
+function sameLanguageSamePath(source, targetChangeSet) {
+  const sourceLanguage = normalizeNativeLanguageId(source?.language);
+  const targetLanguage = normalizeNativeLanguageId(targetChangeSet?.language);
+  return Boolean(sourceLanguage && sourceLanguage === targetLanguage && source?.sourcePath && source.sourcePath === targetChangeSet?.sourcePath);
+}
+
+function sourceAction(replay) {
+  return replay?.status === 'already-applied' ? 'skip-source-backprojection' : 'admit-source-backprojection';
+}