@shapeshift-labs/frontier-lang-compiler 0.2.98 → 0.2.100

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

@@ -2,27 +2,43 @@ import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-imp
 
 export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
   const transformAdmission = semanticTransformAdmission(context);
-  const fallbackReadiness = transformAdmission.readiness === 'ready' ? 'ready' : context.readiness;
-  const readiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
-  const status = input.status ?? admissionStatusForReadiness(readiness, transformAdmission);
-  const autoApplyCandidate = input.autoApplyCandidate ?? (status === 'admitted' && transformAdmission.action === 'admit');
+  const semanticEditAdmission = context.semanticEditAdmission ?? { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] };
+  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
-    ]),
+      ...transformAdmission.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
   });
 }
@@ -68,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) {
@@ -81,17 +97,120 @@ function transformReadiness(value) {
   return undefined;
 }
 
-function admissionStatusForReadiness(readiness, transformAdmission) {
+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, evidenceAdmission) {
   if (readiness === 'blocked') return 'blocked';
-  if (transformAdmission.action === 'admit' && readiness === 'ready') return 'admitted';
+  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission, evidenceAdmission) && readiness === 'ready') return 'admitted';
   return readiness === 'needs-review' ? 'needs-review' : 'proposed';
 }
 
+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) {
   const source = new Set(strings(index.transformSourceLanguages));
   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

@@ -113,8 +113,12 @@ function sharedIndex(left,right,options){
 }
 
 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([