@shapeshift-labs/frontier-lang-compiler 0.2.94 → 0.2.96

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

@@ -13,6 +13,15 @@ import type { SemanticLineageEvent, SemanticLineageResolution } from './semantic
 import type { SemanticPatchBundleRecord } from './semantic-patch-bundle.js';
 
 export type BidirectionalTargetChangeAnchorStatus = 'matched' | 'unmatched' | 'ambiguous' | 'deleted' | string;
+export type BidirectionalTargetPortabilityStatus = 'portable' | 'needs-port' | 'stale' | 'conflict' | 'blocked' | 'evidence-only' | string;
+export type BidirectionalTargetPortabilityAction =
+  | 'port-with-source-map-review'
+  | 'human-port'
+  | 'refresh-source-map'
+  | 'resolve-anchor-conflict'
+  | 'block'
+  | 'record-evidence'
+  | string;
 
 export interface BidirectionalTargetChangeSourceAnchorMapping {
   readonly targetAnchorKey?: string;
@@ -62,6 +71,20 @@ export interface BidirectionalTargetChangeAnchor {
   readonly metadata?: Record<string, unknown>;
 }
 
+export interface BidirectionalTargetMatchPortability {
+  readonly status: BidirectionalTargetPortabilityStatus;
+  readonly action: BidirectionalTargetPortabilityAction;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly confidence?: number;
+  readonly reviewRequired: true;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly reasonCodes: readonly string[];
+  readonly sourceMapLinkIds: readonly string[];
+  readonly sourceMapMappingIds: readonly string[];
+  readonly staleSourceMapLinkIds: readonly string[];
+}
+
 export interface BidirectionalTargetChangeSourceAnchorMatch {
   readonly kind: 'frontier.lang.bidirectionalTargetChangeSourceAnchorMatch';
   readonly version: 1;
@@ -70,6 +93,7 @@ export interface BidirectionalTargetChangeSourceAnchorMatch {
   readonly sourceAnchors: readonly BidirectionalTargetChangeAnchor[];
   readonly lineageResolutions: readonly SemanticLineageResolution[];
   readonly sourceMapLinks: readonly BidirectionalTargetChangeSourceMapLink[];
+  readonly portability?: BidirectionalTargetMatchPortability;
   readonly status: BidirectionalTargetChangeAnchorStatus;
   readonly confidence?: number;
   readonly reasonCodes: readonly string[];
@@ -79,6 +103,31 @@ export interface BidirectionalTargetChangeSourceAnchorMatch {
   readonly conflictKeys: readonly string[];
 }
 
+export interface BidirectionalTargetPortabilityRecord {
+  readonly kind: 'frontier.lang.bidirectionalTargetPortability';
+  readonly version: 1;
+  readonly id?: string;
+  readonly status: BidirectionalTargetPortabilityStatus;
+  readonly action: BidirectionalTargetPortabilityAction;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly confidence?: number;
+  readonly reviewRequired: true;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly reasonCodes: readonly string[];
+  readonly conflictKeys: readonly string[];
+  readonly sourceAnchorMatchIds: readonly string[];
+  readonly sourceMapLinkIds: readonly string[];
+  readonly sourceMapMappingIds: readonly string[];
+  readonly staleSourceMapLinkIds: readonly string[];
+  readonly targetChangedRegions: number;
+  readonly matchedTargetRegions: number;
+  readonly sourceMapBackedRegions: number;
+  readonly unmatchedTargetRegions: number;
+  readonly ambiguousTargetRegions: number;
+  readonly deletedSourceAnchors: number;
+}
+
 export interface CreateBidirectionalTargetChangeRecordOptions {
   readonly id?: string;
   readonly source?: NativeSourceImportResult | ImportNativeSourceOptions;
@@ -130,6 +179,7 @@ export interface BidirectionalTargetChangeRecord {
   readonly sourceImport?: NativeSourceImportResult;
   readonly targetChangeSet: NativeSourceChangeSet;
   readonly sourceAnchorMatches: readonly BidirectionalTargetChangeSourceAnchorMatch[];
+  readonly targetPortability: BidirectionalTargetPortabilityRecord;
   readonly sourcePatchBundle: SemanticPatchBundleRecord;
   readonly historyRecord: SemanticHistoryRecord;
   readonly evidence: readonly EvidenceRecord[];
@@ -143,6 +193,10 @@ export interface BidirectionalTargetChangeRecord {
     readonly deletedSourceAnchors: number;
     readonly sourceChangedRegions: number;
     readonly sourceMapBackedMatches: number;
+    readonly targetPortabilityStatus: BidirectionalTargetPortabilityStatus;
+    readonly portableTargetRegions: number;
+    readonly staleTargetRegions: number;
+    readonly conflictingTargetRegions: number;
   };
   readonly metadata: {
     readonly autoMergeClaim: false;

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

@@ -28,39 +28,32 @@ export interface SemanticEditScriptOperation {
   readonly kind: string;
   readonly changeKind?: string;
   readonly anchor: {
-    readonly key?: string;
-    readonly conflictKey?: string;
-    readonly regionId?: string;
-    readonly regionKind?: string;
-    readonly granularity?: string;
+    readonly key?: string; readonly conflictKey?: string; readonly regionId?: string;
+    readonly regionKind?: string; readonly granularity?: string;
     readonly language?: FrontierSourceLanguage | string;
-    readonly sourcePath?: string;
-    readonly symbolId?: string;
-    readonly symbolName?: string;
-    readonly symbolKind?: string;
+    readonly sourcePath?: string; readonly symbolId?: string; readonly symbolName?: string; readonly symbolKind?: string;
     readonly sourceSpan?: SourceSpan;
   };
+  readonly insertion?: {
+    readonly mode?: 'before' | 'after' | 'file-start' | 'file-end' | string;
+    readonly anchorKey?: string; readonly anchorSymbolId?: string; readonly anchorSymbolName?: string; readonly anchorSymbolKind?: string;
+    readonly baseSpan?: SourceSpan; readonly workerAnchorSpan?: SourceSpan; readonly headSpan?: SourceSpan; readonly sourcePath?: string;
+    readonly insertedSymbolId?: string; readonly insertedSymbolName?: string; readonly insertedSymbolKind?: string;
+    readonly insertedSourceSpan?: SourceSpan; readonly insertedSourcePath?: string;
+    readonly reasonCodes?: readonly string[];
+  };
   readonly semanticKey?: string;
   readonly semanticIdentityHash?: string;
   readonly sourceIdentityHash?: string;
   readonly operationContentHash?: string;
   readonly spans?: {
-    readonly base?: SourceSpan;
-    readonly worker?: SourceSpan;
-    readonly head?: SourceSpan;
+    readonly base?: SourceSpan; readonly worker?: SourceSpan; readonly head?: SourceSpan;
   };
   readonly hashes?: {
-    readonly baseSourceHash?: string;
-    readonly workerSourceHash?: string;
-    readonly headSourceHash?: string;
-    readonly baseSpanHash?: string;
-    readonly workerSpanHash?: string;
-    readonly headSpanHash?: string;
-    readonly baseTextHash?: string;
-    readonly workerTextHash?: string;
-    readonly headTextHash?: string;
-    readonly beforeSignatureHash?: string;
-    readonly afterSignatureHash?: string;
+    readonly baseSourceHash?: string; readonly workerSourceHash?: string; readonly headSourceHash?: string;
+    readonly baseSpanHash?: string; readonly workerSpanHash?: string; readonly headSpanHash?: string;
+    readonly baseTextHash?: string; readonly workerTextHash?: string; readonly headTextHash?: string;
+    readonly beforeSignatureHash?: string; readonly afterSignatureHash?: string;
   };
   readonly status: SemanticEditScriptOperationStatus;
   readonly reanchor?: {
@@ -135,6 +128,7 @@ export interface SemanticEditProjectionEdit {
   readonly operationId?: string;
   readonly status: 'applied' | 'already-applied';
   readonly kind?: string;
+  readonly editKind?: 'replace' | 'insert' | string;
   readonly changeKind?: string;
   readonly anchorKey?: string;
   readonly conflictKey?: string;
@@ -162,6 +156,11 @@ export interface SemanticEditProjectionEdit {
   readonly replacementBytes: number;
   readonly deletedTextHash?: string;
   readonly replacementTextHash?: string;
+  readonly replacementSpanTextHash?: string;
+  readonly insertionMode?: string;
+  readonly insertionAnchorKey?: string;
+  readonly insertionAnchorSymbolName?: string;
+  readonly insertionAnchorSymbolKind?: string;
   readonly replacementText?: string;
 }
 
@@ -206,6 +205,7 @@ export interface SemanticEditReplayEdit {
   readonly semanticIdentityHash?: string;
   readonly sourceIdentityHash?: string;
   readonly editContentHash?: string;
+  readonly editKind?: 'replace' | 'insert' | string;
   readonly sourcePath?: string;
   readonly symbolName?: string;
   readonly symbolKind?: string;

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

@@ -36,6 +36,9 @@ export interface SemanticPatchBundleRecordIndex {
   readonly transformTargetLanguages: readonly string[];
   readonly transformSourcePaths: readonly string[];
   readonly transformTargetPaths: readonly string[];
+  readonly targetPortabilityStatuses: readonly string[];
+  readonly targetPortabilityActions: readonly string[];
+  readonly targetPortabilityReasonCodes: readonly string[];
   readonly patchIds: readonly string[];
   readonly mergeCandidateIds: readonly string[];
   readonly readinesses: readonly string[];

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

@@ -10,6 +10,7 @@ import type { NativeSourceChangeKind, NativeSourceChangeSet } from './native-dif
 import type { SemanticEditProjection, SemanticEditReplay, SemanticEditScript } from './semantic-edit-script.js';
 import type { SemanticPatchBundleRecordIndex } from './semantic-patch-bundle-index.js';
 import type { SemanticTransformIdentityRecord } from './semantic-transform-identity.js';
+import type { BidirectionalTargetPortabilityRecord } from './bidirectional-target-change.js';
 
 export type { SemanticPatchBundleRecordIndex } from './semantic-patch-bundle-index.js';
 
@@ -56,6 +57,7 @@ export interface SemanticPatchBundleChangedRegion {
     readonly reasonCodes?: readonly string[];
     readonly conflictKeys?: readonly string[];
   };
+  readonly metadata?: Record<string, unknown>;
 }
 
 export interface SemanticPatchBundleSourceMapLink {
@@ -185,6 +187,7 @@ export interface CreateSemanticPatchBundleRecordOptions {
   readonly semanticEditReplays?: readonly SemanticEditReplay[] | SemanticEditReplay;
   readonly semanticTransformIdentity?: SemanticTransformIdentityRecord | Record<string, unknown>;
   readonly semanticTransformIdentities?: readonly (SemanticTransformIdentityRecord | Record<string, unknown>)[];
+  readonly targetPortability?: BidirectionalTargetPortabilityRecord | Record<string, unknown>;
   readonly sourceLanguage?: FrontierSourceLanguage | string;
   readonly targetLanguage?: FrontierSourceLanguage | string;
   readonly conflictKeys?: readonly string[] | string;
@@ -275,6 +278,12 @@ export interface SemanticPatchBundleRecordQuery {
   readonly transformSourcePaths?: readonly string[];
   readonly transformTargetPath?: string | readonly string[];
   readonly transformTargetPaths?: readonly string[];
+  readonly targetPortabilityStatus?: string | readonly string[];
+  readonly targetPortabilityStatuses?: readonly string[];
+  readonly targetPortabilityAction?: string | readonly string[];
+  readonly targetPortabilityActions?: readonly string[];
+  readonly targetPortabilityReasonCode?: string | readonly string[];
+  readonly targetPortabilityReasonCodes?: readonly string[];
   readonly readiness?: SemanticMergeReadiness | string | readonly string[];
   readonly readinesses?: readonly string[];
   readonly admissionStatus?: SemanticPatchBundleAdmissionStatus | readonly string[];

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

@@ -55,6 +55,7 @@ export function classifyBidirectionalReadiness(targetChangeSet, source, matches)
 
 export function sourceRegionsForMatch(match, readiness) {
   const anchors = match.sourceAnchors.length ? match.sourceAnchors : [undefined];
+  const portability = match.portability;
   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}`,
@@ -70,9 +71,9 @@ export function sourceRegionsForMatch(match, readiness) {
     sourceSpan: anchor?.sourceSpan,
     sourceMapLinks: match.sourceMapLinks,
     admission: {
-      readiness,
-      action: 'review-port-from-target-change',
-      reasonCodes: match.reasonCodes,
+      readiness: portability?.readiness ?? readiness,
+      action: portability?.action ?? 'review-port-from-target-change',
+      reasonCodes: uniqueStrings([...match.reasonCodes, ...array(portability?.reasonCodes)]),
       conflictKeys: match.conflictKeys
     },
     metadata: {
@@ -81,6 +82,7 @@ export function sourceRegionsForMatch(match, readiness) {
         targetRegion: match.targetRegion,
         sourceMapLinkIds: match.sourceMapLinks.map((link) => link.id),
         lineageResolutionIds: match.lineageResolutions.map((resolution) => resolution.id),
+        targetPortability: portability,
         reviewRequired: true,
         autoMergeClaim: false,
         semanticEquivalenceClaim: false
@@ -104,6 +106,10 @@ export function createBidirectionalEvidence(context) {
       sourceAnchorMatchIds: context.sourceAnchorMatches.map((match) => match.id),
       sourceMapBackedMatches: context.sourceAnchorMatches.filter((match) => match.sourceMapLinks.length > 0).length,
       sourceMapLinkIds: context.sourceAnchorMatches.flatMap((match) => match.sourceMapLinks.map((link) => link.id)),
+      targetPortabilityStatus: context.targetPortability?.status,
+      targetPortabilityAction: context.targetPortability?.action,
+      targetPortabilityReasonCodes: context.targetPortability?.reasonCodes,
+      targetPortabilitySourceMapLinkIds: context.targetPortability?.sourceMapLinkIds,
       readiness: context.readiness,
       reasons: context.reasons,
       autoMergeClaim: false,

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

@@ -0,0 +1,152 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+
+export function classifyBidirectionalTargetPortability(context = {}) {
+  const matches = array(context.sourceAnchorMatches);
+  const targetRegions = Number(context.targetChangeSet?.changedRegions?.length ?? matches.length);
+  const links = matches.flatMap((match) => array(match.sourceMapLinks));
+  const sourceMapBackedMatches = matches.filter((match) => array(match.sourceMapLinks).length > 0).length;
+  const unmatched = matches.filter((match) => match.status === 'unmatched').length;
+  const ambiguous = matches.filter((match) => match.status === 'ambiguous').length;
+  const deleted = matches.filter((match) => match.status === 'deleted').length;
+  const staleLinks = links.filter((link) => sourceMapLinkIsStale(link, context));
+  const status = portabilityStatus({ context, targetRegions, matches, sourceMapBackedMatches, unmatched, ambiguous, deleted, staleLinks });
+  return compactRecord({
+    kind: 'frontier.lang.bidirectionalTargetPortability',
+    version: 1,
+    id: context.id ? `target_portability_${context.id}` : undefined,
+    status,
+    action: portabilityAction(status),
+    readiness: status === 'blocked' ? 'blocked' : 'needs-review',
+    confidence: portabilityConfidence({ status, targetRegions, sourceMapBackedMatches, unmatched, ambiguous, deleted, staleLinks }),
+    reviewRequired: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: portabilityReasons({ context, targetRegions, matches, sourceMapBackedMatches, unmatched, ambiguous, deleted, staleLinks, status }),
+    conflictKeys: uniqueStrings(matches.flatMap((match) => array(match.conflictKeys))),
+    sourceAnchorMatchIds: uniqueStrings(matches.map((match) => match.id)),
+    sourceMapLinkIds: uniqueStrings(links.map((link) => link.id)),
+    sourceMapMappingIds: uniqueStrings(links.map((link) => link.sourceMapMappingId)),
+    staleSourceMapLinkIds: uniqueStrings(staleLinks.map((link) => link.id)),
+    targetChangedRegions: targetRegions,
+    matchedTargetRegions: matches.filter((match) => match.status === 'matched').length,
+    sourceMapBackedRegions: sourceMapBackedMatches,
+    unmatchedTargetRegions: unmatched,
+    ambiguousTargetRegions: ambiguous,
+    deletedSourceAnchors: deleted
+  });
+}
+
+export function attachBidirectionalMatchPortability(match = {}, context = {}) {
+  return {
+    ...match,
+    portability: classifyBidirectionalMatchPortability(match, context)
+  };
+}
+
+export function classifyBidirectionalMatchPortability(match = {}, context = {}) {
+  const links = array(match.sourceMapLinks);
+  const staleLinks = links.filter((link) => sourceMapLinkIsStale(link, context));
+  const status = matchPortabilityStatus(match, links, staleLinks);
+  return compactRecord({
+    status,
+    action: portabilityAction(status),
+    readiness: status === 'blocked' ? 'blocked' : 'needs-review',
+    confidence: matchPortabilityConfidence(status, links),
+    reviewRequired: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: matchPortabilityReasons(match, links, staleLinks, status),
+    sourceMapLinkIds: uniqueStrings(links.map((link) => link.id)),
+    sourceMapMappingIds: uniqueStrings(links.map((link) => link.sourceMapMappingId)),
+    staleSourceMapLinkIds: uniqueStrings(staleLinks.map((link) => link.id))
+  });
+}
+
+function portabilityStatus(input) {
+  if (!input.context.source) return 'blocked';
+  if (input.targetRegions === 0 || input.matches.length === 0) return 'evidence-only';
+  if (input.deleted > 0) return 'blocked';
+  if (input.unmatched === input.targetRegions) return 'blocked';
+  if (input.staleLinks.length > 0) return 'stale';
+  if (input.ambiguous > 0) return 'conflict';
+  if (input.unmatched > 0) return 'needs-port';
+  if (input.sourceMapBackedMatches === input.targetRegions) return 'portable';
+  return 'needs-port';
+}
+
+function portabilityAction(status) {
+  if (status === 'portable') return 'port-with-source-map-review';
+  if (status === 'needs-port') return 'human-port';
+  if (status === 'stale') return 'refresh-source-map';
+  if (status === 'conflict') return 'resolve-anchor-conflict';
+  if (status === 'blocked') return 'block';
+  return 'record-evidence';
+}
+
+function matchPortabilityStatus(match, links, staleLinks) {
+  if (match.status === 'deleted' || match.status === 'unmatched') return 'blocked';
+  if (staleLinks.length > 0) return 'stale';
+  if (match.status === 'ambiguous') return 'conflict';
+  if (match.status === 'matched' && links.length > 0) return 'portable';
+  return 'needs-port';
+}
+
+function matchPortabilityConfidence(status, links) {
+  if (status === 'portable') return 0.72;
+  if (status === 'needs-port') return links.length > 0 ? 0.52 : 0.35;
+  return undefined;
+}
+
+function matchPortabilityReasons(match, links, staleLinks, status) {
+  return uniqueStrings([
+    status === 'portable' ? 'target-region-source-map-portable' : undefined,
+    links.length > 0 ? 'target-region-source-map-backed' : undefined,
+    links.length === 0 ? 'target-region-not-source-map-backed' : undefined,
+    match.status === 'unmatched' ? 'target-anchor-unmatched' : undefined,
+    match.status === 'ambiguous' ? 'target-anchor-ambiguous' : undefined,
+    match.status === 'deleted' ? 'target-anchor-deleted' : undefined,
+    staleLinks.length > 0 ? 'target-source-map-stale' : undefined,
+    'target-region-is-portability-evidence-not-proof'
+  ]);
+}
+
+function portabilityConfidence(input) {
+  if (input.status === 'portable') return 0.74;
+  if (input.status === 'needs-port') return input.sourceMapBackedMatches > 0 ? 0.52 : 0.35;
+  if (input.status === 'evidence-only') return 0.25;
+  return undefined;
+}
+
+function portabilityReasons(input) {
+  const sourceMapBacked = input.sourceMapBackedMatches > 0;
+  return uniqueStrings([
+    input.context.source ? undefined : 'source-import-missing',
+    input.targetRegions === 0 ? 'target-change-empty' : undefined,
+    input.status === 'portable' ? 'target-change-source-map-portable' : undefined,
+    sourceMapBacked ? 'target-change-source-map-backed' : undefined,
+    input.sourceMapBackedMatches < input.targetRegions ? 'target-change-not-fully-source-map-backed' : undefined,
+    input.unmatched > 0 ? 'target-anchor-unmatched' : undefined,
+    input.ambiguous > 0 ? 'target-anchor-ambiguous' : undefined,
+    input.deleted > 0 ? 'target-anchor-deleted' : undefined,
+    input.staleLinks.length > 0 ? 'target-source-map-stale' : undefined,
+    'target-change-is-portability-evidence-not-proof',
+    ...input.matches.flatMap((match) => array(match.reasonCodes))
+  ]);
+}
+
+function sourceMapLinkIsStale(link, context) {
+  const currentSourceHash = context.currentSourceHash;
+  const baseTargetHash = context.targetChangeSet?.beforeHash;
+  return Boolean(
+    (link.sourceHash && currentSourceHash && link.sourceHash !== currentSourceHash)
+    || (link.targetHash && baseTargetHash && link.targetHash !== baseTargetHash)
+  );
+}
+
+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

@@ -8,6 +8,7 @@ import { createSemanticPatchBundleRecord } from './semanticPatchBundleRecords.js
 import { createSemanticHistoryRecord } from './semanticHistoryRecords.js';
 import { diffNativeSourceImports } from './diffNativeSourceImports.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
+import { attachBidirectionalMatchPortability, classifyBidirectionalTargetPortability } from './bidirectionalTargetPortability.js';
 import {
   anchorsFromSourceSidecar,
   classifyBidirectionalReadiness,
@@ -64,12 +65,24 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     mappings,
     sourceMaps,
     lineage
+  })).map((match) => attachBidirectionalMatchPortability(match, {
+    currentSourceHash: sourceHash(source),
+    targetChangeSet
   }));
+  const targetPortability = classifyBidirectionalTargetPortability({
+    id,
+    source,
+    currentSourceHash: sourceHash(source),
+    targetChangeSet,
+    sourceAnchorMatches
+  });
   const readiness = classifyBidirectionalReadiness(targetChangeSet, source, sourceAnchorMatches);
   const reasons = uniqueStrings([
     'source-port-review-required',
     'target-change-is-merge-evidence-not-proof',
+    `target-portability:${targetPortability.status}`,
     ...array(targetChangeSet.reasons),
+    ...array(targetPortability.reasonCodes),
     ...sourceAnchorMatches.flatMap((match) => match.reasonCodes)
   ]);
   const evidence = [createBidirectionalEvidence({
@@ -78,6 +91,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     source,
     targetChangeSet,
     sourceAnchorMatches,
+    targetPortability,
     readiness,
     reasons
   })];
@@ -97,6 +111,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       targetChangeSetId: targetChangeSet.id,
       targetPatchId: targetChangeSet.patch?.id,
       targetMergeCandidateId: targetChangeSet.mergeCandidate?.id,
+      targetPortability,
       sourceMapBackprojection: summarizeSourceMapBackprojection(sourceAnchorMatches)
     }
   }, {
@@ -106,6 +121,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     admission: { status: readiness === 'blocked' ? 'blocked' : 'needs-review', readiness },
     metadata: {
       source: 'createBidirectionalTargetChangeRecord',
+      targetPortability,
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
@@ -138,6 +154,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       bidirectionalTargetChangeId: id,
       sourcePatchBundleId: sourcePatchBundle.id,
       targetChangeSetId: targetChangeSet.id,
+      targetPortability,
       sourceMapBackprojection: summarizeSourceMapBackprojection(sourceAnchorMatches),
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
@@ -154,6 +171,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     sourceImport: source,
     targetChangeSet,
     sourceAnchorMatches,
+    targetPortability,
     sourcePatchBundle,
     historyRecord,
     evidence,
@@ -166,12 +184,17 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       unmatchedTargetRegions: sourceAnchorMatches.filter((match) => match.status === 'unmatched').length,
       deletedSourceAnchors: sourceAnchorMatches.filter((match) => match.status === 'deleted').length,
       sourceChangedRegions: sourceChangedRegions.length,
-      sourceMapBackedMatches: sourceAnchorMatches.filter((match) => match.sourceMapLinks.length > 0).length
+      sourceMapBackedMatches: sourceAnchorMatches.filter((match) => match.sourceMapLinks.length > 0).length,
+      targetPortabilityStatus: targetPortability.status,
+      portableTargetRegions: targetPortability.status === 'portable' ? targetPortability.targetChangedRegions : 0,
+      staleTargetRegions: targetPortability.status === 'stale' ? targetPortability.targetChangedRegions : 0,
+      conflictingTargetRegions: targetPortability.status === 'conflict' ? targetPortability.ambiguousTargetRegions : 0
     },
     metadata: {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
       reviewRequired: true,
+      targetPortability,
       ...input.metadata
     }
   };

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

@@ -12,13 +12,15 @@ export function projectSemanticEditScriptToSource(input = {}) {
   if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
   if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
   const edits = [];
-  for (const operation of script.operations ?? []) {
-    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText);
+  for (const [index, operation] of (script.operations ?? []).entries()) {
+    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index);
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
   }
+  const deduped = dedupeSourceEdits(edits);
+  reasonCodes.push(...validateSourceEdits(deduped.edits));
   const blocked = reasonCodes.length > 0;
-  const sourceText = blocked ? undefined : applySourceEdits(headSourceText, edits);
+  const sourceText = blocked ? undefined : applySourceEdits(headSourceText, deduped.edits);
   const core = {
     kind: 'frontier.lang.semanticEditProjection',
     version: 1,
@@ -31,9 +33,9 @@ export function projectSemanticEditScriptToSource(input = {}) {
     workerHash: script.workerHash,
     headHash: script.headHash,
     projectedHash: sourceText === undefined ? undefined : hashSemanticValue(sourceText),
-    appliedOperations: blocked ? [] : edits.map((edit) => edit.operationId),
-    skippedOperations: blocked ? (script.operations ?? []).map((operation) => operation.id) : [],
-    edits: blocked ? [] : edits.map(projectionEditRecord),
+    appliedOperations: blocked ? [] : deduped.edits.map((edit) => edit.operationId),
+    skippedOperations: blocked ? (script.operations ?? []).map((operation) => operation.id) : deduped.skippedOperationIds,
+    edits: blocked ? [] : deduped.edits.map(projectionEditRecord),
     sourceText,
     admission: {
       status: blocked ? 'blocked' : 'auto-merge-candidate',
@@ -45,20 +47,24 @@ export function projectSemanticEditScriptToSource(input = {}) {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
       editCount: edits.length,
-      appliedEditCount: edits.filter((edit) => !edit.alreadyApplied).length,
-      alreadyAppliedEditCount: edits.filter((edit) => edit.alreadyApplied).length,
+      appliedEditCount: deduped.edits.filter((edit) => !edit.alreadyApplied).length,
+      alreadyAppliedEditCount: deduped.edits.filter((edit) => edit.alreadyApplied).length,
+      dedupedEditCount: deduped.skippedOperationIds.length,
       ...input.metadata
     })
   };
   return { ...core, hash: hashSemanticValue(core) };
 }
 
-function sourceEditForOperation(operation, workerSourceText, headSourceText) {
+function sourceEditForOperation(operation, workerSourceText, headSourceText, order) {
   const identity = projectionIdentity(operation);
   if (operation.status === 'already-applied') {
-    return { ok: true, value: { ...identity, operationId: operation.id, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
+    return { ok: true, value: { ...identity, operationId: operation.id, order, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
   }
   if (operation.status !== 'portable') return { ok: false, reasonCodes: [`operation-not-portable:${operation.id}`] };
+  if (operation.changeKind === 'added' || String(operation.kind ?? '').startsWith('add')) {
+    return insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order);
+  }
   const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
   const headOffsets = spanOffsets(headSourceText, operation.spans?.head ?? operation.spans?.base ?? operation.anchor?.sourceSpan);
   const reasons = [];
@@ -79,7 +85,9 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText) {
     ok: true,
     value: {
       operationId: operation.id,
+      order,
       ...identity,
+      editKind: 'replace',
       start: headOffsets.start,
       end: headOffsets.end,
       workerStart: workerOffsets.start,
@@ -90,6 +98,37 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText) {
   };
 }
 
+function insertionEditForOperation(operation, identity, workerSourceText, headSourceText, order) {
+  const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
+  const reasons = [];
+  if (!workerOffsets) reasons.push(`worker-span-not-resolvable:${operation.id}`);
+  const insertion = insertionOffset(headSourceText, operation.insertion);
+  if (!insertion.ok) reasons.push(...insertion.reasonCodes.map((reason) => `${reason}:${operation.id}`));
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const spanText = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
+  if (operation.hashes?.workerTextHash && hashSemanticValue(spanText) !== operation.hashes.workerTextHash) {
+    reasons.push(`worker-span-hash-mismatch:${operation.id}`);
+  }
+  if (reasons.length) return { ok: false, reasonCodes: reasons };
+  return {
+    ok: true,
+    value: {
+      operationId: operation.id,
+      order,
+      ...identity,
+      editKind: 'insert',
+      insertion: operation.insertion,
+      start: insertion.offset,
+      end: insertion.offset,
+      workerStart: workerOffsets.start,
+      workerEnd: workerOffsets.end,
+      replacement: insertionReplacement(spanText, headSourceText, insertion.offset),
+      replacementSpanText: spanText,
+      current: ''
+    }
+  };
+}
+
 function projectionIdentity(operation) {
   const identity = semanticEditIdentity(operation);
   return { ...identity, sourcePath: operation.reanchor?.toSourcePath ?? identity.sourcePath };
@@ -103,6 +142,7 @@ function projectionEditRecord(edit) {
     operationId: edit.operationId,
     status: edit.alreadyApplied ? 'already-applied' : 'applied',
     kind: edit.kind,
+    editKind: edit.editKind,
     changeKind: edit.changeKind,
     anchorKey: edit.anchorKey,
     conflictKey: edit.conflictKey,
@@ -133,6 +173,11 @@ function projectionEditRecord(edit) {
     replacementBytes: edit.replacement.length,
     deletedTextHash,
     replacementTextHash,
+    replacementSpanTextHash: hashSemanticValue(edit.replacementSpanText ?? edit.replacement),
+    insertionMode: edit.insertion?.mode,
+    insertionAnchorKey: edit.insertion?.anchorKey,
+    insertionAnchorSymbolName: edit.insertion?.anchorSymbolName,
+    insertionAnchorSymbolKind: edit.insertion?.anchorSymbolKind,
     replacementText: edit.replacement
   });
 }
@@ -164,10 +209,42 @@ function semanticEditIdentity(operation) {
 
 function applySourceEdits(sourceText, edits) {
   return edits.filter((edit) => !edit.alreadyApplied)
-    .sort((left, right) => right.start - left.start)
+    .sort(sourceEditSort)
     .reduce((text, edit) => text.slice(0, edit.start) + edit.replacement + text.slice(edit.end), sourceText);
 }
 
+function dedupeSourceEdits(edits) {
+  const seen = new Map();
+  const result = [];
+  const skippedOperationIds = [];
+  for (const edit of edits) {
+    const key = duplicateEditKey(edit);
+    if (key && seen.has(key)) {
+      skippedOperationIds.push(edit.operationId);
+      continue;
+    }
+    if (key) seen.set(key, edit.operationId);
+    result.push(edit);
+  }
+  return { edits: result, skippedOperationIds };
+}
+
+function duplicateEditKey(edit) {
+  if (edit.editKind !== 'insert') return undefined;
+  return [
+    'insert',
+    edit.start,
+    edit.end,
+    edit.insertion?.mode,
+    edit.insertion?.anchorKey,
+    hashSemanticValue(edit.replacementSpanText ?? edit.replacement)
+  ].join(':');
+}
+
+function sourceEditSort(left, right) {
+  return right.start - left.start || right.end - left.end || (right.order ?? 0) - (left.order ?? 0);
+}
+
 function projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
@@ -189,6 +266,48 @@ function spanOffsets(sourceText, span) {
   return { start: start + startColumn, end: endLineStart + endColumn };
 }
 
+function insertionOffset(sourceText, insertion) {
+  if (typeof sourceText !== 'string') return { ok: false, reasonCodes: ['missing-head-source-text'] };
+  const mode = insertion?.mode;
+  if (mode === 'file-start') return { ok: true, offset: 0 };
+  if (mode === 'file-end') return { ok: true, offset: sourceText.length };
+  const range = spanOffsets(sourceText, insertion?.headSpan);
+  if (!range) return { ok: false, reasonCodes: ['insertion-anchor-not-resolvable'] };
+  if (mode === 'before') return { ok: true, offset: range.start };
+  if (mode === 'after') return { ok: true, offset: afterLineOffset(sourceText, range.end) };
+  return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
+}
+
+function insertionReplacement(text, sourceText, offset) {
+  let replacement = String(text ?? '');
+  if (offset > 0 && sourceText[offset - 1] !== '\n') replacement = `\n${replacement}`;
+  if (offset < sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
+  if (offset === sourceText.length && sourceText && !sourceText.endsWith('\n')) replacement = `\n${replacement}`;
+  if (offset === sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
+  return replacement;
+}
+
+function afterLineOffset(sourceText, offset) {
+  return sourceText[offset] === '\n' ? offset + 1 : offset;
+}
+
+function validateSourceEdits(edits) {
+  const reasons = [];
+  const ordered = edits.filter((edit) => !edit.alreadyApplied).sort((left, right) => left.start - right.start || left.end - right.end);
+  for (let index = 1; index < ordered.length; index += 1) {
+    const previous = ordered[index - 1];
+    const current = ordered[index];
+    if (editsOverlap(previous, current)) reasons.push(`source-edit-overlap:${previous.operationId}:${current.operationId}`);
+  }
+  return uniqueStrings(reasons);
+}
+
+function editsOverlap(left, right) {
+  if (left.start === left.end) return right.start < left.start && left.start < right.end;
+  if (right.start === right.end) return left.start < right.start && right.start < left.end;
+  return left.start < right.end && right.start < left.end;
+}
+
 function compactRecord(value) {
   return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
 }

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

@@ -53,6 +53,7 @@ export function replaySemanticEditProjection(input = {}) {
 function replayProjectionEdit(edit, context) {
   if (edit.status === 'already-applied') return replayEditRecord(edit, 'already-applied', undefined, ['projection-edit-already-applied']);
   if (typeof edit.replacementText !== 'string') return replayEditRecord(edit, 'blocked', undefined, ['missing-replacement-text']);
+  if (edit.editKind === 'insert') return replayInsertionEdit(edit, context);
   const offset = checkRange(edit, { start: edit.headStart, end: edit.headEnd }, context.currentSourceText, 'head-offset');
   if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
   const symbol = findCurrentSymbol(edit, context.currentSymbols);
@@ -64,13 +65,27 @@ function replayProjectionEdit(edit, context) {
   ]);
 }
 
+function replayInsertionEdit(edit, context) {
+  const inserted = findCurrentSymbol(edit, context.currentSymbols);
+  const insertedRange = spanOffsets(context.currentSourceText, inserted?.sourceSpan);
+  const already = checkRange(edit, insertedRange, context.currentSourceText, 'current-inserted-symbol');
+  if (already?.status === 'already-applied') return replayEditRecord(edit, 'already-applied', already.range, [already.reason]);
+  const anchor = findInsertionAnchorSymbol(edit, context.currentSymbols);
+  const range = insertionRange(edit, anchor, context.currentSourceText);
+  if (range) return replayEditRecord(edit, 'applied', range, [anchor ? 'current-insertion-anchor' : `current-${edit.insertionMode}`]);
+  return replayEditRecord(edit, anchor ? 'conflict' : 'stale', undefined, [
+    anchor ? 'current-insertion-anchor-unusable' : 'current-insertion-anchor-missing'
+  ]);
+}
+
 function checkRange(edit, range, sourceText, label) {
   if (!range || range.end < range.start) return undefined;
   const current = sourceText.slice(range.start, range.end);
   const currentHash = hashSemanticValue(current);
-  if (edit.deletedTextHash && currentHash === edit.deletedTextHash) return { status: 'applied', range, reason: `${label}-matches-deleted` };
+  if (edit.replacementSpanTextHash && currentHash === edit.replacementSpanTextHash) return { status: 'already-applied', range, reason: `${label}-matches-replacement-span` };
   if (edit.replacementTextHash && currentHash === edit.replacementTextHash) return { status: 'already-applied', range, reason: `${label}-matches-replacement` };
   if (current === edit.replacementText) return { status: 'already-applied', range, reason: `${label}-matches-replacement-text` };
+  if (edit.deletedTextHash && currentHash === edit.deletedTextHash) return { status: 'applied', range, reason: `${label}-matches-deleted` };
   return undefined;
 }
 
@@ -81,6 +96,7 @@ function replayEditRecord(edit, status, range, reasonCodes) {
     semanticIdentityHash: edit.semanticIdentityHash,
     sourceIdentityHash: edit.sourceIdentityHash,
     editContentHash: edit.editContentHash,
+    editKind: edit.editKind,
     sourcePath: edit.targetSourcePath ?? edit.sourcePath,
     symbolName: edit.targetSymbolName ?? edit.symbolName,
     symbolKind: edit.targetSymbolKind ?? edit.symbolKind,
@@ -115,6 +131,24 @@ function findCurrentSymbol(edit, symbols) {
   return symbols.find((symbol) => symbol.name === name && (!kind || symbol.kind === kind));
 }
 
+function findInsertionAnchorSymbol(edit, symbols) {
+  return symbols.find((symbol) => [symbol.ownershipKey, symbol.key, symbol.id].some((key) => key && key === edit.insertionAnchorKey))
+    ?? symbols.find((symbol) => symbol.name === edit.insertionAnchorSymbolName && (!edit.insertionAnchorSymbolKind || symbol.kind === edit.insertionAnchorSymbolKind));
+}
+
+function insertionRange(edit, anchor, sourceText) {
+  if (edit.insertionMode === 'file-start') return { start: 0, end: 0 };
+  if (edit.insertionMode === 'file-end') return { start: sourceText.length, end: sourceText.length };
+  const anchorRange = spanOffsets(sourceText, anchor?.sourceSpan);
+  if (!anchorRange) return undefined;
+  if (edit.insertionMode === 'before') return { start: anchorRange.start, end: anchorRange.start };
+  if (edit.insertionMode === 'after') {
+    const offset = sourceText[anchorRange.end] === '\n' ? anchorRange.end + 1 : anchorRange.end;
+    return { start: offset, end: offset };
+  }
+  return undefined;
+}
+
 function replayStatus(reasonCodes, edits, projection) {
   if (reasonCodes.some((reason) => reason !== 'current-source-hash-mismatch')) return 'blocked';
   if (!edits.length && !(projection.edits ?? []).length) return 'evidence-only';

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

@@ -0,0 +1,108 @@
+export function semanticEditInsertionAnchor(region, context) {
+  if (region.changeKind !== 'added') return undefined;
+  const workerSymbol = symbolForRegion(context.workerSymbols, region);
+  if (!workerSymbol?.sourceSpan) return fallbackInsertion(region, context, 'worker-symbol-span-missing');
+  const workers = uniqueSymbols(context.workerSymbols)
+    .filter((symbol) => symbol.id !== workerSymbol.id && symbol.key !== workerSymbol.key)
+    .filter((symbol) => hasSymbol(context.baseSymbols, symbol));
+  const before = nearestBefore(workers, workerSymbol);
+  const after = nearestAfter(workers, workerSymbol);
+  const anchor = before
+    ? insertionFromSymbol('after', before, context, 'nearest-previous-base-symbol')
+    : after
+      ? insertionFromSymbol('before', after, context, 'nearest-next-base-symbol')
+      : fallbackInsertion(region, context, 'no-neighbor-base-symbol');
+  return compactRecord({
+    ...anchor,
+    insertedSymbolId: workerSymbol.id,
+    insertedSymbolName: workerSymbol.name,
+    insertedSymbolKind: workerSymbol.kind,
+    insertedSourceSpan: workerSymbol.sourceSpan,
+    insertedSourcePath: workerSymbol.sourcePath
+  });
+}
+
+function insertionFromSymbol(mode, symbol, context, reasonCode) {
+  const headSymbol = symbolForExisting(context.headSymbols, symbol);
+  return compactRecord({
+    mode,
+    anchorKey: symbol.key ?? symbol.ownershipKey ?? symbol.id,
+    anchorSymbolId: symbol.id,
+    anchorSymbolName: symbol.name,
+    anchorSymbolKind: symbol.kind,
+    baseSpan: symbolForExisting(context.baseSymbols, symbol)?.sourceSpan,
+    workerAnchorSpan: symbol.sourceSpan,
+    headSpan: headSymbol?.sourceSpan,
+    sourcePath: headSymbol?.sourcePath ?? symbol.sourcePath,
+    reasonCodes: [headSymbol ? reasonCode : `${reasonCode}:head-anchor-missing`]
+  });
+}
+
+function fallbackInsertion(region, context, reasonCode) {
+  const mode = region.regionKind === 'import' ? 'file-start' : 'file-end';
+  return compactRecord({
+    mode,
+    sourcePath: region.sourcePath ?? context.workerChangeSet.sourcePath,
+    reasonCodes: [reasonCode, `fallback-${mode}`]
+  });
+}
+
+function nearestBefore(symbols, target) {
+  return symbols
+    .filter((symbol) => spanEndLine(symbol.sourceSpan) <= spanStartLine(target.sourceSpan))
+    .sort((left, right) => spanEndLine(right.sourceSpan) - spanEndLine(left.sourceSpan))[0];
+}
+
+function nearestAfter(symbols, target) {
+  return symbols
+    .filter((symbol) => spanStartLine(symbol.sourceSpan) >= spanEndLine(target.sourceSpan))
+    .sort((left, right) => spanStartLine(left.sourceSpan) - spanStartLine(right.sourceSpan))[0];
+}
+
+function symbolForRegion(symbols, region) {
+  return symbolForKeys(symbols, [region.key, region.symbolId, region.symbolName].filter(Boolean));
+}
+
+function symbolForExisting(symbols, symbol) {
+  return symbolForKeys(symbols, symbolKeys(symbol));
+}
+
+function hasSymbol(symbols, symbol) {
+  return Boolean(symbolForExisting(symbols, symbol));
+}
+
+function symbolForKeys(symbols, keys) {
+  for (const key of keys) {
+    const symbol = symbols.get(key);
+    if (symbol) return symbol;
+  }
+  return undefined;
+}
+
+function uniqueSymbols(symbols) {
+  const seen = new Set();
+  const result = [];
+  for (const symbol of symbols.values()) {
+    const key = symbol.id ?? `${symbol.key}:${symbol.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(symbol);
+  }
+  return result;
+}
+
+function symbolKeys(symbol) {
+  return [symbol.key, symbol.ownershipKey, symbol.id, symbol.name].filter(Boolean);
+}
+
+function spanStartLine(span) {
+  return typeof span?.startLine === 'number' ? span.startLine : Number.MAX_SAFE_INTEGER;
+}
+
+function spanEndLine(span) {
+  return typeof span?.endLine === 'number' ? span.endLine : spanStartLine(span);
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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

@@ -12,6 +12,7 @@ import {
   semanticEditAdmission,
   summarizeSemanticEditOperations
 } from './semanticEditScriptClassification.js';
+import { semanticEditInsertionAnchor } from './semanticEditInsertionAnchors.js';
 import { sourceTextForSpan } from './sourceTextForSpan.js';
 import { semanticEditIdentityFields, semanticEditOperationContentHash } from './semanticEditIdentityRecords.js';
 
@@ -168,10 +169,11 @@ function semanticEditOperation(region, index, context, input) {
   const identityRecord = semanticEditIdentityRecord({ kind, region, anchor });
   const identity = semanticEditIdentityFields(identityRecord);
   return compactRecord({
-    id: `semantic_edit_op_${idFragment(firstString(input.id, anchorKey, index))}`,
+    id: `semantic_edit_op_${idFragment([input.id ?? 'semantic_edit', anchorKey, index].join(':'))}`,
     kind,
     changeKind: region.changeKind,
     anchor,
+    insertion: semanticEditInsertionAnchor(region, context),
     ...identity,
     spans: compactRecord({
       base: baseSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.before?.sourceSpan,

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

@@ -16,6 +16,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const transformContext={sourceLanguage:options.sourceLanguage??source.sourceLanguage??source.language,targetLanguage:options.targetLanguage??source.targetLanguage};
   const semanticTransformIdentities=normalizeSemanticTransformIdentityRecords(semanticTransformInputs(source,options),transformContext);
   const semanticTransformIndex=semanticTransformRecordIndex(semanticTransformIdentities,source);
+  const targetPortability=options.targetPortability??source.targetPortability??source.metadata?.targetPortability??options.metadata?.targetPortability;
   const regionInputs=array(options.changedRegions??source.changedRegions??source.regions);
   const sourceMapLinks=normalizeSourceMapLinks([
     ...array(options.sourceMapLinks??source.sourceMapLinks),
@@ -50,7 +51,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     ??`semantic_patch_bundle_${idFragment(firstString(source.id,patchId,mergeCandidateId,source.sourcePath,source.language,'record'))}`;
   const language=options.language??source.language??mergeCandidate?.language??sources.find((item)=>item.language)?.language;
   const sourcePath=options.sourcePath??source.sourcePath??mergeCandidate?.sourcePath??sources.find((item)=>item.sourcePath)?.sourcePath;
-  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditIndex,semanticTransformIndex});
+  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditIndex,semanticTransformIndex,targetPortability});
   return{
     kind:'frontier.lang.semanticPatchBundleRecord',
     version:1,
@@ -85,6 +86,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
       semanticMergeConflictSummary:source.metadata?.semanticMergeConflictSummary,
       semanticEditSummary:semanticEditSummary(semanticEditIndex),
       semanticTransformSummary:semanticTransformSummary(semanticTransformIndex),
+      targetPortability,
       ...options.metadata
     })
   };
@@ -154,11 +156,12 @@ function normalizeRegions(regions,context){
       sourceMapIds:uniqueStrings([...strings(region.sourceMapIds),...links.map((link)=>link.sourceMapId)]),
       sourceMapMappingIds:uniqueStrings([...strings(region.sourceMapMappingIds),...links.map((link)=>link.sourceMapMappingId)]),
       admission:compactRecord({
-        readiness:projection?.admission?.readiness,
-        action:projection?.admission?.action,
-        reasonCodes:uniqueStrings(projection?.admission?.reasons),
-        conflictKeys:uniqueStrings(projection?.admission?.conflictKeys)
-      })
+        readiness:projection?.admission?.readiness??region.admission?.readiness,
+        action:projection?.admission?.action??region.admission?.action,
+        reasonCodes:uniqueStrings([...strings(region.admission?.reasonCodes),...strings(projection?.admission?.reasons)]),
+        conflictKeys:uniqueStrings([...strings(region.admission?.conflictKeys),...strings(projection?.admission?.conflictKeys)])
+      }),
+      metadata:region.metadata
     });
   });
 }
@@ -229,6 +232,9 @@ function recordIndex(parts){
     transformTargetLanguages:semanticTransformIndex.transformTargetLanguages,
     transformSourcePaths:semanticTransformIndex.transformSourcePaths,
     transformTargetPaths:semanticTransformIndex.transformTargetPaths,
+    targetPortabilityStatuses:uniqueStrings([parts.targetPortability?.status]),
+    targetPortabilityActions:uniqueStrings([parts.targetPortability?.action]),
+    targetPortabilityReasonCodes:uniqueStrings(parts.targetPortability?.reasonCodes),
     patchIds:uniqueStrings([parts.patchId]),
     mergeCandidateIds:uniqueStrings([parts.mergeCandidateId]),
     readinesses:uniqueStrings([parts.admission.readiness,...parts.changedRegions.map((region)=>region.admission?.readiness)]),
@@ -237,7 +243,7 @@ function recordIndex(parts){
 }
 
 function matchesRecord(record,query){
-  const index=record.index??recordIndex({...record,baseHash:record.baseHash,targetHash:record.targetHash,sources:record.sources??[],changedRegions:record.changedRegions??[],sourceMapLinks:record.sourceMapLinks??[],evidenceIds:record.evidenceIds??[],proofIds:record.proofIds??[],historyIds:record.historyIds??[],semanticOperationIds:record.semanticOperationIds??[],patchId:record.patchId,mergeCandidateId:record.mergeCandidateId,admission:record.admission??{}});
+  const index=record.index??recordIndex({...record,baseHash:record.baseHash,targetHash:record.targetHash,sources:record.sources??[],changedRegions:record.changedRegions??[],sourceMapLinks:record.sourceMapLinks??[],evidenceIds:record.evidenceIds??[],proofIds:record.proofIds??[],historyIds:record.historyIds??[],semanticOperationIds:record.semanticOperationIds??[],patchId:record.patchId,mergeCandidateId:record.mergeCandidateId,admission:record.admission??{},targetPortability:record.metadata?.targetPortability});
   return matchAny(queryValues(query.id,query.ids),[record.id])
     &&matchAny(queryValues(query.patchId,query.patchIds),index.patchIds)
     &&matchAny(queryValues(query.mergeCandidateId,query.mergeCandidateIds),index.mergeCandidateIds)
@@ -278,6 +284,9 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.transformTargetLanguage,query.transformTargetLanguages),index.transformTargetLanguages)
     &&matchAny(queryValues(query.transformSourcePath,query.transformSourcePaths),index.transformSourcePaths)
     &&matchAny(queryValues(query.transformTargetPath,query.transformTargetPaths),index.transformTargetPaths)
+    &&matchAny(queryValues(query.targetPortabilityStatus,query.targetPortabilityStatuses),index.targetPortabilityStatuses)
+    &&matchAny(queryValues(query.targetPortabilityAction,query.targetPortabilityActions),index.targetPortabilityActions)
+    &&matchAny(queryValues(query.targetPortabilityReasonCode,query.targetPortabilityReasonCodes),index.targetPortabilityReasonCodes)
     &&matchAny(queryValues(query.readiness,query.readinesses),index.readinesses)
     &&matchAny(queryValues(query.admissionStatus,query.admissionStatuses),index.admissionStatuses);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.94",
+  "version": "0.2.96",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",