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

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-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/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.95",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",