@shapeshift-labs/frontier-lang-compiler 0.2.102 → 0.2.104

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

@@ -2,21 +2,25 @@ 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 semanticEditAdmission = semanticEditAdmissionWithReplayRequirement(
+    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'
+  const requestedReadiness = normalizeSemanticMergeReadiness(input.readiness) ?? input.readiness;
+  const inputReadiness = fallbackReadiness === 'blocked' ? 'blocked' : requestedReadiness ?? fallbackReadiness;
+  const positiveApply = !hasSkipReadyAction(semanticEditAdmission) && hasPositiveApplyAction(transformAdmission, semanticEditAdmission);
+  const readiness = positiveApply && 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 status = safePatchBundleStatus(input.status, computedStatus);
   const computedAutoApplyCandidate = status === 'admitted' &&
-    hasPositiveApplyAction(transformAdmission, semanticEditAdmission) &&
+    positiveApply &&
     evidenceAdmission.action === 'admit';
   const autoApplyCandidate = input.autoApplyCandidate === true ? computedAutoApplyCandidate : input.autoApplyCandidate ?? computedAutoApplyCandidate;
   const admittedWithoutPositiveProof = status === 'admitted' &&
-    hasPositiveApplyAction(transformAdmission, semanticEditAdmission) &&
+    positiveApply &&
     evidenceAdmission.action !== 'admit';
   return compactRecord({
     status,
@@ -35,7 +39,7 @@ export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
       ...strings(semanticEditAdmission.reasonCodes),
       ...strings(evidenceAdmission.reasonCodes)
     ].filter(Boolean)),
-    conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...context.conflictKeys]),
+    conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...strings(context.conflictKeys)]),
     admittedAt: input.admittedAt,
     reviewerId: input.reviewerId,
     evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(transformAdmission.evidenceIds), ...strings(evidenceAdmission.evidenceIds)]),
@@ -70,10 +74,15 @@ function semanticTransformAdmission(context) {
     transformKeys: strings(index.semanticTransformKeys),
     contentHashes: strings(index.semanticTransformContentHashes),
     projectionIdentityHashes: strings(index.projectionIdentityHashes),
+    baseHashes: strings(index.transformBaseHashes),
+    targetHashes: strings(index.transformTargetHashes),
     sourceLanguages: strings(index.transformSourceLanguages),
     targetLanguages: strings(index.transformTargetLanguages),
     sourcePaths: strings(index.transformSourcePaths),
     targetPaths: strings(index.transformTargetPaths),
+    sourceMapIds: strings(index.transformSourceMapIds),
+    sourceMapLinkIds: strings(index.transformSourceMapLinkIds),
+    sourceMapMappingIds: strings(index.transformSourceMapMappingIds),
     evidenceIds: strings(index.semanticTransformEvidenceIds)
   });
 }
@@ -106,8 +115,12 @@ function autoMergeEvidenceAdmission(context, admissions) {
     ...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 skipReady = hasSkipReadyAction(admissions.semanticEditAdmission);
+  const positiveApply = !skipReady &&
+    hasPositiveApplyAttempt(admissions.transformAdmission, admissions.semanticEditAdmission);
+  if (!positiveApply) return skipReady
+    ? skipEvidenceAdmission(evidence)
+    : { 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;
@@ -125,6 +138,23 @@ function autoMergeEvidenceAdmission(context, admissions) {
   });
 }
 
