@shapeshift-labs/frontier-lang-compiler 0.2.86 → 0.2.88

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

@@ -0,0 +1,112 @@
+import type { SemanticPatchBundleRecord } from './semantic-patch-bundle.js';
+
+export type SemanticPatchBundleOverlapKind =
+  | 'operation-content'
+  | 'edit-content'
+  | 'semantic-edit-key'
+  | 'semantic-identity'
+  | 'source-identity'
+  | 'region'
+  | 'conflict-key'
+  | 'source-path'
+  | string;
+
+export type SemanticPatchBundleOverlapStatus =
+  | 'duplicate'
+  | 'semantic-overlap'
+  | 'source-overlap'
+  | 'independent'
+  | string;
+
+export interface SemanticPatchBundleOverlapShared {
+  readonly operationContentHashes: readonly string[];
+  readonly editContentHashes: readonly string[];
+  readonly semanticEditKeys: readonly string[];
+  readonly semanticIdentityHashes: readonly string[];
+  readonly sourceIdentityHashes: readonly string[];
+  readonly regionKeys: readonly string[];
+  readonly conflictKeys: readonly string[];
+  readonly sourcePaths: readonly string[];
+  readonly baseHashes: readonly string[];
+  readonly targetHashes: readonly string[];
+}
+
+export interface SemanticPatchBundleOverlapAdmission {
+  readonly status: SemanticPatchBundleOverlapStatus;
+  readonly reviewRequired: boolean;
+  readonly autoMergeClaim: false;
+  readonly reasonCodes: readonly string[];
+  readonly sharedKeyCount: number;
+}
+
+export interface SemanticPatchBundleOverlapRecord {
+  readonly kind: 'frontier.lang.semanticPatchBundleOverlapRecord';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.semanticPatchBundleOverlapRecord.v1';
+  readonly id: string;
+  readonly leftBundleId: string;
+  readonly rightBundleId: string;
+  readonly overlapKinds: readonly SemanticPatchBundleOverlapKind[];
+  readonly shared: SemanticPatchBundleOverlapShared;
+  readonly admission: SemanticPatchBundleOverlapAdmission;
+  readonly score: number;
+  readonly summary: {
+    readonly sharedKeys: number;
+    readonly duplicateSignals: number;
+    readonly semanticSignals: number;
+    readonly sourceSignals: number;
+    readonly baseHashMismatch: boolean;
+    readonly targetHashMismatch: boolean;
+  };
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface CompareSemanticPatchBundleRecordsOptions {
+  readonly id?: string;
+  readonly includeSourcePaths?: boolean;
+  readonly reviewIndependent?: boolean;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticPatchBundleOverlapQuery {
+  readonly includeIndependent?: boolean;
+  readonly includeSourcePaths?: boolean;
+  readonly reviewIndependent?: boolean;
+  readonly metadata?: Record<string, unknown>;
+  readonly id?: string | readonly string[];
+  readonly ids?: readonly string[];
+  readonly bundleId?: string | readonly string[];
+  readonly bundleIds?: readonly string[];
+  readonly status?: SemanticPatchBundleOverlapStatus | readonly string[];
+  readonly statuses?: readonly string[];
+  readonly admissionStatus?: SemanticPatchBundleOverlapStatus | readonly string[];
+  readonly admissionStatuses?: readonly string[];
+  readonly overlapKind?: SemanticPatchBundleOverlapKind | readonly string[];
+  readonly overlapKinds?: readonly string[];
+  readonly reasonCode?: string | readonly string[];
+  readonly reasonCodes?: readonly string[];
+  readonly sourcePath?: string | readonly string[];
+  readonly sourcePaths?: readonly string[];
+  readonly conflictKey?: string | readonly string[];
+  readonly conflictKeys?: readonly string[];
+  readonly semanticEditKey?: string | readonly string[];
+  readonly semanticEditKeys?: readonly string[];
+  readonly operationContentHash?: string | readonly string[];
+  readonly operationContentHashes?: readonly string[];
+  readonly editContentHash?: string | readonly string[];
+  readonly editContentHashes?: readonly string[];
+  readonly reviewRequired?: boolean;
+  readonly minScore?: number;
+}
+
+export declare const SemanticPatchBundleOverlapKinds: readonly SemanticPatchBundleOverlapKind[];
+export declare const SemanticPatchBundleOverlapStatuses: readonly SemanticPatchBundleOverlapStatus[];
+export declare function compareSemanticPatchBundleRecords(
+  left?: SemanticPatchBundleRecord | Record<string, unknown>,
+  right?: SemanticPatchBundleRecord | Record<string, unknown>,
+  options?: CompareSemanticPatchBundleRecordsOptions
+): SemanticPatchBundleOverlapRecord;
+export declare function querySemanticPatchBundleOverlaps(
+  records: SemanticPatchBundleRecord | readonly SemanticPatchBundleRecord[],
+  query?: SemanticPatchBundleOverlapQuery
+): readonly SemanticPatchBundleOverlapRecord[];

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

@@ -7,6 +7,7 @@ import type {
   SourceSpan
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { NativeSourceChangeKind, NativeSourceChangeSet } from './native-diff.js';
+import type { SemanticEditProjection, SemanticEditScript } from './semantic-edit-script.js';
 
 export type SemanticPatchBundleAdmissionStatus = 'proposed' | 'queued' | 'admitted' | 'needs-review' | 'blocked' | 'rejected' | string;
 
@@ -102,6 +103,13 @@ export interface SemanticPatchBundleRecordIndex {
   readonly proofIds: readonly string[];
   readonly historyIds: readonly string[];
   readonly semanticOperationIds: readonly string[];
+  readonly semanticEditScriptIds: readonly string[];
+  readonly semanticEditProjectionIds: readonly string[];
+  readonly semanticEditKeys: readonly string[];
+  readonly semanticIdentityHashes: readonly string[];
+  readonly sourceIdentityHashes: readonly string[];
+  readonly operationContentHashes: readonly string[];
+  readonly editContentHashes: readonly string[];
   readonly patchIds: readonly string[];
   readonly mergeCandidateIds: readonly string[];
   readonly readinesses: readonly string[];
@@ -127,6 +135,8 @@ export interface SemanticPatchBundleRecord {
   readonly proofIds: readonly string[];
   readonly historyIds: readonly string[];
   readonly semanticOperationIds: readonly string[];
+  readonly semanticEditScriptIds: readonly string[];
+  readonly semanticEditProjectionIds: readonly string[];
   readonly admission: SemanticPatchBundleAdmission;
   readonly index: SemanticPatchBundleRecordIndex;
   readonly summary: {
@@ -136,6 +146,9 @@ export interface SemanticPatchBundleRecord {
     readonly proofIds: number;
     readonly historyIds: number;
     readonly semanticOperations: number;
+    readonly semanticEditScripts: number;
+    readonly semanticEditProjections: number;
+    readonly semanticEditProjectionEdits: number;
     readonly reviewRequired: boolean;
     readonly autoMergeClaim: false;
   };
@@ -164,6 +177,10 @@ export interface CreateSemanticPatchBundleRecordOptions {
   readonly historyIds?: readonly string[] | string;
   readonly semanticOperationId?: string;
   readonly semanticOperationIds?: readonly string[] | string;
+  readonly semanticEditScript?: SemanticEditScript;
+  readonly semanticEditScripts?: readonly SemanticEditScript[] | SemanticEditScript;
+  readonly semanticEditProjection?: SemanticEditProjection;
+  readonly semanticEditProjections?: readonly SemanticEditProjection[] | SemanticEditProjection;
   readonly conflictKeys?: readonly string[] | string;
   readonly admission?: Partial<SemanticPatchBundleAdmission>;
   readonly metadata?: Record<string, unknown>;
@@ -206,6 +223,20 @@ export interface SemanticPatchBundleRecordQuery {
   readonly historyIds?: readonly string[];
   readonly semanticOperationId?: string | readonly string[];
   readonly semanticOperationIds?: readonly string[];
+  readonly semanticEditScriptId?: string | readonly string[];
+  readonly semanticEditScriptIds?: readonly string[];
+  readonly semanticEditProjectionId?: string | readonly string[];
+  readonly semanticEditProjectionIds?: readonly string[];
+  readonly semanticEditKey?: string | readonly string[];
+  readonly semanticEditKeys?: readonly string[];
+  readonly semanticIdentityHash?: string | readonly string[];
+  readonly semanticIdentityHashes?: readonly string[];
+  readonly sourceIdentityHash?: string | readonly string[];
+  readonly sourceIdentityHashes?: readonly string[];
+  readonly operationContentHash?: string | readonly string[];
+  readonly operationContentHashes?: readonly string[];
+  readonly editContentHash?: string | readonly string[];
+  readonly editContentHashes?: readonly string[];
   readonly readiness?: SemanticMergeReadiness | string | readonly string[];
   readonly readinesses?: readonly string[];
   readonly admissionStatus?: SemanticPatchBundleAdmissionStatus | readonly string[];

package/dist/index.d.ts

@@ -20,6 +20,7 @@ export * from './declarations/semantic-edit-script.js';
 export * from './declarations/semantic-lineage.js';
 export * from './declarations/semantic-history.js';
 export * from './declarations/semantic-patch-bundle.js';
+export * from './declarations/semantic-patch-bundle-overlaps.js';
 export * from './declarations/bidirectional-target-change.js';
 export * from './declarations/semantic-impact.js';
 export * from './declarations/semantic-sidecar.js';

package/dist/index.js

@@ -67,6 +67,7 @@ export { projectNativeImportToSource } from './internal/index-impl/projectNative
 export { queryNativeParserFeatureMatrix } from './internal/index-impl/queryNativeParserFeatureMatrix.js';
 export { queryProjectionReadinessMatrix } from './internal/index-impl/queryProjectionReadinessMatrix.js';
 export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, SemanticPatchBundleAdmissionStatuses } from './internal/index-impl/semanticPatchBundleRecords.js';
+export { compareSemanticPatchBundleRecords, querySemanticPatchBundleOverlaps, SemanticPatchBundleOverlapKinds, SemanticPatchBundleOverlapStatuses } from './internal/index-impl/semanticPatchBundleOverlaps.js';
 export { createSemanticMergeCandidateAdmissionRecord, decorateSemanticMergeCandidateForAdmission, querySemanticMergeCandidateAdmissionOverlaps, SemanticMergeCandidateProjectionRisks, semanticMergeCandidateReadinessSortKey, sortSemanticMergeCandidateAdmissionRecords } from './internal/index-impl/semanticMergeCandidateRecords.js';
 export { querySemanticMergeConflictClasses, SemanticMergeConflictClasses, semanticMergeConflictRiskScore, sortSemanticMergeCandidatesByConflictRisk, summarizeSemanticMergeConflicts } from './internal/index-impl/semanticMergeConflicts.js';
 export { createSemanticEditScript, SemanticEditScriptAdmissionStatuses } from './internal/index-impl/semanticEditScripts.js';

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

@@ -0,0 +1,173 @@
+import{idFragment,uniqueStrings as uniqueRawStrings}from'../../native-import-utils.js';
+
+export const SemanticPatchBundleOverlapKinds=Object.freeze([
+  'operation-content',
+  'edit-content',
+  'semantic-edit-key',
+  'semantic-identity',
+  'source-identity',
+  'region',
+  'conflict-key',
+  'source-path'
+]);
+
+export const SemanticPatchBundleOverlapStatuses=Object.freeze([
+  'duplicate',
+  'semantic-overlap',
+  'source-overlap',
+  'independent'
+]);
+
+const KIND_FIELDS=Object.freeze({
+  'operation-content':'operationContentHashes',
+  'edit-content':'editContentHashes',
+  'semantic-edit-key':'semanticEditKeys',
+  'semantic-identity':'semanticIdentityHashes',
+  'source-identity':'sourceIdentityHashes',
+  region:'regionKeys',
+  'conflict-key':'conflictKeys',
+  'source-path':'sourcePaths'
+});
+
+export function compareSemanticPatchBundleRecords(left={},right={},options={}){
+  const leftIndex=bundleIndex(left);
+  const rightIndex=bundleIndex(right);
+  const shared=sharedIndex(leftIndex,rightIndex,options);
+  const overlapKinds=SemanticPatchBundleOverlapKinds
+    .filter((kind)=>shared[KIND_FIELDS[kind]]?.length);
+  const admission=overlapAdmission(shared,{leftIndex,rightIndex,options});
+  return{
+    kind:'frontier.lang.semanticPatchBundleOverlapRecord',
+    version:1,
+    schema:'frontier.lang.semanticPatchBundleOverlapRecord.v1',
+    id:options.id??`semantic_patch_bundle_overlap_${idFragment(left?.id??'left')}_${idFragment(right?.id??'right')}`,
+    leftBundleId:String(left?.id??'left'),
+    rightBundleId:String(right?.id??'right'),
+    overlapKinds,
+    shared,
+    admission,
+    score:overlapScore(admission.status,shared,admission.reasonCodes),
+    summary:{
+      sharedKeys:countShared(shared),
+      duplicateSignals:shared.operationContentHashes.length+shared.editContentHashes.length,
+      semanticSignals:shared.semanticEditKeys.length+shared.semanticIdentityHashes.length+shared.sourceIdentityHashes.length,
+      sourceSignals:shared.regionKeys.length+shared.conflictKeys.length+shared.sourcePaths.length,
+      baseHashMismatch:admission.reasonCodes.includes('base-hash-mismatch'),
+      targetHashMismatch:admission.reasonCodes.includes('target-hash-mismatch')
+    },
+    metadata:compactRecord(options.metadata)
+  };
+}
+
+export function querySemanticPatchBundleOverlaps(records,query={}){
+  const list=array(records).filter(Boolean);
+  const result=[];
+  const compareOptions={
+    includeSourcePaths:query.includeSourcePaths,
+    reviewIndependent:query.reviewIndependent,
+    metadata:query.metadata
+  };
+  for(let leftIndex=0;leftIndex<list.length;leftIndex+=1){
+    for(let rightIndex=leftIndex+1;rightIndex<list.length;rightIndex+=1){
+      const overlap=compareSemanticPatchBundleRecords(list[leftIndex],list[rightIndex],compareOptions);
+      if(matchesOverlap(overlap,query))result.push(overlap);
+    }
+  }
+  return result.sort((left,right)=>right.score-left.score||left.leftBundleId.localeCompare(right.leftBundleId)
+    ||left.rightBundleId.localeCompare(right.rightBundleId));
+}
+
+function sharedIndex(left,right,options){
+  return{
+    operationContentHashes:intersect(left.operationContentHashes,right.operationContentHashes),
+    editContentHashes:intersect(left.editContentHashes,right.editContentHashes),
+    semanticEditKeys:intersect(left.semanticEditKeys,right.semanticEditKeys),
+    semanticIdentityHashes:intersect(left.semanticIdentityHashes,right.semanticIdentityHashes),
+    sourceIdentityHashes:intersect(left.sourceIdentityHashes,right.sourceIdentityHashes),
+    regionKeys:intersect(left.regionKeys,right.regionKeys),
+    conflictKeys:intersect(left.conflictKeys,right.conflictKeys),
+    sourcePaths:options.includeSourcePaths===false?[]:intersect(left.sourcePaths,right.sourcePaths),
+    baseHashes:intersect(left.baseHashes,right.baseHashes),
+    targetHashes:intersect(left.targetHashes,right.targetHashes)
+  };
+}
+
+function overlapAdmission(shared,{leftIndex,rightIndex,options}){
+  const duplicate=shared.operationContentHashes.length||shared.editContentHashes.length;
+  const semantic=shared.semanticEditKeys.length||shared.semanticIdentityHashes.length||shared.sourceIdentityHashes.length;
+  const source=shared.regionKeys.length||shared.conflictKeys.length||shared.sourcePaths.length;
+  const status=duplicate?'duplicate':semantic?'semantic-overlap':source?'source-overlap':'independent';
+  const reasonCodes=uniqueStrings([
+    shared.operationContentHashes.length?'same-operation-content':undefined,
+    shared.editContentHashes.length?'same-edit-content':undefined,
+    shared.semanticEditKeys.length?'same-semantic-edit-key':undefined,
+    shared.semanticIdentityHashes.length?'same-semantic-identity':undefined,
+    shared.sourceIdentityHashes.length?'same-source-identity':undefined,
+    shared.regionKeys.length?'same-region-key':undefined,
+    shared.conflictKeys.length?'same-conflict-key':undefined,
+    shared.sourcePaths.length?'same-source-path':undefined,
+    status!=='independent'&&disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)?'base-hash-mismatch':undefined,
+    status!=='independent'&&disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes)?'target-hash-mismatch':undefined
+  ]);
+  return{
+    status,
+    reviewRequired:options.reviewIndependent?true:status!=='independent',
+    autoMergeClaim:false,
+    reasonCodes,
+    sharedKeyCount:countShared(shared)
+  };
+}
+
+function bundleIndex(record){
+  const index=record?.index??{};
+  return{
+    baseHashes:uniqueStrings([record?.baseHash,...strings(index.baseHashes)]),
+    targetHashes:uniqueStrings([record?.targetHash,...strings(index.targetHashes)]),
+    sourcePaths:uniqueStrings([record?.sourcePath,...strings(index.sourcePaths)]),
+    regionKeys:uniqueStrings(index.regionKeys),
+    conflictKeys:uniqueStrings(index.conflictKeys),
+    semanticEditKeys:uniqueStrings(index.semanticEditKeys),
+    semanticIdentityHashes:uniqueStrings(index.semanticIdentityHashes),
+    sourceIdentityHashes:uniqueStrings(index.sourceIdentityHashes),
+    operationContentHashes:uniqueStrings(index.operationContentHashes),
+    editContentHashes:uniqueStrings(index.editContentHashes)
+  };
+}
+
+function matchesOverlap(overlap,query){
+  const statusFilters=queryValues(query.status,query.statuses,query.admissionStatus,query.admissionStatuses);
+  const includeIndependent=query.includeIndependent===true||statusFilters.includes('independent');
+  if(!includeIndependent&&overlap.admission.status==='independent')return false;
+  return matchAny(queryValues(query.id,query.ids),[overlap.id])
+    &&matchAny(queryValues(query.bundleId,query.bundleIds),[overlap.leftBundleId,overlap.rightBundleId])
+    &&matchAny(statusFilters,[overlap.admission.status])
+    &&matchAny(queryValues(query.overlapKind,query.overlapKinds),overlap.overlapKinds)
+    &&matchAny(queryValues(query.reasonCode,query.reasonCodes),overlap.admission.reasonCodes)
+    &&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.operationContentHash,query.operationContentHashes),overlap.shared.operationContentHashes)
+    &&matchAny(queryValues(query.editContentHash,query.editContentHashes),overlap.shared.editContentHashes)
+    &&(query.reviewRequired===undefined||overlap.admission.reviewRequired===query.reviewRequired)
+    &&(query.minScore===undefined||overlap.score>=Number(query.minScore));
+}
+
+function overlapScore(status,shared,reasonCodes){
+  const base=status==='duplicate'?100:status==='semantic-overlap'?75:status==='source-overlap'?35:0;
+  const sharedBonus=Math.min(20,countShared(shared));
+  const stalePenalty=reasonCodes.includes('base-hash-mismatch')||reasonCodes.includes('target-hash-mismatch')?15:0;
+  return Math.max(0,base+sharedBonus-stalePenalty);
+}
+
+function countShared(shared){
+  return Object.values(shared).reduce((total,values)=>total+(Array.isArray(values)?values.length:0),0);
+}
+
+function intersect(left,right){const rightSet=new Set(right??[]);return uniqueStrings((left??[]).filter((value)=>rightSet.has(value)));}
+function disjointNonEmpty(left,right){return Boolean(left?.length&&right?.length&&intersect(left,right).length===0);}
+function queryValues(...values){return uniqueStrings(values.flatMap((value)=>strings(value)));}
+function matchAny(filters,values){if(filters.length===0)return true;const valueSet=new Set(strings(values));return filters.some((filter)=>valueSet.has(filter));}
+function array(value){if(value===undefined||value===null)return[];return Array.isArray(value)?value:[value];}
+function strings(value){return array(value).map((entry)=>String(entry??'')).filter(Boolean);}
+function uniqueStrings(values){return uniqueRawStrings((values??[]).filter((entry)=>entry!==undefined&&entry!==null&&String(entry)!==''));}
+function compactRecord(value){return Object.fromEntries(Object.entries(value??{}).filter(([,entry])=>entry!==undefined&&(!Array.isArray(entry)||entry.length>0)));}

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

@@ -6,6 +6,9 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const source=input?.changeSet??input;
   const patch=options.patch??source.patch??source.semanticPatch??source.patchBundle;
   const mergeCandidate=options.mergeCandidate??source.mergeCandidate??source.candidate;
+  const semanticEditScripts=array(options.semanticEditScripts??source.semanticEditScripts??source.semanticEditScript);
+  const semanticEditProjections=array(options.semanticEditProjections??source.semanticEditProjections??source.semanticEditProjection);
+  const semanticEditIndex=semanticEditRecordIndex(semanticEditScripts,semanticEditProjections,source);
   const regionInputs=array(options.changedRegions??source.changedRegions??source.regions);
   const sourceMapLinks=normalizeSourceMapLinks([
     ...array(options.sourceMapLinks??source.sourceMapLinks),
@@ -17,7 +20,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     sourceRef(source.before,'before',source.beforeHash),
     sourceRef(source.after,'after',source.afterHash)
   ],source);
-  const evidenceRecords=[...array(options.evidence??source.evidence),...array(patch?.evidence),...array(mergeCandidate?.evidence)];
+  const evidenceRecords=[...array(options.evidence??source.evidence),...array(patch?.evidence),...array(mergeCandidate?.evidence),...semanticEditScripts.flatMap((script)=>array(script.evidence))];
   const patchId=firstString(options.patchId,source.patchId,patch?.id,mergeCandidate?.patchId);
   const mergeCandidateId=firstString(options.mergeCandidateId,source.mergeCandidateId,mergeCandidate?.id);
   const baseHash=firstString(options.baseHash,source.baseHash,source.beforeHash,patch?.baseHash,mergeCandidate?.baseHash,...sources.map((item)=>item.baseHash));
@@ -27,7 +30,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const evidenceIds=uniqueStrings([...strings(options.evidenceIds),...strings(source.evidenceIds),...evidenceRecords.map((record)=>record?.id),...strings(mergeCandidate?.evidenceIds)]);
   const proofIds=uniqueStrings([...strings(options.proofIds),...strings(source.proofIds),...evidenceRecords.filter((record)=>record?.kind==='proof').map((record)=>record.id),...strings(mergeCandidate?.proofIds)]);
   const historyIds=uniqueStrings([...strings(options.historyIds),...strings(options.historyId),...strings(source.historyIds),...strings(source.historyId)]);
-  const semanticOperationIds=uniqueStrings([...strings(options.semanticOperationIds),...strings(options.semanticOperationId),...strings(source.semanticOperationIds),...strings(source.semanticOperationId),...strings(patch?.semanticOperationIds),...strings(mergeCandidate?.semanticOperationIds)]);
+  const semanticOperationIds=uniqueStrings([...strings(options.semanticOperationIds),...strings(options.semanticOperationId),...strings(source.semanticOperationIds),...strings(source.semanticOperationId),...strings(patch?.semanticOperationIds),...strings(mergeCandidate?.semanticOperationIds),...semanticEditIndex.semanticEditOperationIds]);
   const conflictKeys=uniqueStrings([
     ...strings(options.conflictKeys),
     ...strings(source.conflictKeys),
@@ -40,7 +43,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});
+  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditIndex});
   return{
     kind:'frontier.lang.semanticPatchBundleRecord',
     version:1,
@@ -60,15 +63,18 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     proofIds,
     historyIds,
     semanticOperationIds,
+    semanticEditScriptIds:semanticEditIndex.semanticEditScriptIds,
+    semanticEditProjectionIds:semanticEditIndex.semanticEditProjectionIds,
     admission,
     index,
-    summary:{changedRegions:changedRegions.length,sourceMapLinks:sourceMapLinks.length,evidenceIds:evidenceIds.length,proofIds:proofIds.length,historyIds:historyIds.length,semanticOperations:semanticOperationIds.length,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
+    summary:{changedRegions:changedRegions.length,sourceMapLinks:sourceMapLinks.length,evidenceIds:evidenceIds.length,proofIds:proofIds.length,historyIds:historyIds.length,semanticOperations:semanticOperationIds.length,semanticEditScripts:semanticEditScripts.length,semanticEditProjections:semanticEditProjections.length,semanticEditProjectionEdits:semanticEditIndex.semanticEditProjectionEditCount,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
     metadata:compactRecord({
       sourceChangeSetId:source.kind==='frontier.lang.nativeSourceChangeSet'?source.id:undefined,
       patchRisk:patch?.risk,
       nativeChangeSummary:source.summary,
       changedRegionProjectionSummary:source.metadata?.changedRegionProjectionSummary,
       semanticMergeConflictSummary:source.metadata?.semanticMergeConflictSummary,
+      semanticEditSummary:semanticEditSummary(semanticEditIndex),
       ...options.metadata
     })
   };
@@ -190,14 +196,15 @@ function normalizeAdmission(input={},context){
 }
 
 function recordIndex(parts){
+  const semanticEditIndex=parts.semanticEditIndex??semanticEditRecordIndex([],[]);
   return{
     baseHashes:uniqueStrings([parts.baseHash,...parts.sources.map((item)=>item.baseHash)]),
     targetHashes:uniqueStrings([parts.targetHash,...parts.sources.map((item)=>item.targetHash)]),
     sourceHashes:uniqueStrings(parts.sources.map((item)=>item.sourceHash)),
-    sourcePaths:uniqueStrings(parts.sources.map((item)=>item.sourcePath)),
-    regionKeys:uniqueStrings(parts.changedRegions.map((region)=>region.key)),
+    sourcePaths:uniqueStrings([...parts.sources.map((item)=>item.sourcePath),...semanticEditIndex.projectedSourcePaths]),
+    regionKeys:uniqueStrings([...parts.changedRegions.map((region)=>region.key),...semanticEditIndex.anchorKeys]),
     regionKinds:uniqueStrings(parts.changedRegions.map((region)=>region.regionKind)),
-    conflictKeys:uniqueStrings(parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)])),
+    conflictKeys:uniqueStrings([...parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),...semanticEditIndex.conflictKeys]),
     sourceMapIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapId),...parts.changedRegions.flatMap((region)=>region.sourceMapIds??[])]),
     sourceMapMappingIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapMappingId),...parts.changedRegions.flatMap((region)=>region.sourceMapMappingIds??[])]),
     sourceMapLinkIds:uniqueStrings(parts.sourceMapLinks.map((link)=>link.id)),
