@shapeshift-labs/frontier-lang-compiler 0.2.87 → 0.2.89

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

@@ -0,0 +1,124 @@
+import type { SemanticPatchBundleRecord } from './semantic-patch-bundle.js';
+
+export type SemanticPatchBundleOverlapKind =
+  | 'operation-content'
+  | 'edit-content'
+  | 'semantic-edit-key'
+  | 'semantic-identity'
+  | 'source-identity'
+  | 'transform-content'
+  | 'semantic-transform'
+  | 'projection-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 semanticTransformContentHashes: readonly string[];
+  readonly semanticTransformIdentityHashes: readonly string[];
+  readonly projectionIdentityHashes: 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 semanticTransformIdentityHash?: string | readonly string[];
+  readonly semanticTransformIdentityHashes?: readonly string[];
+  readonly semanticTransformContentHash?: string | readonly string[];
+  readonly semanticTransformContentHashes?: readonly string[];
+  readonly projectionIdentityHash?: string | readonly string[];
+  readonly projectionIdentityHashes?: 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

@@ -8,6 +8,7 @@ import type {
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { NativeSourceChangeKind, NativeSourceChangeSet } from './native-diff.js';
 import type { SemanticEditProjection, SemanticEditScript } from './semantic-edit-script.js';
+import type { SemanticTransformIdentityRecord } from './semantic-transform-identity.js';
 
 export type SemanticPatchBundleAdmissionStatus = 'proposed' | 'queued' | 'admitted' | 'needs-review' | 'blocked' | 'rejected' | string;
 
@@ -110,6 +111,15 @@ export interface SemanticPatchBundleRecordIndex {
   readonly sourceIdentityHashes: readonly string[];
   readonly operationContentHashes: readonly string[];
   readonly editContentHashes: readonly string[];
+  readonly semanticTransformIds: readonly string[];
+  readonly semanticTransformKeys: readonly string[];
+  readonly semanticTransformIdentityHashes: readonly string[];
+  readonly semanticTransformContentHashes: readonly string[];
+  readonly projectionIdentityHashes: readonly string[];
+  readonly transformSourceLanguages: readonly string[];
+  readonly transformTargetLanguages: readonly string[];
+  readonly transformSourcePaths: readonly string[];
+  readonly transformTargetPaths: readonly string[];
   readonly patchIds: readonly string[];
   readonly mergeCandidateIds: readonly string[];
   readonly readinesses: readonly string[];
@@ -137,6 +147,7 @@ export interface SemanticPatchBundleRecord {
   readonly semanticOperationIds: readonly string[];
   readonly semanticEditScriptIds: readonly string[];
   readonly semanticEditProjectionIds: readonly string[];
+  readonly semanticTransformIdentityIds: readonly string[];
   readonly admission: SemanticPatchBundleAdmission;
   readonly index: SemanticPatchBundleRecordIndex;
   readonly summary: {
@@ -149,6 +160,7 @@ export interface SemanticPatchBundleRecord {
     readonly semanticEditScripts: number;
     readonly semanticEditProjections: number;
     readonly semanticEditProjectionEdits: number;
+    readonly semanticTransformIdentities: number;
     readonly reviewRequired: boolean;
     readonly autoMergeClaim: false;
   };
@@ -181,6 +193,10 @@ export interface CreateSemanticPatchBundleRecordOptions {
   readonly semanticEditScripts?: readonly SemanticEditScript[] | SemanticEditScript;
   readonly semanticEditProjection?: SemanticEditProjection;
   readonly semanticEditProjections?: readonly SemanticEditProjection[] | SemanticEditProjection;
+  readonly semanticTransformIdentity?: SemanticTransformIdentityRecord | Record<string, unknown>;
+  readonly semanticTransformIdentities?: readonly (SemanticTransformIdentityRecord | Record<string, unknown>)[];
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly targetLanguage?: FrontierSourceLanguage | string;
   readonly conflictKeys?: readonly string[] | string;
   readonly admission?: Partial<SemanticPatchBundleAdmission>;
   readonly metadata?: Record<string, unknown>;
@@ -237,6 +253,24 @@ export interface SemanticPatchBundleRecordQuery {
   readonly operationContentHashes?: readonly string[];
   readonly editContentHash?: string | readonly string[];
   readonly editContentHashes?: readonly string[];
+  readonly semanticTransformId?: string | readonly string[];
+  readonly semanticTransformIds?: readonly string[];
+  readonly semanticTransformKey?: string | readonly string[];
+  readonly semanticTransformKeys?: readonly string[];
+  readonly semanticTransformIdentityHash?: string | readonly string[];
+  readonly semanticTransformIdentityHashes?: readonly string[];
+  readonly semanticTransformContentHash?: string | readonly string[];
+  readonly semanticTransformContentHashes?: readonly string[];
+  readonly projectionIdentityHash?: string | readonly string[];
+  readonly projectionIdentityHashes?: readonly string[];
+  readonly transformSourceLanguage?: string | readonly string[];
+  readonly transformSourceLanguages?: readonly string[];
+  readonly transformTargetLanguage?: string | readonly string[];
+  readonly transformTargetLanguages?: readonly string[];
+  readonly transformSourcePath?: string | readonly string[];
+  readonly transformSourcePaths?: readonly string[];
+  readonly transformTargetPath?: string | readonly string[];
+  readonly transformTargetPaths?: readonly string[];
   readonly readiness?: SemanticMergeReadiness | string | readonly string[];
   readonly readinesses?: readonly string[];
   readonly admissionStatus?: SemanticPatchBundleAdmissionStatus | readonly string[];

package/dist/declarations/semantic-transform-identity.d.ts

@@ -0,0 +1,57 @@
+import type { FrontierSourceLanguage } from '@shapeshift-labs/frontier-lang-kernel';
+
+export interface SemanticTransformIdentityRecord {
+  readonly kind: 'frontier.lang.semanticTransformIdentityRecord';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.semanticTransformIdentityRecord.v1';
+  readonly id: string;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly targetLanguage?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly targetPath?: string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly semanticKey?: string;
+  readonly transformKey?: string;
+  readonly semanticIdentityHash?: string;
+  readonly sourceIdentityHash?: string;
+  readonly operationContentHash?: string;
+  readonly editContentHash?: string;
+  readonly transformIdentityHash?: string;
+  readonly projectionIdentityHash?: string;
+  readonly transformContentHash?: string;
+  readonly readiness?: string;
+  readonly confidence?: number;
+  readonly evidenceIds?: readonly string[];
+  readonly metadata?: {
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+    readonly sourceTransformId?: string;
+    readonly [key: string]: unknown;
+  };
+}
+
+export interface CreateSemanticTransformIdentityRecordOptions extends Partial<SemanticTransformIdentityRecord> {
+  readonly language?: FrontierSourceLanguage | string;
+  readonly projectedLanguage?: FrontierSourceLanguage | string;
+  readonly originalSourcePath?: string;
+  readonly targetSourcePath?: string;
+  readonly projectedSourcePath?: string;
+  readonly symbolName?: string;
+  readonly symbolKind?: string;
+  readonly anchorKey?: string;
+  readonly regionId?: string;
+  readonly operationId?: string;
+}
+
+export type CreateSemanticTransformIdentityRecordInput =
+  | Partial<SemanticTransformIdentityRecord>
+  | Record<string, unknown>;
+
+export declare function createSemanticTransformIdentityRecord(
+  input?: CreateSemanticTransformIdentityRecordInput,
+  options?: CreateSemanticTransformIdentityRecordOptions
+): SemanticTransformIdentityRecord;
+export declare function semanticTransformIdentityFields(
+  record?: SemanticTransformIdentityRecord | Record<string, unknown>
+): SemanticTransformIdentityRecord;

package/dist/index.d.ts

@@ -20,6 +20,8 @@ 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/semantic-transform-identity.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,8 @@ 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 { createSemanticTransformIdentityRecord, semanticTransformIdentityFields } from './internal/index-impl/semanticTransformIdentityRecords.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,191 @@
+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',
+  'transform-content',
+  'semantic-transform',
+  'projection-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',
+  'transform-content':'semanticTransformContentHashes',
+  'semantic-transform':'semanticTransformIdentityHashes',
+  'projection-identity':'projectionIdentityHashes',
+  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+shared.semanticTransformContentHashes.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,
+      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),
+    semanticTransformContentHashes:intersect(left.semanticTransformContentHashes,right.semanticTransformContentHashes),
+    semanticTransformIdentityHashes:intersect(left.semanticTransformIdentityHashes,right.semanticTransformIdentityHashes),
+    projectionIdentityHashes:intersect(left.projectionIdentityHashes,right.projectionIdentityHashes),
+    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||shared.semanticTransformContentHashes.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 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.semanticTransformContentHashes.length?'same-transform-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.semanticTransformIdentityHashes.length?'same-semantic-transform':undefined,
+    shared.projectionIdentityHashes.length?'same-projection-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),
+    semanticTransformContentHashes:uniqueStrings(index.semanticTransformContentHashes),
+    semanticTransformIdentityHashes:uniqueStrings(index.semanticTransformIdentityHashes),
+    projectionIdentityHashes:uniqueStrings(index.projectionIdentityHashes),
+    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.semanticTransformIdentityHash,query.semanticTransformIdentityHashes),overlap.shared.semanticTransformIdentityHashes)
+    &&matchAny(queryValues(query.semanticTransformContentHash,query.semanticTransformContentHashes),overlap.shared.semanticTransformContentHashes)
+    &&matchAny(queryValues(query.projectionIdentityHash,query.projectionIdentityHashes),overlap.shared.projectionIdentityHashes)
+    &&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

@@ -1,4 +1,5 @@
 import{idFragment,normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{normalizeSemanticTransformIdentityRecords,semanticTransformInputs,semanticTransformRecordIndex,semanticTransformSummary}from'./semanticTransformIdentityRecords.js';
 
 export const SemanticPatchBundleAdmissionStatuses=Object.freeze(['proposed','queued','admitted','needs-review','blocked','rejected']);
 
@@ -9,6 +10,9 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   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 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 regionInputs=array(options.changedRegions??source.changedRegions??source.regions);
   const sourceMapLinks=normalizeSourceMapLinks([
     ...array(options.sourceMapLinks??source.sourceMapLinks),
@@ -43,7 +47,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});
+  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditIndex,semanticTransformIndex});
   return{
     kind:'frontier.lang.semanticPatchBundleRecord',
     version:1,
@@ -65,9 +69,10 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     semanticOperationIds,
     semanticEditScriptIds:semanticEditIndex.semanticEditScriptIds,
     semanticEditProjectionIds:semanticEditIndex.semanticEditProjectionIds,
+    semanticTransformIdentityIds:semanticTransformIndex.semanticTransformIds,
     admission,
     index,
-    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},
+    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,semanticTransformIdentities:semanticTransformIdentities.length,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
     metadata:compactRecord({
       sourceChangeSetId:source.kind==='frontier.lang.nativeSourceChangeSet'?source.id:undefined,
       patchRisk:patch?.risk,
@@ -75,6 +80,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
       changedRegionProjectionSummary:source.metadata?.changedRegionProjectionSummary,
       semanticMergeConflictSummary:source.metadata?.semanticMergeConflictSummary,
       semanticEditSummary:semanticEditSummary(semanticEditIndex),
+      semanticTransformSummary:semanticTransformSummary(semanticTransformIndex),
       ...options.metadata
     })
   };
@@ -197,11 +203,12 @@ function normalizeAdmission(input={},context){
 
 function recordIndex(parts){
   const semanticEditIndex=parts.semanticEditIndex??semanticEditRecordIndex([],[]);
+  const semanticTransformIndex=parts.semanticTransformIndex??semanticTransformRecordIndex([],parts);
   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),...semanticEditIndex.projectedSourcePaths]),
