@shapeshift-labs/frontier-lang-compiler 0.2.74 → 0.2.76

package/README.md

@@ -383,6 +383,45 @@ console.log(querySemanticPatchBundleRecords([bundle], { sourcePath: 'src/runtime
 
 Semantic patch bundle records keep compact refs and query indexes for base/target/source hashes, source paths, changed region keys, conflict keys, source-map IDs, evidence IDs, proof IDs, history IDs, readiness, and admission status. They intentionally omit `before`/`after` import payloads and source text; use the original diff result when a worker needs to re-read or re-project source.
 
+Map an edited target-language file back to source-language semantic anchors for review. This is the reverse direction a swarm needs when a worker changes generated Rust/Python/etc. and the coordinator wants source-port evidence:
+
+```js
+import {
+  createBidirectionalTargetChangeRecord,
+  importNativeSource
+} from '@shapeshift-labs/frontier-lang-compiler';
+
+const source = importNativeSource({
+  language: 'typescript',
+  sourcePath: 'src/counter.ts',
+  sourceText: 'export function add(count: number) { return count + 1; }\n'
+});
+
+const targetChange = createBidirectionalTargetChangeRecord({
+  source,
+  targetLanguage: 'rust',
+  targetPath: 'src/counter.rs',
+  baseTarget: {
+    language: 'rust',
+    sourcePath: 'src/counter.rs',
+    sourceText: 'pub fn add(count: i32) -> i32 { count + 1 }\n'
+  },
+  editedTarget: {
+    language: 'rust',
+    sourcePath: 'src/counter.rs',
+    sourceText: 'pub fn add(count: i32, step: i32) -> i32 { count + step }\n'
+  },
+  sourceAnchorMappings: [{ targetSymbolName: 'add', sourceSymbolName: 'add' }]
+});
+
+console.log(targetChange.sourceAnchorMatches[0].status); // "matched"
+console.log(targetChange.sourcePatchBundle.admission.reviewRequired); // true
+console.log(targetChange.historyRecord.index.ownershipKeys);
+console.log(targetChange.metadata.semanticEquivalenceClaim); // false
+```
+
+Bidirectional target-change records are merge-admission evidence, not transpiler proof. They keep target diffs, source anchor matches, optional lineage resolutions, source patch-bundle records, semantic history records, evidence IDs, readiness, and reason codes. They always keep `autoMergeClaim: false` and `semanticEquivalenceClaim: false`; unmatched or deleted anchors block the source-port route, while matched and ambiguous anchors still require human or verifier review.
+
 Store worker outputs as compact semantic history records when a coordinator needs to compare distributed changes without merging whole files:
 
 ```js

package/bench/smoke.mjs

@@ -110,6 +110,10 @@ console.log(JSON.stringify({
   changedRegionProjections: sourceChangeMetrics.changedRegionProjections,
   changedRegionProjectionSourceMapLinks: sourceChangeMetrics.changedRegionProjectionSourceMapLinks,
   changeProjectionDurationMs: Number(sourceChangeMetrics.changeProjectionDurationMs.toFixed(2)),
+  bidirectionalTargetChanges: sourceChangeMetrics.bidirectionalTargetChanges,
+  bidirectionalTargetChangeMatches: sourceChangeMetrics.bidirectionalTargetChangeMatches,
+  bidirectionalTargetChangeBlocked: sourceChangeMetrics.bidirectionalTargetChangeBlocked,
+  bidirectionalTargetChangeDurationMs: Number(sourceChangeMetrics.bidirectionalTargetChangeDurationMs.toFixed(2)),
   externalSemanticImports: sourceChangeMetrics.externalSemanticImports,
   externalSemanticSymbols: sourceChangeMetrics.externalSemanticSymbols,
   externalSemanticMappings: sourceChangeMetrics.externalSemanticMappings,

package/bench/source-change-suite.mjs

@@ -1,6 +1,8 @@
 import { performance } from 'node:perf_hooks';
 import {
+  createBidirectionalTargetChangeRecord,
   createSemanticImportSidecar,
+  createSemanticLineageEvent,
   diffNativeSources,
   importExternalSemanticIndex,
   importNativeSource
@@ -10,6 +12,7 @@ export function measureSourceChangeSuites() {
   return {
     ...measureRegionScan(),
     ...measureChangeProjection(),
+    ...measureBidirectionalTargetChanges(),
     ...measureExternalSemanticImports()
   };
 }
@@ -72,6 +75,47 @@ function measureChangeProjection() {
   };
 }
 
+function measureBidirectionalTargetChanges() {
+  const start = performance.now();
+  const source = importNativeSource({
+    language: 'typescript',
+    sourcePath: 'src/bidirectional-source.ts',
+    sourceText: 'export function advance(frame: number): number { return frame + 1; }\n'
+  });
+  const lineage = [createSemanticLineageEvent({
+    eventKind: 'moved',
+    from: { key: 'source#src/bidirectional-source.ts#body#advance', symbolName: 'advance' },
+    to: { key: 'source#src/runtime-core.ts#body#advanceFrame', symbolName: 'advanceFrame' }
+  })];
+  const records = [];
+  for (let index = 0; index < 60; index += 1) {
+    records.push(createBidirectionalTargetChangeRecord({
+      id: `bench_bidirectional_target_change_${index}`,
+      source,
+      targetLanguage: 'rust',
+      targetPath: `src/bidirectional-${index}.rs`,
+      baseTarget: {
+        language: 'rust',
+        sourcePath: `src/bidirectional-${index}.rs`,
+        sourceText: `pub fn advance(frame: i32) -> i32 { frame + ${index} }\n`
+      },
+      editedTarget: {
+        language: 'rust',
+        sourcePath: `src/bidirectional-${index}.rs`,
+        sourceText: `pub fn advance(frame: i32, delta: i32) -> i32 { frame + delta + ${index} }\n`
+      },
+      sourceAnchorMappings: [{ targetSymbolName: 'advance', sourceSymbolName: 'advance' }],
+      lineage: index % 4 === 0 ? lineage : []
+    }));
+  }
+  return {
+    bidirectionalTargetChanges: records.length,
+    bidirectionalTargetChangeMatches: records.reduce((sum, record) => sum + record.summary.sourceAnchorMatches, 0),
+    bidirectionalTargetChangeBlocked: records.filter((record) => record.readiness === 'blocked').length,
+    bidirectionalTargetChangeDurationMs: performance.now() - start
+  };
+}
+
 function measureExternalSemanticImports() {
   const externalSemanticStart = performance.now();
   const externalSemanticImports = [];

package/dist/declarations/bidirectional-target-change.d.ts

@@ -0,0 +1,129 @@
+import type {
+  EvidenceRecord,
+  FrontierSourceLanguage,
+  SemanticMergeReadiness,
+  SourceSpan
+} from '@shapeshift-labs/frontier-lang-kernel';
+import type { ImportNativeSourceOptions, NativeSourceImportResult } from './import-adapter-core.js';
+import type { NativeSourceChangeRegion, NativeSourceChangeSet } from './native-diff.js';
+import type { SemanticHistoryRecord } from './semantic-history.js';
+import type { SemanticLineageEvent, SemanticLineageResolution } from './semantic-lineage.js';
+import type { SemanticPatchBundleRecord } from './semantic-patch-bundle.js';
+
+export type BidirectionalTargetChangeAnchorStatus = 'matched' | 'unmatched' | 'ambiguous' | 'deleted' | string;
+
+export interface BidirectionalTargetChangeSourceAnchorMapping {
+  readonly targetAnchorKey?: string;
+  readonly targetRegionKey?: string;
+  readonly targetConflictKey?: string;
+  readonly targetKey?: string;
+  readonly targetSymbolName?: string;
+  readonly targetSymbolId?: string;
+  readonly sourceAnchorKey?: string;
+  readonly sourceRegionKey?: string;
+  readonly sourceConflictKey?: string;
+  readonly sourceKey?: string;
+  readonly sourceSymbolName?: string;
+  readonly sourceSymbolId?: string;
+}
+
+export interface BidirectionalTargetChangeAnchor {
+  readonly id?: string;
+  readonly key?: string;
+  readonly kind?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly symbolId?: string;
+  readonly symbolName?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface BidirectionalTargetChangeSourceAnchorMatch {
+  readonly kind: 'frontier.lang.bidirectionalTargetChangeSourceAnchorMatch';
+  readonly version: 1;
+  readonly id: string;
+  readonly targetRegion: Partial<NativeSourceChangeRegion>;
+  readonly sourceAnchors: readonly BidirectionalTargetChangeAnchor[];
+  readonly lineageResolutions: readonly SemanticLineageResolution[];
+  readonly status: BidirectionalTargetChangeAnchorStatus;
+  readonly confidence?: number;
+  readonly reasonCodes: readonly string[];
+  readonly reviewRequired: true;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly conflictKeys: readonly string[];
+}
+
+export interface CreateBidirectionalTargetChangeRecordOptions {
+  readonly id?: string;
+  readonly source?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly sourceImport?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly baseSource?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceParser?: string;
+  readonly targetChangeSet?: NativeSourceChangeSet;
+  readonly targetChangeSetId?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly targetLanguage?: FrontierSourceLanguage | string;
+  readonly targetPath?: string;
+  readonly baseTarget?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly beforeTarget?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly before?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly editedTarget?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly afterTarget?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly after?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly sourceAnchorMappings?: readonly BidirectionalTargetChangeSourceAnchorMapping[];
+  readonly anchorMappings?: readonly BidirectionalTargetChangeSourceAnchorMapping[];
+  readonly lineage?: readonly SemanticLineageEvent[];
+  readonly lineageEvents?: readonly SemanticLineageEvent[];
+  readonly lineageMap?: unknown;
+  readonly targetEvidenceId?: string;
+  readonly targetPatchId?: string;
+  readonly targetMergeCandidateId?: string;
+  readonly sourceRegionPrefix?: string;
+  readonly sourcePatchBundleId?: string;
+  readonly historyRecordId?: string;
+  readonly evidenceId?: string;
+  readonly generatedAt?: number | string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface BidirectionalTargetChangeRecord {
+  readonly kind: 'frontier.lang.bidirectionalTargetChangeRecord';
+  readonly version: 1;
+  readonly id: string;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly targetLanguage?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly targetPath?: string;
+  readonly sourceImport?: NativeSourceImportResult;
+  readonly targetChangeSet: NativeSourceChangeSet;
+  readonly sourceAnchorMatches: readonly BidirectionalTargetChangeSourceAnchorMatch[];
+  readonly sourcePatchBundle: SemanticPatchBundleRecord;
+  readonly historyRecord: SemanticHistoryRecord;
+  readonly evidence: readonly EvidenceRecord[];
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly reasons: readonly string[];
+  readonly summary: {
+    readonly targetChangedRegions: number;
+    readonly sourceAnchorMatches: number;
+    readonly ambiguousMatches: number;
+    readonly unmatchedTargetRegions: number;
+    readonly deletedSourceAnchors: number;
+    readonly sourceChangedRegions: number;
+  };
+  readonly metadata: {
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+    readonly reviewRequired: true;
+    readonly [key: string]: unknown;
+  };
+}
+
+export declare function createBidirectionalTargetChangeRecord(
+  input?: CreateBidirectionalTargetChangeRecordOptions,
+  options?: Record<string, unknown>
+): BidirectionalTargetChangeRecord;

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export * from './declarations/semantic-merge-conflicts.js';
 export * from './declarations/semantic-lineage.js';
 export * from './declarations/semantic-history.js';
 export * from './declarations/semantic-patch-bundle.js';
+export * from './declarations/bidirectional-target-change.js';
 export * from './declarations/semantic-impact.js';
 export * from './declarations/semantic-sidecar.js';
 export * from './declarations/native-diff.js';

package/dist/index.js

@@ -4,6 +4,7 @@ export { compileFrontierDocument } from './internal/index-impl/compileFrontierDo
 export { compileFrontierSource } from './internal/index-impl/compileFrontierSource.js';
 export { compileNativeSource } from './internal/index-impl/compileNativeSource.js';
 export { createBabelNativeImporterAdapter } from './internal/index-impl/createBabelNativeImporterAdapter.js';
+export { createBidirectionalTargetChangeRecord } from './internal/index-impl/createBidirectionalTargetChangeRecord.js';
 export { createClangAstNativeImporterAdapter } from './internal/index-impl/createClangAstNativeImporterAdapter.js';
 export { createCSharpRoslynNativeImporterAdapter } from './internal/index-impl/createCSharpRoslynNativeImporterAdapter.js';
 export { createEstreeNativeImporterAdapter } from './internal/index-impl/createEstreeNativeImporterAdapter.js';

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

@@ -0,0 +1,198 @@
+import {
+  idFragment,
+  maxSemanticMergeReadiness,
+  uniqueRecordsById,
+  uniqueStrings
+} from '../../native-import-utils.js';
+import { resolveSemanticLineage } from './semanticLineageResolutionRecords.js';
+
+export function matchTargetRegion(context) {
+  const explicit = explicitMappingForRegion(context.region, context.mappings);
+  const candidateAnchors = explicit
+    ? sourceAnchorsForMapping(explicit, context.sourceAnchors)
+    : sourceAnchorsByName(context.region, context.sourceAnchors);
+  const resolvedAnchors = candidateAnchors.flatMap((anchor) => resolveAnchor(anchor, context.lineage));
+  const status = matchStatus(candidateAnchors, resolvedAnchors);
+  const reasonCodes = uniqueStrings([
+    explicit ? 'explicit-anchor-mapping' : 'inferred-by-symbol-name',
+    status === 'unmatched' ? 'source-anchor-not-found' : undefined,
+    status === 'ambiguous' ? 'source-anchor-ambiguous' : undefined,
+    status === 'deleted' ? 'source-anchor-deleted' : undefined,
+    'human-source-port-required'
+  ]);
+  return {
+    kind: 'frontier.lang.bidirectionalTargetChangeSourceAnchorMatch',
+    version: 1,
+    id: `source_anchor_match_${idFragment(context.id)}_${context.index + 1}`,
+    targetRegion: compactRegion(context.region),
+    sourceAnchors: resolvedAnchors.map((entry) => entry.anchor),
+    lineageResolutions: uniqueRecordsById(resolvedAnchors.map((entry) => entry.resolution).filter(Boolean)),
+    status,
+    confidence: status === 'matched' && explicit ? 0.8 : status === 'matched' ? 0.58 : undefined,
+    reasonCodes,
+    reviewRequired: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    conflictKeys: uniqueStrings([
+      context.region.conflictKey,
+      context.region.key,
+      ...resolvedAnchors.map((entry) => entry.anchor?.key),
+      status === 'unmatched' ? `target:${context.region.sourcePath ?? context.region.language ?? 'unknown'}` : undefined
+    ])
+  };
+}
+
+export function classifyBidirectionalReadiness(targetChangeSet, source, matches) {
+  let readiness = maxSemanticMergeReadiness(targetChangeSet.readiness, 'needs-review');
+  if (!source) readiness = 'blocked';
+  if (matches.some((match) => match.status === 'deleted')) readiness = 'blocked';
+  if (matches.every((match) => match.status === 'unmatched') && matches.length > 0) readiness = 'blocked';
+  return readiness;
+}
+
+export function sourceRegionsForMatch(match, readiness) {
+  const anchors = match.sourceAnchors.length ? match.sourceAnchors : [undefined];
+  return anchors.map((anchor, index) => compactRecord({
+    id: `source_port_region_${idFragment(match.id)}_${index + 1}`,
+    key: anchor?.key ?? `unmapped-target#${match.targetRegion.key ?? match.targetRegion.id}`,
+    conflictKey: anchor?.key ?? match.targetRegion.conflictKey ?? match.targetRegion.key,
+    changeKind: match.targetRegion.changeKind,
+    regionKind: anchor?.kind ?? match.targetRegion.regionKind,
+    granularity: 'symbol',
+    language: anchor?.language,
+    sourcePath: anchor?.sourcePath,
+    sourceHash: anchor?.sourceHash,
+    symbolId: anchor?.symbolId,
+    symbolName: anchor?.symbolName,
+    sourceSpan: anchor?.sourceSpan,
+    admission: {
+      readiness,
+      action: 'review-port-from-target-change',
+      reasonCodes: match.reasonCodes,
+      conflictKeys: match.conflictKeys
+    },
+    metadata: {
+      bidirectionalTargetChange: {
+        matchId: match.id,
+        targetRegion: match.targetRegion,
+        lineageResolutionIds: match.lineageResolutions.map((resolution) => resolution.id),
+        reviewRequired: true,
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      }
+    }
+  }));
+}
+
+export function createBidirectionalEvidence(context) {
+  return {
+    id: context.input.evidenceId ?? `evidence_${idFragment(context.id)}_bidirectional_target_change`,
+    kind: 'semantic-merge',
+    status: 'passed',
+    path: context.source?.sourcePath ?? context.targetChangeSet.sourcePath,
+    summary: `Mapped ${context.targetChangeSet.changedRegions.length} target changed region(s) to ${matchedCount(context.sourceAnchorMatches)} source anchor match(es).`,
+    metadata: {
+      schema: 'frontier.lang.bidirectionalTargetChangeEvidence.v1',
+      sourceImportId: context.source?.id,
+      targetChangeSetId: context.targetChangeSet.id,
+      targetPatchId: context.targetChangeSet.patch?.id,
+      sourceAnchorMatchIds: context.sourceAnchorMatches.map((match) => match.id),
+      readiness: context.readiness,
+      reasons: context.reasons,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  };
+}
+
+export function anchorsFromSourceSidecar(sidecar, source) {
+  return uniqueRecordsById((sidecar.ownershipRegions ?? []).map((region) => compactRecord({
+    id: region.id,
+    key: region.key,
+    kind: region.regionKind,
+    language: region.language ?? source?.language,
+    sourcePath: region.sourcePath ?? source?.sourcePath,
+    sourceHash: region.sourceHash ?? sourceHash(source),
+    symbolId: region.symbolId,
+    symbolName: region.symbolName,
+    sourceSpan: region.sourceSpan,
+    metadata: region.metadata
+  })));
+}
+
+export function sourceHash(source) {
+  return source?.nativeSource?.sourceHash ?? source?.nativeAst?.sourceHash ?? source?.sourceHash;
+}
+
+function explicitMappingForRegion(region, mappings) {
+  return mappings.find((mapping) => {
+    const targetKeys = uniqueStrings([
+      mapping.targetAnchorKey,
+      mapping.targetRegionKey,
+      mapping.targetConflictKey,
+      mapping.targetKey
+    ]);
+    if (targetKeys.some((key) => key === region.key || key === region.conflictKey || key === region.id)) return true;
+    if (mapping.targetSymbolName && mapping.targetSymbolName === (region.symbolName ?? region.name)) return true;
+    return mapping.targetSymbolId && mapping.targetSymbolId === region.symbolId;
+  });
+}
+
+function sourceAnchorsForMapping(mapping, sourceAnchors) {
+  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);
+  return [];
+}
+
+function sourceAnchorsByName(region, sourceAnchors) {
+  const names = uniqueStrings([region.symbolName, region.name, region.metadata?.changedRegionProjection?.region?.symbolName]);
+  if (names.length === 0) return [];
+  return sourceAnchors.filter((anchor) => names.includes(anchor.symbolName));
+}
+
+function resolveAnchor(anchor, lineage) {
+  if (!anchor) return [];
+  const resolution = array(lineage).length ? resolveSemanticLineage(lineage, { anchorKey: anchor.key }) : undefined;
+  if (!resolution || resolution.status === 'unchanged') return [{ anchor, resolution }];
+  if (resolution.status === 'deleted') return [{ anchor, resolution }];
+  if (resolution.currentAnchors.length === 0) return [{ anchor, resolution }];
+  return resolution.currentAnchors.map((current) => ({ anchor: { ...anchor, ...current }, resolution }));
+}
+
+function matchStatus(originalAnchors, resolvedAnchors) {
+  if (originalAnchors.length === 0 || resolvedAnchors.length === 0) return 'unmatched';
+  if (resolvedAnchors.some((entry) => entry.resolution?.status === 'deleted')) return 'deleted';
+  if (resolvedAnchors.length > 1 || resolvedAnchors.some((entry) => entry.resolution?.status === 'ambiguous')) return 'ambiguous';
+  return 'matched';
+}
+
+function matchedCount(matches) {
+  return matches.filter((match) => match.status === 'matched').length;
+}
+
+function compactRegion(region) {
+  return compactRecord({
+    id: region.id,
+    key: region.key,
+    conflictKey: region.conflictKey,
+    changeKind: region.changeKind,
+    regionKind: region.regionKind,
+    language: region.language,
+    sourcePath: region.sourcePath,
+    sourceHash: region.sourceHash,
+    symbolId: region.symbolId,
+    symbolName: region.symbolName ?? region.name,
+    sourceSpan: region.sourceSpan
+  });
+}
+
+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/createBidirectionalTargetChangeRecord.js