+function skipEvidenceAdmission(evidence) {
+  const summary = summarizeAutoMergeEvidence(evidence);
+  const blocked = summary.failed > 0 || summary.conflict > 0;
+  const status = blocked ? 'blocked' : summary.stale > 0 ? 'stale' : summary.passed > 0 ? 'ready' : 'none';
+  return compactRecord({
+    status,
+    action: blocked ? 'block' : status === 'stale' ? 'rerun-semantic-import' : status === 'ready' ? 'skip' : 'none',
+    readiness: blocked ? 'blocked' : status === 'ready' ? 'ready' : 'needs-review',
+    reasonCodes: status === 'none' ? [] : 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']));
@@ -155,6 +185,7 @@ function fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, e
   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;
+  if (semanticEditAdmission.action === 'review' || semanticEditAdmission.status === 'needs-review') return 'needs-review';
   return fallback;
 }
 
@@ -164,6 +195,12 @@ function admissionStatusForReadiness(readiness, transformAdmission, semanticEdit
   return readiness === 'needs-review' ? 'needs-review' : 'proposed';
 }
 
+function safePatchBundleStatus(requested, computed) {
+  if (computed === 'blocked' && requested !== 'rejected') return 'blocked';
+  if (requested === 'admitted' && computed !== 'admitted') return computed;
+  return requested ?? computed;
+}
+
 function hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission, evidenceAdmission) {
   return hasSkipReadyAction(semanticEditAdmission) ||
     (hasPositiveApplyAction(transformAdmission, semanticEditAdmission) && evidenceAdmission.action === 'admit');
@@ -183,6 +220,51 @@ function hasSkipReadyAction(semanticEditAdmission) {
   return semanticEditAdmission.action === 'skip' && semanticEditAdmission.readiness === 'ready' && semanticEditAdmission.reviewRequired === false;
 }
 
+function semanticEditAdmissionWithReplayRequirement(admission) {
+  if (!requiresSemanticEditReplay(admission) || hasAcceptedCleanSemanticEditReplay(admission)) return admission;
+  return compactRecord({
+    ...admission,
+    status: 'needs-review',
+    action: 'review',
+    readiness: 'needs-review',
+    reviewRequired: true,
+    autoApplyCandidate: false,
+    reasonCodes: uniqueStrings([
+      ...strings(admission.reasonCodes).filter((reason) => reason !== 'semantic-edit-positive-auto-merge-proof'),
+      ...semanticEditReplayRequirementReasonCodes(admission)
+    ])
+  });
+}
+
+function requiresSemanticEditReplay(admission) {
+  return admission.action === 'admit' ||
+    admission.autoApplyCandidate === true ||
+    admission.status === 'ready' ||
+    strings(admission.reasonCodes).includes('semantic-edit-positive-auto-merge-proof');
+}
+
+function hasAcceptedCleanSemanticEditReplay(admission) {
+  const summary = admission.summary ?? {};
+  const acceptedClean = count(summary.acceptedClean);
+  const alreadyApplied = count(summary.alreadyApplied);
+  const replays = count(summary.replays);
+  return acceptedClean > 0 && replays > 0 && acceptedClean + alreadyApplied === replays;
+}
+
+function semanticEditReplayRequirementReasonCodes(admission) {
+  const summary = admission.summary ?? {};
+  const scripts = count(summary.scripts);
+  const projections = count(summary.projections);
+  const replays = count(summary.replays);
+  const acceptedClean = count(summary.acceptedClean);
+  return [
+    scripts > 0 && projections === 0 ? 'semantic-edit-projection-missing' : undefined,
+    (scripts > 0 || projections > 0) && replays === 0 ? 'semantic-edit-replay-missing' : undefined,
+    replays > 0 && acceptedClean === 0 ? 'semantic-edit-replay-accepted-clean-missing' : undefined,
+    'semantic-edit-replay-required'
+  ].filter(Boolean);
+}
+
 function hasCrossLanguageTransform(index) {
   const source = new Set(strings(index.transformSourceLanguages));
   return strings(index.transformTargetLanguages).some((target) => !source.has(target));
@@ -211,6 +293,7 @@ function uniqueEvidenceRecords(records) {
 }
 
 function evidenceIds(evidence) { return uniqueStrings(evidence.map((record) => record.id)); }
+function count(value) { const number = Number(value ?? 0); return Number.isFinite(number) ? number : 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 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

@@ -65,7 +65,8 @@ export function compareSemanticPatchBundleRecords(left={},right={},options={}){
       semanticSignals:shared.semanticEditKeys.length+shared.semanticIdentityHashes.length+shared.sourceIdentityHashes.length+shared.semanticTransformIdentityHashes.length+shared.projectionIdentityHashes.length,
       sourceSignals:shared.regionKeys.length+shared.conflictKeys.length+shared.sourcePaths.length+shared.semanticEditReplayCurrentHashes.length,
       baseHashMismatch:admission.reasonCodes.includes('base-hash-mismatch'),
-      targetHashMismatch:admission.reasonCodes.includes('target-hash-mismatch')
+      targetHashMismatch:admission.reasonCodes.includes('target-hash-mismatch'),
+      replayOutputHashMismatch:admission.reasonCodes.includes('replay-output-hash-mismatch')
     },
     metadata:compactRecord(options.metadata)
   };
@@ -110,21 +111,32 @@ 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{
+  const semanticKeyIndependent=hasDisjointSemanticEditScope(left,right,shared);
+  const scopedShared={
     ...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:[]
+    sourcePaths:semanticKeyIndependent?[]:shared.sourcePaths
+  };
+  const scopedEdit=hasSharedEditScope(scopedShared);
+  const scopedSource=hasSharedSourceScope(scopedShared);
+  return{
+    ...scopedShared,
+    operationContentHashes:scopedEdit?scopedShared.operationContentHashes:[],
+    editContentHashes:scopedEdit?scopedShared.editContentHashes:[],
+    semanticEditKeys:scopedSource?scopedShared.semanticEditKeys:[],
+    semanticIdentityHashes:scopedSource?scopedShared.semanticIdentityHashes:[],
+    semanticEditReplayCurrentHashes:scopedSource?scopedShared.semanticEditReplayCurrentHashes:[],
+    semanticEditReplayOutputHashes:scopedEdit?scopedShared.semanticEditReplayOutputHashes:[],
+    semanticTransformContentHashes:scopedShared.projectionIdentityHashes.length?scopedShared.semanticTransformContentHashes:[],
+    semanticTransformIdentityHashes:scopedShared.projectionIdentityHashes.length?scopedShared.semanticTransformIdentityHashes:[]
   };
 }
 
+function hasDisjointSemanticEditScope(left,right,shared){
+  return Boolean(shared.sourcePaths.length&&left.semanticEditKeys.length&&right.semanticEditKeys.length
+    &&shared.semanticEditKeys.length===0&&shared.regionKeys.length===0&&shared.conflictKeys.length===0
+    &&shared.semanticIdentityHashes.length===0&&shared.sourceIdentityHashes.length===0);
+}
+
 function hasSharedEditScope(shared){
   return Boolean(shared.regionKeys.length||shared.conflictKeys.length||shared.sourceIdentityHashes.length
     ||(shared.sourcePaths.length&&(shared.semanticEditKeys.length||shared.semanticIdentityHashes.length)));
@@ -135,7 +147,10 @@ function hasSharedSourceScope(shared){
 }
 
 function overlapAdmission(shared,{leftIndex,rightIndex,options}){
-  const hashMismatch=disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)||disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes);
+  const baseHashMismatch=disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes);
+  const targetHashMismatch=disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes);
+  const replayOutputHashMismatch=disjointNonEmpty(leftIndex.semanticEditReplayOutputHashes,rightIndex.semanticEditReplayOutputHashes);
+  const hashMismatch=baseHashMismatch||targetHashMismatch||replayOutputHashMismatch;
   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;
@@ -158,8 +173,9 @@ function overlapAdmission(shared,{leftIndex,rightIndex,options}){
     shared.regionKeys.length?'same-region-key':undefined,
     shared.conflictKeys.length?'same-conflict-key':undefined,
     shared.sourcePaths.length?'same-source-path':undefined,
-    status!=='independent'&&disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)?'base-hash-mismatch':undefined,
-    status!=='independent'&&disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes)?'target-hash-mismatch':undefined
+    status!=='independent'&&baseHashMismatch?'base-hash-mismatch':undefined,
+    status!=='independent'&&targetHashMismatch?'target-hash-mismatch':undefined,
+    status!=='independent'&&replayOutputHashMismatch?'replay-output-hash-mismatch':undefined
   ]);
   return{
     status,
@@ -223,7 +239,8 @@ function matchesOverlap(overlap,query){
 function overlapScore(status,shared,reasonCodes){
   const base=status==='duplicate'?100:status==='semantic-overlap'?75:status==='source-overlap'?35:0;
   const sharedBonus=Math.min(20,countShared(shared));
-  const stalePenalty=reasonCodes.includes('base-hash-mismatch')||reasonCodes.includes('target-hash-mismatch')?15:0;
+  const stalePenalty=reasonCodes.includes('base-hash-mismatch')||reasonCodes.includes('target-hash-mismatch')
+    ||reasonCodes.includes('replay-output-hash-mismatch')?15:0;
   return Math.max(0,base+sharedBonus-stalePenalty);
 }
 

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

@@ -141,11 +141,13 @@ function recordIndex(parts){
     semanticEditReplayIds:editIndex.semanticEditReplayIds,
     semanticEditReplayStatuses:editIndex.semanticEditReplayStatuses,
     semanticEditReplayActions:editIndex.semanticEditReplayActions,
+    semanticEditReplayReasonCodes:editIndex.semanticEditReplayReasonCodes,
     semanticEditAdmissionStatuses:uniqueStrings([editAdmission.status]),
     semanticEditAdmissionActions:uniqueStrings([editAdmission.action]),
     semanticEditAdmissionReadinesses:uniqueStrings([editAdmission.readiness]),
     semanticEditReplayCurrentHashes:editIndex.semanticEditReplayCurrentHashes,
     semanticEditReplayOutputHashes:editIndex.semanticEditReplayOutputHashes,
+    sourceBackprojectionModes:editIndex.sourceBackprojectionModes,
     semanticEditKeys:editIndex.semanticEditKeys,
     semanticIdentityHashes:editIndex.semanticIdentityHashes,
     sourceIdentityHashes:editIndex.sourceIdentityHashes,
@@ -156,12 +158,18 @@ function recordIndex(parts){
     semanticTransformIdentityHashes:semanticTransformIndex.semanticTransformIdentityHashes,
     semanticTransformContentHashes:semanticTransformIndex.semanticTransformContentHashes,
     projectionIdentityHashes:semanticTransformIndex.projectionIdentityHashes,
+    transformBaseHashes:semanticTransformIndex.transformBaseHashes,
+    transformTargetHashes:semanticTransformIndex.transformTargetHashes,
     semanticTransformReadinesses:semanticTransformIndex.semanticTransformReadinesses,
     semanticTransformEvidenceIds:semanticTransformIndex.semanticTransformEvidenceIds,
     transformSourceLanguages:semanticTransformIndex.transformSourceLanguages,
     transformTargetLanguages:semanticTransformIndex.transformTargetLanguages,
     transformSourcePaths:semanticTransformIndex.transformSourcePaths,
     transformTargetPaths:semanticTransformIndex.transformTargetPaths,
+    transformCrossLanguages:semanticTransformIndex.transformCrossLanguages,
+    transformSourceMapIds:semanticTransformIndex.transformSourceMapIds,
+    transformSourceMapLinkIds:semanticTransformIndex.transformSourceMapLinkIds,
+    transformSourceMapMappingIds:semanticTransformIndex.transformSourceMapMappingIds,
     targetPortabilityStatuses:uniqueStrings([parts.targetPortability?.status]),
     targetPortabilityActions:uniqueStrings([parts.targetPortability?.action]),
     targetPortabilityReasonCodes:uniqueStrings(parts.targetPortability?.reasonCodes),
@@ -202,11 +210,13 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.semanticEditReplayId,query.semanticEditReplayIds),index.semanticEditReplayIds)
     &&matchAny(queryValues(query.semanticEditReplayStatus,query.semanticEditReplayStatuses),index.semanticEditReplayStatuses)
     &&matchAny(queryValues(query.semanticEditReplayAction,query.semanticEditReplayActions),index.semanticEditReplayActions)
+    &&matchAny(queryValues(query.semanticEditReplayReasonCode,query.semanticEditReplayReasonCodes),index.semanticEditReplayReasonCodes)
     &&matchAny(queryValues(query.semanticEditAdmissionStatus,query.semanticEditAdmissionStatuses),index.semanticEditAdmissionStatuses)
     &&matchAny(queryValues(query.semanticEditAdmissionAction,query.semanticEditAdmissionActions),index.semanticEditAdmissionActions)
     &&matchAny(queryValues(query.semanticEditAdmissionReadiness,query.semanticEditAdmissionReadinesses),index.semanticEditAdmissionReadinesses)
     &&matchAny(queryValues(query.semanticEditReplayCurrentHash,query.semanticEditReplayCurrentHashes),index.semanticEditReplayCurrentHashes)
     &&matchAny(queryValues(query.semanticEditReplayOutputHash,query.semanticEditReplayOutputHashes),index.semanticEditReplayOutputHashes)
+    &&matchAny(queryValues(query.sourceBackprojectionMode,query.sourceBackprojectionModes),index.sourceBackprojectionModes)
     &&matchAny(queryValues(query.semanticEditKey,query.semanticEditKeys),index.semanticEditKeys)
     &&matchAny(queryValues(query.semanticIdentityHash,query.semanticIdentityHashes),index.semanticIdentityHashes)
     &&matchAny(queryValues(query.sourceIdentityHash,query.sourceIdentityHashes),index.sourceIdentityHashes)
@@ -217,12 +227,18 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.semanticTransformIdentityHash,query.semanticTransformIdentityHashes),index.semanticTransformIdentityHashes)
     &&matchAny(queryValues(query.semanticTransformContentHash,query.semanticTransformContentHashes),index.semanticTransformContentHashes)
     &&matchAny(queryValues(query.projectionIdentityHash,query.projectionIdentityHashes),index.projectionIdentityHashes)
