@shapeshift-labs/frontier-lang-compiler 0.2.93 → 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-overlaps.d.ts

@@ -6,6 +6,9 @@ export type SemanticPatchBundleOverlapKind =
   | 'semantic-edit-key'
   | 'semantic-identity'
   | 'source-identity'
+  | 'semantic-edit-replay'
+  | 'replay-output'
+  | 'replay-current'
   | 'transform-content'
   | 'semantic-transform'
   | 'projection-identity'
@@ -27,6 +30,11 @@ export interface SemanticPatchBundleOverlapShared {
   readonly semanticEditKeys: readonly string[];
   readonly semanticIdentityHashes: readonly string[];
   readonly sourceIdentityHashes: readonly string[];
+  readonly semanticEditReplayIds: readonly string[];
+  readonly semanticEditReplayStatuses: readonly string[];
+  readonly semanticEditReplayActions: readonly string[];
+  readonly semanticEditReplayCurrentHashes: readonly string[];
+  readonly semanticEditReplayOutputHashes: readonly string[];
   readonly semanticTransformContentHashes: readonly string[];
   readonly semanticTransformIdentityHashes: readonly string[];
   readonly projectionIdentityHashes: readonly string[];
@@ -97,6 +105,16 @@ export interface SemanticPatchBundleOverlapQuery {
   readonly conflictKeys?: readonly string[];
   readonly semanticEditKey?: string | readonly string[];
   readonly semanticEditKeys?: readonly string[];
+  readonly semanticEditReplayId?: string | readonly string[];
+  readonly semanticEditReplayIds?: readonly string[];
+  readonly semanticEditReplayStatus?: string | readonly string[];
+  readonly semanticEditReplayStatuses?: readonly string[];
+  readonly semanticEditReplayAction?: string | readonly string[];
+  readonly semanticEditReplayActions?: readonly string[];
+  readonly semanticEditReplayCurrentHash?: string | readonly string[];
+  readonly semanticEditReplayCurrentHashes?: readonly string[];
+  readonly semanticEditReplayOutputHash?: string | readonly string[];
+  readonly semanticEditReplayOutputHashes?: readonly string[];
   readonly semanticTransformIdentityHash?: string | readonly string[];
   readonly semanticTransformIdentityHashes?: readonly string[];
   readonly semanticTransformContentHash?: string | 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/semanticPatchBundleOverlaps.js

@@ -6,6 +6,9 @@ export const SemanticPatchBundleOverlapKinds=Object.freeze([
   'semantic-edit-key',
   'semantic-identity',
   'source-identity',
+  'semantic-edit-replay',
+  'replay-output',
+  'replay-current',
   'transform-content',
   'semantic-transform',
   'projection-identity',
@@ -27,6 +30,9 @@ const KIND_FIELDS=Object.freeze({
   'semantic-edit-key':'semanticEditKeys',
   'semantic-identity':'semanticIdentityHashes',
   'source-identity':'sourceIdentityHashes',
+  'semantic-edit-replay':'semanticEditReplayIds',
+  'replay-output':'semanticEditReplayOutputHashes',
+  'replay-current':'semanticEditReplayCurrentHashes',
   'transform-content':'semanticTransformContentHashes',
   'semantic-transform':'semanticTransformIdentityHashes',
   'projection-identity':'projectionIdentityHashes',
@@ -55,9 +61,9 @@ export function compareSemanticPatchBundleRecords(left={},right={},options={}){
     score:overlapScore(admission.status,shared,admission.reasonCodes),
     summary:{
       sharedKeys:countShared(shared),
-      duplicateSignals:shared.operationContentHashes.length+shared.editContentHashes.length+shared.semanticTransformContentHashes.length,
+      duplicateSignals:shared.operationContentHashes.length+shared.editContentHashes.length+shared.semanticTransformContentHashes.length+shared.semanticEditReplayIds.length+shared.semanticEditReplayOutputHashes.length,
       semanticSignals:shared.semanticEditKeys.length+shared.semanticIdentityHashes.length+shared.sourceIdentityHashes.length+shared.semanticTransformIdentityHashes.length+shared.projectionIdentityHashes.length,
-      sourceSignals:shared.regionKeys.length+shared.conflictKeys.length+shared.sourcePaths.length,
+      sourceSignals:shared.regionKeys.length+shared.conflictKeys.length+shared.sourcePaths.length+shared.semanticEditReplayCurrentHashes.length,
       baseHashMismatch:admission.reasonCodes.includes('base-hash-mismatch'),
       targetHashMismatch:admission.reasonCodes.includes('target-hash-mismatch')
     },
@@ -90,6 +96,11 @@ function sharedIndex(left,right,options){
     semanticEditKeys:intersect(left.semanticEditKeys,right.semanticEditKeys),
     semanticIdentityHashes:intersect(left.semanticIdentityHashes,right.semanticIdentityHashes),
     sourceIdentityHashes:intersect(left.sourceIdentityHashes,right.sourceIdentityHashes),
+    semanticEditReplayIds:intersect(left.semanticEditReplayIds,right.semanticEditReplayIds),
+    semanticEditReplayStatuses:intersect(left.semanticEditReplayStatuses,right.semanticEditReplayStatuses),
+    semanticEditReplayActions:intersect(left.semanticEditReplayActions,right.semanticEditReplayActions),
+    semanticEditReplayCurrentHashes:intersect(left.semanticEditReplayCurrentHashes,right.semanticEditReplayCurrentHashes),
+    semanticEditReplayOutputHashes:intersect(left.semanticEditReplayOutputHashes,right.semanticEditReplayOutputHashes),
     semanticTransformContentHashes:intersect(left.semanticTransformContentHashes,right.semanticTransformContentHashes),
     semanticTransformIdentityHashes:intersect(left.semanticTransformIdentityHashes,right.semanticTransformIdentityHashes),
     projectionIdentityHashes:intersect(left.projectionIdentityHashes,right.projectionIdentityHashes),
@@ -102,9 +113,9 @@ function sharedIndex(left,right,options){
 }
 
 function overlapAdmission(shared,{leftIndex,rightIndex,options}){
-  const duplicate=shared.operationContentHashes.length||shared.editContentHashes.length||shared.semanticTransformContentHashes.length;
+  const duplicate=shared.operationContentHashes.length||shared.editContentHashes.length||shared.semanticTransformContentHashes.length||shared.semanticEditReplayIds.length||shared.semanticEditReplayOutputHashes.length;
   const semantic=shared.semanticEditKeys.length||shared.semanticIdentityHashes.length||shared.sourceIdentityHashes.length||shared.semanticTransformIdentityHashes.length||shared.projectionIdentityHashes.length;
-  const source=shared.regionKeys.length||shared.conflictKeys.length||shared.sourcePaths.length;
+  const source=shared.regionKeys.length||shared.conflictKeys.length||shared.sourcePaths.length||shared.semanticEditReplayCurrentHashes.length;
   const status=duplicate?'duplicate':semantic?'semantic-overlap':source?'source-overlap':'independent';
   const reasonCodes=uniqueStrings([
     shared.operationContentHashes.length?'same-operation-content':undefined,
@@ -113,6 +124,9 @@ function overlapAdmission(shared,{leftIndex,rightIndex,options}){
     shared.semanticEditKeys.length?'same-semantic-edit-key':undefined,
     shared.semanticIdentityHashes.length?'same-semantic-identity':undefined,
     shared.sourceIdentityHashes.length?'same-source-identity':undefined,
+    shared.semanticEditReplayIds.length?'same-semantic-edit-replay':undefined,
+    shared.semanticEditReplayOutputHashes.length?'same-replay-output':undefined,
+    shared.semanticEditReplayCurrentHashes.length?'same-replay-current':undefined,
     shared.semanticTransformIdentityHashes.length?'same-semantic-transform':undefined,
     shared.projectionIdentityHashes.length?'same-projection-identity':undefined,
     shared.regionKeys.length?'same-region-key':undefined,
@@ -141,6 +155,11 @@ function bundleIndex(record){
     semanticEditKeys:uniqueStrings(index.semanticEditKeys),
     semanticIdentityHashes:uniqueStrings(index.semanticIdentityHashes),
     sourceIdentityHashes:uniqueStrings(index.sourceIdentityHashes),
+    semanticEditReplayIds:uniqueStrings(index.semanticEditReplayIds),
+    semanticEditReplayStatuses:uniqueStrings(index.semanticEditReplayStatuses),
+    semanticEditReplayActions:uniqueStrings(index.semanticEditReplayActions),
+    semanticEditReplayCurrentHashes:uniqueStrings(index.semanticEditReplayCurrentHashes),
+    semanticEditReplayOutputHashes:uniqueStrings(index.semanticEditReplayOutputHashes),
     semanticTransformContentHashes:uniqueStrings(index.semanticTransformContentHashes),
     semanticTransformIdentityHashes:uniqueStrings(index.semanticTransformIdentityHashes),
     projectionIdentityHashes:uniqueStrings(index.projectionIdentityHashes),
@@ -161,6 +180,11 @@ function matchesOverlap(overlap,query){
     &&matchAny(queryValues(query.sourcePath,query.sourcePaths),overlap.shared.sourcePaths)
     &&matchAny(queryValues(query.conflictKey,query.conflictKeys),overlap.shared.conflictKeys)
     &&matchAny(queryValues(query.semanticEditKey,query.semanticEditKeys),overlap.shared.semanticEditKeys)
+    &&matchAny(queryValues(query.semanticEditReplayId,query.semanticEditReplayIds),overlap.shared.semanticEditReplayIds)
+    &&matchAny(queryValues(query.semanticEditReplayStatus,query.semanticEditReplayStatuses),overlap.shared.semanticEditReplayStatuses)
+    &&matchAny(queryValues(query.semanticEditReplayAction,query.semanticEditReplayActions),overlap.shared.semanticEditReplayActions)
+    &&matchAny(queryValues(query.semanticEditReplayCurrentHash,query.semanticEditReplayCurrentHashes),overlap.shared.semanticEditReplayCurrentHashes)
+    &&matchAny(queryValues(query.semanticEditReplayOutputHash,query.semanticEditReplayOutputHashes),overlap.shared.semanticEditReplayOutputHashes)
     &&matchAny(queryValues(query.semanticTransformIdentityHash,query.semanticTransformIdentityHashes),overlap.shared.semanticTransformIdentityHashes)
     &&matchAny(queryValues(query.semanticTransformContentHash,query.semanticTransformContentHashes),overlap.shared.semanticTransformContentHashes)
     &&matchAny(queryValues(query.projectionIdentityHash,query.projectionIdentityHashes),overlap.shared.projectionIdentityHashes)

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