@pilio/gemini-watermark-remover 1.0.24 → 1.0.26

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pilio/gemini-watermark-remover",
   "description": "Automatically removes watermarks from Gemini AI generated images",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [
@@ -96,7 +96,8 @@
     "release:readiness": "node scripts/create-release-readiness-report.js",
     "release:quality-gate": "pnpm compare:allenk-v2 -- --fail-on-incomplete && pnpm release:readiness -- --fail-on-not-ready",
     "release:goal-audit": "node scripts/create-release-goal-audit-report.js",
-    "release:preflight": "pnpm test && pnpm build && pnpm package:extension && pnpm release:quality-gate && pnpm release:goal-audit -- --fail-on-incomplete",
+    "release:ci-check": "node scripts/check-github-ci.js --workflow ci.yml --commit HEAD --fail-closed",
+    "release:preflight": "pnpm test && pnpm build && pnpm package:extension && pnpm release:quality-gate && pnpm release:goal-audit -- --fail-on-incomplete && pnpm release:ci-check",
     "visible-residual:loop": "node scripts/run-visible-residual-loop.js",
     "visible-residual:verify": "node scripts/verify-visible-residual-loop.js",
     "visible-residual:validate-human-review": "node scripts/validate-visible-residual-human-review.js",
@@ -108,6 +109,10 @@
     "visible-residual:goal-audit": "node scripts/create-visible-residual-goal-audit-report.js",
     "visible-residual:cluster-report": "node scripts/create-visible-residual-cluster-report.js",
     "visible-residual:geometry-audit": "node scripts/audit-visible-residual-geometry.js",
+    "review:metric-mismatch": "node scripts/create-metric-mismatch-review-pack.js",
+    "probe:metric-48-alpha-profile": "node scripts/probe-metric-48-96-96-alpha-profile.js",
+    "probe:metric-48-localization": "node scripts/probe-metric-48-96-96-localization.js",
+    "review:metric-48-taxonomy": "node scripts/create-metric-48-96-96-failure-taxonomy.js",
     "scan:sample-watermarks": "node scripts/scan-sample-watermarks.js",
     "render:skipped-crops": "node scripts/render-skipped-candidate-crops.js",
     "render:video-crops": "node scripts/render-video-crop-sheet.js",

package/src/core/candidateSelector.js

@@ -22,6 +22,7 @@ import {
 import {
     buildRankingKey,
     compareRankingKey,
+    scoreBalancedVisualCandidate,
     scoreDamage,
     scoreOriginalEvidence,
     scoreResidual,
@@ -76,6 +77,13 @@ const STANDARD_TEXT_OVERLAP_MIN_GRADIENT_SCORE = 0.18;
 const STANDARD_TEXT_OVERLAP_MIN_IMPROVEMENT = 0.25;
 const STANDARD_TEXT_OVERLAP_MAX_RESIDUAL = 0.1;
 const STANDARD_TEXT_OVERLAP_MIN_GRADIENT_DROP = 0.1;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_ORIGINAL_SPATIAL_SCORE = 0.12;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_ORIGINAL_GRADIENT_SCORE = 0.06;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_IMPROVEMENT = 0.08;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_SPATIAL_RESIDUAL = 0.08;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_GRADIENT_RESIDUAL = 0.08;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_NEAR_BLACK_INCREASE = 0.005;
+const STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_TEXTURE = 0.05;
 const STANDARD_VALIDATION_MIN_ORIGINAL_SPATIAL_SCORE = 0.05;
 const STANDARD_VALIDATION_MIN_ORIGINAL_GRADIENT_SCORE = 0.12;
 const STANDARD_CONSERVATIVE_CATALOG_PREFERRED_ALPHA_GAIN = 0.55;
@@ -114,6 +122,14 @@ const STANDARD_STRONG_SIGNAL_NEAR_BLACK_OVERRIDE_MAX_GRADIENT = 0.32;
 const STANDARD_STRONG_SIGNAL_NEAR_BLACK_OVERRIDE_MIN_IMPROVEMENT = 0.7;
 const STANDARD_STRONG_SIGNAL_NEAR_BLACK_OVERRIDE_MIN_GRADIENT_DROP = 0.6;
 const STANDARD_STRONG_SIGNAL_NEAR_BLACK_OVERRIDE_MAX_NEAR_BLACK_INCREASE = 0.4;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MIN_SPATIAL = 0.35;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MIN_GRADIENT = 0.16;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_SPATIAL_ADVANTAGE = 0.18;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_GRADIENT_ADVANTAGE = 0.12;
+const BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MAX_RESIDUAL_DELTA = 0.08;
+const DARK_POLARITY_CATALOG_MIN_ORIGINAL_SPATIAL = 0.12;
+const DARK_POLARITY_CATALOG_MIN_ORIGINAL_GRADIENT = 0.08;
+const DARK_POLARITY_CATALOG_MAX_TEXTURE_FOR_WEAK_EVIDENCE = 0.25;
 const TEMPLATE_ALIGN_SHIFTS = [-0.5, -0.25, 0, 0.25, 0.5];
 const TEMPLATE_ALIGN_SCALES = [0.99, 1, 1.01];
 const STANDARD_NEARBY_SHIFTS = [-12, -8, -4, 0, 4, 8, 12];
@@ -137,15 +153,16 @@ const PREVIEW_ANCHOR_MIN_SCORE = 0.2;
 const PREVIEW_ANCHOR_LOCAL_DELTAS = [-1, 0, 1];
 const PREVIEW_TEMPLATE_ALIGN_SHIFTS = [-1, -0.5, 0, 0.5, 1];
 const PREVIEW_TEMPLATE_ALIGN_SCALES = [0.985, 1, 1.015];
-const PREVIEW_ANCHOR_GAIN_SKIP_RESIDUAL_THRESHOLD = 0.22;
+const PREVIEW_ANCHOR_GAIN_SKIP_RESIDUAL_THRESHOLD = 0.24;
 const PREVIEW_ANCHOR_GAIN_SKIP_GRADIENT_THRESHOLD = 0.24;
-const CORE_ALPHA_PRIORITY_GAINS = Object.freeze([0.6, 1, 1.15, 1.3, 0.45, 0.7, 0.85, 0.55]);
+const CORE_ALPHA_PRIORITY_GAINS = Object.freeze([0.6, 1, 1.1, 1.15, 1.3, 0.45, 0.7, 0.85, 0.55]);
 const CURRENT_LARGE_MARGIN_ULTRA_WEAK_ALPHA_GAINS = Object.freeze([0.25, 0.3, 0.35, 0.4]);
 const STANDARD_ANCHOR_WEAK_ALPHA_RESCUE_GAINS = Object.freeze([0.55, 0.7, 0.85]);
 const STANDARD_ANCHOR_WEAK_RESCUE_MAX_SPATIAL = 0.35;
-const STANDARD_ANCHOR_WEAK_RESCUE_MAX_GRADIENT = 0.18;
+const STANDARD_ANCHOR_WEAK_RESCUE_MAX_GRADIENT = 0.24;
 const STANDARD_ANCHOR_WEAK_RESCUE_MIN_IMPROVEMENT = 0.08;
 const STANDARD_ANCHOR_WEAK_RESCUE_MAX_NEAR_BLACK_INCREASE = 0.02;
+const STANDARD_ANCHOR_WEAK_RESCUE_MIN_BALANCED_ADVANTAGE = 0.03;
 const CURRENT_LARGE_MARGIN_WEAK_RESCUE_MAX_SPATIAL = 0.22;
 const CURRENT_LARGE_MARGIN_WEAK_RESCUE_MAX_GRADIENT = 0.36;
 const CURRENT_LARGE_MARGIN_WEAK_RESCUE_MIN_ORIGINAL_SPATIAL = 0.17;
@@ -595,6 +612,35 @@ function isWeakAlphaRescueCandidate(seed, trial) {
         trial.texturePenalty <= 0.25;
 }
 
+function isStandardTextOverlapWeakAlphaCandidate(seed, trial) {
+    if (!trial?.accepted || trial.alphaGain >= 1 || trial.hardReject === true) {
+        return false;
+    }
+    if (
+        seed?.config?.logoSize !== 96 ||
+        seed.config.marginRight !== 64 ||
+        seed.config.marginBottom !== 64
+    ) {
+        return false;
+    }
+
+    return trial.originalSpatialScore >= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_ORIGINAL_SPATIAL_SCORE &&
+        trial.originalGradientScore >= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_ORIGINAL_GRADIENT_SCORE &&
+        trial.improvement >= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MIN_IMPROVEMENT &&
+        Math.abs(trial.processedSpatialScore) <= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_SPATIAL_RESIDUAL &&
+        Math.max(0, trial.processedGradientScore) <= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_GRADIENT_RESIDUAL &&
+        trial.nearBlackIncrease <= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_NEAR_BLACK_INCREASE &&
+        trial.texturePenalty <= STANDARD_TEXT_OVERLAP_WEAK_ALPHA_MAX_TEXTURE;
+}
+
+function tagCandidateSource(candidate, tag) {
+    if (!candidate || String(candidate.source).includes(tag)) return candidate;
+    return {
+        ...candidate,
+        source: `${candidate.source}+${tag}`
+    };
+}
+
 function shouldPreferLargeMarginGradientClearance(currentBest, candidate) {
     if (!isCurrentLargeMarginCatalogCandidate(currentBest) || !isCurrentLargeMarginCatalogCandidate(candidate)) {
         return false;
@@ -640,6 +686,20 @@ function pickBetterWeakAlphaRescueCandidate(seed, currentBest, candidate) {
     return pickBetterCandidate(currentBest, candidate, 0.002);
 }
 
+function shouldPreferWeakAlphaRescueOverAccepted(acceptedTrial, rescueTrial) {
+    if (!acceptedTrial?.accepted || !rescueTrial?.accepted) return false;
+    if (rescueTrial.alphaGain >= 1) return false;
+
+    const acceptedCost = Number(acceptedTrial.validationCost);
+    const rescueCost = Number(rescueTrial.validationCost);
+    if (!Number.isFinite(acceptedCost) || !Number.isFinite(rescueCost)) return false;
+
+    return rescueCost <= acceptedCost - STANDARD_ANCHOR_WEAK_RESCUE_MIN_BALANCED_ADVANTAGE &&
+        Math.abs(rescueTrial.processedSpatialScore) <= Math.abs(acceptedTrial.processedSpatialScore) &&
+        Math.max(0, rescueTrial.processedGradientScore) <= STANDARD_ANCHOR_WEAK_RESCUE_MAX_GRADIENT &&
+        rescueTrial.nearBlackIncrease <= STANDARD_ANCHOR_WEAK_RESCUE_MAX_NEAR_BLACK_INCREASE;
+}
+
 function evaluateStandardTrialForSeed({
     originalImageData,
     seed,
@@ -669,6 +729,13 @@ function evaluateStandardTrialForSeed({
             fallbackTrial = trial;
         }
         if (alphaGain < 1) {
+            if (isStandardTextOverlapWeakAlphaCandidate(seed, trial)) {
+                bestWeakAlphaPriorityTrial = pickBetterCandidate(
+                    bestWeakAlphaPriorityTrial,
+                    tagCandidateSource(trial, 'text-overlap'),
+                    0.002
+                );
+            }
             if (
                 isWeakAlphaPrioritySeed(seed) &&
                 isCleanWeakAlphaPriorityCandidate(trial) &&
@@ -688,7 +755,14 @@ function evaluateStandardTrialForSeed({
 
     return isWeakAlphaPrioritySeed(seed)
         ? bestWeakAlphaPriorityTrial ?? bestWeakAlphaRescueTrial ?? bestAcceptedTrial ?? fallbackTrial
-        : bestWeakAlphaPriorityTrial ?? bestAcceptedTrial ?? bestWeakAlphaRescueTrial ?? fallbackTrial;
+        : bestWeakAlphaPriorityTrial ??
+            (
+                shouldPreferWeakAlphaRescueOverAccepted(bestAcceptedTrial, bestWeakAlphaRescueTrial)
+                    ? bestWeakAlphaRescueTrial
+                    : bestAcceptedTrial
+            ) ??
+            bestWeakAlphaRescueTrial ??
+            fallbackTrial;
 }
 
 export function evaluateRestorationCandidate({
@@ -807,9 +881,16 @@ export function evaluateRestorationCandidate({
         catalogEvidenceGate !== 'medium' ||
         originalScores.spatialScore >= 0.15 ||
         originalScores.gradientScore >= 0.08;
+    const darkPolarityCatalogEvidenceAllowed =
+        provenance?.darkPolarity !== true ||
+        provenance?.catalogVariant !== true ||
+        originalScores.spatialScore >= DARK_POLARITY_CATALOG_MIN_ORIGINAL_SPATIAL ||
+        originalScores.gradientScore >= DARK_POLARITY_CATALOG_MIN_ORIGINAL_GRADIENT ||
+        texturePenalty <= DARK_POLARITY_CATALOG_MAX_TEXTURE_FOR_WEAK_EVIDENCE;
     const accepted =
         originalEvidenceAllowed &&
         catalogEvidenceAllowed &&
+        darkPolarityCatalogEvidenceAllowed &&
         (
             hardRejectAllowed ||
             conservativeCatalogHardRejectAllowed ||
@@ -838,6 +919,13 @@ export function evaluateRestorationCandidate({
         processedGradient: processedScores.gradientScore,
         suppressionGain: improvement
     });
+    const balancedVisual = scoreBalancedVisualCandidate({
+        processedSpatial: processedScores.spatialScore,
+        processedGradient: processedScores.gradientScore,
+        nearBlackIncrease,
+        texturePenalty,
+        gradientIncrease
+    });
     const hardRejectBypassed =
         conservativeCatalogHardRejectAllowed ||
         visibleCatalogHardRejectAllowed ||
@@ -893,13 +981,10 @@ export function evaluateRestorationCandidate({
         originalEvidence,
         residual,
         damage,
-        validationCost:
-            Math.abs(processedScores.spatialScore) +
-            Math.max(0, processedScores.gradientScore) * 0.6 +
-            Math.max(0, nearBlackIncrease) * 3 +
-            texturePenalty
-    };
-}
+        balancedVisual,
+        validationCost: balancedVisual.score
+    };
+}
 
 function pickBestValidatedCandidate(candidates) {
     const accepted = candidates.filter((candidate) => candidate?.accepted);
@@ -1038,12 +1123,36 @@ export function pickBetterCandidate(currentBest, candidate, minCostDelta = 0.005
     if (shouldPreserveCatalogOriginalSignal(currentBest, candidate)) {
         return currentBest;
     }
+    if (shouldPreserveDominantBottomRight48AgainstWeakStandard(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveDominantBottomRight48AgainstWeakStandard(candidate, currentBest)) {
+        return candidate;
+    }
     if (shouldPreserveStrongCanonical96AgainstWeakCurrentLargeMargin(currentBest, candidate)) {
         return currentBest;
     }
     if (shouldPreserveStrongCanonical96AgainstWeakCurrentLargeMargin(candidate, currentBest)) {
         return candidate;
     }
+    if (shouldPreserveStrongCanonical96AgainstWeakNewMargin(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveStrongCanonical96AgainstWeakNewMargin(candidate, currentBest)) {
+        return candidate;
+    }
+    if (shouldPreserveStandardAlphaCanonical96AgainstDarkGain(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveStandardAlphaCanonical96AgainstDarkGain(candidate, currentBest)) {
+        return candidate;
+    }
+    if (shouldPreserveBalancedAlphaCanonical96(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveBalancedAlphaCanonical96(candidate, currentBest)) {
+        return candidate;
+    }
     if (shouldPreferCatalogOriginalSignal(candidate, currentBest)) {
         return candidate;
     }
@@ -1146,6 +1255,51 @@ function isCurrentLargeMarginCandidate(candidate) {
         candidate.config.marginBottom === 96;
 }
 
+function isBottomRight48Candidate(candidate) {
+    return candidate?.config?.logoSize === 48 &&
+        candidate.config.marginRight === 32 &&
+        candidate.config.marginBottom === 32 &&
+        candidate?.provenance?.localShift !== true &&
+        candidate?.provenance?.sizeJitter !== true &&
+        candidate?.provenance?.previewAnchor !== true;
+}
+
+function isWeakCompetingStandardAnchor(candidate) {
+    return isStandardCandidateSource(candidate) &&
+        candidate?.provenance?.localShift !== true &&
+        candidate?.provenance?.sizeJitter !== true &&
+        candidate?.provenance?.previewAnchor !== true &&
+        !isBottomRight48Candidate(candidate);
+}
+
+function shouldPreserveDominantBottomRight48AgainstWeakStandard(bottomRightCandidate, competingCandidate) {
+    if (!isBottomRight48Candidate(bottomRightCandidate)) return false;
+    if (!isWeakCompetingStandardAnchor(competingCandidate)) return false;
+
+    const bottomSpatial = Number(bottomRightCandidate.originalSpatialScore);
+    const bottomGradient = Number(bottomRightCandidate.originalGradientScore);
+    const largeSpatial = Number(competingCandidate.originalSpatialScore);
+    const largeGradient = Number(competingCandidate.originalGradientScore);
+    const bottomResidual = Number(bottomRightCandidate.residual?.score);
+    const largeResidual = Number(competingCandidate.residual?.score);
+    if (
+        !Number.isFinite(bottomSpatial) ||
+        !Number.isFinite(bottomGradient) ||
+        !Number.isFinite(largeSpatial) ||
+        !Number.isFinite(largeGradient) ||
+        !Number.isFinite(bottomResidual) ||
+        !Number.isFinite(largeResidual)
+    ) {
+        return false;
+    }
+
+    return bottomSpatial >= BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MIN_SPATIAL &&
+        bottomGradient >= BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MIN_GRADIENT &&
+        bottomSpatial >= largeSpatial + BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_SPATIAL_ADVANTAGE &&
+        bottomGradient >= largeGradient + BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_GRADIENT_ADVANTAGE &&
+        bottomResidual <= largeResidual + BOTTOM_RIGHT_48_EVIDENCE_DOMINANCE_MAX_RESIDUAL_DELTA;
+}
+
 function isPreviewAnchorCandidate(candidate) {
     return candidate?.provenance?.previewAnchor === true;
 }
@@ -1198,6 +1352,16 @@ function isDefault96GeometryCandidate(candidate) {
         candidate.config.marginBottom === 64;
 }
 
+function isNewMargin96Candidate(candidate) {
+    return isStandardCandidateSource(candidate) &&
+        candidate?.provenance?.localShift !== true &&
+        candidate?.provenance?.sizeJitter !== true &&
+        candidate?.provenance?.previewAnchor !== true &&
+        candidate?.config?.logoSize === 96 &&
+        candidate.config.marginRight === 192 &&
+        candidate.config.marginBottom === 192;
+}
+
 function shouldPreserveStrongCanonical96AgainstWeakCurrentLargeMargin(currentBest, candidate) {
     if (!isCanonicalDefault96Candidate(currentBest)) return false;
     if (!isCurrentLargeMarginCatalogCandidate(candidate)) return false;
@@ -1238,6 +1402,111 @@ function shouldPreserveStrongCanonical96AgainstWeakCurrentLargeMargin(currentBes
         candidateHasWeakOriginalSignal;
 }
 
+function shouldPreserveStrongCanonical96AgainstWeakNewMargin(currentBest, candidate) {
+    if (!isCanonicalDefault96Candidate(currentBest)) return false;
+    if (!isNewMargin96Candidate(candidate)) return false;
+
+    const currentSpatial = Number(currentBest.originalSpatialScore);
+    const currentGradient = Number(currentBest.originalGradientScore);
+    const candidateSpatial = Number(candidate.originalSpatialScore);
+    const candidateGradient = Number(candidate.originalGradientScore);
+    if (
+        !Number.isFinite(currentSpatial) ||
+        !Number.isFinite(currentGradient) ||
+        !Number.isFinite(candidateSpatial) ||
+        !Number.isFinite(candidateGradient)
+    ) {
+        return false;
+    }
+
+    const currentHasStrongCanonicalSignal =
+        currentSpatial >= 0.55 &&
+        currentGradient >= 0.2;
+    const candidateHasStrongNewMarginSignal =
+        candidateSpatial >= 0.55 &&
+        candidateGradient >= 0.3;
+    const candidateHasWeakOrMuchWeakerSignal =
+        candidateSpatial < STANDARD_VALIDATION_MIN_ORIGINAL_SPATIAL_SCORE ||
+        candidateGradient < STANDARD_VALIDATION_MIN_ORIGINAL_GRADIENT_SCORE ||
+        (
+            candidateSpatial <= currentSpatial - STRONG_ORIGINAL_SIGNAL_SPATIAL_ADVANTAGE &&
+            candidateGradient <= currentGradient - STRONG_ORIGINAL_SIGNAL_GRADIENT_ADVANTAGE
+        );
+
+    return currentHasStrongCanonicalSignal &&
+        !candidateHasStrongNewMarginSignal &&
+        candidateHasWeakOrMuchWeakerSignal;
+}
+
+function isBalancedCanonical96AlphaGain(candidate) {
+    const alphaGain = Number(candidate?.alphaGain);
+    return Number.isFinite(alphaGain) && alphaGain >= 1 && alphaGain <= 1.1;
+}
+
+function shouldPreserveStandardAlphaCanonical96AgainstDarkGain(currentBest, candidate) {
+    if (!sameCandidateAnchor(currentBest, candidate)) return false;
+    if (!isCanonicalDefault96Candidate(currentBest)) return false;
+
+    const currentAlphaGain = Number(currentBest?.alphaGain);
+    const candidateAlphaGain = Number(candidate?.alphaGain);
+    if (
+        !Number.isFinite(currentAlphaGain) ||
+        !Number.isFinite(candidateAlphaGain) ||
+        currentAlphaGain !== 1 ||
+        candidateAlphaGain <= 1 ||
+        candidate?.tooDark !== true
+    ) {
+        return false;
+    }
+
+    const originalSpatial = Number(currentBest.originalSpatialScore);
+    const originalGradient = Number(currentBest.originalGradientScore);
+    const currentSpatial = Number(currentBest.processedSpatialScore);
+    const currentGradient = Number(currentBest.processedGradientScore);
+    if (
+        !Number.isFinite(originalSpatial) ||
+        !Number.isFinite(originalGradient) ||
+        !Number.isFinite(currentSpatial) ||
+        !Number.isFinite(currentGradient)
+    ) {
+        return false;
+    }
+
+    return originalSpatial >= 0.55 &&
+        originalGradient >= 0.2 &&
+        currentSpatial >= 0 &&
+        currentSpatial <= 0.35 &&
+        Math.max(0, currentGradient) <= 0.08;
+}
+
+function shouldPreserveBalancedAlphaCanonical96(currentBest, candidate) {
+    if (!sameCandidateAnchor(currentBest, candidate)) return false;
+    if (!isCanonicalDefault96Candidate(currentBest)) return false;
+    if (!isBalancedCanonical96AlphaGain(currentBest)) return false;
+
+    const candidateAlphaGain = Number(candidate?.alphaGain);
+    if (!Number.isFinite(candidateAlphaGain) || candidateAlphaGain <= 1.1) return false;
+
+    const originalSpatial = Number(currentBest.originalSpatialScore);
+    const originalGradient = Number(currentBest.originalGradientScore);
+    const currentSpatial = Number(currentBest.processedSpatialScore);
+    const currentGradient = Number(currentBest.processedGradientScore);
+    if (
+        !Number.isFinite(originalSpatial) ||
+        !Number.isFinite(originalGradient) ||
+        !Number.isFinite(currentSpatial) ||
+        !Number.isFinite(currentGradient)
+    ) {
+        return false;
+    }
+
+    return originalSpatial >= 0.55 &&
+        originalGradient >= 0.2 &&
+        currentSpatial >= 0 &&
+        currentSpatial <= 0.22 &&
+        Math.max(0, currentGradient) <= 0.1;
+}
+
 function hasWeakDriftEvidence(candidate) {
     const candidateSpatial = Number(candidate?.originalSpatialScore);
     const candidateGradient = Number(candidate?.originalGradientScore);

package/src/core/restorationMetrics.js

@@ -26,6 +26,24 @@ const RESIDUAL_VISIBILITY_OUTER_MARGIN = 4;
 const RESIDUAL_VISIBILITY_POSITIVE_HALO_LUM_THRESHOLD = 6;
 const RESIDUAL_VISIBILITY_GRADIENT_THRESHOLD = 0.22;
 const RESIDUAL_VISIBILITY_SPATIAL_THRESHOLD = 0.18;
+const FLAT_CLIPPED_METRIC_RISK_NEAR_BLACK_RATIO = 0.92;
+const FLAT_CLIPPED_METRIC_RISK_NEWLY_CLIPPED_RATIO = 0.18;
+const FLAT_CLIPPED_METRIC_RISK_MAX_POSITIVE_HALO_LUM = 2;
+const FLAT_CLIPPED_METRIC_RISK_MIN_NEGATIVE_SPATIAL = 0.18;
+const POSITIVE_SPATIAL_BACKGROUND_COLLISION_MIN_SPATIAL = 0.14;
+const POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_GRADIENT = 0.12;
+const POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_POSITIVE_HALO_LUM = 32;
+const POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_ARTIFACT_COST = 0.12;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_ABS_SPATIAL = 0.14;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_GRADIENT = 0.12;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_POSITIVE_HALO_LUM = 16;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_ARTIFACT_COST = 0.12;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_NEAR_BLACK_RATIO = 0.25;
+const WEAK_HALO_BACKGROUND_COLLISION_MAX_NEWLY_CLIPPED_RATIO = 0.02;
+const STRUCTURED_EDGE_BACKGROUND_COLLISION_MIN_GRADIENT = 0.2;
+const STRUCTURED_EDGE_BACKGROUND_COLLISION_MIN_ARTIFACT_COST = 0.2;
+const STRUCTURED_EDGE_BACKGROUND_COLLISION_MAX_NEAR_BLACK_RATIO = 0.1;
+const STRUCTURED_EDGE_BACKGROUND_COLLISION_MAX_NEWLY_CLIPPED_RATIO = 0.01;
 
 function meanAndVariance(values) {
     let sum = 0;
@@ -359,6 +377,123 @@ export function assessWatermarkResidualVisibility({
     };
 }
 
+export function assessCalibratedWatermarkResidualVisibility({
+    imageData,
+    originalImageData = null,
+    position,
+    alphaMap,
+    alphaGain = 1
+}) {
+    const visibility = assessWatermarkResidualVisibility({
+        imageData,
+        position,
+        alphaMap
+    });
+    if (!visibility) return null;
+
+    const scores = scoreRegion(imageData, alphaMap, position);
+    const nearBlackRatio = calculateNearBlackRatio(imageData, position);
+    const artifacts = originalImageData
+        ? assessRemovalDiffArtifacts({
+            originalImageData,
+            candidateImageData: imageData,
+            alphaMap,
+            position,
+            alphaGain
+        })
+        : null;
+    const newlyClippedRatio = artifacts?.newlyClippedRatio ?? 0;
+    const metricRisk = classifyCalibratedResidualMetricRisk({
+        visibility,
+        spatialScore: scores.spatialScore,
+        gradientScore: scores.gradientScore,
+        nearBlackRatio,
+        newlyClippedRatio,
+        visualArtifactCost: artifacts?.visualArtifactCost ?? null,
+        hasOriginalImageData: Boolean(originalImageData)
+    });
+
+    return {
+        ...visibility,
+        rawVisible: visibility.visible,
+        visible: visibility.visible && !metricRisk,
+        calibratedVisible: visibility.visible && !metricRisk,
+        metricRisk,
+        nearBlackRatio,
+        newlyClippedRatio,
+        rawSpatialScore: scores.spatialScore,
+        rawGradientScore: scores.gradientScore
+    };
+}
+
+export function classifyCalibratedResidualMetricRisk({
+    visibility,
+    spatialScore,
+    gradientScore,
+    nearBlackRatio = 0,
+    newlyClippedRatio = 0,
+    visualArtifactCost = null,
+    hasOriginalImageData = false
+}) {
+    if (visibility?.visible !== true) return null;
+
+    if (
+        visibility.visibleSpatialResidual === true &&
+        visibility.visiblePositiveHalo !== true &&
+        spatialScore <= -FLAT_CLIPPED_METRIC_RISK_MIN_NEGATIVE_SPATIAL &&
+        visibility.positiveHaloLum <= FLAT_CLIPPED_METRIC_RISK_MAX_POSITIVE_HALO_LUM &&
+        nearBlackRatio >= FLAT_CLIPPED_METRIC_RISK_NEAR_BLACK_RATIO &&
+        (
+            !hasOriginalImageData ||
+            newlyClippedRatio >= FLAT_CLIPPED_METRIC_RISK_NEWLY_CLIPPED_RATIO
+        )
+    ) {
+        return 'flat-clipped-low-texture-spatial-correlation';
+    }
+
+    if (
+        visibility.visibleGradientResidual !== true &&
+        spatialScore >= POSITIVE_SPATIAL_BACKGROUND_COLLISION_MIN_SPATIAL &&
+        gradientScore < POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_GRADIENT &&
+        visibility.positiveHaloLum <= POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_POSITIVE_HALO_LUM &&
+        visualArtifactCost !== null &&
+        visualArtifactCost <= POSITIVE_SPATIAL_BACKGROUND_COLLISION_MAX_ARTIFACT_COST
+    ) {
+        return visibility.visiblePositiveHalo === true
+            ? 'positive-halo-background-collision'
+            : 'positive-spatial-background-collision';
+    }
+
+    if (
+        visibility.visiblePositiveHalo === true &&
+        visibility.visibleSpatialResidual !== true &&
+        visibility.visibleGradientResidual !== true &&
+        Math.abs(spatialScore) < WEAK_HALO_BACKGROUND_COLLISION_MAX_ABS_SPATIAL &&
+        gradientScore < WEAK_HALO_BACKGROUND_COLLISION_MAX_GRADIENT &&
+        visibility.positiveHaloLum <= WEAK_HALO_BACKGROUND_COLLISION_MAX_POSITIVE_HALO_LUM &&
+        nearBlackRatio < WEAK_HALO_BACKGROUND_COLLISION_MAX_NEAR_BLACK_RATIO &&
+        newlyClippedRatio <= WEAK_HALO_BACKGROUND_COLLISION_MAX_NEWLY_CLIPPED_RATIO &&
+        visualArtifactCost !== null &&
+        visualArtifactCost <= WEAK_HALO_BACKGROUND_COLLISION_MAX_ARTIFACT_COST
+    ) {
+        return 'weak-halo-background-collision';
+    }
+
+    if (
+        visibility.visiblePositiveHalo === true &&
+        visibility.visibleGradientResidual !== true &&
+        gradientScore >= STRUCTURED_EDGE_BACKGROUND_COLLISION_MIN_GRADIENT &&
+        nearBlackRatio < STRUCTURED_EDGE_BACKGROUND_COLLISION_MAX_NEAR_BLACK_RATIO &&
+        newlyClippedRatio <= STRUCTURED_EDGE_BACKGROUND_COLLISION_MAX_NEWLY_CLIPPED_RATIO &&
+        visualArtifactCost !== null &&
+        visualArtifactCost >= STRUCTURED_EDGE_BACKGROUND_COLLISION_MIN_ARTIFACT_COST
+    ) {
+        return 'structured-edge-background-collision';
+    }
+
+    return null;
+}
+
 function getReferenceRegion(position, imageData) {
     const referenceY = position.y - position.height;
     if (referenceY < 0) return null;