+    &&matchAny(queryValues(query.transformBaseHash,query.transformBaseHashes),index.transformBaseHashes)
+    &&matchAny(queryValues(query.transformTargetHash,query.transformTargetHashes),index.transformTargetHashes)
     &&matchAny(queryValues(query.semanticTransformReadiness,query.semanticTransformReadinesses),index.semanticTransformReadinesses)
     &&matchAny(queryValues(query.semanticTransformEvidenceId,query.semanticTransformEvidenceIds),index.semanticTransformEvidenceIds)
     &&matchAny(queryValues(query.transformSourceLanguage,query.transformSourceLanguages),index.transformSourceLanguages)
     &&matchAny(queryValues(query.transformTargetLanguage,query.transformTargetLanguages),index.transformTargetLanguages)
     &&matchAny(queryValues(query.transformSourcePath,query.transformSourcePaths),index.transformSourcePaths)
     &&matchAny(queryValues(query.transformTargetPath,query.transformTargetPaths),index.transformTargetPaths)
+    &&matchAny(queryValues(query.transformCrossLanguage,query.transformCrossLanguages),index.transformCrossLanguages)
+    &&matchAny(queryValues(query.transformSourceMapId,query.transformSourceMapIds),index.transformSourceMapIds)
+    &&matchAny(queryValues(query.transformSourceMapLinkId,query.transformSourceMapLinkIds),index.transformSourceMapLinkIds)
+    &&matchAny(queryValues(query.transformSourceMapMappingId,query.transformSourceMapMappingIds),index.transformSourceMapMappingIds)
     &&matchAny(queryValues(query.targetPortabilityStatus,query.targetPortabilityStatuses),index.targetPortabilityStatuses)
     &&matchAny(queryValues(query.targetPortabilityAction,query.targetPortabilityActions),index.targetPortabilityActions)
     &&matchAny(queryValues(query.targetPortabilityReasonCode,query.targetPortabilityReasonCodes),index.targetPortabilityReasonCodes)

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

