@shapeshift-labs/frontier-lang-compiler 0.2.99 → 0.2.101

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

@@ -3,32 +3,42 @@ import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-imp
 export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
   const transformAdmission = semanticTransformAdmission(context);
   const semanticEditAdmission = context.semanticEditAdmission ?? { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] };
-  const fallbackReadiness = fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, context.readiness);
-  const readiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
-  const status = input.status ?? admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission);
-  const autoApplyCandidate = input.autoApplyCandidate ?? (status === 'admitted' && [
-    transformAdmission.action,
-    semanticEditAdmission.action
-  ].includes('admit'));
+  const evidenceAdmission = autoMergeEvidenceAdmission(context, { transformAdmission, semanticEditAdmission });
+  const fallbackReadiness = fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, evidenceAdmission, context.readiness);
+  const inputReadiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
+  const readiness = hasPositiveApplyAction(transformAdmission, semanticEditAdmission) && evidenceAdmission.action !== 'admit'
+    ? evidenceAdmission.readiness
+    : inputReadiness;
+  const computedStatus = admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission, evidenceAdmission);
+  const status = input.status === 'admitted' && computedStatus !== 'admitted' ? computedStatus : input.status ?? computedStatus;
+  const computedAutoApplyCandidate = status === 'admitted' &&
+    hasPositiveApplyAction(transformAdmission, semanticEditAdmission) &&
+    evidenceAdmission.action === 'admit';
+  const autoApplyCandidate = input.autoApplyCandidate === true ? computedAutoApplyCandidate : input.autoApplyCandidate ?? computedAutoApplyCandidate;
+  const admittedWithoutPositiveProof = status === 'admitted' &&
+    hasPositiveApplyAction(transformAdmission, semanticEditAdmission) &&
+    evidenceAdmission.action !== 'admit';
   return compactRecord({
     status,
     readiness,
-    reviewRequired: input.reviewRequired ?? status !== 'admitted',
+    reviewRequired: input.reviewRequired ?? (status !== 'admitted' || admittedWithoutPositiveProof),
     autoMergeClaim: false,
     autoApplyCandidate,
     transformAdmission,
     semanticEditAdmission,
+    evidenceAdmission,
     reasonCodes: uniqueStrings([
       ...strings(input.reasonCodes),
       ...strings(context.source?.reasons),
       ...strings(context.mergeCandidate?.reasons),
       ...transformAdmission.reasonCodes,
-      ...strings(semanticEditAdmission.reasonCodes)
-    ]),
+      ...strings(semanticEditAdmission.reasonCodes),
+      ...strings(evidenceAdmission.reasonCodes)
+    ].filter(Boolean)),
     conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...context.conflictKeys]),
     admittedAt: input.admittedAt,
     reviewerId: input.reviewerId,
-    evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(transformAdmission.evidenceIds)]),
+    evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(transformAdmission.evidenceIds), ...strings(evidenceAdmission.evidenceIds)]),
     metadata: input.metadata
   });
 }
