@shapeshift-labs/frontier-swarm-codex 0.5.119 → 0.5.121

package/dist/semantic-import-quality.js

@@ -1,4 +1,4 @@
-import { nonNegativeNumber, readStringArray, uniqueStrings } from './common.js';
+import { isObject, nonNegativeNumber, numberRecord, readStringArray, uniqueStrings } from './common.js';
 import { semanticImportFactSummary } from './semantic-import-facts.js';
 import { semanticImportUniversalAstLayerSummary } from './semantic-import-layers.js';
 import { semanticImportParadigmSemanticsSummary } from './semantic-import-paradigm.js';
@@ -8,6 +8,7 @@ import { summarizeSemanticEditScript } from './semantic-edit-script.js';
 import { summarizeSemanticEditProjection, emptySemanticEditProjectionSummary } from './semantic-edit-projection.js';
 import { emptySemanticEditReplaySummary, summarizeSemanticEditReplay } from './semantic-edit-replay.js';
 import { classifySemanticEditScriptAdmission } from './semantic-edit-admission.js';
+import { semanticImportCandidateCount, semanticImportExpected, semanticImportExpectedMissingReasonCodes, semanticImportExpectedSatisfied, semanticImportNativeCompileSummary, semanticImportSliceAdmissionSummary, semanticImportSourceProjectionSummary, semanticLineageExpectedForBeforeSourceDiff, semanticSelectionSummary } from './semantic-import-quality-helpers.js';
 export function summarizeCodexSemanticImportQuality(summary, expected = false) {
     const total = nonNegativeNumber(summary?.total);
     const candidates = semanticImportCandidateCount(summary);
@@ -15,9 +16,16 @@ export function summarizeCodexSemanticImportQuality(summary, expected = false) {
     const eligible = nonNegativeNumber(summary?.eligible);
     const imported = nonNegativeNumber(summary?.imported);
     const errors = nonNegativeNumber(summary?.errors);
+    const lossCount = nonNegativeNumber(summary?.lossCount);
+    const lossesBySeverity = numberRecord(summary?.lossesBySeverity);
+    const semanticErrorLosses = nonNegativeNumber(lossesBySeverity.error);
+    const semanticWarningLosses = nonNegativeNumber(lossesBySeverity.warning);
     const symbols = nonNegativeNumber(summary?.semanticIndex?.symbols);
     const ownershipRegions = nonNegativeNumber(summary?.semanticSidecars?.ownershipRegions);
     const patchHints = nonNegativeNumber(summary?.semanticSidecars?.patchHints);
+    const semanticReadiness = numberRecord(summary?.readiness);
+    const sourceProjections = semanticImportSourceProjectionSummary(summary);
+    const nativeCompiles = semanticImportNativeCompileSummary(summary);
     const semanticFacts = semanticImportFactSummary(summary);
     const dependencyRelations = nonNegativeNumber(summary?.dependencies?.total);
     const dependencyPredicates = Array.isArray(summary?.dependencies?.predicates)
@@ -35,11 +43,14 @@ export function summarizeCodexSemanticImportQuality(summary, expected = false) {
     const universalAstLayerNames = universalAstLayerSummary.names;
     const proofSpec = semanticImportProofSpecSummary(summary);
     const paradigmSemantics = semanticImportParadigmSemanticsSummary(summary);
+    const semanticSliceAdmissions = semanticImportSliceAdmissionSummary(summary);
     const semanticLineage = semanticImportLineageSummary(summary);
     const semanticEditScript = summarizeSemanticEditScript(summary) ?? summarizeSemanticEditScript({ semanticEditScripts: summary?.semanticEditScripts });
     const semanticEditProjection = summarizeSemanticEditProjection(summary) ?? emptySemanticEditProjectionSummary();
     const semanticEditReplay = summarizeSemanticEditReplay(summary) ?? emptySemanticEditReplaySummary();
-    const semanticEditAdmission = classifySemanticEditScriptAdmission(semanticEditScript);
+    const semanticMergeAdmission = summarizeSemanticMergeAdmissionQuality(summary);
+    const jsTsSafeMergeApply = summarizeJsTsSafeMergeApplyQuality(summary);
+    const semanticEditAdmission = semanticEditAdmissionWithSafeMerge(classifySemanticEditScriptAdmission(semanticEditScript), semanticMergeAdmission, jsTsSafeMergeApply);
     const semanticLineageExpected = semanticLineageExpectedForBeforeSourceDiff(summary, semanticLineage.beforeSymbols);
     const selection = semanticSelectionSummary(summary);
     const present = !!summary;
@@ -78,6 +89,20 @@ export function summarizeCodexSemanticImportQuality(summary, expected = false) {
         warnings.push('semantic import imported no files');
     if (present && errors > 0)
         warnings.push('semantic import has errors');
+    if (present && semanticErrorLosses > 0)
+        warnings.push('semantic import has error losses');
+    if (present && semanticReadiness.blocked > 0)
+        warnings.push('semantic import readiness is blocked');
+    if (present && semanticReadiness['needs-review'] > 0)
+        warnings.push('semantic import readiness needs review');
+    if (present && sourceProjections.blocked > 0)
+        warnings.push('semantic source projection is blocked');
+    if (present && sourceProjections.stubs > 0)
+        warnings.push('semantic source projection uses stubs');
+    if (present && nativeCompiles.blocked > 0)
+        warnings.push('semantic native compile is blocked');
+    if (present && nativeCompiles.targetStubs > 0)
+        warnings.push('semantic native compile emitted target stubs');
     if (present && selected === 0 && selection.includeFiltered > 0)
         warnings.push('semantic import include filters selected no files');
     if (present && selected === 0 && selection.unsupportedLanguage > 0)
@@ -96,6 +121,8 @@ export function summarizeCodexSemanticImportQuality(summary, expected = false) {
         warnings.push('semantic import has failed proof obligations');
     if (present && proofSpec.stale > 0)
         warnings.push('semantic import has stale proof obligations');
+    if (present && semanticSliceAdmissions.rejected > 0)
+        warnings.push('semantic slice admission rejected candidates');
     if (present && symbols > 0 && semanticLineageExpected && semanticLineage.inferredEvents === 0) {
         warnings.push('semantic import has symbols but no inferred semantic lineage for expected before-source diff');
     }
@@ -126,6 +153,26 @@ export function summarizeCodexSemanticImportQuality(summary, expected = false) {
         warnings.push('semantic edit replay is blocked');
     if (present && semanticEditReplay.needsPort > 0)
         warnings.push('semantic edit replay needs port');
+    if (present && semanticMergeAdmission.noOp > 0)
+        warnings.push('semantic merge admission is no-op');
+    if (present && semanticMergeAdmission.stale > 0)
+        warnings.push('semantic merge admission is stale');
+    if (present && semanticMergeAdmission.conflicts > 0)
+        warnings.push('semantic merge admission has conflicts');
+    if (present && semanticMergeAdmission.reviewRequired > 0)
+        warnings.push('semantic merge admission needs review');
+    if (present && semanticMergeAdmission.blocked > 0)
+        warnings.push('semantic merge admission is blocked');
+    if (present && jsTsSafeMergeApply.noOp > 0)
+        warnings.push('semantic safe-merge apply is no-op');
+    if (present && jsTsSafeMergeApply.stale > 0)
+        warnings.push('semantic safe-merge apply is stale');
+    if (present && jsTsSafeMergeApply.conflicts > 0)
+        warnings.push('semantic safe-merge apply has conflicts');
+    if (present && jsTsSafeMergeApply.needsReview > 0)
+        warnings.push('semantic safe-merge apply needs review');
+    if (present && jsTsSafeMergeApply.blocked > 0)
+        warnings.push('semantic safe-merge apply is blocked');
     return {
         expected: effectiveExpected,
         expectedSatisfied,
@@ -138,9 +185,27 @@ export function summarizeCodexSemanticImportQuality(summary, expected = false) {
         eligible,
         imported,
         errors,
+        lossCount,
+        lossesBySeverity,
+        semanticErrorLosses,
+        semanticWarningLosses,
         symbols,
         ownershipRegions,
         patchHints,
+        semanticReadiness,
+        sourceProjectionTotal: sourceProjections.total,
+        sourceProjectionPreserved: sourceProjections.preserved,
+        sourceProjectionStubs: sourceProjections.stubs,
+        sourceProjectionReady: sourceProjections.ready,
+        sourceProjectionNeedsReview: sourceProjections.needsReview,
+        sourceProjectionBlocked: sourceProjections.blocked,
+        nativeCompileTotal: nativeCompiles.total,
+        nativeCompileEmitted: nativeCompiles.emitted,
+        nativeCompilePreserved: nativeCompiles.preserved,
+        nativeCompileTargetStubs: nativeCompiles.targetStubs,
+        nativeCompileReady: nativeCompiles.ready,
+        nativeCompileNeedsReview: nativeCompiles.needsReview,
+        nativeCompileBlocked: nativeCompiles.blocked,
         semanticFacts: semanticFacts.total,
         semanticFactPredicates: semanticFacts.predicates,
         semanticFactSummary: semanticFacts.byPredicate,
@@ -156,6 +221,10 @@ export function summarizeCodexSemanticImportQuality(summary, expected = false) {
         paradigmSemanticsRecords: paradigmSemantics.total,
         paradigmSemanticsGroups: paradigmSemantics.groups.length,
         paradigmSemanticsLoweringRecords: paradigmSemantics.loweringRecords,
+        semanticSliceAdmissionTotal: semanticSliceAdmissions.total,
+        semanticSliceAdmissionAdmitted: semanticSliceAdmissions.admitted,
+        semanticSliceAdmissionPrioritized: semanticSliceAdmissions.prioritized,
+        semanticSliceAdmissionRejected: semanticSliceAdmissions.rejected,
         semanticLineageEvents: semanticLineage.inferredEvents,
         semanticLineageMoved: semanticLineage.moved,
         semanticLineageRenamed: semanticLineage.renamed,
@@ -169,121 +238,11 @@ export function summarizeCodexSemanticImportQuality(summary, expected = false) {
         semanticEditProjection,
         semanticEditReplay,
         semanticEditAdmission,
+        semanticMergeAdmission,
+        jsTsSafeMergeApply,
         warnings: uniqueStrings(warnings)
     };
 }
-function semanticImportCandidateCount(summary) {
-    const record = summaryRecord(summary);
-    return nonNegativeNumber(record?.selection?.candidates ?? record?.total);
-}
-function semanticImportExpected(summary, fallback) {
-    if (fallback)
-        return true;
-    const record = summaryRecord(summary);
-    if (!record)
-        return false;
-    return record.semanticImportExpected === true ||
-        record.expected === true ||
-        record.quality?.expected === true ||
-        record.admission?.expected === true;
-}
-function semanticImportExpectedSatisfied(summary, input) {
-    if (!input.expected)
-        return true;
-    const explicit = semanticImportExplicitExpectedSatisfied(summary);
-    if (explicit !== undefined)
-        return explicit && input.reasonCodes.length === 0;
-    return input.present &&
-        !input.empty &&
-        input.imported > 0 &&
-        input.symbols > 0 &&
-        input.ownershipRegions > 0 &&
-        input.patchHints > 0 &&
-        input.reasonCodes.length === 0;
-}
-function semanticImportExpectedMissingReasonCodes(summary, input) {
-    const record = summaryRecord(summary);
-    const explicitCodes = uniqueStrings([
-        ...readStringArray(record?.semanticImportExpectedMissingReasonCodes),
-        ...readStringArray(record?.quality?.expectedMissingReasonCodes),
-        ...readStringArray(record?.admission?.expectedMissingReasonCodes)
-    ]);
-    if (!input.expected)
-        return explicitCodes;
-    const inferredCodes = [];
-    if (!input.present)
-        inferredCodes.push('expected-semantic-import-missing');
-    if (input.present && input.selected === 0)
-        inferredCodes.push('expected-semantic-import-missing');
-    if (input.present && input.selected > 0 && input.imported === 0)
-        inferredCodes.push('missing-imports');
-    if (input.present && input.imported > 0 && input.symbols === 0) {
-        inferredCodes.push('expected-semantic-import-empty', 'empty-semantic-index');
-    }
-    if (input.present && input.imported > 0 && input.ownershipRegions === 0)
-        inferredCodes.push('missing-ownership-regions');
-    if (input.present && input.imported > 0 && input.patchHints === 0)
-        inferredCodes.push('missing-patch-hints');
-    if (input.empty && !inferredCodes.includes('expected-semantic-import-empty')) {
-        inferredCodes.push('expected-semantic-import-empty');
-    }
-    return uniqueStrings([...explicitCodes, ...inferredCodes]);
-}
-function semanticImportExplicitExpectedSatisfied(summary) {
-    const record = summaryRecord(summary);
-    const candidates = [
-        record?.semanticImportExpectedSatisfied,
-        record?.quality?.expectedSatisfied,
-        record?.admission?.expectedSatisfied
-    ];
-    for (const value of candidates) {
-        if (typeof value === 'boolean')
-            return value;
-    }
-    return undefined;
-}
-function semanticLineageExpectedForBeforeSourceDiff(summary, beforeSymbols) {
-    if (beforeSymbols > 0)
-        return true;
-    const record = summaryRecord(summary);
-    if (!record)
-        return false;
-    const quality = record.quality;
-    const admission = record.admission;
-    const lineage = record.semanticLineage;
-    const inference = record.semanticLineageInference;
-    const lineageInference = record.lineageInference;
-    return [
-        record.semanticLineageExpected,
-        record.semanticLineageInferenceExpected,
-        record.beforeSourceDiffExpected,
-        record.beforeSourceExpected,
-        quality?.semanticLineageExpected,
-        quality?.beforeSourceDiffExpected,
-        admission?.semanticLineageExpected,
-        admission?.beforeSourceDiffExpected,
-        lineage?.expected,
-        lineage?.beforeSourceDiffExpected,
-        inference?.expected,
-        inference?.beforeSourceDiffExpected,
-        lineageInference?.expected,
-        lineageInference?.beforeSourceDiffExpected
-    ].some((value) => value === true);
-}
-function summaryRecord(summary) {
-    return summary && typeof summary === 'object' && !Array.isArray(summary)
-        ? summary
-        : undefined;
-}
-function semanticSelectionSummary(summary) {
-    const selection = summary && typeof summary === 'object'
-        ? summary.selection
-        : undefined;
-    return {
-        includeFiltered: nonNegativeNumber(selection?.includeFiltered),
-        unsupportedLanguage: nonNegativeNumber(selection?.unsupportedLanguage)
-    };
-}
 export function semanticImportSummaryFromBundle(bundle) {
     const metadata = bundle.metadata;
     return richerSemanticImportSummary(bundle.semanticImport, metadata?.semanticImport);
@@ -311,7 +270,9 @@ function semanticImportSummaryRichness(summary) {
         semanticImportUniversalAstLayerSummary(summary).total,
         semanticImportProofSpecSummary(summary).total,
         semanticImportParadigmSemanticsSummary(summary).total,
-        semanticImportLineageSummary(summary).inferredEvents
+        semanticImportLineageSummary(summary).inferredEvents,
+        summarizeSemanticMergeAdmissionQuality(summary).total,
+        summarizeJsTsSafeMergeApplyQuality(summary).total
     ];
     return values.reduce((sum, value) => sum + nonNegativeNumber(value), 0);
 }
@@ -322,4 +283,447 @@ export function semanticImportEnabled(input) {
         return false;
     return input.enabled !== false;
 }
+function semanticEditAdmissionWithSafeMerge(editAdmission, semanticMergeAdmission, jsTsSafeMergeApply) {
+    if (editAdmission.status === 'conflict' || editAdmission.status === 'stale' || editAdmission.status === 'blocked' || editAdmission.status === 'review-required') {
+        return editAdmission;
+    }
+    if (jsTsSafeMergeApply.conflicts > 0 || semanticMergeAdmission.conflicts > 0) {
+        return safeMergeAdmissionDecision('conflict', `semantic safe-merge conflict signals: ${jsTsSafeMergeApply.conflicts + semanticMergeAdmission.conflicts}`);
+    }
+    if (jsTsSafeMergeApply.stale > 0 || semanticMergeAdmission.stale > 0) {
+        return safeMergeAdmissionDecision('stale', `semantic safe-merge stale signals: ${jsTsSafeMergeApply.stale + semanticMergeAdmission.stale}`);
+    }
+    if (jsTsSafeMergeApply.blocked > 0 || semanticMergeAdmission.blocked > 0) {
+        return safeMergeAdmissionDecision('blocked', `semantic safe-merge blocked signals: ${jsTsSafeMergeApply.blocked + semanticMergeAdmission.blocked}`);
+    }
+    if (jsTsSafeMergeApply.needsReview > 0 || semanticMergeAdmission.reviewRequired > 0 || semanticMergeAdmission.safeWithLosses > 0) {
+        return safeMergeAdmissionDecision('review-required', 'semantic safe-merge needs review');
+    }
+    if (safeMergeApplyClean(jsTsSafeMergeApply)) {
+        return {
+            status: 'auto-merge-candidate',
+            autoMergeCandidate: true,
+            cleanEligible: true,
+            reasons: ['semantic safe-merge apply accepted clean']
+        };
+    }
+    if (semanticMergeAdmissionClean(semanticMergeAdmission)) {
+        return {
+            status: 'auto-merge-candidate',
+            autoMergeCandidate: true,
+            cleanEligible: true,
+            reasons: ['semantic merge admission is safe']
+        };
+    }
+    return editAdmission;
+}
+function safeMergeAdmissionDecision(status, reason) {
+    return {
+        status,
+        autoMergeCandidate: false,
+        cleanEligible: false,
+        reasons: [reason]
+    };
+}
+function safeMergeApplyClean(summary) {
+    return summary.total > 0 &&
+        summary.acceptedClean + summary.alreadyApplied > 0 &&
+        summary.noOp + summary.stale + summary.conflicts + summary.needsReview + summary.blocked === 0;
+}
+function semanticMergeAdmissionClean(summary) {
+    return summary.total > 0 &&
+        summary.autoMergeable + summary.safe > 0 &&
+        summary.safeWithLosses + summary.noOp + summary.stale + summary.conflicts + summary.reviewRequired + summary.blocked === 0;
+}
+function summarizeSemanticMergeAdmissionQuality(value) {
+    const direct = directSafeMergeValues(value, ['semanticMergeAdmissions', 'semanticMergeAdmission', 'semanticMergeAdmissionSummary']);
+    if (direct.length > 0)
+        return mergeSemanticMergeAdmissionSummaries(direct.map(normalizeSemanticMergeAdmissionRecord));
+    const records = isObject(value) && Array.isArray(value.records) ? value.records.filter(isObject) : [];
+    return mergeSemanticMergeAdmissionSummaries(records.flatMap((record) => {
+        const sidecar = isObject(record.semanticSidecar) ? record.semanticSidecar : {};
+        const mergeCandidate = isObject(record.mergeCandidate) ? record.mergeCandidate : {};
+        return directSafeMergeValues({
+            semanticMergeAdmission: record.semanticMergeAdmission,
+            semanticMergeAdmissions: record.semanticMergeAdmissions,
+            semanticMergeAdmissionSummary: record.semanticMergeAdmissionSummary,
+            sidecarSemanticMergeAdmission: sidecar.semanticMergeAdmission,
+            sidecarSemanticMergeAdmissions: sidecar.semanticMergeAdmissions,
+            mergeCandidateAdmission: mergeCandidate.semanticMergeAdmission ?? mergeCandidate.mergeAdmission ?? mergeCandidate.admission
+        }, [
+            'semanticMergeAdmission',
+            'semanticMergeAdmissions',
+            'semanticMergeAdmissionSummary',
+            'sidecarSemanticMergeAdmission',
+            'sidecarSemanticMergeAdmissions',
+            'mergeCandidateAdmission'
+        ]).map(normalizeSemanticMergeAdmissionRecord);
+    }));
+}
+function summarizeJsTsSafeMergeApplyQuality(value) {
+    const direct = directSafeMergeValues(value, ['jsTsSafeMergeApply', 'jsTsSafeMergeApplies', 'safeMergeApply', 'safeMergeApplies']);
+    if (direct.length > 0)
+        return mergeJsTsSafeMergeApplySummaries(direct.map(normalizeJsTsSafeMergeApplyRecord));
+    const records = isObject(value) && Array.isArray(value.records) ? value.records.filter(isObject) : [];
+    return mergeJsTsSafeMergeApplySummaries(records.flatMap((record) => {
+        const sidecar = isObject(record.semanticSidecar) ? record.semanticSidecar : {};
+        return directSafeMergeValues({
+            jsTsSafeMergeApply: record.jsTsSafeMergeApply,
+            jsTsSafeMergeApplies: record.jsTsSafeMergeApplies,
+            safeMergeApply: record.safeMergeApply,
+            safeMergeApplies: record.safeMergeApplies,
+            sidecarJsTsSafeMergeApply: sidecar.jsTsSafeMergeApply,
+            sidecarSafeMergeApply: sidecar.safeMergeApply
+        }, [
+            'jsTsSafeMergeApply',
+            'jsTsSafeMergeApplies',
+            'safeMergeApply',
+            'safeMergeApplies',
+            'sidecarJsTsSafeMergeApply',
+            'sidecarSafeMergeApply'
+        ]).map(normalizeJsTsSafeMergeApplyRecord);
+    }));
+}
+function normalizeSemanticMergeAdmissionRecord(value) {
+    const record = isObject(value) ? value : {};
+    const summary = isObject(record.summary) ? record.summary : record;
+    const byClassification = mergeNumberRecords(numberRecord(summary.byClassification), numberRecord(summary.classificationCounts));
+    const byDecision = mergeNumberRecords(numberRecord(summary.byDecision), numberRecord(summary.decisionCounts));
+    const classification = stringValue(summary.classification ?? record.classification);
+    const decision = stringValue(summary.decision ?? record.decision ?? summary.status ?? record.status);
+    if (classification)
+        addSignalCount(byClassification, classification);
+    if (decision)
+        addSignalCount(byDecision, decision);
+    if (Object.keys(byClassification).length === 0) {
+        for (const entry of readStringArray(summary.classifications))
+            addSignalCount(byClassification, entry);
+    }
+    if (Object.keys(byDecision).length === 0) {
+        for (const entry of readStringArray(summary.decisions))
+            addSignalCount(byDecision, entry);
+    }
+    const safe = Math.max(nonNegativeNumber(summary.safe), signalCount(byClassification, 'safe'));
+    const safeWithLosses = Math.max(nonNegativeNumber(summary.safeWithLosses), signalCount(byClassification, 'safe-with-losses'));
+    const reviewRequired = Math.max(nonNegativeNumber(summary.reviewRequired), nonNegativeNumber(summary.needsReview), signalCount(byClassification, 'review-required', 'needs-review', 'review', 'human-review'), signalCount(byDecision, 'review-required', 'needs-review', 'review', 'human-review'));
+    const autoMergeable = Math.max(nonNegativeNumber(summary.autoMergeable), record.autoMergeable === true ? 1 : 0, signalCount(byDecision, 'auto-mergeable', 'auto-merge-candidate'), safe);
+    const noOp = Math.max(nonNegativeNumber(summary.noOp), signalCount(byDecision, 'no-op', 'noop', 'no-change'));
+    const stale = Math.max(nonNegativeNumber(summary.stale), signalCount(byDecision, 'stale', 'rerun-semantic-import'));
+    const blocked = Math.max(nonNegativeNumber(summary.blocked), signalCount(byClassification, 'blocked', 'blocked-evidence'), signalCount(byDecision, 'blocked', 'blocked-evidence', 'block'));
+    const conflicts = Math.max(nonNegativeNumber(summary.conflicts), signalCount(byDecision, 'conflict', 'conflicts', 'conflict-blocked'));
+    const total = nonNegativeNumber(summary.total) ||
+        sumRecord(byClassification) ||
+        sumRecord(byDecision) ||
+        (classification || decision || record.kind === 'frontier.lang.semanticMergeAdmission' ? 1 : 0);
+    return {
+        total,
+        classifications: positiveRecordKeys(byClassification),
+        byClassification,
+        decisions: positiveRecordKeys(byDecision),
+        byDecision,
+        noOp,
+        stale,
+        needsReview: Math.max(nonNegativeNumber(summary.needsReview), reviewRequired),
+        blocked,
+        conflicts,
+        conflictReasonCodes: uniqueStrings([...readStringArray(summary.conflictReasonCodes), ...readStringArray(record.conflictReasonCodes)]),
+        conflictKeys: uniqueStrings([...readStringArray(summary.conflictKeys), ...readStringArray(record.conflictKeys)]),
+        evidenceIds: uniqueStrings([...readStringArray(summary.evidenceIds), ...readStringArray(record.evidenceIds), ...objectIds(record.evidence)]),
+        autoApplyable: Math.max(nonNegativeNumber(summary.autoApplyable), autoMergeable),
+        autoApplyCandidates: Math.max(nonNegativeNumber(summary.autoApplyCandidates), autoMergeable),
+        empty: total === 0,
+        safe,
+        safeWithLosses,
+        reviewRequired,
+        autoMergeable,
+        reasonCodes: uniqueStrings([...readStringArray(summary.reasonCodes), ...readStringArray(record.reasonCodes), ...readStringArray(record.reasons)]),
+        conflictKeyKinds: uniqueStrings([...readStringArray(summary.conflictKeyKinds), ...readStringArray(record.conflictKeyKinds)]),
+        candidateIds: uniqueStrings([...readStringArray(summary.candidateIds), ...stringArray(record.candidateId)])
+    };
+}
+function normalizeJsTsSafeMergeApplyRecord(value) {
+    const record = isObject(value) ? value : {};
+    const summary = isObject(record.summary) ? record.summary : record;
+    const admission = isObject(record.admission) ? record.admission : {};
+    const byClassification = mergeNumberRecords(numberRecord(summary.byClassification), numberRecord(summary.classificationCounts));
+    const byDecision = mergeNumberRecords(numberRecord(summary.byDecision), numberRecord(summary.decisionCounts));
+    const byStatus = mergeNumberRecords(numberRecord(summary.byStatus), numberRecord(summary.statusCounts));
+    const byAction = mergeNumberRecords(numberRecord(summary.byAction), numberRecord(summary.actionCounts));
+    const classification = stringValue(summary.classification ?? record.classification);
+    const decision = stringValue(summary.decision ?? record.decision ?? summary.decision ?? admission.decision);
+    const status = stringValue(summary.status ?? record.status ?? admission.status);
+    const action = stringValue(summary.action ?? record.action ?? admission.action);
+    if (classification)
+        addSignalCount(byClassification, classification);
+    if (decision)
+        addSignalCount(byDecision, decision);
+    if (status)
+        addSignalCount(byStatus, status);
+    if (action)
+        addSignalCount(byAction, action);
+    if (Object.keys(byClassification).length === 0) {
+        for (const entry of readStringArray(summary.classifications))
+            addSignalCount(byClassification, entry);
+    }
+    if (Object.keys(byDecision).length === 0) {
+        for (const entry of readStringArray(summary.decisions))
+            addSignalCount(byDecision, entry);
+    }
+    if (Object.keys(byStatus).length === 0) {
+        for (const entry of readStringArray(summary.statuses))
+            addSignalCount(byStatus, entry);
+    }
+    if (Object.keys(byAction).length === 0) {
+        for (const entry of readStringArray(summary.actions))
+            addSignalCount(byAction, entry);
+    }
+    const acceptedClean = Math.max(nonNegativeNumber(summary.acceptedClean), signalCount(byStatus, 'accepted-clean'), signalCount(byClassification, 'accepted-clean'));
+    const alreadyApplied = Math.max(nonNegativeNumber(summary.alreadyApplied), signalCount(byStatus, 'already-applied'), signalCount(byClassification, 'already-applied'));
+    const noOp = Math.max(nonNegativeNumber(summary.noOp), signalCount(byStatus, 'no-op', 'noop', 'no-change'), signalCount(byClassification, 'no-op', 'noop', 'no-change'), signalCount(byDecision, 'no-op', 'noop', 'no-change'));
+    const stale = Math.max(nonNegativeNumber(summary.stale), signalCount(byStatus, 'stale'), signalCount(byClassification, 'stale'), signalCount(byDecision, 'stale', 'rerun-semantic-import'));
+    const needsReview = Math.max(nonNegativeNumber(summary.needsReview), signalCount(byStatus, 'needs-review', 'review-required', 'review', 'human-review'), signalCount(byClassification, 'needs-review', 'review-required', 'review', 'human-review'), signalCount(byDecision, 'needs-review', 'review-required', 'review', 'human-review'));
+    const blocked = Math.max(nonNegativeNumber(summary.blocked), signalCount(byStatus, 'blocked', 'blocked-evidence'), signalCount(byClassification, 'blocked', 'blocked-evidence'), signalCount(byDecision, 'blocked', 'blocked-evidence', 'block'));
+    const conflicts = Math.max(nonNegativeNumber(summary.conflicts), signalCount(byStatus, 'conflict', 'conflicts', 'conflict-blocked'), signalCount(byClassification, 'conflict', 'conflicts', 'conflict-blocked'));
+    const applied = Math.max(nonNegativeNumber(summary.applied), signalCount(byAction, 'apply'), acceptedClean);
+    const skipped = Math.max(nonNegativeNumber(summary.skipped), signalCount(byAction, 'skip'), alreadyApplied + noOp);
+    const total = nonNegativeNumber(summary.total) ||
+        sumRecord(byStatus) ||
+        sumRecord(byClassification) ||
+        sumRecord(byDecision) ||
+        (classification || decision || status || action ? 1 : 0);
+    return {
+        total,
+        classifications: positiveRecordKeys(byClassification),
+        byClassification,
+        decisions: positiveRecordKeys(byDecision),
+        byDecision,
+        noOp,
+        stale,
+        needsReview,
+        blocked,
+        conflicts,
+        conflictReasonCodes: uniqueStrings([...readStringArray(summary.conflictReasonCodes), ...readStringArray(record.conflictReasonCodes)]),
+        conflictKeys: uniqueStrings([...readStringArray(summary.conflictKeys), ...readStringArray(record.conflictKeys)]),
+        evidenceIds: uniqueStrings([...readStringArray(summary.evidenceIds), ...readStringArray(record.evidenceIds), ...objectIds(record.evidence)]),
+        autoApplyable: Math.max(nonNegativeNumber(summary.autoApplyable), acceptedClean + alreadyApplied),
+        autoApplyCandidates: Math.max(nonNegativeNumber(summary.autoApplyCandidates), acceptedClean + alreadyApplied),
+        empty: total === 0,
+        acceptedClean,
+        alreadyApplied,
+        applied,
+        skipped,
+        scripts: nonNegativeNumber(summary.scripts) || readStringArray(summary.scriptIds).length,
+        projections: nonNegativeNumber(summary.projections) || readStringArray(summary.projectionIds).length,
+        replays: nonNegativeNumber(summary.replays) || readStringArray(summary.replayIds).length,
+        statuses: positiveRecordKeys(byStatus),
+        byStatus,
+        actions: positiveRecordKeys(byAction),
+        byAction,
+        reasonCodes: uniqueStrings([...readStringArray(summary.reasonCodes), ...readStringArray(record.reasonCodes), ...readStringArray(admission.reasonCodes)]),
+        sourcePaths: uniqueStrings([...readStringArray(summary.sourcePaths), ...readStringArray(record.sourcePaths), ...stringArray(record.sourcePath)]),
+        scriptIds: uniqueStrings([...readStringArray(summary.scriptIds), ...stringArray(record.scriptId)]),
+        projectionIds: uniqueStrings([...readStringArray(summary.projectionIds), ...stringArray(record.projectionId)]),
+        replayIds: uniqueStrings([...readStringArray(summary.replayIds), ...stringArray(record.replayId)])
+    };
+}
+function mergeSemanticMergeAdmissionSummaries(entries) {
+    const merged = emptySemanticMergeAdmissionSummary();
+    for (const entry of entries) {
+        if (entry.empty && entry.total === 0)
+            continue;
+        addBaseSafeMergeSummary(merged, entry);
+        for (const key of ['safe', 'safeWithLosses', 'reviewRequired', 'autoMergeable'])
+            merged[key] += nonNegativeNumber(entry[key]);
+        merged.reasonCodes = uniqueStrings([...merged.reasonCodes, ...entry.reasonCodes]);
+        merged.conflictKeyKinds = uniqueStrings([...merged.conflictKeyKinds, ...entry.conflictKeyKinds]);
+        merged.candidateIds = uniqueStrings([...merged.candidateIds, ...entry.candidateIds]);
+    }
+    merged.empty = merged.total === 0;
+    return merged;
+}
+function mergeJsTsSafeMergeApplySummaries(entries) {
+    const merged = emptyJsTsSafeMergeApplySummary();
+    for (const entry of entries) {
+        if (entry.empty && entry.total === 0)
+            continue;
+        addBaseSafeMergeSummary(merged, entry);
+        for (const key of ['acceptedClean', 'alreadyApplied', 'applied', 'skipped', 'scripts', 'projections', 'replays']) {
+            merged[key] += nonNegativeNumber(entry[key]);
+        }
+        mergeIntoNumberRecord(merged.byStatus, entry.byStatus);
+        mergeIntoNumberRecord(merged.byAction, entry.byAction);
+        merged.statuses = positiveRecordKeys(merged.byStatus);
+        merged.actions = positiveRecordKeys(merged.byAction);
+        merged.reasonCodes = uniqueStrings([...merged.reasonCodes, ...entry.reasonCodes]);
+        merged.sourcePaths = uniqueStrings([...merged.sourcePaths, ...entry.sourcePaths]);
+        merged.scriptIds = uniqueStrings([...merged.scriptIds, ...entry.scriptIds]);
+        merged.projectionIds = uniqueStrings([...merged.projectionIds, ...entry.projectionIds]);
+        merged.replayIds = uniqueStrings([...merged.replayIds, ...entry.replayIds]);
+    }
+    merged.empty = merged.total === 0;
+    return merged;
+}
+function addBaseSafeMergeSummary(target, source) {
+    for (const key of ['total', 'noOp', 'stale', 'needsReview', 'blocked', 'conflicts', 'autoApplyable', 'autoApplyCandidates']) {
+        target[key] += nonNegativeNumber(source[key]);
+    }
+    mergeIntoNumberRecord(target.byClassification, source.byClassification);
+    mergeIntoNumberRecord(target.byDecision, source.byDecision);
+    target.classifications = positiveRecordKeys(target.byClassification);
+    target.decisions = positiveRecordKeys(target.byDecision);
+    target.conflictReasonCodes = uniqueStrings([...target.conflictReasonCodes, ...source.conflictReasonCodes]);
+    target.conflictKeys = uniqueStrings([...target.conflictKeys, ...source.conflictKeys]);
+    target.evidenceIds = uniqueStrings([...target.evidenceIds, ...source.evidenceIds]);
+}
+function emptySemanticMergeAdmissionSummary() {
+    return {
+        total: 0,
+        classifications: [],
+        byClassification: {},
+        decisions: [],
+        byDecision: {},
+        noOp: 0,
+        stale: 0,
+        needsReview: 0,
+        blocked: 0,
+        conflicts: 0,
+        conflictReasonCodes: [],
+        conflictKeys: [],
+        evidenceIds: [],
+        autoApplyable: 0,
+        autoApplyCandidates: 0,
+        empty: true,
+        safe: 0,
+        safeWithLosses: 0,
+        reviewRequired: 0,
+        autoMergeable: 0,
+        reasonCodes: [],
+        conflictKeyKinds: [],
+        candidateIds: []
+    };
+}
+function emptyJsTsSafeMergeApplySummary() {
+    return {
+        total: 0,
+        classifications: [],
+        byClassification: {},
+        decisions: [],
+        byDecision: {},
+        noOp: 0,
+        stale: 0,
+        needsReview: 0,
+        blocked: 0,
+        conflicts: 0,
+        conflictReasonCodes: [],
+        conflictKeys: [],
+        evidenceIds: [],
+        autoApplyable: 0,
+        autoApplyCandidates: 0,
+        empty: true,
+        acceptedClean: 0,
+        alreadyApplied: 0,
+        applied: 0,
+        skipped: 0,
+        scripts: 0,
+        projections: 0,
+        replays: 0,
+        statuses: [],
+        byStatus: {},
+        actions: [],
+        byAction: {},
+        reasonCodes: [],
+        sourcePaths: [],
+        scriptIds: [],
+        projectionIds: [],
+        replayIds: []
+    };
+}
+function directSafeMergeValues(value, keys) {
+    if (Array.isArray(value))
+        return value;
+    if (!isObject(value))
+        return [];
+    const out = [];
+    for (const key of keys) {
+        const entry = value[key];
+        if (Array.isArray(entry))
+            out.push(...entry);
+        else if (entry !== undefined)
+            out.push(entry);
+    }
+    return out;
+}
+function addSignalCount(record, key) {
+    const normalized = normalizeSafeMergeSignal(key);
+    if (!normalized)
+        return;
+    record[normalized] = (record[normalized] ?? 0) + 1;
+}
+function signalCount(record, ...keys) {
+    const aliases = new Set(keys.map(normalizeSafeMergeSignal));
+    let count = 0;
+    for (const [key, value] of Object.entries(record)) {
+        if (aliases.has(normalizeSafeMergeSignal(key)))
+            count += nonNegativeNumber(value);
+    }
+    return count;
+}
+function normalizeSafeMergeSignal(value) {
+    const normalized = value.trim().replace(/_/g, '-').toLowerCase();
+    const compact = normalized.replace(/-/g, '');
+    if (compact === 'safewithlosses')
+        return 'safe-with-losses';
+    if (compact === 'acceptedclean')
+        return 'accepted-clean';
+    if (compact === 'alreadyapplied')
+        return 'already-applied';
+    if (compact === 'noop' || compact === 'nochange' || compact === 'nooperation' || compact === 'unchanged')
+        return 'no-op';
+    if (compact === 'needsreview')
+        return 'needs-review';
+    if (compact === 'reviewrequired')
+        return 'review-required';
+    if (compact === 'humanreview')
+        return 'human-review';
+    if (compact === 'blockedevidence')
+        return 'blocked-evidence';
+    if (compact === 'conflictblocked')
+        return 'conflict-blocked';
+    if (compact === 'automergeable')
+        return 'auto-mergeable';
+    if (compact === 'automergecandidate')
+        return 'auto-merge-candidate';
+    return normalized;
+}
+function mergeNumberRecords(...records) {
+    const out = {};
+    for (const record of records)
+        mergeIntoNumberRecord(out, record);
+    return out;
+}
+function mergeIntoNumberRecord(target, source) {
+    for (const [key, value] of Object.entries(source)) {
+        const normalized = normalizeSafeMergeSignal(key);
+        if (!normalized)
+            continue;
+        target[normalized] = (target[normalized] ?? 0) + nonNegativeNumber(value);
+    }
+}
+function sumRecord(record) {
+    return Object.values(record).reduce((sum, value) => sum + nonNegativeNumber(value), 0);
+}
+function positiveRecordKeys(record) {
+    return Object.keys(record).filter((key) => nonNegativeNumber(record[key]) > 0).sort();
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function stringArray(value) {
+    return typeof value === 'string' && value.trim() ? [value] : [];
+}
+function objectIds(value) {
+    return Array.isArray(value)
+        ? value.flatMap((entry) => isObject(entry) ? stringArray(entry.id) : stringArray(entry))
+        : [];
+}
 //# sourceMappingURL=semantic-import-quality.js.map