@@ -102,6 +102,8 @@ export function normalizeSourceMapLinks(links) {
       precision: link.precision,
       sourceSpan: link.sourceSpan,
       generatedSpan: link.generatedSpan,
+      sourceReplacementText: link.sourceReplacementText,
+      sourceReplacementTextHash: link.sourceReplacementTextHash,
       regionKey: link.ownershipRegionKey,
       regionKind: link.ownershipRegionKind
     }));

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

@@ -0,0 +1,111 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+
+function summarizeSemanticSidecarQuality(sources) {
+  const records = uniqueSemanticSidecarQualityRecords(array(sources).flatMap(semanticSidecarQualityRecords));
+  const warningCodes = uniqueStrings(records.flatMap(sidecarQualityWarningCodes));
+  const zeroRecordWarningCodes = uniqueStrings(records.flatMap(sidecarQualityZeroRecordWarningCodes));
+  return {
+    records: records.length,
+    symbols: records.reduce((sum, record) => sum + sidecarQualityCount(record, 'symbolCount', 'symbols'), 0),
+    ownershipRegions: records.reduce((sum, record) => sum + sidecarQualityCount(record, 'ownershipRegionCount', 'ownershipRegions'), 0),
+    patchHints: records.reduce((sum, record) => sum + sidecarQualityCount(record, 'patchHintCount', 'patchHints'), 0),
+    warnings: records.reduce((sum, record) => sum + sidecarQualityWarningCount(record), 0),
+    zeroRecordWarnings: zeroRecordWarningCodes.length,
+    warningCodes,
+    zeroRecordWarningCodes
+  };
+}
+
+function semanticSidecarQualityRecords(source) {
+  if (!source || typeof source !== 'object') return [];
+  return [
+    source.semanticSidecarQuality,
+    source.sidecarQuality,
+    source.semanticSidecar?.quality,
+    source.sidecar?.quality,
+    source.semanticSidecarAdmission,
+    source.sidecarAdmission,
+    source.semanticSidecar?.admission,
+    source.sidecar?.admission,
+    source.metadata?.semanticSidecarQuality,
+    source.metadata?.sidecarQuality,
+    source.metadata?.semanticSidecarAdmission,
+    source.metadata?.sidecarAdmission
+  ].filter(looksLikeSemanticSidecarQuality);
+}
+
+function looksLikeSemanticSidecarQuality(value) {
+  return value && typeof value === 'object' && (
+    value.schema === 'frontier.lang.semanticSidecarQuality.v1' ||
+    value.schema === 'frontier.lang.semanticSidecarAdmission.v1' ||
+    value.imported !== undefined ||
+    value.eligible !== undefined ||
+    value.expectedSatisfied !== undefined ||
+    value.warningCount !== undefined ||
+    value.emptyEvidenceWarnings !== undefined ||
+    value.proofSummary !== undefined ||
+    value.counts !== undefined
+  );
+}
+
+function uniqueSemanticSidecarQualityRecords(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records) {
+    const key = record.id ?? JSON.stringify({
+      schema: record.schema,
+      symbols: sidecarQualityCount(record, 'symbolCount', 'symbols'),
+      ownershipRegions: sidecarQualityCount(record, 'ownershipRegionCount', 'ownershipRegions'),
+      patchHints: sidecarQualityCount(record, 'patchHintCount', 'patchHints'),
+      warningCodes: sidecarQualityWarningCodes(record)
+    });
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
+function sidecarQualityCount(record, field, countsField) {
+  for (const value of [record?.[field], record?.counts?.[countsField]]) {
+    const count = Number(value ?? 0);
+    if (Number.isFinite(count) && count > 0) return count;
+  }
+  return 0;
+}
+
+function sidecarQualityWarningCount(record) {
+  const count = Number(record?.warningCount ?? 0);
+  if (Number.isFinite(count) && count > 0) return count;
+  return sidecarQualityWarningCodes(record).length;
+}
+
+function sidecarQualityWarningCodes(record) {
+  return uniqueStrings([
+    ...array(record?.warnings).map((warning) => warning?.code ?? warning?.reasonCode),
+    ...array(record?.emptyEvidenceWarnings).map((warning) => warning?.code ?? warning?.reasonCode),
+    ...strings(record?.expectedMissingReasonCodes),
+    ...strings(record?.reasonCodes)
+  ].filter(Boolean));
+}
+
+function sidecarQualityZeroRecordWarningCodes(record) {
+  return sidecarQualityWarningCodes(record).filter(isZeroRecordWarningCode);
+}
+
+function isZeroRecordWarningCode(code) {
+  return [
+    'empty-evidence',
+    'empty-semantic-index',
+    'expected-semantic-import-empty',
+    'expected-semantic-import-missing',
+    'missing-imports',
+    'missing-ownership-regions',
+    'missing-patch-hints'
+  ].includes(code);
+}
+
+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); }
+
+export { summarizeSemanticSidecarQuality };

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