+    sourcePaths:uniqueStrings([...parts.sources.map((item)=>item.sourcePath),...semanticEditIndex.projectedSourcePaths,...semanticTransformIndex.transformSourcePaths,...semanticTransformIndex.transformTargetPaths]),
     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)]),...semanticEditIndex.conflictKeys]),
@@ -219,6 +226,15 @@ function recordIndex(parts){
     sourceIdentityHashes:semanticEditIndex.sourceIdentityHashes,
     operationContentHashes:semanticEditIndex.operationContentHashes,
     editContentHashes:semanticEditIndex.editContentHashes,
+    semanticTransformIds:semanticTransformIndex.semanticTransformIds,
+    semanticTransformKeys:semanticTransformIndex.semanticTransformKeys,
+    semanticTransformIdentityHashes:semanticTransformIndex.semanticTransformIdentityHashes,
+    semanticTransformContentHashes:semanticTransformIndex.semanticTransformContentHashes,
+    projectionIdentityHashes:semanticTransformIndex.projectionIdentityHashes,
+    transformSourceLanguages:semanticTransformIndex.transformSourceLanguages,
+    transformTargetLanguages:semanticTransformIndex.transformTargetLanguages,
+    transformSourcePaths:semanticTransformIndex.transformSourcePaths,
+    transformTargetPaths:semanticTransformIndex.transformTargetPaths,
     patchIds:uniqueStrings([parts.patchId]),
     mergeCandidateIds:uniqueStrings([parts.mergeCandidateId]),
     readinesses:uniqueStrings([parts.admission.readiness,...parts.changedRegions.map((region)=>region.admission?.readiness)]),
@@ -252,6 +268,15 @@ function matchesRecord(record,query){
     &&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.semanticTransformId,query.semanticTransformIds),index.semanticTransformIds)