@@ -0,0 +1,169 @@
+import {
+  idFragment,
+  uniqueStrings
+} from '../../native-import-utils.js';
+import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
+import { createSemanticPatchBundleRecord } from './semanticPatchBundleRecords.js';
+import { createSemanticHistoryRecord } from './semanticHistoryRecords.js';
+import { diffNativeSourceImports } from './diffNativeSourceImports.js';
+import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
+import {
+  anchorsFromSourceSidecar,
+  classifyBidirectionalReadiness,
+  createBidirectionalEvidence,
+  matchTargetRegion,
+  sourceHash,
+  sourceRegionsForMatch
+} from './bidirectionalTargetChangeRecordInternals.js';
+
+export function createBidirectionalTargetChangeRecord(input = {}, options = {}) {
+  const source = normalizeNativeDiffImport(
+    input.source ?? input.sourceImport ?? input.baseSource,
+    { language: input.sourceLanguage, sourcePath: input.sourcePath, parser: input.sourceParser },
+    'source'
+  );
+  const targetChangeSet = input.targetChangeSet ?? diffNativeSourceImports({
+    id: input.targetChangeSetId ?? input.id,
+    language: input.targetLanguage ?? input.language,
+    sourcePath: input.targetPath ?? input.sourcePath,
+    before: input.baseTarget ?? input.beforeTarget ?? input.before,
+    after: input.editedTarget ?? input.afterTarget ?? input.after,
+    evidenceId: input.targetEvidenceId,
+    patchId: input.targetPatchId,
+    mergeCandidateId: input.targetMergeCandidateId,
+    metadata: { direction: 'target-to-source', ...(input.targetMetadata ?? {}) }
+  });
+  const id = input.id ?? `bidirectional_target_change_${idFragment([
+    source?.sourcePath,
+    targetChangeSet.sourcePath,
+    targetChangeSet.id
+  ].filter(Boolean).join('_'))}`;
+  const sourceSidecar = source ? createSemanticImportSidecar(source, {
+    id: `sidecar_source_${idFragment(id)}`,
+    generatedAt: input.generatedAt,
+    regionPrefix: input.sourceRegionPrefix
+  }) : undefined;
+  const sourceAnchors = sourceSidecar ? anchorsFromSourceSidecar(sourceSidecar, source) : [];
+  const mappings = array(input.sourceAnchorMappings ?? input.anchorMappings);
+  const lineage = input.lineage ?? input.lineageEvents ?? input.lineageMap ?? [];
+  const sourceAnchorMatches = targetChangeSet.changedRegions.map((region, index) => matchTargetRegion({
+    id,
+    region,
+    index,
+    source,
+    sourceAnchors,
+    mappings,
+    lineage
+  }));
+  const readiness = classifyBidirectionalReadiness(targetChangeSet, source, sourceAnchorMatches);
+  const reasons = uniqueStrings([
+    'source-port-review-required',
+    'target-change-is-merge-evidence-not-proof',
+    ...array(targetChangeSet.reasons),
+    ...sourceAnchorMatches.flatMap((match) => match.reasonCodes)
+  ]);
+  const evidence = [createBidirectionalEvidence({
+    id,
+    input,
+    source,
+    targetChangeSet,
+    sourceAnchorMatches,
+    readiness,
+    reasons
+  })];
+  const sourceChangedRegions = sourceAnchorMatches.flatMap((match) => sourceRegionsForMatch(match, readiness));
+  const sourcePatchBundle = createSemanticPatchBundleRecord({
+    id: `${id}_source_port_projection`,
+    language: source?.language,
+    sourcePath: source?.sourcePath,
+    baseHash: sourceHash(source),
+    changedRegions: sourceChangedRegions,
+    evidence,
+    readiness,
+    reasons,
+    conflictKeys: uniqueStrings(sourceAnchorMatches.flatMap((match) => match.conflictKeys)),
+    metadata: {
+      projectionOnly: true,
+      targetChangeSetId: targetChangeSet.id,
+      targetPatchId: targetChangeSet.patch?.id,
+      targetMergeCandidateId: targetChangeSet.mergeCandidate?.id
+    }
+  }, {
+    id: input.sourcePatchBundleId ?? `semantic_patch_bundle_${idFragment(id)}_source_port`,
+    patchId: targetChangeSet.patch?.id,
+    mergeCandidateId: targetChangeSet.mergeCandidate?.id,
+    admission: { status: readiness === 'blocked' ? 'blocked' : 'needs-review', readiness },
+    metadata: {
+      source: 'createBidirectionalTargetChangeRecord',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  });
+  const historyRecord = createSemanticHistoryRecord({
+    id: input.historyRecordId ?? `semantic_history_${idFragment(id)}_target_change`,
+    importResult: source,
+    language: source?.language,
+    sourcePath: source?.sourcePath,
+    baseHash: sourceHash(source),
+    targetHash: sourceHash(source),
+    ownershipRegions: sourceChangedRegions,
+    semanticCandidates: [targetChangeSet.mergeCandidate].filter(Boolean),
+    evidence,
+    evidenceIds: evidence.map((record) => record.id),
+    patchAncestry: targetChangeSet.patch ? [{
+      patchId: targetChangeSet.patch.id,
+      baseHash: targetChangeSet.beforeHash,
+      targetHash: targetChangeSet.afterHash,
+      conflictKeys: targetChangeSet.mergeCandidate?.conflictKeys,
+      metadata: { direction: 'target-to-source' }
+    }] : [],
+    admission: { status: readiness === 'blocked' ? 'blocked' : 'needs-review', readiness, reasonCodes: reasons },
+    replayLinks: targetChangeSet.patch ? [{
+      id: `replay_${idFragment(targetChangeSet.patch.id)}`,
+      kind: 'patch',
+      path: targetChangeSet.patch.id
+    }] : [],
+    metadata: {
+      bidirectionalTargetChangeId: id,
+      sourcePatchBundleId: sourcePatchBundle.id,
+      targetChangeSetId: targetChangeSet.id,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  }, options);
+  return {
+    kind: 'frontier.lang.bidirectionalTargetChangeRecord',
+    version: 1,
+    id,
+    sourceLanguage: source?.language,
+    targetLanguage: targetChangeSet.language,
+    sourcePath: source?.sourcePath,
+    targetPath: targetChangeSet.sourcePath,
+    sourceImport: source,
+    targetChangeSet,
+    sourceAnchorMatches,
+    sourcePatchBundle,
+    historyRecord,
+    evidence,
+    readiness,
+    reasons,
+    summary: {
+      targetChangedRegions: targetChangeSet.changedRegions.length,
+      sourceAnchorMatches: sourceAnchorMatches.filter((match) => match.status === 'matched').length,
+      ambiguousMatches: sourceAnchorMatches.filter((match) => match.status === 'ambiguous').length,
+      unmatchedTargetRegions: sourceAnchorMatches.filter((match) => match.status === 'unmatched').length,
+      deletedSourceAnchors: sourceAnchorMatches.filter((match) => match.status === 'deleted').length,
+      sourceChangedRegions: sourceChangedRegions.length
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reviewRequired: true,
+      ...input.metadata
+    }
+  };
+}
+
+function array(value) {
+  return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value];
+}

package/dist/language-adapter-package-rows.js

@@ -1,9 +1,9 @@
 const packageRows = [
-  row('@shapeshift-labs/frontier-lang-typescript', '0.3.8', 'typescript', 'typescript-compiler-api', { target: 'typescript' }),
-  row('@shapeshift-labs/frontier-lang-javascript', '0.2.8', 'javascript', 'estree', { target: 'javascript', formats: ['estree', 'babel'] }),
-  row('@shapeshift-labs/frontier-lang-rust', '0.2.8', 'rust', 'rust-syn', { target: 'rust', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'macroExpansionEvidence'] }),
-  row('@shapeshift-labs/frontier-lang-python', '0.2.8', 'python', 'python-ast', { target: 'python', formats: ['python-ast', 'libcst'] }),
-  row('@shapeshift-labs/frontier-lang-c', '0.2.8', 'c', 'clang-ast-json', { target: 'c', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'compileCommandsHash', 'preprocessorRecordsHash'] }),
+  row('@shapeshift-labs/frontier-lang-typescript', '0.3.9', 'typescript', 'typescript-compiler-api', { target: 'typescript' }),
+  row('@shapeshift-labs/frontier-lang-javascript', '0.2.9', 'javascript', 'estree', { target: 'javascript', formats: ['estree', 'babel'] }),
+  row('@shapeshift-labs/frontier-lang-rust', '0.2.9', 'rust', 'rust-syn', { target: 'rust', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'macroExpansionEvidence'] }),
+  row('@shapeshift-labs/frontier-lang-python', '0.2.9', 'python', 'python-ast', { target: 'python', formats: ['python-ast', 'libcst'] }),
+  row('@shapeshift-labs/frontier-lang-c', '0.2.9', 'c', 'clang-ast-json', { target: 'c', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'compileCommandsHash', 'preprocessorRecordsHash'] }),
   platform('@shapeshift-labs/frontier-lang-java', '0.1.8', 'java', 'java-ast', ['semanticdb', 'lsp']),
   platform('@shapeshift-labs/frontier-lang-kotlin', '0.1.8', 'kotlin', 'kotlin-psi', ['semanticdb', 'lsp']),
   platform('@shapeshift-labs/frontier-lang-swift', '0.1.8', 'swift', 'swift-syntax', ['sourcekit-lsp', 'lsp']),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.74",