@@ -8,11 +8,18 @@ export function applySourceEdits(sourceText, edits) {
 }
 
 export function dedupeSourceEdits(edits) {
-  const exact = dedupeExactInsertions(edits);
-  const covered = removeCoveredContainerReplacements(exact.edits);
+  const exact = dedupeExactEdits(edits);
+  const noops = removeNoopReplacements(exact.edits);
+  const coveredDeletes = removeContainedDeletionEdits(noops.edits);
+  const covered = removeCoveredContainerReplacements(coveredDeletes.edits);
   return {
     edits: covered.edits,
-    skippedOperationIds: [...exact.skippedOperationIds, ...covered.skippedOperationIds]
+    skippedOperationIds: [
+      ...exact.skippedOperationIds,
+      ...noops.skippedOperationIds,
+      ...coveredDeletes.skippedOperationIds,
+      ...covered.skippedOperationIds
+    ]
   };
 }
 
@@ -27,7 +34,7 @@ export function validateSourceEdits(edits) {
   return uniqueStrings(reasons);
 }
 
-function dedupeExactInsertions(edits) {
+function dedupeExactEdits(edits) {
   const seen = new Map();
   const result = [];
   const skippedOperationIds = [];
@@ -43,6 +50,19 @@ function dedupeExactInsertions(edits) {
   return { edits: result, skippedOperationIds };
 }
 
+function removeNoopReplacements(edits) {
+  const skippedOperationIds = [];
+  const result = [];
+  for (const edit of edits) {
+    if (edit.editKind === 'replace' && !edit.alreadyApplied && edit.current === edit.replacement) {
+      skippedOperationIds.push(edit.operationId);
+      continue;
+    }
+    result.push(edit);
+  }
+  return { edits: result, skippedOperationIds };
+}
+
 function removeCoveredContainerReplacements(edits) {
   const skippedOperationIds = [];
   const result = [];
@@ -56,6 +76,31 @@ function removeCoveredContainerReplacements(edits) {
   return { edits: result, skippedOperationIds };
 }
 
+function removeContainedDeletionEdits(edits) {
+  const skippedOperationIds = [];
+  const result = [];
+  for (const edit of edits) {
+    if (deleteCoveredByLargerDelete(edit, edits)) {
+      skippedOperationIds.push(edit.operationId);
+      continue;
+    }
+    result.push(edit);
+  }
+  return { edits: result, skippedOperationIds };
+}
+
+function deleteCoveredByLargerDelete(edit, edits) {
+  return edit.editKind === 'delete' && !edit.alreadyApplied && edits.some((candidate) => (
+    candidate !== edit &&
+    candidate.editKind === 'delete' &&
+    !candidate.alreadyApplied &&
+    sameSourcePath(candidate, edit) &&
+    candidate.start <= edit.start &&
+    edit.end <= candidate.end &&
+    (candidate.start !== edit.start || candidate.end !== edit.end)
+  ));
+}
+
 function containerReplacementCoveredByInsertions(edit, edits) {
   if (edit.editKind !== 'replace' || edit.alreadyApplied) return false;
   const insertions = containedInsertions(edit, edits);
@@ -76,15 +121,30 @@ function containedInsertions(container, edits) {
     .sort((left, right) => left.start - right.start || (left.order ?? 0) - (right.order ?? 0));
 }
 
+function sameSourcePath(left, right) {
+  const leftPath = left.targetSourcePath ?? left.sourcePath;
+  const rightPath = right.targetSourcePath ?? right.sourcePath;
+  return !leftPath || !rightPath || leftPath === rightPath;
+}
+
 function duplicateEditKey(edit) {
-  if (edit.editKind !== 'insert') return undefined;
+  if (edit.alreadyApplied) return undefined;
+  if (edit.editKind === 'insert') {
+    return [
+      'insert',
+      edit.start,
+      edit.end,
+      edit.insertion?.mode,
+      edit.insertion?.anchorKey,
+      hashSemanticValue(edit.replacementSpanText ?? edit.replacement)
+    ].join(':');
+  }
   return [
-    'insert',
+    edit.editKind,
     edit.start,
     edit.end,
-    edit.insertion?.mode,
-    edit.insertion?.anchorKey,
-    hashSemanticValue(edit.replacementSpanText ?? edit.replacement)
+    hashSemanticValue(edit.current),
+    hashSemanticValue(edit.replacement)
   ].join(':');
 }