+    &&matchAny(queryValues(query.semanticTransformKey,query.semanticTransformKeys),index.semanticTransformKeys)
+    &&matchAny(queryValues(query.semanticTransformIdentityHash,query.semanticTransformIdentityHashes),index.semanticTransformIdentityHashes)
+    &&matchAny(queryValues(query.semanticTransformContentHash,query.semanticTransformContentHashes),index.semanticTransformContentHashes)
+    &&matchAny(queryValues(query.projectionIdentityHash,query.projectionIdentityHashes),index.projectionIdentityHashes)
+    &&matchAny(queryValues(query.transformSourceLanguage,query.transformSourceLanguages),index.transformSourceLanguages)
+    &&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.readiness,query.readinesses),index.readinesses)
     &&matchAny(queryValues(query.admissionStatus,query.admissionStatuses),index.admissionStatuses);
 }

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

@@ -0,0 +1,127 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings as uniqueRawStrings } from '../../native-import-utils.js';
+import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+
+export function createSemanticTransformIdentityRecord(input = {}, options = {}) {
+  const source = input?.transform ?? input;
+  const merged = { ...source, ...options };
+  const editIdentity = semanticEditIdentityFields(merged);
+  const semanticKey = firstString(merged.semanticKey, editIdentity.semanticKey);
+  const transformKey = firstString(merged.transformKey, semanticTransformKey({ ...merged, semanticKey }));
+  const sourceLanguage = firstString(merged.sourceLanguage, merged.language);
+  const targetLanguage = firstString(merged.targetLanguage, merged.projectedLanguage);
+  const sourcePath = firstString(merged.sourcePath, merged.originalSourcePath);
+  const targetPath = firstString(merged.targetPath, merged.targetSourcePath, merged.projectedSourcePath);
+  const semanticIdentityHash = firstString(merged.semanticIdentityHash, editIdentity.semanticIdentityHash);
+  const sourceIdentityHash = firstString(merged.sourceIdentityHash, editIdentity.sourceIdentityHash);
+  const transformIdentityHash = firstString(merged.transformIdentityHash, hashSemanticValue(compactRecord({
+    transformKey,
+    semanticIdentityHash,
+    sourceLanguage,
+    targetLanguage
+  })));
+  const projectionIdentityHash = firstString(merged.projectionIdentityHash, hashSemanticValue(compactRecord({
+    transformIdentityHash,
+    sourceIdentityHash,
+    sourcePath,
+    targetPath
+  })));
+  const operationContentHash = firstString(merged.operationContentHash);
+  const editContentHash = firstString(merged.editContentHash);
+  const transformContentHash = firstString(
+    merged.transformContentHash,
+    operationContentHash || editContentHash ? hashSemanticValue(compactRecord({ transformIdentityHash, operationContentHash, editContentHash })) : undefined
+  );
+  const id = merged.id && source.kind === 'frontier.lang.semanticTransformIdentityRecord'
+    ? merged.id
+    : firstString(merged.id, `semantic_transform_${idFragment(firstString(transformKey, semanticKey, sourcePath, targetPath, 'record'))}`);
+  return compactRecord({
+    kind: 'frontier.lang.semanticTransformIdentityRecord',
+    version: 1,
+    schema: 'frontier.lang.semanticTransformIdentityRecord.v1',
+    id,
+    sourceLanguage,
+    targetLanguage,
+    sourcePath,
+    targetPath,
+    baseHash: firstString(merged.baseHash),
+    targetHash: firstString(merged.targetHash, merged.projectedHash),
+    semanticKey,
+    transformKey,
+    semanticIdentityHash,
+    sourceIdentityHash,
+    operationContentHash,
+    editContentHash,
+    transformIdentityHash,
+    projectionIdentityHash,
+    transformContentHash,
+    readiness: firstString(merged.readiness),
+    confidence: typeof merged.confidence === 'number' ? merged.confidence : undefined,
+    evidenceIds: uniqueStrings(merged.evidenceIds),
+    metadata: compactRecord({
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      sourceTransformId: source.kind === 'frontier.lang.semanticTransformIdentityRecord' ? source.id : undefined,
+      ...merged.metadata
+    })
+  });
+}
+
+export function semanticTransformIdentityFields(record = {}) {
+  return createSemanticTransformIdentityRecord(record);
+}
+
+export function normalizeSemanticTransformIdentityRecords(records, context = {}) {
+  return array(records).filter(Boolean).map((record) => createSemanticTransformIdentityRecord(record, context));
+}
+
+export function semanticTransformInputs(source = {}, options = {}) {
+  return [
+    ...array(options.semanticTransformIdentities ?? options.semanticTransformIdentity),
+    ...array(source.semanticTransformIdentities ?? source.semanticTransformIdentity ?? source.semanticTransforms),
+    ...array(source.index?.semanticTransformIdentities)
+  ];
+}
+
+export function semanticTransformRecordIndex(records, source = {}) {
+  const index = source.index ?? {};
+  return {
+    semanticTransformIds: uniqueStrings([...strings(source.semanticTransformIds), ...strings(index.semanticTransformIds), ...records.map((record) => record.id)]),
+    semanticTransformKeys: uniqueStrings([...strings(source.semanticTransformKeys), ...strings(index.semanticTransformKeys), ...records.map((record) => record.transformKey)]),
+    semanticTransformIdentityHashes: uniqueStrings([...strings(source.semanticTransformIdentityHashes), ...strings(index.semanticTransformIdentityHashes), ...records.map((record) => record.transformIdentityHash)]),
+    semanticTransformContentHashes: uniqueStrings([...strings(source.semanticTransformContentHashes), ...strings(index.semanticTransformContentHashes), ...records.map((record) => record.transformContentHash)]),
+    projectionIdentityHashes: uniqueStrings([...strings(source.projectionIdentityHashes), ...strings(index.projectionIdentityHashes), ...records.map((record) => record.projectionIdentityHash)]),
+    transformSourceLanguages: uniqueStrings([...strings(source.transformSourceLanguages), ...strings(index.transformSourceLanguages), ...records.map((record) => record.sourceLanguage)]),
+    transformTargetLanguages: uniqueStrings([...strings(source.transformTargetLanguages), ...strings(index.transformTargetLanguages), ...records.map((record) => record.targetLanguage)]),
+    transformSourcePaths: uniqueStrings([...strings(source.transformSourcePaths), ...strings(index.transformSourcePaths), ...records.map((record) => record.sourcePath)]),
+    transformTargetPaths: uniqueStrings([...strings(source.transformTargetPaths), ...strings(index.transformTargetPaths), ...records.map((record) => record.targetPath)])
+  };
+}
+
+export function semanticTransformSummary(index) {
+  if (!index.semanticTransformIds.length && !index.semanticTransformKeys.length) return undefined;
+  return compactRecord({
+    ids: index.semanticTransformIds,
+    keys: index.semanticTransformKeys,
+    identityHashes: index.semanticTransformIdentityHashes,
+    contentHashes: index.semanticTransformContentHashes,
+    projectionIdentityHashes: index.projectionIdentityHashes,
+    sourceLanguages: index.transformSourceLanguages,
+    targetLanguages: index.transformTargetLanguages,
+    targetPaths: index.transformTargetPaths
+  });
+}
+
+function semanticTransformKey(record) {
+  const scope = record.semanticKey ?? (record.symbolName
+    ? `${record.symbolKind ?? 'symbol'}:${record.symbolName}`
+    : record.anchorKey ?? record.regionId ?? record.operationId ?? record.id);
+  const route = [record.sourceLanguage ?? record.language, record.targetLanguage ?? record.projectedLanguage].filter(Boolean).join('->');
+  return ['semantic-transform', route, scope].filter(Boolean).join(':');
+}
+
+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 firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(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/package.json

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