@shapeshift-labs/frontier-lang-compiler 0.2.66 → 0.2.68

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

@@ -0,0 +1,113 @@
+import{uniqueStrings as uniqueRawStrings}from'../../native-import-utils.js';
+
+export function querySemanticHistoryRecordOverlaps(records,options={}){
+  const list=array(records).filter(Boolean);
+  const overlaps=[];
+  for(let leftIndex=0;leftIndex<list.length;leftIndex+=1){
+    for(let rightIndex=leftIndex+1;rightIndex<list.length;rightIndex+=1){
+      const overlap=semanticHistoryOverlap(list[leftIndex],list[rightIndex],options);
+      if(overlap.overlapKinds.length||overlap.conflictReasons.length)overlaps.push(overlap);
+    }
+  }
+  return overlaps.sort((left,right)=>Number(right.conflict)-Number(left.conflict)||left.leftId.localeCompare(right.leftId)||left.rightId.localeCompare(right.rightId));
+}
+
+export function semanticHistoryRecordsOverlap(left,right,options={}){
+  return semanticHistoryOverlap(left,right,options).overlapKinds.length>0;
+}
+
+export function semanticHistoryRecordsConflict(left,right,options={}){
+  return semanticHistoryOverlap(left,right,options).conflict;
+}
+
+function semanticHistoryOverlap(left,right,options){
+  const leftIndex=historyIndex(left);
+  const rightIndex=historyIndex(right);
+  const overlap=compactRecord({
+    ownership:intersect(leftIndex.ownershipKeys,rightIndex.ownershipKeys),
+    'conflict-key':intersect(leftIndex.conflictKeys,rightIndex.conflictKeys),
+    source:intersect(leftIndex.sourceIds,rightIndex.sourceIds),
+    'source-path':options.includeSourcePaths===false?[]:intersect(leftIndex.sourcePaths,rightIndex.sourcePaths),
+    import:intersect(leftIndex.importIds,rightIndex.importIds),
+    'semantic-candidate':intersect(leftIndex.semanticCandidateIds,rightIndex.semanticCandidateIds),
+    'semantic-claim':options.includeClaims?intersect(leftIndex.semanticClaimIds,rightIndex.semanticClaimIds):[],
+    'claim-hash':options.includeClaims?intersect(leftIndex.semanticClaimHashes,rightIndex.semanticClaimHashes):[],
+    evidence:options.includeEvidence?intersect(leftIndex.evidenceIds,rightIndex.evidenceIds):[],
+    proof:options.includeProofs?intersect(leftIndex.proofIds,rightIndex.proofIds):[],
+    replay:options.includeReplay?intersect(leftIndex.replayIds,rightIndex.replayIds):[],
+    patch:options.includePatches?intersect(leftIndex.patchIds,rightIndex.patchIds):[],
+    'merge-decision':options.includeMergeDecisions?intersect(leftIndex.mergeDecisionIds,rightIndex.mergeDecisionIds):[],
+    actor:options.includeActors?intersect(leftIndex.actorIds,rightIndex.actorIds):[],
+    'record-source':options.includeRecordSources?intersect(leftIndex.recordSourceIds,rightIndex.recordSourceIds):[],
+    'base-hash':options.includeBaseHashes?intersect(leftIndex.baseHashes,rightIndex.baseHashes):[],
+    'target-hash':options.includeTargetHashes?intersect(leftIndex.targetHashes,rightIndex.targetHashes):[]
+  });
+  const overlapKinds=Object.keys(overlap);
+  const semanticOverlap=Boolean(overlap.ownership?.length||overlap['conflict-key']?.length||overlap.source?.length||overlap['source-path']?.length||overlap.import?.length);
+  const conflictReasons=uniqueStrings([
+    overlap.ownership?.length?'ownership-overlap':undefined,
+    overlap['conflict-key']?.length?'semantic-conflict-key-overlap':undefined,
+    semanticOverlap&&disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)?'base-hash-mismatch':undefined,
+    (overlap.ownership?.length||overlap['conflict-key']?.length)&&disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes)?'target-hash-mismatch':undefined,
+    semanticOverlap&&(blockedAdmission(left)||blockedAdmission(right))?'admission-blocked':undefined,
+    semanticOverlap&&(rejectedReview(left)||rejectedReview(right))?'reviewer-rejected':undefined,
+    options.conflictOnSourcePath&&overlap['source-path']?.length?'source-path-overlap':undefined
+  ]);
+  return{
+    schema:'frontier.lang.semanticHistoryOverlap.v1',
+    leftId:String(left?.id??'left'),
+    rightId:String(right?.id??'right'),
+    overlap,
+    overlapKinds,
+    conflict:conflictReasons.length>0,
+    conflictReasons,
+    admission:{left:left?.admission?.status,right:right?.admission?.status},
+    reviewer:{left:left?.reviewer?.status,right:right?.reviewer?.status}
+  };
+}
+
+function historyIndex(record){
+  const acceptedFacts=record?.acceptedFacts??[];
+  const rejectedTheories=record?.rejectedTheories??[];
+  const importedParserEvidence=record?.importedParserEvidence??[];
+  const proofAttempts=record?.proofAttempts??[];
+  const patchAncestry=record?.patchAncestry??[];
+  const mergeDecisions=record?.mergeDecisions??[];
+  return record?.index??{
+    baseHashes:uniqueStrings([record?.baseHash]),
+    targetHashes:uniqueStrings([record?.targetHash]),
+    sourceIds:uniqueStrings(record?.sourceIds),
+    importIds:uniqueStrings(record?.importIds),
+    sourcePaths:uniqueStrings([record?.sourcePath,...(record?.sources??[]).map((source)=>source.sourcePath)]),
+    sourceHashes:uniqueStrings((record?.sources??[]).map((source)=>source.sourceHash)),
+    actorIds:uniqueStrings([record?.actor?.id,...acceptedFacts.map((claim)=>claim.actor?.id),...rejectedTheories.map((claim)=>claim.actor?.id),...importedParserEvidence.map((entry)=>entry.actor?.id),...proofAttempts.map((entry)=>entry.actor?.id),...patchAncestry.map((entry)=>entry.actor?.id),...mergeDecisions.map((entry)=>entry.actor?.id)]),
+    recordSourceIds:uniqueStrings([record?.recordSource?.id,record?.recordSource?.sourceId,...acceptedFacts.flatMap((claim)=>[claim.recordSource?.id,claim.recordSource?.sourceId]),...rejectedTheories.flatMap((claim)=>[claim.recordSource?.id,claim.recordSource?.sourceId]),...importedParserEvidence.flatMap((entry)=>[entry.recordSource?.id,entry.recordSource?.sourceId]),...proofAttempts.flatMap((entry)=>[entry.recordSource?.id,entry.recordSource?.sourceId]),...patchAncestry.flatMap((entry)=>[entry.recordSource?.id,entry.recordSource?.sourceId]),...mergeDecisions.flatMap((entry)=>[entry.recordSource?.id,entry.recordSource?.sourceId])]),
+    ownershipKeys:uniqueStrings((record?.ownershipRegions??[]).map((region)=>region.key)),
+    semanticCandidateIds:uniqueStrings((record?.semanticCandidates??[]).map((candidate)=>candidate.id)),
+    semanticClaimIds:uniqueStrings([...acceptedFacts.map((claim)=>claim.id),...rejectedTheories.map((claim)=>claim.id)]),
+    semanticClaimHashes:uniqueStrings([...acceptedFacts.map((claim)=>claim.hash),...rejectedTheories.map((claim)=>claim.hash)]),
+    acceptedFactIds:uniqueStrings(acceptedFacts.map((claim)=>claim.id)),
+    rejectedTheoryIds:uniqueStrings(rejectedTheories.map((claim)=>claim.id)),
+    conflictKeys:uniqueStrings([...(record?.semanticCandidates??[]).flatMap((candidate)=>candidate.conflictKeys??[]),...acceptedFacts.flatMap((claim)=>claim.conflictKeys??[]),...rejectedTheories.flatMap((claim)=>claim.conflictKeys??[]),...patchAncestry.flatMap((patch)=>patch.conflictKeys??[]),...mergeDecisions.flatMap((decision)=>decision.conflictKeys??[])]),
+    evidenceIds:uniqueStrings([...(record?.evidenceIds??[]),...acceptedFacts.flatMap((claim)=>claim.evidenceIds??[]),...rejectedTheories.flatMap((claim)=>claim.evidenceIds??[]),...importedParserEvidence.flatMap((entry)=>[entry.evidenceId,...(entry.evidenceIds??[])]),...proofAttempts.flatMap((entry)=>entry.evidenceIds??[]),...mergeDecisions.flatMap((entry)=>entry.evidenceIds??[])]),
+    importedParserEvidenceIds:uniqueStrings(importedParserEvidence.map((entry)=>entry.id)),
+    importedParserEvidenceHashes:uniqueStrings(importedParserEvidence.map((entry)=>entry.hash)),
+    proofIds:uniqueStrings([...(record?.proofIds??[]),...acceptedFacts.flatMap((claim)=>claim.proofIds??[]),...rejectedTheories.flatMap((claim)=>claim.proofIds??[]),...proofAttempts.flatMap((entry)=>[entry.proofId,...(entry.proofIds??[])]),...mergeDecisions.flatMap((entry)=>entry.proofIds??[])]),
+    proofAttemptIds:uniqueStrings(proofAttempts.map((entry)=>entry.id)),
+    proofAttemptHashes:uniqueStrings(proofAttempts.map((entry)=>entry.hash)),
+    replayIds:uniqueStrings([...(record?.replayLinks??[]).map((link)=>link.id),...(record?.semanticCandidates??[]).flatMap((candidate)=>candidate.replayIds??[]),...acceptedFacts.flatMap((claim)=>claim.replayIds??[]),...rejectedTheories.flatMap((claim)=>claim.replayIds??[]),...proofAttempts.flatMap((entry)=>entry.replayIds??[])]),
+    patchIds:uniqueStrings([...(record?.semanticCandidates??[]).map((candidate)=>candidate.patchId),...patchAncestry.flatMap((entry)=>[entry.patchId,...(entry.parentPatchIds??[]),...(entry.ancestorPatchIds??[])]),...mergeDecisions.flatMap((entry)=>entry.patchIds??[])]),
+    patchHashes:uniqueStrings(patchAncestry.flatMap((entry)=>[entry.hash,...(entry.parentHashes??[]),...(entry.ancestorHashes??[])])),
+    mergeDecisionIds:uniqueStrings(mergeDecisions.map((entry)=>entry.id)),
+    mergeDecisionHashes:uniqueStrings(mergeDecisions.map((entry)=>entry.hash))
+  };
+}
+
+function blockedAdmission(record){return ['blocked','rejected'].includes(String(record?.admission?.status??''));}
+function rejectedReview(record){return ['rejected','changes-requested'].includes(String(record?.reviewer?.status??''));}
+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 array(value){if(value===undefined||value===null)return[];return Array.isArray(value)?value:[value];}
+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/semanticHistoryRecords.js

