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

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

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

@@ -0,0 +1,319 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueRecordsById, uniqueStrings } from '../../native-import-utils.js';
+import { exactSourceBackprojectionForMatch } from './bidirectionalExactSourceBackprojection.js';
+import { createBidirectionalSourceEditProjectionArtifacts } from './bidirectionalSourceEditProjectionArtifacts.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { summarizeSemanticEditOperations } from './semanticEditScriptClassification.js';
+import { projectionCoveredContainerOperationIds, spanOffsets } from './semanticEditSourceRanges.js';
+
+const exactSourceBackprojectionModes = ['same-language-exact-source-map', 'cross-language-explicit-source-replacement'];
+
+export function createBidirectionalSourceEditProjection(context = {}) {
+  const source = context.source;
+  const targetChangeSet = context.targetChangeSet;
+  const matches = portableSingleAnchorMatches(context.sourceAnchorMatches, context.targetPortability);
+  if (!source || !targetChangeSet || matches.length === 0) return {};
+
+  const scriptId = `semantic_edit_script_${idFragment(context.id)}_source_projection`;
+  const sourceText = nativeImportSourceText(source);
+  const initialOperations = matches.map((match, index) => sourceEditOperationForMatch(match, index, context));
+  const operations = markCoveredByExactSourceRange(initialOperations, sourceText);
+  const sourceMapLinks = uniqueRecordsById(matches.flatMap((match) => match.sourceMapLinks));
+  const coveredOperationIds = projectionCoveredContainerOperationIds(operations, nativeImportSourceText(targetChangeSet.after));
+  const exactBackprojection = operations.length > 0 && operations.every((operation) => (
+    exactSourceBackprojectionModes.includes(operation.metadata?.sourceBackprojection?.mode) ||
+    operation.status === 'covered' ||
+    coveredOperationIds.has(operation.id) ||
+    operationCoveredByExactSourceRange(operation, operations, sourceText)
+  ));
+  const sourceProjectionHint = sourceProjectionHintRecord({ context, matches, operations, sourceMapLinks, scriptId });
+  const evidence = sourceEditProjectionEvidence({ context, operations, scriptId, sourceProjectionHint });
+  const reasonCodes = sourceEditAdmissionReasonCodes(context, matches, exactBackprojection);
+  const core = {
+    kind: 'frontier.lang.semanticEditScript',
+    version: 1,
+    schema: 'frontier.lang.semanticEditScript.v1',
+    id: scriptId,
+    stableId: `semantic_edit_script_${idFragment(hashSemanticValue([scriptId, operations]))}`,
+    language: source.language,
+    sourcePath: projectionSourcePath(source, matches),
+    baseHash: sourceHash(source),
+    workerChangeSetId: targetChangeSet.id,
+    operations,
+    summary: summarizeSemanticEditOperations(operations),
+    admission: {
+      status: exactBackprojection ? 'auto-merge-candidate' : 'needs-port',
+      action: exactBackprojection ? 'apply-source-map-backprojection' : 'reanchor-or-human-port',
+      reviewRequired: !exactBackprojection,
+      autoApplyCandidate: exactBackprojection,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes,
+      conflictKeys: uniqueStrings(matches.flatMap((match) => match.conflictKeys)),
+      evidenceIds: evidence.map((record) => record.id)
+    },
+    evidence,
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      sourceProjectionHint,
+      bidirectionalTargetChangeId: context.id,
+      targetChangeSetId: targetChangeSet.id,
+      targetPatchId: targetChangeSet.patch?.id,
+      targetMergeCandidateId: targetChangeSet.mergeCandidate?.id,
+      targetLanguage: targetChangeSet.language,
+      targetPath: targetChangeSet.sourcePath,
+      targetPortabilityStatus: context.targetPortability?.status,
+      targetPortabilityAction: context.targetPortability?.action,
+      sourceMapBacked: true,
+      singleSourceAnchor: true,
+      sourceBackprojectionMode: sourceProjectionHint.sourceBackprojectionMode
+    }
+  };
+  const sourceEditScript = { ...core, hash: hashSemanticValue(core) };
+  const artifacts = createBidirectionalSourceEditProjectionArtifacts(context, sourceEditScript);
+  return {
+    sourceEditScript,
+    sourceProjectionHint,
+    sourceEditProjection: artifacts.sourceEditProjection,
+    sourceEditReplay: artifacts.sourceEditReplay,
+    evidence: [...evidence, ...array(artifacts.evidence)]
+  };
+}
+
+function sourceEditOperationForMatch(match, index, context) {
+  const anchor = match.sourceAnchors[0] ?? {};
+  const region = match.targetRegion ?? {};
+  const sourceMapLinks = uniqueRecordsById(match.sourceMapLinks);
+  const backprojection = exactSourceBackprojectionForMatch(match, context);
+  const sourceIdentity = {
+    sourcePath: anchor.sourcePath,
+    sourceHash: anchor.sourceHash,
+    anchorKey: anchor.key,
+    symbolId: anchor.symbolId,
+    symbolName: anchor.symbolName,
+    sourceSpan: anchor.sourceSpan
+  };
+  const core = compactRecord({
+    id: `semantic_edit_op_${idFragment([context.id, match.id, index + 1].join(':'))}`,
+    kind: semanticEditKind(region),
+    changeKind: region.changeKind,
+    anchor: compactRecord({
+      key: anchor.key,
+      conflictKey: anchor.key ?? region.conflictKey,
+      regionId: region.id,
+      regionKind: anchor.kind ?? region.regionKind,
+      granularity: 'symbol',
+      language: anchor.language ?? context.source?.language,
+      sourcePath: anchor.sourcePath,
+      symbolId: anchor.symbolId,
+      symbolName: anchor.symbolName,
+      sourceSpan: anchor.sourceSpan
+    }),
+    semanticKey: `bidirectional-source-edit:${anchor.key ?? match.id}`,
+    semanticIdentityHash: hashSemanticValue({ matchId: match.id, targetRegion: region.key, sourceIdentity }),
+    sourceIdentityHash: hashSemanticValue(sourceIdentity),
+    spans: {
+      base: backprojection?.sourceEditSpan ?? anchor.sourceSpan,
+      worker: backprojection?.targetAfterEditSpan ?? anchor.sourceSpan,
+      head: backprojection?.sourceEditSpan
+    },
+    hashes: {
+      baseSourceHash: anchor.sourceHash,
+      workerSourceHash: backprojection?.targetAfterSourceHash ?? sourceHash(context.source),
+      baseTextHash: backprojection?.sourceEditTextHash,
+      headTextHash: backprojection?.sourceEditTextHash,
+      workerTextHash: backprojection?.targetAfterEditTextHash
+    },
+    status: backprojection?.alreadyApplied ? 'already-applied' : 'portable',
+    readiness: backprojection ? 'ready' : 'needs-review',
+    confidence: match.portability?.confidence ?? match.confidence,
+    reasonCodes: uniqueStrings([
+      'source-edit-script-projection-hint',
+      'target-change-source-map-portable',
+      'single-source-anchor-projection-hint',
+      backprojection?.alreadyApplied ? 'source-edit-already-applied' : undefined,
+      ...array(match.reasonCodes),
+      ...array(match.portability?.reasonCodes)
+    ]),
+    evidenceIds: uniqueStrings(sourceMapLinks.map((link) => link.id)),
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      bidirectionalTargetChangeId: context.id,
+      targetRegion: region,
+      sourceMapLinkIds: sourceMapLinks.map((link) => link.id),
+      sourceMapMappingIds: uniqueStrings(sourceMapLinks.map((link) => link.sourceMapMappingId)),
+      sourceBackprojection: backprojection
+    }
+  });
+  return { ...core, operationContentHash: hashSemanticValue(core) };
+}
+
+function sourceProjectionHintRecord(input) {
+  const { context, matches, operations, sourceMapLinks, scriptId } = input;
+  const source = context.source;
+  const targetChangeSet = context.targetChangeSet;
+  const exactBackprojection = operations.length > 0 && operations.every((operation) => (
+    exactSourceBackprojectionModes.includes(operation.metadata?.sourceBackprojection?.mode) || operation.status === 'covered'
+  ));
+  const core = {
+    schema: 'frontier.lang.bidirectionalTargetChangeSourceEditProjectionHint.v1',
+    version: 1,
+    id: `source_projection_hint_${idFragment(context.id)}`,
+    scriptId,
+    status: exactBackprojection ? 'auto-merge-candidate' : 'portable',
+    action: exactBackprojection ? 'apply-source-map-backprojection' : context.targetPortability?.action ?? 'port-with-source-map-review',
+    readiness: exactBackprojection ? 'ready' : 'needs-review',
+    sourcePath: projectionSourcePath(source, matches),
+    sourceHash: sourceHash(source),
+    targetPath: targetChangeSet.sourcePath,
+    targetHash: targetChangeSet.afterHash,
+    targetChangeSetId: targetChangeSet.id,
+    targetPatchId: targetChangeSet.patch?.id,
+    targetMergeCandidateId: targetChangeSet.mergeCandidate?.id,
+    sourceAnchorMatchIds: matches.map((match) => match.id),
+    sourceAnchorKeys: uniqueStrings(matches.flatMap((match) => match.sourceAnchors.map((anchor) => anchor.key))),
+    sourceMapLinkIds: sourceMapLinks.map((link) => link.id),
+    sourceMapIds: uniqueStrings(sourceMapLinks.map((link) => link.sourceMapId)),
+    sourceMapMappingIds: uniqueStrings(sourceMapLinks.map((link) => link.sourceMapMappingId)),
+    operationIds: operations.map((operation) => operation.id),
+    reviewRequired: !exactBackprojection,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: sourceEditAdmissionReasonCodes(context, matches, exactBackprojection),
+    sourceBackprojectionMode: exactBackprojection ? firstBackprojectionMode(operations) : 'review-only'
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function sourceEditProjectionEvidence(input) {
+  const { context, operations, scriptId, sourceProjectionHint } = input;
+  return [{
+    id: `evidence_${idFragment(scriptId)}_source_projection_hint`,
+    kind: 'semantic-edit-script',
+    status: 'passed',
+    path: sourceProjectionHint.sourcePath,
+    summary: `Created source-side projection hint for ${operations.length} source-map-backed target edit operation(s).`,
+    metadata: {
+      schema: 'frontier.lang.bidirectionalTargetChangeSourceEditHintEvidence.v1',
+      bidirectionalTargetChangeId: context.id,
+      targetChangeSetId: context.targetChangeSet.id,
+      sourceProjectionHintId: sourceProjectionHint.id,
+      sourceEditScriptId: scriptId,
+      operationIds: sourceProjectionHint.operationIds,
+      sourceMapLinkIds: sourceProjectionHint.sourceMapLinkIds,
+      sourceMapMappingIds: sourceProjectionHint.sourceMapMappingIds,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  }];
+}
+
+function markCoveredByExactSourceRange(operations, sourceText) {
+  return operations.map((operation) => {
+    const coveredBy = exactSourceRangeCoveringOperation(operation, operations, sourceText);
+    if (!coveredBy) return operation;
+    return {
+      ...operation,
+      status: 'covered',
+      readiness: 'ready',
+      metadata: {
+        ...(operation.metadata ?? {}),
+        coveredByOperationIds: [coveredBy.id]
+      }
+    };
+  });
+}
+
+function operationCoveredByExactSourceRange(operation, operations, sourceText) { return Boolean(exactSourceRangeCoveringOperation(operation, operations, sourceText)); }
+
+function exactSourceRangeCoveringOperation(operation, operations, sourceText) {
+  if (operation.metadata?.sourceBackprojection?.mode === 'same-language-exact-source-map') return undefined;
+  const operationRange = spanOffsets(sourceText, operation.spans?.base ?? operation.anchor?.sourceSpan);
+  if (!operationRange) return undefined;
+  return operations.find((candidate) => {
+    if (candidate === operation || candidate.status === 'covered') return false;
+    const backprojection = candidate.metadata?.sourceBackprojection;
+    const candidateRange = spanOffsets(sourceText, backprojection?.sourceEditSpan);
+    return backprojection?.mode === 'same-language-exact-source-map' &&
+      sameSourcePath(operation, candidate) &&
+      containedRange(operationRange, candidateRange);
+  });
+}
+
+function sameSourcePath(left, right) {
+  const leftPath = left.anchor?.sourcePath ?? left.insertion?.sourcePath;
+  const rightPath = right.anchor?.sourcePath ?? right.insertion?.sourcePath;
+  return !leftPath || !rightPath || leftPath === rightPath;
+}
+
+function containedRange(inner, outer) { return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end); }
+
+function portableSingleAnchorMatches(matches = [], targetPortability = {}) {
+  return matches.filter((match) => (
+    match.status === 'matched' &&
+    match.sourceAnchors.length === 1 &&
+    match.sourceMapLinks.length > 0 &&
+    match.portability?.status === 'portable' &&
+    targetPortability.status === 'portable'
+  ));
+}
+
+function projectionReasonCodes(context, matches) {
+  return uniqueStrings([
+    'source-edit-script-projection-hint',
+    'target-change-source-map-portable',
+    'target-edit-requires-source-review',
+    ...array(context.reasons),
+    ...array(context.targetPortability?.reasonCodes),
+    ...matches.flatMap((match) => [...array(match.reasonCodes), ...array(match.portability?.reasonCodes)])
+  ]);
+}
+
+function sourceEditAdmissionReasonCodes(context, matches, exactBackprojection) {
+  if (!exactBackprojection) return projectionReasonCodes(context, matches);
+  return uniqueStrings([
+    'source-edit-script-projection-hint',
+    'target-change-source-map-portable',
+    'source-map-backprojection-verified',
+    ...array(context.targetPortability?.reasonCodes).filter((reason) => !reviewOnlyReason(reason)),
+    ...matches.flatMap((match) => [...array(match.reasonCodes), ...array(match.portability?.reasonCodes)])
+      .filter((reason) => !reviewOnlyReason(reason))
+  ]);
+}
+
+function targetRegionForMatch(match, context) {
+  return context.targetChangeSet.changedRegions.find((region) => region.id === match.targetRegion?.id)
+    ?? match.targetRegion;
+}
+
+function semanticEditKind(region = {}) {
+  const prefix = region.changeKind === 'added' ? 'add' : region.changeKind === 'removed' ? 'remove' : 'replace';
+  if (region.regionKind === 'body') return `${prefix}Body`;
+  if (region.regionKind === 'import') return `${prefix}Import`;
+  if (region.regionKind === 'property') return `${prefix}Property`;
+  return `${prefix}Region`;
+}
+
+function projectionSourcePath(source, matches) {
+  return source?.sourcePath ?? matches.find((match) => match.sourceAnchors[0]?.sourcePath)?.sourceAnchors[0]?.sourcePath;
+}
+
+function sourceHash(source) {
+  return source?.nativeSource?.sourceHash ?? source?.nativeAst?.sourceHash ?? source?.sourceHash;
+}
+
+function reviewOnlyReason(reason) {
+  return ['target-edit-requires-source-review', 'source-port-review-required', 'human-source-port-required'].includes(reason);
+}
+
+function firstBackprojectionMode(operations) {
+  return operations.find((operation) => exactSourceBackprojectionModes.includes(operation.metadata?.sourceBackprojection?.mode))
+    ?.metadata?.sourceBackprojection?.mode;
+}
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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

@@ -0,0 +1,67 @@
+import { idFragment } from '../../native-import-utils.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { projectSemanticEditScriptToSource } from './projectSemanticEditScriptToSource.js';
+import { replaySemanticEditProjection } from './replaySemanticEditProjection.js';
+
+export function createBidirectionalSourceEditProjectionArtifacts(context = {}, sourceEditScript) {
+  if (!isExactBackprojectionScript(sourceEditScript)) return {};
+  const sourceText = nativeImportSourceText(context.source);
+  const workerSourceText = nativeImportSourceText(context.targetChangeSet?.after);
+  if (typeof sourceText !== 'string' || typeof workerSourceText !== 'string') return {};
+  const projection = projectSemanticEditScriptToSource({
+    id: `semantic_edit_projection_${idFragment(context.id)}_source_backprojection`,
+    script: sourceEditScript,
+    workerSourceText,
+    headSourceText: sourceText,
+    metadata: {
+      targetLanguage: context.targetChangeSet.language,
+      targetPath: context.targetChangeSet.sourcePath,
+      targetHash: context.targetChangeSet.afterHash,
+      sourceMapIds: sourceEditScript.metadata?.sourceProjectionHint?.sourceMapIds,
+      sourceMapLinkIds: sourceEditScript.metadata?.sourceProjectionHint?.sourceMapLinkIds,
+      sourceMapMappingIds: sourceEditScript.metadata?.sourceProjectionHint?.sourceMapMappingIds
+    }
+  });
+  const replay = projection.status === 'projected'
+    ? replaySemanticEditProjection({
+      id: `semantic_edit_replay_${idFragment(context.id)}_source_backprojection`,
+      projection,
+      currentSourceText: sourceText
+    })
+    : undefined;
+  return {
+    sourceEditProjection: projection,
+    sourceEditReplay: replay,
+    evidence: [backprojectionEvidence(context, sourceEditScript, projection, replay)]
+  };
+}
+
+function backprojectionEvidence(context, script, projection, replay) {
+  const replayReady = replay?.status === 'accepted-clean' || replay?.status === 'already-applied';
+  const passed = projection?.status === 'projected' && replayReady;
+  return {
+    id: `evidence_${idFragment(context.id)}_source_backprojection_replay`,
+    kind: 'verification',
+    status: passed ? 'passed' : 'failed',
+    path: script.sourcePath,
+    summary: passed
+      ? 'Verified exact source-map backprojection by projecting and replaying the source edit.'
+      : 'Exact source-map backprojection did not project and replay cleanly.',
+    metadata: {
+      schema: 'frontier.lang.bidirectionalSourceBackprojectionEvidence.v1',
+      bidirectionalTargetChangeId: context.id,
+      sourceEditScriptId: script.id,
+      sourceEditProjectionId: projection?.id,
+      sourceEditReplayId: replay?.id,
+      projectionStatus: projection?.status,
+      replayStatus: replay?.status,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  };
+}
+
+function isExactBackprojectionScript(script) {
+  return script?.admission?.status === 'auto-merge-candidate'
+    && ['same-language-exact-source-map', 'cross-language-explicit-source-replacement'].includes(script?.metadata?.sourceBackprojectionMode);
+}

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

@@ -8,7 +8,7 @@ import { resolveSemanticLineage } from './semanticLineageResolutionRecords.js';
 
 export function matchTargetRegion(context) {
   const explicit = explicitMappingForRegion(context.region, context.mappings);
-  const mapped = explicit ? { anchors: sourceAnchorsForMapping(explicit, context.sourceAnchors), links: [] }
+  const mapped = explicit ? { anchors: sourceAnchorsForMapping(explicit, context.sourceAnchors, context.region), links: [] }
     : sourceMapAnchorsForRegion(context.region, context.sourceMaps, context.sourceAnchors);
   const candidateAnchors = mapped.anchors.length ? mapped.anchors : sourceAnchorsByName(context.region, context.sourceAnchors);
   const resolvedAnchors = candidateAnchors.flatMap((anchor) => resolveAnchor(anchor, context.lineage));
@@ -184,6 +184,8 @@ function sourceMapLinkForMapping(sourceMap, mapping) {
     precision: mapping.precision,
     sourceSpan: mapping.sourceSpan,
     generatedSpan: mapping.generatedSpan,
+    sourceReplacementText: mapping.sourceReplacementText,
+    sourceReplacementTextHash: mapping.sourceReplacementTextHash ?? mapping.sourceReplacementHash,
     regionKey: mapping.ownershipRegionKey,
     regionKind: mapping.ownershipRegionKind
   });
@@ -222,19 +224,29 @@ function explicitMappingForRegion(region, mappings) {
   });
 }
 
-function sourceAnchorsForMapping(mapping, sourceAnchors) {
+function sourceAnchorsForMapping(mapping, sourceAnchors, region) {
   const keys = uniqueStrings([mapping.sourceAnchorKey, mapping.sourceRegionKey, mapping.sourceConflictKey, mapping.sourceKey]);
   const matches = sourceAnchors.filter((anchor) => keys.includes(anchor.key) || keys.includes(anchor.id));
   if (matches.length) return matches;
-  if (mapping.sourceSymbolName) return sourceAnchors.filter((anchor) => anchor.symbolName === mapping.sourceSymbolName);
-  if (mapping.sourceSymbolId) return sourceAnchors.filter((anchor) => anchor.symbolId === mapping.sourceSymbolId);
+  const compatible = sourceAnchors.filter((anchor) => sourceAnchorCompatibleWithRegion(anchor, region));
+  if (mapping.sourceSymbolName) return compatible.filter((anchor) => anchor.symbolName === mapping.sourceSymbolName);
+  if (mapping.sourceSymbolId) return compatible.filter((anchor) => anchor.symbolId === mapping.sourceSymbolId);
   return [];
 }
 
 function sourceAnchorsByName(region, sourceAnchors) {
   const names = namesForRegion(region);
   if (names.length === 0) return [];
-  return sourceAnchors.filter((anchor) => names.includes(anchor.symbolName));
+  return sourceAnchors
+    .filter((anchor) => sourceAnchorCompatibleWithRegion(anchor, region))
+    .filter((anchor) => names.includes(anchor.symbolName));
+}
+
+function sourceAnchorCompatibleWithRegion(anchor, region) {
+  const sourceKind = String(anchor?.kind ?? '').toLowerCase();
+  const targetKind = String(region?.regionKind ?? '').toLowerCase();
+  if (sourceKind !== 'export') return true;
+  return targetKind === 'export' || targetKind === 'module';
 }
 
 function namesForRegion(region) {

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

@@ -52,27 +52,37 @@ export function createRoundtripEvidence(context) {
       reasonCodes: context.targetPortability.reasonCodes,
       conflictKeys: context.targetPortability.conflictKeys
     },
-    admission: {
-      status: context.readiness === 'blocked' ? 'blocked' : 'needs-review',
-      readiness: context.readiness,
-      action: context.targetPortability.action,
-      reasonCodes: context.reasons,
-      conflictKeys: uniqueStrings([
-        ...array(context.targetPortability.conflictKeys),
-        ...context.sourceAnchorMatches.flatMap((match) => match.conflictKeys ?? [])
-      ]),
-      evidenceIds: [context.evidenceId],
-      reviewRequired: true,
-      autoMergeClaim: false,
-      semanticEquivalenceClaim: false
-    },
-    reviewRequired: true,
+    admission: admissionRecord(context),
+    reviewRequired: !verifiedSourceBackprojection(context),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function admissionRecord(context) {
+  const verified = verifiedSourceBackprojection(context);
+  const verifiedReason = verifiedSourceBackprojectionReason(context);
+  const action = sourceBackprojectionAction(context);
+  return {
+    status: verified ? 'ready' : context.readiness === 'blocked' ? 'blocked' : 'needs-review',
+    readiness: verified ? 'ready' : context.readiness,
+    action: verified ? action : context.targetPortability.action,
+    reasonCodes: uniqueStrings([...array(context.reasons), verifiedReason]),
+    conflictKeys: uniqueStrings([
+      ...array(context.targetPortability.conflictKeys),
+      ...context.sourceAnchorMatches.flatMap((match) => match.conflictKeys ?? [])
+    ]),
+    evidenceIds: uniqueStrings([context.evidenceId, ...array(context.sourceEditProjection?.evidence).map((record) => record.id)]),
+    reviewRequired: !verified,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false
   };
 }
 
 export function createSemanticMergeAdmissionEvidence(context) {
+  const verified = verifiedSourceBackprojection(context);
+  const verifiedReason = verifiedSourceBackprojectionReason(context);
+  const action = sourceBackprojectionAction(context);
   return {
     schema: 'frontier.lang.bidirectionalTargetChangeSemanticMergeAdmission.v1',
     version: 1,
@@ -83,10 +93,10 @@ export function createSemanticMergeAdmissionEvidence(context) {
     targetChangeSetId: context.targetChangeSet.id,
     targetPatchId: context.targetChangeSet.patch?.id,
     targetMergeCandidateId: context.targetChangeSet.mergeCandidate?.id,
-    readiness: context.readiness,
-    status: context.readiness === 'blocked' ? 'blocked' : 'needs-review',
-    action: context.targetPortability.action,
-    reasonCodes: context.reasons,
+    readiness: verified ? 'ready' : context.readiness,
+    status: verified ? 'ready' : context.readiness === 'blocked' ? 'blocked' : 'needs-review',
+    action: verified ? action : context.targetPortability.action,
+    reasonCodes: uniqueStrings([...array(context.reasons), verifiedReason]),
     conflictKeys: context.roundtripEvidence.admission.conflictKeys,
     sourceAnchorMatchIds: uniqueStrings(context.sourceAnchorMatches.map((match) => match.id)),
     sourceAnchorKeys: uniqueStrings(context.roundtripEvidence.sourceAnchors.map((anchor) => anchor.key)),
@@ -98,12 +108,40 @@ export function createSemanticMergeAdmissionEvidence(context) {
     targetProjectionSourceMapLinkIds: context.roundtripEvidence.sourceMapEvidence.targetProjectionSourceMapLinkIds,
     targetProjectionSourceMapMappingIds: context.roundtripEvidence.sourceMapEvidence.targetProjectionSourceMapMappingIds,
     lineageResolutionIds: context.roundtripEvidence.lineageEvidence.lineageResolutionIds,
-    reviewRequired: true,
+    sourceEditScriptId: context.sourceEditProjection?.sourceEditScript?.id,
+    sourceEditProjectionId: context.sourceEditProjection?.sourceEditProjection?.id,
+    sourceEditReplayId: context.sourceEditProjection?.sourceEditReplay?.id,
+    sourceBackprojectionMode: context.sourceEditProjection?.sourceProjectionHint?.sourceBackprojectionMode,
+    reviewRequired: !verified,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false
   };
 }
 
+function verifiedSourceBackprojection(context) {
+  return verifiedSourceBackprojectionModes().includes(context.sourceEditProjection?.sourceProjectionHint?.sourceBackprojectionMode)
+    && context.sourceEditProjection?.sourceEditProjection?.status === 'projected'
+    && ['accepted-clean', 'already-applied'].includes(context.sourceEditProjection?.sourceEditReplay?.status);
+}
+
+function verifiedSourceBackprojectionModes() {
+  return ['same-language-exact-source-map', 'same-language-target-source-edit', 'cross-language-explicit-source-replacement'];
+}
+
+function verifiedSourceBackprojectionReason(context) {
+  const mode = context.sourceEditProjection?.sourceProjectionHint?.sourceBackprojectionMode;
+  if (mode === 'cross-language-explicit-source-replacement' && verifiedSourceBackprojection(context)) return 'verified-cross-language-explicit-source-replacement';
+  if (mode === 'same-language-target-source-edit' && verifiedSourceBackprojection(context)) return 'verified-same-language-target-source-edit';
+  if (mode === 'same-language-exact-source-map' && verifiedSourceBackprojection(context)) return 'verified-source-map-backprojection';
+  return undefined;
+}
+
+function sourceBackprojectionAction(context) {
+  return context.sourceEditProjection?.sourceEditReplay?.status === 'already-applied'
+    ? 'skip-source-backprojection'
+    : 'admit-source-backprojection';
+}
+
 function sourceIdentity(source) {
   return compactRecord({
     importId: source?.id,