@@ -74,7 +84,7 @@ function transformReasonCodes(input) {
     !input.complete ? 'transform-evidence-incomplete' : undefined,
     input.ready ? 'transform-auto-apply-candidate' : undefined,
     ...input.readinesses.map((readiness) => `transform-readiness:${readiness}`)
-  ]);
+  ].filter(Boolean));
 }
 
 function transformReadiness(value) {
@@ -87,21 +97,90 @@ function transformReadiness(value) {
   return undefined;
 }
 
-function fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, fallback) {
-  if ([transformAdmission.readiness, semanticEditAdmission.readiness].includes('blocked')) return 'blocked';
-  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission)) return 'ready';
+function autoMergeEvidenceAdmission(context, admissions) {
+  const evidence = uniqueEvidenceRecords([
+    ...array(context.evidenceRecords),
+    ...array(context.evidence),
+    ...array(context.source?.evidence),
+    ...array(context.source?.patch?.evidence),
+    ...array(context.source?.semanticPatch?.evidence),
+    ...array(context.mergeCandidate?.evidence)
+  ]);
+  const positiveApply = hasPositiveApplyAttempt(admissions.transformAdmission, admissions.semanticEditAdmission);
+  if (!positiveApply) return { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [], evidenceIds: evidenceIds(evidence) };
+  const summary = summarizeAutoMergeEvidence(evidence);
+  const blocked = summary.failed > 0 || summary.conflict > 0;
+  const ready = !blocked && summary.stale === 0 && summary.passed > 0;
+  const status = blocked ? 'blocked' : summary.stale > 0 ? 'stale' : ready ? 'ready' : 'needs-review';
+  return compactRecord({
+    status,
+    action: blocked ? 'block' : status === 'stale' ? 'rerun-semantic-import' : ready ? 'admit' : 'review',
+    readiness: blocked ? 'blocked' : ready ? 'ready' : 'needs-review',
+    reasonCodes: autoMergeEvidenceReasonCodes(summary, status),
+    evidenceIds: summary.evidenceIds,
+    passed: summary.passed,
+    failed: summary.failed,
+    conflict: summary.conflict,
+    stale: summary.stale
+  });
+}
+
+function summarizeAutoMergeEvidence(evidence) {
+  const testLike = evidence.filter(isAutoMergeTestEvidence);
+  const failed = testLike.filter((record) => evidenceStatus(record, ['failed', 'failure', 'error', 'blocked', 'rejected']));
+  const passed = testLike.filter((record) => evidenceStatus(record, ['passed', 'ok', 'success', 'succeeded', 'accepted', 'verified']));
+  const conflict = evidence.filter((record) => evidenceStatus(record, ['conflict', 'conflicted']) || record?.metadata?.conflict === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('conflict')));
+  const stale = evidence.filter((record) => evidenceStatus(record, ['stale']) || record?.metadata?.stale === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('stale')));
+  return {
+    evidenceIds: evidenceIds(evidence),
+    passed: passed.length,
+    failed: failed.length,
+    conflict: conflict.length,
+    stale: stale.length
+  };
+}
+
+function autoMergeEvidenceReasonCodes(summary, status) {
+  return uniqueStrings([
+    summary.passed ? 'auto-merge-tests-passed' : undefined,
+    summary.passed === 0 ? 'auto-merge-tests-passed-evidence-missing' : undefined,
+    summary.failed ? 'auto-merge-tests-failed' : undefined,
+    summary.conflict ? 'auto-merge-conflict-evidence' : undefined,
+    summary.stale ? 'auto-merge-stale-evidence' : undefined,
+    status === 'ready' ? 'auto-merge-positive-proof' : undefined
+  ].filter(Boolean));
+}
+
+function fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, evidenceAdmission, fallback) {
+  if ([transformAdmission.readiness, semanticEditAdmission.readiness, evidenceAdmission.readiness].includes('blocked')) return 'blocked';
+  if (hasSkipReadyAction(semanticEditAdmission)) return 'ready';
+  if (hasPositiveApplyAction(transformAdmission, semanticEditAdmission)) return evidenceAdmission.action === 'admit' ? 'ready' : evidenceAdmission.readiness;
   return fallback;
 }
 
-function admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission) {
+function admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission, evidenceAdmission) {
   if (readiness === 'blocked') return 'blocked';
-  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission) && readiness === 'ready') return 'admitted';
+  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission, evidenceAdmission) && readiness === 'ready') return 'admitted';
   return readiness === 'needs-review' ? 'needs-review' : 'proposed';
 }
 