+  "version": "0.2.76",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",
@@ -61,14 +61,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@shapeshift-labs/frontier-lang-c": "0.2.8",
-    "@shapeshift-labs/frontier-lang-checker": "0.3.7",
-    "@shapeshift-labs/frontier-lang-javascript": "0.2.8",
+    "@shapeshift-labs/frontier-lang-c": "0.2.9",
+    "@shapeshift-labs/frontier-lang-checker": "0.3.8",
+    "@shapeshift-labs/frontier-lang-javascript": "0.2.9",
     "@shapeshift-labs/frontier-lang-kernel": "0.3.12",
-    "@shapeshift-labs/frontier-lang-parser": "0.3.7",
-    "@shapeshift-labs/frontier-lang-python": "0.2.8",
-    "@shapeshift-labs/frontier-lang-rust": "0.2.8",
-    "@shapeshift-labs/frontier-lang-typescript": "0.3.8"
+    "@shapeshift-labs/frontier-lang-parser": "0.3.8",
+    "@shapeshift-labs/frontier-lang-python": "0.2.9",
+    "@shapeshift-labs/frontier-lang-rust": "0.2.9",
+    "@shapeshift-labs/frontier-lang-typescript": "0.3.9"
   },
   "devDependencies": {
     "typescript": "^5.9.3"