@shapeshift-labs/frontier-lang-compiler 0.2.87 → 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/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/package.json

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