@@ -205,6 +212,13 @@ function recordIndex(parts){
     proofIds:parts.proofIds,
     historyIds:parts.historyIds,
     semanticOperationIds:uniqueStrings(parts.semanticOperationIds),
+    semanticEditScriptIds:semanticEditIndex.semanticEditScriptIds,
+    semanticEditProjectionIds:semanticEditIndex.semanticEditProjectionIds,
+    semanticEditKeys:semanticEditIndex.semanticEditKeys,
+    semanticIdentityHashes:semanticEditIndex.semanticIdentityHashes,
+    sourceIdentityHashes:semanticEditIndex.sourceIdentityHashes,
+    operationContentHashes:semanticEditIndex.operationContentHashes,
+    editContentHashes:semanticEditIndex.editContentHashes,
     patchIds:uniqueStrings([parts.patchId]),
     mergeCandidateIds:uniqueStrings([parts.mergeCandidateId]),
     readinesses:uniqueStrings([parts.admission.readiness,...parts.changedRegions.map((region)=>region.admission?.readiness)]),
@@ -231,11 +245,48 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.proofId,query.proofIds),index.proofIds)
     &&matchAny(queryValues(query.historyId,query.historyIds),index.historyIds)
     &&matchAny(queryValues(query.semanticOperationId,query.semanticOperationIds),index.semanticOperationIds)