-function hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission) {
-  return [transformAdmission.action, semanticEditAdmission.action].includes('admit') ||
-    (semanticEditAdmission.action === 'skip' && semanticEditAdmission.readiness === 'ready' && semanticEditAdmission.reviewRequired === false);
+function hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission, evidenceAdmission) {
+  return hasSkipReadyAction(semanticEditAdmission) ||
+    (hasPositiveApplyAction(transformAdmission, semanticEditAdmission) && evidenceAdmission.action === 'admit');
+}
+
+function hasPositiveApplyAction(transformAdmission, semanticEditAdmission) {
+  return [transformAdmission.action, semanticEditAdmission.action].includes('admit');
+}
+
+function hasPositiveApplyAttempt(transformAdmission, semanticEditAdmission) {
+  return hasPositiveApplyAction(transformAdmission, semanticEditAdmission) ||
+    Number(semanticEditAdmission.summary?.acceptedClean ?? 0) > 0 ||
+    strings(transformAdmission.reasonCodes).includes('transform-readiness:auto-merge-candidate');
+}
+
+function hasSkipReadyAction(semanticEditAdmission) {
+  return semanticEditAdmission.action === 'skip' && semanticEditAdmission.readiness === 'ready' && semanticEditAdmission.reviewRequired === false;
 }
 
 function hasCrossLanguageTransform(index) {
@@ -109,6 +188,29 @@ function hasCrossLanguageTransform(index) {
   return strings(index.transformTargetLanguages).some((target) => !source.has(target));
 }
 
+function isAutoMergeTestEvidence(record) {
+  const kind = String(record?.kind ?? record?.type ?? '').toLowerCase();
+  return ['test', 'tests', 'proof', 'gate', 'verification', 'check'].includes(kind);
+}
+
+function evidenceStatus(record, statuses) {
+  const status = String(record?.status ?? record?.outcome ?? '').toLowerCase();
+  return statuses.includes(status);
+}
+
+function uniqueEvidenceRecords(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records.filter(Boolean)) {
+    const key = record.id ?? JSON.stringify(record);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
+function evidenceIds(evidence) { return uniqueStrings(evidence.map((record) => record.id)); }
 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 compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -0,0 +1,199 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+
+export function lineageLinkInputs(source, options, changedRegions, targetPortability) {
+  return [
+    ...array(options.lineageResolutionLinks ?? options.semanticLineageResolutionLinks),
+    ...array(options.lineageResolutions ?? options.semanticLineageResolutions),
+    ...array(source.lineageResolutionLinks ?? source.semanticLineageResolutionLinks),
+    ...array(source.lineageResolutions ?? source.semanticLineageResolutions),
+    ...array(source.metadata?.semanticLineageResolutionLinks),
+    ...array(source.metadata?.semanticHistoryLineageResolution),
+    ...array(source.metadata?.semanticLineageResolution),
+    ...array(source.metadata?.targetPortability?.lineageResolutionLinks),
+    ...array(targetPortability?.lineageResolutionLinks),
+    ...array(targetPortability?.lineageResolutions),
+    ...changedRegions.flatMap((region) => lineageLinksFromRegion(region))
+  ];
+}
+
+export function normalizeLineageResolutionLinks(entries) {
+  const seen = new Set();
+  const result = [];
+  for (const entry of lineageResolutionEntries(entries)) {
+    const currentAnchors = array(entry.currentAnchors);
+    const summary = entry.summary ?? {};
+    const anchorSummary = entry.anchorSummary ?? {};
+    const ids = uniqueStrings([
+      entry.id,
+      entry.resolutionId,
+      entry.lineageResolutionId,
+      ...strings(entry.lineageResolutionIds),
+      ...strings(entry.semanticLineageResolutionIds),
+      ...strings(summary.lineageResolutionIds)
+    ]);
+    const link = compactRecord({
+      id: firstString(entry.id, entry.resolutionId, entry.lineageResolutionId, ids[0]),
+      lineageResolutionIds: ids,
+      status: entry.status,
+      readiness: entry.readiness ?? entry.admission?.readiness,
+      action: entry.action ?? entry.admission?.action,
+      anchorKeys: uniqueStrings([
+        entry.anchorKey,
+        entry.query?.anchorKey,
+        entry.startAnchor?.key,
+        ...strings(entry.anchorKeys),
+        ...strings(anchorSummary.activeAnchorKeys),
+        ...strings(anchorSummary.candidateAnchorKeys),
+        ...strings(anchorSummary.blockedAnchorKeys),
+        ...strings(summary.activeAnchorKeys),
+        ...strings(summary.candidateAnchorKeys),
+        ...strings(summary.blockedAnchorKeys),
+        ...currentAnchors.map((anchor) => anchor.key)
+      ]),
+      sourcePaths: uniqueStrings([
+        entry.sourcePath,
+        entry.query?.sourcePath,
+        entry.startAnchor?.sourcePath,
+        ...strings(entry.sourcePaths),
+        ...strings(entry.lineageSourcePaths),
+        ...strings(summary.sourcePaths),
+        ...currentAnchors.flatMap((anchor) => [anchor.sourcePath, ...strings(anchor.lineageSourcePaths)])
+      ]),
+      evidenceIds: uniqueStrings([
+        ...strings(entry.evidenceIds),
+        ...strings(entry.lineageEvidenceIds),
+        ...strings(summary.evidenceIds),
+        ...currentAnchors.flatMap((anchor) => strings(anchor.evidenceIds))
+      ]),
+      proofIds: uniqueStrings([
+        ...strings(entry.proofIds),
+        ...strings(entry.lineageProofIds),
+        ...strings(summary.proofIds),
+        ...currentAnchors.flatMap((anchor) => strings(anchor.proofIds))
+      ]),
+      lineageEventIds: uniqueStrings([
+        ...strings(entry.lineageEventIds),
+        ...strings(entry.traversedEventIds),
+        ...strings(summary.lineageEventIds),
+        ...strings(summary.traversedEventIds),
+        ...currentAnchors.flatMap((anchor) => strings(anchor.lineageEventIds))
+      ]),
+      terminalEventIds: uniqueStrings([
+        ...strings(entry.terminalEventIds),
+        ...strings(summary.terminalEventIds),
+        ...currentAnchors.flatMap((anchor) => strings(anchor.terminalLineageEventIds))
+      ]),
+      crdtOperationIds: uniqueStrings([
+        ...strings(entry.crdtOperationIds),
+        ...strings(summary.crdtOperationIds),
+        ...currentAnchors.flatMap((anchor) => strings(anchor.crdtOperationIds))
+      ]),
+      crdtHeads: uniqueStrings([
+        ...strings(entry.crdtHeads),
+        ...strings(summary.crdtHeads),
+        ...currentAnchors.flatMap((anchor) => strings(anchor.crdtHeads))
+      ]),
+      reasonCodes: uniqueStrings([
+        ...strings(entry.reasonCodes),
+        ...strings(entry.lineageReasonCodes),
+        ...strings(summary.reasonCodes),
+        ...currentAnchors.flatMap((anchor) => strings(anchor.lineageReasonCodes))
+      ])
+    });
+    const key = firstString(link.id, ...strings(link.lineageResolutionIds), ...strings(link.lineageEventIds), ...strings(link.evidenceIds), ...strings(link.sourcePaths));
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    result.push(link);
+  }
+  return result;
+}
+
+export function semanticLineageLinkIndex(links = [], changedRegions = [], targetPortability, admission) {
+  const records = normalizeLineageResolutionLinks([
+    ...array(links),
+    ...array(targetPortability?.lineageResolutionLinks),
+    ...array(targetPortability?.lineageResolutions),
+    ...array(admission?.metadata?.semanticLineageResolutionLinks),
+    ...array(changedRegions).flatMap((region) => lineageLinksFromRegion(region))
+  ]);
+  return {
+    lineageResolutionIds: uniqueStrings(records.flatMap((record) => [record.id, ...strings(record.lineageResolutionIds)])),
+    lineageEventIds: uniqueStrings(records.flatMap((record) => record.lineageEventIds)),
+    sourcePaths: uniqueStrings(records.flatMap((record) => record.sourcePaths)),
+    evidenceIds: uniqueStrings(records.flatMap((record) => record.evidenceIds)),
+    proofIds: uniqueStrings(records.flatMap((record) => record.proofIds)),
+    reasonCodes: uniqueStrings(records.flatMap((record) => record.reasonCodes)),
+    terminalEventIds: uniqueStrings(records.flatMap((record) => record.terminalEventIds)),
+    crdtOperationIds: uniqueStrings(records.flatMap((record) => record.crdtOperationIds)),
+    crdtHeads: uniqueStrings(records.flatMap((record) => record.crdtHeads))
+  };
+}
+
+export function linkAdmissionLineage(admission, lineageLinks) {
+  if (lineageLinks.length === 0) return admission;
+  const lineageIndex = semanticLineageLinkIndex(lineageLinks);
+  return {
+    ...admission,
+    evidenceIds: uniqueStrings([...strings(admission.evidenceIds), ...lineageIndex.evidenceIds]),
+    reasonCodes: uniqueStrings([...strings(admission.reasonCodes), 'semantic-lineage-resolution-linked', ...lineageIndex.reasonCodes]),
+    metadata: compactRecord({
+      ...(admission.metadata ?? {}),
+      semanticLineageResolutionLinks: lineageLinks
+    })
+  };
+}
+
+function lineageLinksFromRegion(region = {}) {
+  const metadata = region.metadata ?? {};
+  const bidirectional = metadata.bidirectionalTargetChange ?? {};
+  const history = metadata.semanticHistoryLineageResolution ?? {};
+  const lineage = metadata.semanticLineageResolution ?? {};
+  return [
+    ...array(region.lineageResolutionLinks),
+    ...array(region.lineageResolutions),
+    compactRecord({
+      lineageResolutionIds: region.lineageResolutionIds,
+      lineageEventIds: region.lineageEventIds,
+      sourcePaths: region.lineageSourcePaths,
+      evidenceIds: region.lineageEvidenceIds,
+      proofIds: region.lineageProofIds,
+      reasonCodes: region.lineageReasonCodes
+    }),
+    bidirectional,
+    history,
+    lineage,
+    ...array(bidirectional.lineageResolutionLinks),
+    ...array(history.lineageResolutionLinks),
+    ...array(lineage.lineageResolutionLinks)
+  ].filter((entry) => Object.keys(entry ?? {}).length > 0);
+}
+
+function lineageResolutionEntries(entries) {
+  const result = [];
+  for (const entry of array(entries).filter(Boolean)) {
+    result.push(entry);
+    result.push(...array(entry.resolutions));
+    result.push(...array(entry.lineageResolutions));
+    result.push(...array(entry.semanticLineageResolutions));
+    result.push(...array(entry.lineageResolutionLinks));
+    result.push(...array(entry.semanticLineageResolutionLinks));
+  }
+  return result;
+}
+
+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 compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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

@@ -90,7 +90,7 @@ export function querySemanticPatchBundleOverlaps(records,query={}){
 }
 
 function sharedIndex(left,right,options){
-  return{
+  const shared={
     operationContentHashes:intersect(left.operationContentHashes,right.operationContentHashes),
     editContentHashes:intersect(left.editContentHashes,right.editContentHashes),
     semanticEditKeys:intersect(left.semanticEditKeys,right.semanticEditKeys),
@@ -110,11 +110,37 @@ function sharedIndex(left,right,options){
     baseHashes:intersect(left.baseHashes,right.baseHashes),
     targetHashes:intersect(left.targetHashes,right.targetHashes)
   };
+  const scopedEdit=hasSharedEditScope(shared);
+  const scopedSource=hasSharedSourceScope(shared);
+  return{
+    ...shared,
+    operationContentHashes:scopedEdit?shared.operationContentHashes:[],
+    editContentHashes:scopedEdit?shared.editContentHashes:[],
+    semanticEditKeys:scopedSource?shared.semanticEditKeys:[],
+    semanticIdentityHashes:scopedSource?shared.semanticIdentityHashes:[],
+    semanticEditReplayCurrentHashes:scopedSource?shared.semanticEditReplayCurrentHashes:[],
+    semanticEditReplayOutputHashes:scopedEdit?shared.semanticEditReplayOutputHashes:[],
+    semanticTransformContentHashes:shared.projectionIdentityHashes.length?shared.semanticTransformContentHashes:[],
+    semanticTransformIdentityHashes:shared.projectionIdentityHashes.length?shared.semanticTransformIdentityHashes:[]
+  };
+}
+
+function hasSharedEditScope(shared){
+  return Boolean(shared.regionKeys.length||shared.conflictKeys.length||shared.sourceIdentityHashes.length
+    ||(shared.sourcePaths.length&&(shared.semanticEditKeys.length||shared.semanticIdentityHashes.length)));
+}
+
+function hasSharedSourceScope(shared){
+  return Boolean(shared.sourcePaths.length||shared.regionKeys.length||shared.conflictKeys.length||shared.sourceIdentityHashes.length);
 }
 
 function overlapAdmission(shared,{leftIndex,rightIndex,options}){
-  const duplicate=shared.operationContentHashes.length||shared.editContentHashes.length||shared.semanticTransformContentHashes.length||shared.semanticEditReplayIds.length||shared.semanticEditReplayOutputHashes.length;
-  const semantic=shared.semanticEditKeys.length||shared.semanticIdentityHashes.length||shared.sourceIdentityHashes.length||shared.semanticTransformIdentityHashes.length||shared.projectionIdentityHashes.length;
+  const hashMismatch=disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)||disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes);
+  const sourceRelated=shared.sourcePaths.length||shared.regionKeys.length||shared.conflictKeys.length||shared.sourceIdentityHashes.length;
+  const editContent=shared.operationContentHashes.length||shared.editContentHashes.length||shared.semanticEditReplayOutputHashes.length;
+  const transformContent=shared.semanticTransformContentHashes.length&&shared.projectionIdentityHashes.length;
+  const duplicate=(transformContent||shared.semanticEditReplayIds.length||(editContent&&sourceRelated))&&!hashMismatch;
+  const semantic=editContent||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||shared.semanticEditReplayCurrentHashes.length;
   const status=duplicate?'duplicate':semantic?'semantic-overlap':source?'source-overlap':'independent';
   const reasonCodes=uniqueStrings([

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

@@ -2,6 +2,8 @@ import{idFragment,normalizeSemanticMergeReadiness,uniqueStrings}from'../../nativ
 import{createSemanticEditBundleAdmission}from'./semanticEditBundleAdmission.js';
 import{createSemanticPatchBundleAdmission}from'./semanticPatchBundleAdmission.js';
 import{semanticEditRecordIndex,semanticEditSummary}from'./semanticEditBundleIndex.js';
+import{lineageLinkInputs,linkAdmissionLineage,normalizeLineageResolutionLinks,semanticLineageLinkIndex}from'./semanticPatchBundleLineageLinks.js';
+import{normalizeRegions,normalizeSourceMapLinks,normalizeSources,sourceRef}from'./semanticPatchBundleSourceRecords.js';
 import{normalizeSemanticTransformIdentityRecords,semanticTransformInputs,semanticTransformRecordIndex,semanticTransformSummary}from'./semanticTransformIdentityRecords.js';
 
 export const SemanticPatchBundleAdmissionStatuses=Object.freeze(['proposed','queued','admitted','needs-review','blocked','rejected']);
@@ -13,8 +15,10 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const semanticEditScripts=array(options.semanticEditScripts??source.semanticEditScripts??source.semanticEditScript);
   const semanticEditProjections=array(options.semanticEditProjections??source.semanticEditProjections??source.semanticEditProjection);
   const semanticEditReplays=array(options.semanticEditReplays??source.semanticEditReplays??source.semanticEditReplay);
+  const evidenceRecords=[...array(options.evidence??source.evidence),...array(patch?.evidence),...array(mergeCandidate?.evidence),...semanticEditScripts.flatMap((script)=>array(script.evidence))];
   const editAdmission=createSemanticEditBundleAdmission({
     semanticEditScripts,semanticEditProjections,semanticEditReplays,
+    evidence:evidenceRecords,
     ...(source.metadata?.semanticEditAdmission??{}),
     ...(source.semanticEditAdmission??{}),
     ...(options.semanticEditAdmission??{})
@@ -35,15 +39,16 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     sourceRef(source.before,'before',source.beforeHash),
     sourceRef(source.after,'after',source.afterHash)
   ],source);
-  const evidenceRecords=[...array(options.evidence??source.evidence),...array(patch?.evidence),...array(mergeCandidate?.evidence),...semanticEditScripts.flatMap((script)=>array(script.evidence))];
   const patchId=firstString(options.patchId,source.patchId,patch?.id,mergeCandidate?.patchId);
   const mergeCandidateId=firstString(options.mergeCandidateId,source.mergeCandidateId,mergeCandidate?.id);
   const baseHash=firstString(options.baseHash,source.baseHash,source.beforeHash,patch?.baseHash,mergeCandidate?.baseHash,...sources.map((item)=>item.baseHash));
   const targetHash=firstString(options.targetHash,source.targetHash,source.afterHash,patch?.targetHash,mergeCandidate?.targetHash,...sources.map((item)=>item.targetHash));
   const readiness=normalizeSemanticMergeReadiness(firstString(options.readiness,source.readiness,source.admission?.readiness,mergeCandidate?.readiness))
     ?? firstString(options.readiness,source.readiness,source.admission?.readiness,mergeCandidate?.readiness,'needs-review');
-  const evidenceIds=uniqueStrings([...strings(options.evidenceIds),...strings(source.evidenceIds),...evidenceRecords.map((record)=>record?.id),...strings(mergeCandidate?.evidenceIds)]);
-  const proofIds=uniqueStrings([...strings(options.proofIds),...strings(source.proofIds),...evidenceRecords.filter((record)=>record?.kind==='proof').map((record)=>record.id),...strings(mergeCandidate?.proofIds)]);
+  const lineageLinks=normalizeLineageResolutionLinks(lineageLinkInputs(source,options,changedRegions,targetPortability));
+  const lineageIndex=semanticLineageLinkIndex(lineageLinks,changedRegions,targetPortability);
+  const evidenceIds=uniqueStrings([...strings(options.evidenceIds),...strings(source.evidenceIds),...evidenceRecords.map((record)=>record?.id),...strings(mergeCandidate?.evidenceIds),...lineageIndex.evidenceIds]);
+  const proofIds=uniqueStrings([...strings(options.proofIds),...strings(source.proofIds),...evidenceRecords.filter((record)=>record?.kind==='proof').map((record)=>record.id),...strings(mergeCandidate?.proofIds),...lineageIndex.proofIds]);
   const historyIds=uniqueStrings([...strings(options.historyIds),...strings(options.historyId),...strings(source.historyIds),...strings(source.historyId)]);
   const semanticOperationIds=uniqueStrings([...strings(options.semanticOperationIds),...strings(options.semanticOperationId),...strings(source.semanticOperationIds),...strings(source.semanticOperationId),...strings(patch?.semanticOperationIds),...strings(mergeCandidate?.semanticOperationIds),...editIndex.semanticEditOperationIds]);
   const conflictKeys=uniqueStrings([
@@ -53,12 +58,12 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     ...changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),
     ...(source.metadata?.semanticMergeConflictSummary?.conflictKeys??[])
   ]);
-  const admission=createSemanticPatchBundleAdmission(options.admission??source.admission,{readiness,conflictKeys,source,mergeCandidate,semanticTransformIndex,semanticTransformIdentities,semanticEditAdmission:editAdmission});
+  const admission=linkAdmissionLineage(createSemanticPatchBundleAdmission(options.admission??source.admission,{readiness,conflictKeys,source,mergeCandidate,evidenceRecords,semanticTransformIndex,semanticTransformIdentities,semanticEditAdmission:editAdmission}),lineageLinks);
   const id=options.id??(source.kind==='frontier.lang.semanticPatchBundleRecord'?source.id:undefined)
     ??`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,semanticEditAdmission:editAdmission,semanticEditIndex:editIndex,semanticTransformIndex,targetPortability});
+  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditAdmission:editAdmission,semanticEditIndex:editIndex,semanticTransformIndex,targetPortability,lineageLinks});
   return{
     kind:'frontier.lang.semanticPatchBundleRecord',
     version:1,
@@ -95,6 +100,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
       semanticEditAdmission:editAdmission,
       semanticTransformSummary:semanticTransformSummary(semanticTransformIndex),
       targetPortability,
+      semanticLineageResolutionLinks:lineageLinks,
       ...options.metadata
     })
   };
@@ -104,118 +110,30 @@ export function querySemanticPatchBundleRecords(records,query={}){
   return array(records).filter(Boolean).filter((record)=>matchesRecord(record,query)).sort((left,right)=>String(left.id).localeCompare(String(right.id)));
 }
 
-function normalizeSources(entries,context){
-  return entries.filter(Boolean).map((entry,index)=>compactRecord({
-    id:entry.id??entry.sourceId,
-    side:entry.side,
-    importId:entry.importId??entry.importResultId,
-    language:entry.language??context.language,
-    sourcePath:entry.sourcePath??context.sourcePath,
-    sourceHash:entry.sourceHash??entry.hash,
-    baseHash:entry.baseHash??entry.beforeHash??context.baseHash??context.beforeHash,
-    targetHash:entry.targetHash??entry.afterHash??context.targetHash??context.afterHash,
-    nativeSourceId:entry.nativeSourceId,
-    nativeAstId:entry.nativeAstId,
-    semanticIndexId:entry.semanticIndexId,
-    universalAstId:entry.universalAstId,
-    sourceMapIds:uniqueStrings(entry.sourceMapIds),
-    ordinal:index
-  })).filter((entry)=>entry.importId||entry.sourcePath||entry.sourceHash||entry.baseHash||entry.targetHash);
-}
-
-function sourceRef(importResult,side,sourceHash){
-  if(!importResult)return undefined;
-  return compactRecord({
-    id:`${side}_${importResult.id??idFragment(importResult.sourcePath??'source')}`,side,importId:importResult.id,
-    language:importResult.language,
-    sourcePath:importResult.sourcePath,
-    sourceHash:sourceHash??importResult.nativeSource?.sourceHash??importResult.nativeAst?.sourceHash??importResult.sourceHash,
-    nativeSourceId:importResult.nativeSource?.id,
-    nativeAstId:importResult.nativeAst?.id,
-    semanticIndexId:importResult.semanticIndex?.id,
-    universalAstId:importResult.universalAst?.id,
-    sourceMapIds:uniqueStrings((importResult.sourceMaps??[]).map((map)=>map.id))
-  });
-}
-
-function normalizeRegions(regions,context){
-  return regions.filter(Boolean).map((region,index)=>{
-    const projection=region.metadata?.changedRegionProjection??region.projection;
-    const projected=projection?.region??{};
-    const key=firstString(region.key,region.ownershipKey,projected.key,region.conflictKey,region.id);
-    const conflictKey=firstString(region.conflictKey,projection?.conflictKey,key);
-    const links=array(projection?.sourceMapLinks??region.sourceMapLinks);
-    return compactRecord({
-      id:region.id??projected.id??`changed_region_${index+1}`,
-      key,
-      conflictKey,
-      changeKind:region.changeKind??projection?.changeKind,
-      regionKind:region.regionKind??region.ownershipRegionKind??projected.kind,
-      granularity:region.granularity??projected.granularity,
-      precision:region.precision??projected.precision,
-      language:region.language??projection?.language??context.language,
-      sourcePath:region.sourcePath??projection?.sourcePath??context.sourcePath,
-      sourceHash:region.sourceHash??projection?.after?.sourceHash??projection?.before?.sourceHash,
-      symbolId:region.symbolId??projected.symbolId,
-      symbolName:region.symbolName??region.name??projected.symbolName,
-      symbolKind:region.symbolKind??projected.symbolKind,
-      sourceSpan:region.sourceSpan??projected.sourceSpan,
-      sourceMapLinkIds:uniqueStrings([...strings(region.sourceMapLinkIds),...links.map((link)=>link.id)]),
-      sourceMapIds:uniqueStrings([...strings(region.sourceMapIds),...links.map((link)=>link.sourceMapId)]),
-      sourceMapMappingIds:uniqueStrings([...strings(region.sourceMapMappingIds),...links.map((link)=>link.sourceMapMappingId)]),
-      admission:compactRecord({
-        readiness:projection?.admission?.readiness??region.admission?.readiness,
-        action:projection?.admission?.action??region.admission?.action,
-        reasonCodes:uniqueStrings([...strings(region.admission?.reasonCodes),...strings(projection?.admission?.reasons)]),
-        conflictKeys:uniqueStrings([...strings(region.admission?.conflictKeys),...strings(projection?.admission?.conflictKeys)])
-      }),
-      metadata:region.metadata
-    });
-  });
-}
-
-function normalizeSourceMapLinks(links){
-  const seen=new Set();
-  const result=[];
-  for(const link of links.filter(Boolean)){
-    const id=link.id??`source_map_link_${result.length+1}`;
-    if(seen.has(id))continue;
-    seen.add(id);
-    result.push(compactRecord({
-      id,side:link.side,sourceMapId:link.sourceMapId,sourceMapMappingId:link.sourceMapMappingId,
-      sourcePath:link.sourcePath,sourceHash:link.sourceHash,targetPath:link.targetPath,targetHash:link.targetHash,
-      semanticSymbolId:link.semanticSymbolId,
-      semanticOccurrenceId:link.semanticOccurrenceId,
-      semanticNodeId:link.semanticNodeId,
-      nativeSourceId:link.nativeSourceId,
-      nativeAstNodeId:link.nativeAstNodeId,
-      precision:link.precision,
-      sourceSpan:link.sourceSpan,
-      generatedSpan:link.generatedSpan,
-      regionKey:link.ownershipRegionKey,
-      regionKind:link.ownershipRegionKind
-    }));
-  }
-  return result;
-}
-
 function recordIndex(parts){
   const editIndex=parts.semanticEditIndex??semanticEditRecordIndex([],[],[],parts);
   const editAdmission=parts.semanticEditAdmission??{};
   const semanticTransformIndex=parts.semanticTransformIndex??semanticTransformRecordIndex([],parts);
+  const lineageIndex=semanticLineageLinkIndex(parts.lineageLinks,parts.changedRegions,parts.targetPortability,parts.admission);
   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),...strings(editAdmission.sourcePaths),...editIndex.projectedSourcePaths,...semanticTransformIndex.transformSourcePaths,...semanticTransformIndex.transformTargetPaths]),
+    sourcePaths:uniqueStrings([...parts.sources.map((item)=>item.sourcePath),...strings(editAdmission.sourcePaths),...editIndex.projectedSourcePaths,...semanticTransformIndex.transformSourcePaths,...semanticTransformIndex.transformTargetPaths,...lineageIndex.sourcePaths]),
     regionKeys:uniqueStrings([...parts.changedRegions.map((region)=>region.key),...editIndex.anchorKeys]),
     regionKinds:uniqueStrings(parts.changedRegions.map((region)=>region.regionKind)),
     conflictKeys:uniqueStrings([...parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),...editIndex.conflictKeys]),
     sourceMapIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapId),...parts.changedRegions.flatMap((region)=>region.sourceMapIds??[])]),
     sourceMapMappingIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapMappingId),...parts.changedRegions.flatMap((region)=>region.sourceMapMappingIds??[])]),
     sourceMapLinkIds:uniqueStrings(parts.sourceMapLinks.map((link)=>link.id)),
-    evidenceIds:parts.evidenceIds,
-    proofIds:parts.proofIds,
+    evidenceIds:uniqueStrings([...parts.evidenceIds,...lineageIndex.evidenceIds]),
+    proofIds:uniqueStrings([...parts.proofIds,...lineageIndex.proofIds]),
+    lineageResolutionIds:lineageIndex.lineageResolutionIds,
+    lineageEventIds:lineageIndex.lineageEventIds,
+    lineageSourcePaths:lineageIndex.sourcePaths,
+    lineageEvidenceIds:lineageIndex.evidenceIds,
+    lineageProofIds:lineageIndex.proofIds,
+    lineageReasonCodes:lineageIndex.reasonCodes,
     historyIds:parts.historyIds,
     semanticOperationIds:uniqueStrings(parts.semanticOperationIds),
     semanticEditScriptIds:editIndex.semanticEditScriptIds,
@@ -255,7 +173,7 @@ function recordIndex(parts){
 }
 
 function matchesRecord(record,query){
-  const index=record.index??recordIndex({...record,baseHash:record.baseHash,targetHash:record.targetHash,sources:record.sources??[],changedRegions:record.changedRegions??[],sourceMapLinks:record.sourceMapLinks??[],evidenceIds:record.evidenceIds??[],proofIds:record.proofIds??[],historyIds:record.historyIds??[],semanticOperationIds:record.semanticOperationIds??[],patchId:record.patchId,mergeCandidateId:record.mergeCandidateId,admission:record.admission??{},semanticEditAdmission:record.admission?.semanticEditAdmission??record.metadata?.semanticEditAdmission,targetPortability:record.metadata?.targetPortability});
+  const index=record.index??recordIndex({...record,baseHash:record.baseHash,targetHash:record.targetHash,sources:record.sources??[],changedRegions:record.changedRegions??[],sourceMapLinks:record.sourceMapLinks??[],evidenceIds:record.evidenceIds??[],proofIds:record.proofIds??[],historyIds:record.historyIds??[],semanticOperationIds:record.semanticOperationIds??[],patchId:record.patchId,mergeCandidateId:record.mergeCandidateId,admission:record.admission??{},semanticEditAdmission:record.admission?.semanticEditAdmission??record.metadata?.semanticEditAdmission,targetPortability:record.metadata?.targetPortability,lineageLinks:normalizeLineageResolutionLinks([...array(record.metadata?.semanticLineageResolutionLinks),...array(record.admission?.metadata?.semanticLineageResolutionLinks)])});
   return matchAny(queryValues(query.id,query.ids),[record.id])
     &&matchAny(queryValues(query.patchId,query.patchIds),index.patchIds)
     &&matchAny(queryValues(query.mergeCandidateId,query.mergeCandidateIds),index.mergeCandidateIds)
@@ -271,6 +189,12 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.sourceMapLinkId,query.sourceMapLinkIds),index.sourceMapLinkIds)
     &&matchAny(queryValues(query.evidenceId,query.evidenceIds),index.evidenceIds)
     &&matchAny(queryValues(query.proofId,query.proofIds),index.proofIds)
+    &&matchAny(queryValues(query.lineageResolutionId,query.lineageResolutionIds,query.semanticLineageResolutionId,query.semanticLineageResolutionIds),index.lineageResolutionIds)
+    &&matchAny(queryValues(query.lineageEventId,query.lineageEventIds),index.lineageEventIds)
+    &&matchAny(queryValues(query.lineageSourcePath,query.lineageSourcePaths),index.lineageSourcePaths)
+    &&matchAny(queryValues(query.lineageEvidenceId,query.lineageEvidenceIds),index.lineageEvidenceIds)
+    &&matchAny(queryValues(query.lineageProofId,query.lineageProofIds),index.lineageProofIds)
+    &&matchAny(queryValues(query.lineageReasonCode,query.lineageReasonCodes),index.lineageReasonCodes)
     &&matchAny(queryValues(query.historyId,query.historyIds),index.historyIds)
     &&matchAny(queryValues(query.semanticOperationId,query.semanticOperationIds),index.semanticOperationIds)
     &&matchAny(queryValues(query.semanticEditScriptId,query.semanticEditScriptIds),index.semanticEditScriptIds)