@@ -1,182 +1,263 @@
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 import{ idFragment, maxSemanticMergeReadiness, normalizeSemanticMergeReadiness, uniqueStrings as uniqueRawStrings }from'../../native-import-utils.js';
+import{normalizeOwnershipRegions,normalizeSemanticCandidates,normalizeSemanticClaims,normalizeSources,semanticClaimsByStatus}from'./semanticHistoryRecordNormalizers.js';
 
 export const SemanticHistoryAdmissionStatuses=Object.freeze(['proposed','queued','admitted','needs-review','blocked','rejected']);
 export const SemanticHistoryReviewerStatuses=Object.freeze(['unreviewed','approved','changes-requested','reviewed','rejected']);
-export const SemanticHistoryOverlapKinds=Object.freeze(['ownership','conflict-key','source','source-path','import','semantic-candidate','evidence','proof','replay','base-hash','target-hash']);
+export const SemanticHistoryOverlapKinds=Object.freeze(['ownership','conflict-key','source','source-path','import','semantic-candidate','semantic-claim','claim-hash','evidence','proof','replay','patch','merge-decision','actor','record-source','base-hash','target-hash']);
 export const SemanticHistoryConflictReasons=Object.freeze(['ownership-overlap','semantic-conflict-key-overlap','base-hash-mismatch','target-hash-mismatch','admission-blocked','reviewer-rejected','source-path-overlap']);
 
 export function createSemanticHistoryRecord(input={},options={}){
   const imported=input.importResult??input.imported;
+  const actor=normalizeActor(input.actor??options.actor??compactRecord({id:input.actorId??options.actorId,kind:input.actorKind??options.actorKind,role:input.actorRole??options.actorRole,runId:input.runId??options.runId,lane:input.lane??options.lane,taskId:input.taskId??options.taskId}));
+  const recordSource=normalizeRecordSource(input.recordSource??input.historySource??options.recordSource??options.historySource,compactRecord({...input,...options}));
   const sources=normalizeSources(input,imported);
   const ownershipRegions=normalizeOwnershipRegions([...(array(input.ownershipRegions)),...(array(input.changedRegions)),...(array(input.changeSet?.changedRegions)),...(array(imported?.ownershipRegions))]);
   const semanticCandidates=normalizeSemanticCandidates([...(array(input.semanticCandidates)),...(array(input.mergeCandidates)),...(array(input.mergeCandidate)),...(array(input.changeSet?.mergeCandidate)),...(array(imported?.mergeCandidates))]);
   const replayLinks=normalizeReplayLinks(input.replayLinks??input.replay);
   const baseHash=firstString(input.baseHash,input.beforeHash,...sources.map((source)=>source.baseHash),...semanticCandidates.map((candidate)=>candidate.baseHash));
   const targetHash=firstString(input.targetHash,input.afterHash,...sources.map((source)=>source.targetHash),...semanticCandidates.map((candidate)=>candidate.targetHash));
-  const evidenceIds=uniqueStrings([...(strings(input.evidenceIds)),...(array(input.evidence)).map((record)=>record?.id),...(array(imported?.evidence)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.evidenceIds),...(strings(input.reviewer?.evidenceIds)),...(strings(input.admission?.evidenceIds))]);
-  const proofIds=uniqueStrings([...(strings(input.proofIds)),...(array(input.proofs)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.proofIds)]);
+  const sourceContext={actor,recordSource,language:input.language??imported?.language??sources.find((source)=>source.language)?.language,sourcePath:input.sourcePath??imported?.sourcePath??sources.find((source)=>source.sourcePath)?.sourcePath,sourceHash:input.sourceHash??imported?.sourceHash??sources.find((source)=>source.sourceHash)?.sourceHash,baseHash,targetHash};
+  const acceptedFacts=normalizeSemanticClaims([
+    ...(array(input.acceptedFacts)),
+    ...(array(input.acceptedSemanticClaims)),
+    ...semanticClaimsByStatus(input,'accepted')
+  ],{...sourceContext,status:'accepted',claimKind:'fact',prefix:'semantic_fact'});
+  const rejectedTheories=normalizeSemanticClaims([
+    ...(array(input.rejectedTheories)),
+    ...(array(input.rejectedSemanticClaims)),
+    ...semanticClaimsByStatus(input,'rejected')
+  ],{...sourceContext,status:'rejected',claimKind:'theory',prefix:'semantic_theory'});
+  const importedParserEvidence=normalizeImportedParserEvidence([
+    ...(array(input.importedParserEvidence)),
+    ...(array(input.parserEvidence)),
+    ...(array(imported?.parserEvidence))
+  ],sourceContext);
+  const proofAttempts=normalizeProofAttempts([...(array(input.proofAttempts)),...(array(input.proofs))],sourceContext);
+  const patchAncestry=normalizePatchAncestry(input.patchAncestry??input.patchAncestors??input.ancestry,sourceContext);
+  const mergeDecisions=normalizeMergeDecisions(input.mergeDecisions??input.decisions,sourceContext);
+  const semanticClaimIds=uniqueStrings([...acceptedFacts.map((claim)=>claim.id),...rejectedTheories.map((claim)=>claim.id)]);
+  const semanticClaimHashes=uniqueStrings([...acceptedFacts.map((claim)=>claim.hash),...rejectedTheories.map((claim)=>claim.hash)]);
+  const evidenceIds=uniqueStrings([...(strings(input.evidenceIds)),...(array(input.evidence)).map((record)=>record?.id),...(array(imported?.evidence)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.evidenceIds),...acceptedFacts.flatMap((claim)=>claim.evidenceIds),...rejectedTheories.flatMap((claim)=>claim.evidenceIds),...importedParserEvidence.flatMap((record)=>[record.evidenceId,...array(record.evidenceIds)]),...proofAttempts.flatMap((record)=>record.evidenceIds),...mergeDecisions.flatMap((decision)=>decision.evidenceIds),...(strings(input.reviewer?.evidenceIds)),...(strings(input.admission?.evidenceIds))]);
+  const proofIds=uniqueStrings([...(strings(input.proofIds)),...(array(input.proofs)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.proofIds),...acceptedFacts.flatMap((claim)=>claim.proofIds),...rejectedTheories.flatMap((claim)=>claim.proofIds),...proofAttempts.flatMap((record)=>[record.proofId,...array(record.proofIds)]),...mergeDecisions.flatMap((decision)=>decision.proofIds)]);
   const sourceIds=uniqueStrings([input.sourceId,...strings(input.sourceIds),...sources.map((source)=>source.id)]);
   const importIds=uniqueStrings([input.importId,input.importResultId,imported?.id,...strings(input.importIds),...sources.map((source)=>source.importId),...semanticCandidates.map((candidate)=>candidate.importResultId)]);
   const sourcePaths=uniqueStrings([input.sourcePath,imported?.sourcePath,...sources.map((source)=>source.sourcePath),...ownershipRegions.map((region)=>region.sourcePath),...semanticCandidates.map((candidate)=>candidate.sourcePath)]);
   const sourceHashes=uniqueStrings([input.sourceHash,imported?.sourceHash,...sources.map((source)=>source.sourceHash),...ownershipRegions.map((region)=>region.sourceHash)]);
-  const conflictKeys=uniqueStrings([...(strings(input.conflictKeys)),...semanticCandidates.flatMap((candidate)=>candidate.conflictKeys)]);
+  const conflictKeys=uniqueStrings([...(strings(input.conflictKeys)),...semanticCandidates.flatMap((candidate)=>candidate.conflictKeys),...acceptedFacts.flatMap((claim)=>claim.conflictKeys),...rejectedTheories.flatMap((claim)=>claim.conflictKeys),...patchAncestry.flatMap((patch)=>patch.conflictKeys),...mergeDecisions.flatMap((decision)=>decision.conflictKeys)]);
   const reviewer=normalizeReviewer(input.reviewer);
   const admission=normalizeAdmission(input.admission,semanticCandidates,reviewer);
-  return{
+  const actorIds=uniqueStrings([actor?.id,actor?.actorId,...acceptedFacts.map((claim)=>claim.actor?.id),...rejectedTheories.map((claim)=>claim.actor?.id),...importedParserEvidence.map((record)=>record.actor?.id),...proofAttempts.map((record)=>record.actor?.id),...patchAncestry.map((record)=>record.actor?.id),...mergeDecisions.map((record)=>record.actor?.id)]);
+  const recordSourceIds=uniqueStrings([recordSource?.id,recordSource?.sourceId,...acceptedFacts.flatMap((claim)=>[claim.recordSource?.id,claim.recordSource?.sourceId]),...rejectedTheories.flatMap((claim)=>[claim.recordSource?.id,claim.recordSource?.sourceId]),...importedParserEvidence.flatMap((record)=>[record.recordSource?.id,record.recordSource?.sourceId]),...proofAttempts.flatMap((record)=>[record.recordSource?.id,record.recordSource?.sourceId]),...patchAncestry.flatMap((record)=>[record.recordSource?.id,record.recordSource?.sourceId]),...mergeDecisions.flatMap((record)=>[record.recordSource?.id,record.recordSource?.sourceId])]);
+  const patchIds=uniqueStrings([...semanticCandidates.map((candidate)=>candidate.patchId),...patchAncestry.flatMap((patch)=>[patch.patchId,...array(patch.parentPatchIds),...array(patch.ancestorPatchIds)]),...mergeDecisions.flatMap((decision)=>decision.patchIds)]);
+  const mergeDecisionIds=uniqueStrings(mergeDecisions.map((decision)=>decision.id));
+  const index={
+    baseHashes:uniqueStrings([baseHash,...sources.map((source)=>source.baseHash),...semanticCandidates.map((candidate)=>candidate.baseHash),...patchAncestry.map((patch)=>patch.baseHash)]),
+    targetHashes:uniqueStrings([targetHash,...sources.map((source)=>source.targetHash),...semanticCandidates.map((candidate)=>candidate.targetHash),...patchAncestry.map((patch)=>patch.targetHash)]),
+    sourceIds,
+    importIds,
+    sourcePaths,
+    sourceHashes,
+    actorIds,
+    recordSourceIds,
+    ownershipKeys:uniqueStrings([...ownershipRegions.map((region)=>region.key),...semanticCandidates.flatMap((candidate)=>candidate.ownershipKeys)]),
+    semanticCandidateIds:uniqueStrings(semanticCandidates.map((candidate)=>candidate.id)),
+    semanticClaimIds,
+    semanticClaimHashes,
+    acceptedFactIds:uniqueStrings(acceptedFacts.map((claim)=>claim.id)),
+    rejectedTheoryIds:uniqueStrings(rejectedTheories.map((claim)=>claim.id)),
+    conflictKeys,
+    evidenceIds,
+    importedParserEvidenceIds:uniqueStrings(importedParserEvidence.map((record)=>record.id)),
+    importedParserEvidenceHashes:uniqueStrings(importedParserEvidence.map((record)=>record.hash)),
+    proofIds,
+    proofAttemptIds:uniqueStrings(proofAttempts.map((record)=>record.id)),
+    proofAttemptHashes:uniqueStrings(proofAttempts.map((record)=>record.hash)),
+    replayIds:uniqueStrings([...replayLinks.map((link)=>link.id),...semanticCandidates.flatMap((candidate)=>candidate.replayIds),...acceptedFacts.flatMap((claim)=>claim.replayIds),...rejectedTheories.flatMap((claim)=>claim.replayIds),...proofAttempts.flatMap((record)=>record.replayIds)]),
+    patchIds,
+    patchHashes:uniqueStrings(patchAncestry.flatMap((patch)=>[patch.hash,...array(patch.parentHashes),...array(patch.ancestorHashes)])),
+    mergeDecisionIds,
+    mergeDecisionHashes:uniqueStrings(mergeDecisions.map((decision)=>decision.hash))
+  };
+  const recordCore={
     kind:'frontier.lang.semanticHistoryRecord',
     version:1,
-    id:input.id??options.id??`semantic_history_${idFragment(firstString(sourcePaths[0],importIds[0],sourceIds[0],'record'))}`,
-    createdAt:input.createdAt??options.createdAt??Date.now(),
     baseHash,
     targetHash,
-    language:input.language??imported?.language??sources.find((source)=>source.language)?.language,
-    sourcePath:input.sourcePath??imported?.sourcePath??sourcePaths[0],
+    language:sourceContext.language,
+    sourcePath:sourceContext.sourcePath??sourcePaths[0],
+    actor,
+    recordSource,
     sourceIds,
     importIds,
     sources,
     ownershipRegions,
     semanticCandidates,
+    acceptedFacts,
+    rejectedTheories,
+    importedParserEvidence,
+    proofAttempts,
+    patchAncestry,
+    mergeDecisions,
     evidenceIds,
     proofIds,
     reviewer,
     admission,
     replayLinks,
-    index:{
-      baseHashes:uniqueStrings([baseHash,...sources.map((source)=>source.baseHash),...semanticCandidates.map((candidate)=>candidate.baseHash)]),
-      targetHashes:uniqueStrings([targetHash,...sources.map((source)=>source.targetHash),...semanticCandidates.map((candidate)=>candidate.targetHash)]),
-      sourceIds,
-      importIds,
-      sourcePaths,
-      sourceHashes,
-      ownershipKeys:uniqueStrings([...ownershipRegions.map((region)=>region.key),...semanticCandidates.flatMap((candidate)=>candidate.ownershipKeys)]),
-      semanticCandidateIds:uniqueStrings(semanticCandidates.map((candidate)=>candidate.id)),
-      conflictKeys,
-      evidenceIds,
-      proofIds,
-      replayIds:uniqueStrings(replayLinks.map((link)=>link.id))
-    },
+    index,
     metadata:compactRecord(input.metadata)
   };
+  const hash=hashSemanticValue(recordCore);
+  const stableId=`semantic_history_${idFragment(hash)}`;
+  return{
+    ...recordCore,
+    id:input.id??options.id??stableId,
+    stableId,
+    hash,
+    createdAt:input.createdAt??options.createdAt??Date.now()
+  };
 }
 
-export function querySemanticHistoryRecordOverlaps(records,options={}){
-  const list=array(records).filter(Boolean);
-  const overlaps=[];
-  for(let leftIndex=0;leftIndex<list.length;leftIndex+=1){
-    for(let rightIndex=leftIndex+1;rightIndex<list.length;rightIndex+=1){
-      const overlap=semanticHistoryOverlap(list[leftIndex],list[rightIndex],options);
-      if(overlap.overlapKinds.length||overlap.conflictReasons.length)overlaps.push(overlap);
-    }
-  }
-  return overlaps.sort((left,right)=>Number(right.conflict)-Number(left.conflict)||left.leftId.localeCompare(right.leftId)||left.rightId.localeCompare(right.rightId));
+export{querySemanticHistoryRecordOverlaps,semanticHistoryRecordsConflict,semanticHistoryRecordsOverlap}from'./semanticHistoryRecordOverlaps.js';
+
+function normalizeImportedParserEvidence(records,defaults){
+  return records.filter(Boolean).map((record,index)=>{
+    const source=typeof record==='string'?{evidenceId:record}:record;
+    const normalized=compactRecord({
+      kind:'frontier.lang.semanticHistoryImportedParserEvidence',
+      version:1,
+      evidenceId:firstString(source.evidenceId,source.id),
+      importId:source.importId??source.importResultId??defaults.importId,
+      parserId:source.parserId??source.parser??source.adapterId,
+      parserKind:source.parserKind??source.kind,
+      language:source.language??defaults.language,
+      sourcePath:source.sourcePath??defaults.sourcePath,
+      sourceHash:source.sourceHash??source.hash??defaults.sourceHash,
+      astHash:source.astHash??source.nativeAstHash,
+      semanticIndexHash:source.semanticIndexHash,
+      status:source.status??'unknown',
+      evidenceIds:uniqueStrings([source.evidenceId,source.id,...strings(source.evidenceIds)]),
+      replayIds:uniqueStrings(source.replayIds),
+      actor:normalizeActor(source.actor)??defaults.actor,
+      recordSource:normalizeRecordSource(source.recordSource??source.historySource??defaults.recordSource,defaults),
+      metadata:source.metadata
+    });
+    return withStableSubrecordIdentity('imported_parser_evidence',normalized,source,index);
+  });
 }
 
-export function semanticHistoryRecordsOverlap(left,right,options={}){
-  return semanticHistoryOverlap(left,right,options).overlapKinds.length>0;
+function normalizeProofAttempts(records,defaults){
+  return records.filter(Boolean).map((record,index)=>{
+    const source=typeof record==='string'?{proofId:record}:record;
+    const normalized=compactRecord({
+      kind:'frontier.lang.semanticHistoryProofAttempt',
+      version:1,
+      proofId:firstString(source.proofId,source.id),
+      proofKind:source.proofKind??source.kind,
+      status:source.status??'unknown',
+      proverId:source.proverId??source.prover,
+      claimIds:uniqueStrings(source.claimIds),
+      evidenceIds:uniqueStrings(source.evidenceIds),
+      proofIds:uniqueStrings(source.proofIds),
+      replayIds:uniqueStrings(source.replayIds),
+      command:source.command,
+      resultHash:source.resultHash??source.proofHash,
+      actor:normalizeActor(source.actor)??defaults.actor,
+      recordSource:normalizeRecordSource(source.recordSource??source.historySource??defaults.recordSource,defaults),
+      metadata:source.metadata
+    });
+    return withStableSubrecordIdentity('proof_attempt',normalized,source,index);
+  });
 }
 
-export function semanticHistoryRecordsConflict(left,right,options={}){
-  return semanticHistoryOverlap(left,right,options).conflict;
+function normalizePatchAncestry(records,defaults){
+  return array(records).filter(Boolean).map((record,index)=>{
+    const source=typeof record==='string'?{patchId:record}:record;
+    const normalized=compactRecord({
+      kind:'frontier.lang.semanticHistoryPatchAncestry',
+      version:1,
+      patchId:firstString(source.patchId,source.id),
+      parentPatchIds:uniqueStrings([...(strings(source.parentPatchIds)),...(strings(source.parents))]),
+      ancestorPatchIds:uniqueStrings([...(strings(source.ancestorPatchIds)),...(strings(source.ancestors))]),
+      baseHash:source.baseHash??defaults.baseHash,
+      targetHash:source.targetHash??defaults.targetHash,
+      parentHashes:uniqueStrings(source.parentHashes),
+      ancestorHashes:uniqueStrings(source.ancestorHashes),
+      conflictKeys:uniqueStrings(source.conflictKeys),
+      actor:normalizeActor(source.actor)??defaults.actor,
+      recordSource:normalizeRecordSource(source.recordSource??source.historySource??defaults.recordSource,defaults),
+      metadata:source.metadata
+    });
+    return withStableSubrecordIdentity('patch_ancestry',normalized,source,index);
+  });
 }
 
-function semanticHistoryOverlap(left,right,options){
-  const leftIndex=historyIndex(left);
-  const rightIndex=historyIndex(right);
-  const overlap=compactRecord({
-    ownership:intersect(leftIndex.ownershipKeys,rightIndex.ownershipKeys),
-    'conflict-key':intersect(leftIndex.conflictKeys,rightIndex.conflictKeys),
-    source:intersect(leftIndex.sourceIds,rightIndex.sourceIds),
-    'source-path':options.includeSourcePaths===false?[]:intersect(leftIndex.sourcePaths,rightIndex.sourcePaths),
-    import:intersect(leftIndex.importIds,rightIndex.importIds),
-    'semantic-candidate':intersect(leftIndex.semanticCandidateIds,rightIndex.semanticCandidateIds),
-    evidence:options.includeEvidence?intersect(leftIndex.evidenceIds,rightIndex.evidenceIds):[],
-    proof:options.includeProofs?intersect(leftIndex.proofIds,rightIndex.proofIds):[],
-    replay:options.includeReplay?intersect(leftIndex.replayIds,rightIndex.replayIds):[],
-    'base-hash':options.includeBaseHashes?intersect(leftIndex.baseHashes,rightIndex.baseHashes):[],
-    'target-hash':options.includeTargetHashes?intersect(leftIndex.targetHashes,rightIndex.targetHashes):[]
+function normalizeMergeDecisions(records,defaults){
+  return array(records).filter(Boolean).map((record,index)=>{
+    const source=typeof record==='string'?{decision:record}:record;
+    const normalized=compactRecord({
+      kind:'frontier.lang.semanticHistoryMergeDecision',
+      version:1,
+      decision:source.decision??source.status,
+      status:source.status??source.decision,
+      decidedAt:source.decidedAt,
+      claimIds:uniqueStrings(source.claimIds),
+      acceptedClaimIds:uniqueStrings(source.acceptedClaimIds),
+      rejectedClaimIds:uniqueStrings(source.rejectedClaimIds),
+      patchIds:uniqueStrings([...(strings(source.patchIds)),source.patchId]),
+      conflictKeys:uniqueStrings(source.conflictKeys),
+      evidenceIds:uniqueStrings(source.evidenceIds),
+      proofIds:uniqueStrings(source.proofIds),
+      reasonCodes:uniqueStrings(source.reasonCodes),
+      actor:normalizeActor(source.actor)??defaults.actor,
+      recordSource:normalizeRecordSource(source.recordSource??source.historySource??defaults.recordSource,defaults),
+      metadata:source.metadata
+    });
+    return withStableSubrecordIdentity('merge_decision',normalized,source,index);
   });
-  const overlapKinds=Object.keys(overlap);
-  const semanticOverlap=Boolean(overlap.ownership?.length||overlap['conflict-key']?.length||overlap.source?.length||overlap['source-path']?.length||overlap.import?.length);
-  const conflictReasons=uniqueStrings([
-    overlap.ownership?.length?'ownership-overlap':undefined,
-    overlap['conflict-key']?.length?'semantic-conflict-key-overlap':undefined,
-    semanticOverlap&&disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)?'base-hash-mismatch':undefined,
-    (overlap.ownership?.length||overlap['conflict-key']?.length)&&disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes)?'target-hash-mismatch':undefined,
-    semanticOverlap&&(blockedAdmission(left)||blockedAdmission(right))?'admission-blocked':undefined,
-    semanticOverlap&&(rejectedReview(left)||rejectedReview(right))?'reviewer-rejected':undefined,
-    options.conflictOnSourcePath&&overlap['source-path']?.length?'source-path-overlap':undefined
-  ]);
-  return{
-    schema:'frontier.lang.semanticHistoryOverlap.v1',
-    leftId:String(left?.id??'left'),
-    rightId:String(right?.id??'right'),
-    overlap,
-    overlapKinds,
-    conflict:conflictReasons.length>0,
-    conflictReasons,
-    admission:{left:left?.admission?.status,right:right?.admission?.status},
-    reviewer:{left:left?.reviewer?.status,right:right?.reviewer?.status}
-  };
 }
 
-function normalizeSources(input,imported){
-  const entries=[...(array(input.sources)),...(array(input.sourceRefs)),...(array(input.source)),...(array(imported))];
-  if(entries.length===0&&(input.sourcePath||input.sourceHash||input.baseHash||input.targetHash||input.sourceId||input.importId)){
-    entries.push(input);
-  }
-  return entries.map((source,index)=>compactRecord({
-    id:source?.id??source?.sourceId,
-    importId:source?.importId??source?.importResultId??(source?.kind==='frontier.lang.importResult'?source.id:undefined),
-    language:source?.language??input.language,
-    sourcePath:source?.sourcePath??source?.path??input.sourcePath,
-    sourceHash:source?.sourceHash??source?.hash,
-    baseHash:source?.baseHash??source?.beforeHash??input.baseHash??input.beforeHash,
-    targetHash:source?.targetHash??source?.afterHash??input.targetHash??input.afterHash,
-    metadata:source?.metadata,
-    ordinal:index
-  })).filter((source)=>source.id||source.importId||source.sourcePath||source.sourceHash||source.baseHash||source.targetHash);
+function withStableSubrecordIdentity(prefix,record,source,index){
+  const hash=source.hash??hashSemanticValue(record);
+  return{
+    ...record,
+    id:source.id??`${prefix}_${idFragment(firstString(record.subject,record.evidenceId,record.proofId,record.patchId,record.decision,hash,index+1))}`,
+    hash
+  };
 }
 
-function normalizeOwnershipRegions(regions){
-  const seen=new Set();
-  const normalized=[];
-  for(const region of regions){
-    const key=firstString(region?.key,region?.ownershipKey,region?.conflictKey,region?.id);
-    if(!key||seen.has(key))continue;
-    seen.add(key);
-    normalized.push(compactRecord({
-      id:region?.id,
-      key,
-      regionKind:region?.regionKind??region?.ownershipRegionKind,
-      granularity:region?.granularity??'semantic',
-      language:region?.language,
-      sourcePath:region?.sourcePath,
-      sourceHash:region?.sourceHash,
-      symbolId:region?.symbolId,
-      symbolName:region?.symbolName??region?.name,
-      sourceSpan:region?.sourceSpan??region?.span,
-      metadata:region?.metadata
-    }));
-  }
-  return normalized;
+function normalizeActor(value){
+  const actor=typeof value==='string'?{id:value}:value;
+  const normalized=compactRecord({
+    id:actor?.id??actor?.actorId,
+    kind:actor?.kind??actor?.actorKind??actor?.type,
+    role:actor?.role,
+    displayName:actor?.displayName??actor?.name,
+    runId:actor?.runId,
+    lane:actor?.lane,
+    taskId:actor?.taskId,
+    metadata:actor?.metadata
+  });
+  return nonEmptyRecord(normalized);
 }
 
-function normalizeSemanticCandidates(candidates){
-  return candidates.filter(Boolean).map((candidate,index)=>compactRecord({
-    id:candidate.id??candidate.candidateId??`semantic_candidate_${index+1}`,
-    importResultId:candidate.importResultId,
-    patchId:candidate.patchId,
-    sourcePath:candidate.sourcePath,
-    baseHash:candidate.baseHash,
-    targetHash:candidate.targetHash,
-    readiness:normalizeSemanticMergeReadiness(candidate.readiness)??candidate.readiness,
-    conflictKeys:uniqueStrings([...(strings(candidate.conflictKeys)),...(array(candidate.touchedSymbols)).map((entry)=>entry?.conflictKey),...(array(candidate.touchedSemanticNodes)).map((entry)=>entry?.conflictKey),...(array(candidate.nativeSpans)).map((entry)=>entry?.conflictKey),...(array(candidate.conflictClasses??candidate.metadata?.conflictClasses)).flatMap((entry)=>entry?.conflictKeys??[]),...(candidate.conflictSummary?.conflictKeys??candidate.metadata?.conflictSummary?.conflictKeys??[])]),
-    ownershipKeys:uniqueStrings([...(strings(candidate.ownershipKeys)),...(strings(candidate.regionKeys))]),
-    evidenceIds:uniqueStrings([...(strings(candidate.evidenceIds)),...(array(candidate.evidence)).map((record)=>record?.id),...(array(candidate.conflictClasses??candidate.metadata?.conflictClasses)).flatMap((entry)=>entry?.evidenceIds??[])]),
-    proofIds:uniqueStrings([...(strings(candidate.proofIds)),...(array(candidate.evidence)).filter((record)=>record?.kind==='proof').map((record)=>record?.id)]),
-    replayIds:uniqueStrings([...(strings(candidate.replayIds)),...(array(candidate.evidence)).filter((record)=>record?.kind==='replay').map((record)=>record?.id)]),
-    metadata:compactRecord({risk:candidate.risk,reasons:candidate.reasons,...candidate.metadata})
-  }));
+function normalizeRecordSource(value,context={}){
+  const source=typeof value==='string'?{id:value}:value;
+  const normalized=compactRecord({
+    id:source?.id??source?.sourceId??context.recordSourceId??context.historySourceId,
+    sourceId:source?.sourceId??source?.id??context.recordSourceId??context.historySourceId,
+    sourceKind:source?.sourceKind??source?.kind??source?.type,
+    sourcePath:source?.sourcePath??source?.path,
+    sourceHash:source?.sourceHash??source?.hash,
+    href:source?.href??source?.url,
+    importId:source?.importId??context.importId??context.importResultId,
+    runId:source?.runId??context.runId,
+    jobId:source?.jobId??context.jobId,
+    lane:source?.lane??context.lane,
+    taskId:source?.taskId??context.taskId,
+    metadata:source?.metadata
+  });
+  return nonEmptyRecord(normalized);
 }
 
 function normalizeReplayLinks(value){
@@ -205,29 +286,9 @@ function normalizeAdmission(admission,candidates,reviewer){
   return compactRecord({status:admission?.status??'proposed',readiness,admittedAt:admission?.admittedAt,reviewerId:admission?.reviewerId??reviewer.reviewerId,reasonCodes:uniqueStrings(admission?.reasonCodes),evidenceIds:uniqueStrings(admission?.evidenceIds),metadata:admission?.metadata});
 }
 
-function historyIndex(record){
-  return record?.index??{
-    baseHashes:uniqueStrings([record?.baseHash]),
-    targetHashes:uniqueStrings([record?.targetHash]),
-    sourceIds:uniqueStrings(record?.sourceIds),
-    importIds:uniqueStrings(record?.importIds),
-    sourcePaths:uniqueStrings([record?.sourcePath,...(record?.sources??[]).map((source)=>source.sourcePath)]),
-    sourceHashes:uniqueStrings((record?.sources??[]).map((source)=>source.sourceHash)),
-    ownershipKeys:uniqueStrings((record?.ownershipRegions??[]).map((region)=>region.key)),
-    semanticCandidateIds:uniqueStrings((record?.semanticCandidates??[]).map((candidate)=>candidate.id)),
-    conflictKeys:uniqueStrings((record?.semanticCandidates??[]).flatMap((candidate)=>candidate.conflictKeys??[])),
-    evidenceIds:uniqueStrings(record?.evidenceIds),
-    proofIds:uniqueStrings(record?.proofIds),
-    replayIds:uniqueStrings((record?.replayLinks??[]).map((link)=>link.id))
-  };
-}
-
-function blockedAdmission(record){return ['blocked','rejected'].includes(String(record?.admission?.status??''));}
-function rejectedReview(record){return ['rejected','changes-requested'].includes(String(record?.reviewer?.status??''));}
-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 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 firstString(...values){return values.map((value)=>value===undefined||value===null?'':String(value)).find(Boolean);}
 function compactRecord(value){return Object.fromEntries(Object.entries(value??{}).filter(([,entry])=>entry!==undefined&&(!Array.isArray(entry)||entry.length>0)));}
+function nonEmptyRecord(value){return Object.keys(value??{}).length?value:undefined;}