+    &&matchAny(queryValues(query.semanticEditScriptId,query.semanticEditScriptIds),index.semanticEditScriptIds)
+    &&matchAny(queryValues(query.semanticEditProjectionId,query.semanticEditProjectionIds),index.semanticEditProjectionIds)
+    &&matchAny(queryValues(query.semanticEditKey,query.semanticEditKeys),index.semanticEditKeys)
+    &&matchAny(queryValues(query.semanticIdentityHash,query.semanticIdentityHashes),index.semanticIdentityHashes)
+    &&matchAny(queryValues(query.sourceIdentityHash,query.sourceIdentityHashes),index.sourceIdentityHashes)
+    &&matchAny(queryValues(query.operationContentHash,query.operationContentHashes),index.operationContentHashes)
+    &&matchAny(queryValues(query.editContentHash,query.editContentHashes),index.editContentHashes)
     &&matchAny(queryValues(query.readiness,query.readinesses),index.readinesses)
     &&matchAny(queryValues(query.admissionStatus,query.admissionStatuses),index.admissionStatuses);
 }
 
 function admissionStatusForReadiness(readiness){return readiness==='blocked'?'blocked':readiness==='needs-review'?'needs-review':'proposed';}
+function semanticEditRecordIndex(scripts,projections,source={}){
+  const operations=scripts.flatMap((script)=>array(script.operations));
+  const edits=projections.flatMap((projection)=>array(projection.edits));
+  const index=source.index??{};
+  return{
+    semanticEditScriptIds:uniqueStrings([...strings(source.semanticEditScriptIds),...strings(source.semanticEditScriptId),...strings(index.semanticEditScriptIds),...scripts.map((script)=>script.id)]),
+    semanticEditProjectionIds:uniqueStrings([...strings(source.semanticEditProjectionIds),...strings(source.semanticEditProjectionId),...strings(index.semanticEditProjectionIds),...projections.map((projection)=>projection.id)]),
+    semanticEditOperationIds:uniqueStrings([...strings(source.semanticOperationIds),...strings(index.semanticOperationIds),...operations.map((operation)=>operation.id)]),
+    semanticEditProjectionEditCount:edits.length,
+    semanticEditKeys:uniqueStrings([...strings(source.semanticEditKeys),...strings(index.semanticEditKeys),...operations.map((operation)=>operation.semanticKey),...edits.map((edit)=>edit.semanticKey)]),
+    semanticIdentityHashes:uniqueStrings([...strings(source.semanticIdentityHashes),...strings(index.semanticIdentityHashes),...operations.map((operation)=>operation.semanticIdentityHash),...edits.map((edit)=>edit.semanticIdentityHash)]),
+    sourceIdentityHashes:uniqueStrings([...strings(source.sourceIdentityHashes),...strings(index.sourceIdentityHashes),...operations.map((operation)=>operation.sourceIdentityHash),...edits.map((edit)=>edit.sourceIdentityHash)]),
+    operationContentHashes:uniqueStrings([...strings(source.operationContentHashes),...strings(index.operationContentHashes),...operations.map((operation)=>operation.operationContentHash),...edits.map((edit)=>edit.operationContentHash)]),
+    editContentHashes:uniqueStrings([...strings(source.editContentHashes),...strings(index.editContentHashes),...edits.map((edit)=>edit.editContentHash)]),
+    anchorKeys:uniqueStrings([...operations.map((operation)=>operation.anchor?.key),...edits.map((edit)=>edit.anchorKey)]),
+    conflictKeys:uniqueStrings([...operations.map((operation)=>operation.anchor?.conflictKey),...edits.map((edit)=>edit.conflictKey)]),
+    projectedSourcePaths:uniqueStrings([...projections.map((projection)=>projection.sourcePath),...edits.flatMap((edit)=>[edit.sourcePath,edit.targetSourcePath])])
+  };
+}
+function semanticEditSummary(index){
+  if(!index.semanticEditScriptIds.length&&!index.semanticEditProjectionIds.length)return undefined;
+  return compactRecord({
+    scriptIds:index.semanticEditScriptIds,
+    projectionIds:index.semanticEditProjectionIds,
+    semanticEditKeys:index.semanticEditKeys,
+    operationContentHashes:index.operationContentHashes,
+    editContentHashes:index.editContentHashes,
+    projectedSourcePaths:index.projectedSourcePaths
+  });
+}
 function queryValues(...values){return uniqueStrings(values.flatMap((value)=>strings(value)));}
 function matchAny(filters,values){if(filters.length===0)return true;const valueSet=new Set(strings(values));return filters.some((filter)=>valueSet.has(filter));}
 function array(value){if(value===undefined||value===null)return[];return Array.isArray(value)?value:[value];}

package/package.json

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