@pilio/gemini-watermark-remover 1.0.30 → 1.0.32

package/dist/video-app.js

@@ -1,5 +1,5 @@
 /*!
- * @pilio/gemini-watermark-remover v1.0.30+d4717dc
+ * @pilio/gemini-watermark-remover v1.0.32+6fab72e
  * Automatically removes watermarks from Gemini AI generated images
  * (c) 2026 GargantuaX
  * https://github.com/GargantuaX/gemini-watermark-remover

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pilio/gemini-watermark-remover",
   "description": "Automatically removes watermarks from Gemini AI generated images",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [
@@ -102,6 +102,7 @@
     "probe:tm:profile": "node scripts/open-tampermonkey-profile.js",
     "probe:tm:setup": "node scripts/tampermonkey-smoke.js setup",
     "probe:real-page:compare": "node scripts/real-page-pixel-compare.js",
+    "probe:real-page:copy-download": "node scripts/real-page-copy-download-probe.js",
     "benchmark:samples": "node scripts/sample-benchmark.js",
     "benchmark:userscript": "node scripts/userscript-benchmark.js",
     "benchmark:online-sample:gate": "node scripts/gate-online-gemini-watermark-sample-benchmark.js",

package/src/core/adaptiveDetector.js

@@ -196,6 +196,52 @@ export function computeSizeAdjustedConfidence(confidence, size, referenceSize =
     return confidence * sizeWeight;
 }
 
+function compareAdaptiveCandidatePriority(left, right) {
+    const leftScore = Number.isFinite(left?.adjustedScore)
+        ? left.adjustedScore
+        : computeSizeAdjustedConfidence(left?.confidence, left?.size);
+    const rightScore = Number.isFinite(right?.adjustedScore)
+        ? right.adjustedScore
+        : computeSizeAdjustedConfidence(right?.confidence, right?.size);
+    if (Math.abs(leftScore - rightScore) > 1e-12) {
+        return leftScore - rightScore;
+    }
+
+    const leftSize = Number.isFinite(left?.size) ? left.size : 0;
+    const rightSize = Number.isFinite(right?.size) ? right.size : 0;
+    const leftDistance = Math.abs(leftSize - REFERENCE_WATERMARK_SIZE);
+    const rightDistance = Math.abs(rightSize - REFERENCE_WATERMARK_SIZE);
+    if (leftDistance !== rightDistance) {
+        return rightDistance - leftDistance;
+    }
+
+    const leftConfidence = Number.isFinite(left?.confidence) ? left.confidence : 0;
+    const rightConfidence = Number.isFinite(right?.confidence) ? right.confidence : 0;
+    if (leftConfidence !== rightConfidence) {
+        return leftConfidence - rightConfidence;
+    }
+    if (leftSize !== rightSize) {
+        return leftSize - rightSize;
+    }
+
+    const leftX = Number.isFinite(left?.x) ? left.x : Infinity;
+    const rightX = Number.isFinite(right?.x) ? right.x : Infinity;
+    if (leftX !== rightX) {
+        return rightX - leftX;
+    }
+    const leftY = Number.isFinite(left?.y) ? left.y : Infinity;
+    const rightY = Number.isFinite(right?.y) ? right.y : Infinity;
+    return rightY - leftY;
+}
+
+export function selectAdaptiveFineCandidate(currentBest, candidate) {
+    if (!currentBest) return candidate;
+    if (!candidate) return currentBest;
+    return compareAdaptiveCandidatePriority(candidate, currentBest) > 0
+        ? candidate
+        : currentBest;
+}
+
 function buildSeedConfigs(width, height, defaultConfig) {
     // Start adaptive search from both the coarse default anchor and any
     // catalog-projected anchors for official or near-official Gemini sizes.
@@ -445,10 +491,10 @@ export function detectAdaptiveWatermarkRegion({
         })
         .filter(Boolean);
 
-    const bestSeed = seedCandidates.reduce((best, candidate) => {
-        if (!best || candidate.confidence > best.confidence) return candidate;
-        return best;
-    }, null);
+    const bestSeed = seedCandidates.reduce(
+        (best, candidate) => selectAdaptiveFineCandidate(best, candidate),
+        null
+    );
     if (bestSeed && bestSeed.confidence >= threshold + 0.08) {
         return {
             found: true,
@@ -483,7 +529,7 @@ export function detectAdaptiveWatermarkRegion({
     const topK = [];
     const pushTopK = (candidate) => {
         topK.push(candidate);
-        topK.sort((a, b) => b.adjustedScore - a.adjustedScore);
+        topK.sort((left, right) => -compareAdaptiveCandidatePriority(left, right));
         if (topK.length > 5) topK.length = 5;
     };
 
@@ -545,14 +591,12 @@ export function detectAdaptiveWatermarkRegion({
                     const score = scoreCandidate(context, tpl.alpha, tpl.grad, { x, y, size });
                     if (!score) continue;
 
-                    if (score.confidence > best.confidence) {
-                        best = {
-                            x,
-                            y,
-                            size,
-                            ...score
-                        };
-                    }
+                    best = selectAdaptiveFineCandidate(best, {
+                        x,
+                        y,
+                        size,
+                        ...score
+                    });
                 }
             }
         }

package/src/core/candidateEvaluation.js

@@ -5,8 +5,13 @@ import { createRepairTrialFromStages } from './pipelineRepairTrial.js';
 
 const NEW_MARGIN_96_SIZE = 96;
 const NEW_MARGIN_96_MARGIN = 192;
-const HIGH_RISK_NEW_MARGIN_MIN_SPATIAL = 0.4;
-const HIGH_RISK_NEW_MARGIN_MIN_GRADIENT = 0.08;
+const HIGH_RISK_NEW_MARGIN_MIN_SPATIAL = 0.4;
+const HIGH_RISK_NEW_MARGIN_MIN_GRADIENT = 0.08;
+const SAFE_EXACT_NEW_MARGIN_MIN_SPATIAL = 0.18;
+const SAFE_EXACT_NEW_MARGIN_MIN_GRADIENT = 0.05;
+const SAFE_EXACT_NEW_MARGIN_MIN_IMPROVEMENT = 0.1;
+const SAFE_EXACT_NEW_MARGIN_MAX_PROCESSED_SPATIAL = 0.32;
+const SAFE_EXACT_NEW_MARGIN_MAX_PROCESSED_GRADIENT = 0.05;
 const DEFAULT_ALPHA_NEW_MARGIN_MAX_SPATIAL_RESIDUAL = 0.18;
 const DEFAULT_ALPHA_NEW_MARGIN_MAX_GRADIENT_RESIDUAL = 0.08;
 const DEFAULT_ALPHA_NEW_MARGIN_MIN_IMPROVEMENT = 0.12;
@@ -40,11 +45,30 @@ export function isNewMarginAlphaVariantTrial(candidate) {
         config.alphaVariant === '20260520';
 }
 
-export function isDefaultAlphaNewMarginTrial(candidate) {
-    const config = getConfig(candidate);
-    return isNewMargin96Candidate(candidate) &&
-        !config.alphaVariant;
-}
+export function isDefaultAlphaNewMarginTrial(candidate) {
+    const config = getConfig(candidate);
+    return isNewMargin96Candidate(candidate) &&
+        !config.alphaVariant;
+}
+
+function isNewMarginVariantFamilyCandidate(candidate) {
+    const config = getConfig(candidate);
+    const provenance = getProvenance(candidate);
+    return config.marginRight === NEW_MARGIN_96_MARGIN &&
+        config.marginBottom === NEW_MARGIN_96_MARGIN &&
+        (config.alphaVariant === '20260520' || provenance.alphaVariant === '20260520');
+}
+
+function hasSafeExactNewMarginVariantRecovery(candidate) {
+    if (!isNewMarginAlphaVariantTrial(candidate)) return false;
+    if (candidate?.damage?.safe !== true) return false;
+
+    return numberOr(candidate?.originalSpatialScore) >= SAFE_EXACT_NEW_MARGIN_MIN_SPATIAL &&
+        numberOr(candidate?.originalGradientScore) >= SAFE_EXACT_NEW_MARGIN_MIN_GRADIENT &&
+        numberOr(candidate?.improvement, -Infinity) >= SAFE_EXACT_NEW_MARGIN_MIN_IMPROVEMENT &&
+        Math.abs(numberOr(candidate?.processedSpatialScore, Infinity)) <= SAFE_EXACT_NEW_MARGIN_MAX_PROCESSED_SPATIAL &&
+        Math.max(0, numberOr(candidate?.processedGradientScore, Infinity)) <= SAFE_EXACT_NEW_MARGIN_MAX_PROCESSED_GRADIENT;
+}
 
 export function hasClearedResidual(candidate) {
     return candidate?.residual?.cleared === true ||
@@ -61,13 +85,14 @@ export function hasSafeDefaultAlphaNewMarginResidual(candidate) {
         numberOr(candidate?.improvement, -Infinity) >= DEFAULT_ALPHA_NEW_MARGIN_MIN_IMPROVEMENT;
 }
 
-export function hasHighRiskNewMarginPositiveEvidence(candidate) {
-    if (getProvenance(candidate).darkPolarity === true) return true;
-    if (!isNewMarginAlphaVariantTrial(candidate) && !isDefaultAlphaNewMarginTrial(candidate)) return true;
-
-    return numberOr(candidate?.originalGradientScore) >= HIGH_RISK_NEW_MARGIN_MIN_GRADIENT ||
-        numberOr(candidate?.originalSpatialScore) >= HIGH_RISK_NEW_MARGIN_MIN_SPATIAL;
-}
+export function hasHighRiskNewMarginPositiveEvidence(candidate) {
+    if (getProvenance(candidate).darkPolarity === true) return true;
+    if (!isNewMarginVariantFamilyCandidate(candidate) && !isDefaultAlphaNewMarginTrial(candidate)) return true;
+
+    const hasStrongEvidence = numberOr(candidate?.originalGradientScore) >= HIGH_RISK_NEW_MARGIN_MIN_GRADIENT ||
+        numberOr(candidate?.originalSpatialScore) >= HIGH_RISK_NEW_MARGIN_MIN_SPATIAL;
+    return hasStrongEvidence || hasSafeExactNewMarginVariantRecovery(candidate);
+}
 
 export function shouldFailClosedForVisibleResidualUnsafeDamage({
     selectedTrial = null,
@@ -124,10 +149,11 @@ export function createCandidateEvaluation({
         provenance,
         originalSpatialScore: originalScores?.spatialScore,
         originalGradientScore: originalScores?.gradientScore,
-        processedSpatialScore: processedScores?.spatialScore,
-        processedGradientScore: processedScores?.gradientScore,
-        improvement
-    };
+        processedSpatialScore: processedScores?.spatialScore,
+        processedGradientScore: processedScores?.gradientScore,
+        improvement,
+        damage
+    };
     const originalSpatial = numberOr(originalScores?.spatialScore);
     const originalGradient = numberOr(originalScores?.gradientScore);
     const processedSpatial = numberOr(processedScores?.spatialScore);

package/src/core/candidateSelector.js

@@ -137,6 +137,8 @@ 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_48_MIN_ORIGINAL_SPATIAL = 0.6;
+const DARK_POLARITY_48_MIN_ORIGINAL_GRADIENT = 0.3;
 const DARK_POLARITY_CATALOG_MAX_TEXTURE_FOR_WEAK_EVIDENCE = 0.25;
 const DARK_POLARITY_MAX_NEAR_WHITE_RATIO_INCREASE_FOR_WEAK_EVIDENCE = 0.05;
 const DARK_POLARITY_NEAR_WHITE_OVERRIDE_MIN_ORIGINAL_SPATIAL = 0.4;
@@ -183,6 +185,7 @@ 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.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 DARK_POLARITY_48_ULTRA_WEAK_ALPHA_GAINS = Object.freeze([0.08, 0.1, 0.12, 0.15, 0.2]);
 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.24;
@@ -393,13 +396,17 @@ function buildStandardCandidateSeeds({
         }
 
         if (shouldAddDarkPolaritySeed(candidateConfig)) {
+            const weakDarkPolarity48 = candidateConfig.logoSize === 48;
             seeds.push({
                 ...baseSeed,
                 alphaMap: createNegativeAlphaMap(alphaMap),
                 source: `${baseSeed.source}+dark-polarity`,
                 provenance: mergeCandidateProvenance(
                     baseSeed.provenance,
-                    { darkPolarity: true }
+                    {
+                        darkPolarity: true,
+                        ...(weakDarkPolarity48 ? { weakDarkPolarity48: true } : {})
+                    }
                 )
             });
         }
@@ -409,9 +416,19 @@ function buildStandardCandidateSeeds({
 }
 
 function shouldAddDarkPolaritySeed(config) {
-    return config?.logoSize === 96 &&
+    if (
+        config?.logoSize === 96 &&
         config.marginRight === 192 &&
-        config.marginBottom === 192;
+        config.marginBottom === 192
+    ) {
+        return true;
+    }
+
+    return config?.logoSize === 48 &&
+        config.marginRight >= 90 &&
+        config.marginRight <= 100 &&
+        config.marginBottom >= 90 &&
+        config.marginBottom <= 100;
 }
 
 const negativeAlphaMapCache = new WeakMap();
@@ -496,6 +513,23 @@ function resolveAlphaMapForSize(size, { alpha48, alpha96, getAlphaMap } = {}) {
     return alpha96 ? interpolateAlphaMap(alpha96, 96, size) : null;
 }
 
+export function resolveSizeJitterAlphaMap(seed, size, {
+    alpha48,
+    alpha96,
+    getAlphaMap,
+    resolveAlphaMap = null
+} = {}) {
+    const seedSize = Number(seed?.position?.width);
+    if (seed?.alphaMap && Number.isFinite(seedSize) && seedSize > 0) {
+        if (size === seedSize) return seed.alphaMap;
+        return interpolateAlphaMap(seed.alphaMap, seedSize, size);
+    }
+
+    return typeof resolveAlphaMap === 'function'
+        ? resolveAlphaMap(size)
+        : resolveAlphaMapForSize(size, { alpha48, alpha96, getAlphaMap });
+}
+
 function resolveAlphaMapForConfig(config, {
     alpha48,
     alpha96,
@@ -642,7 +676,15 @@ function isWeakAlphaPrioritySeed(seed) {
         seed.config.marginBottom === 96;
 }
 
+function isWeakDarkPolarity48Seed(seed) {
+    return seed?.provenance?.weakDarkPolarity48 === true;
+}
+
 function resolveStandardSeedAlphaPriorityGains(seed, alphaPriorityGains) {
+    if (isWeakDarkPolarity48Seed(seed)) {
+        return DARK_POLARITY_48_ULTRA_WEAK_ALPHA_GAINS;
+    }
+
     const extras = isWeakAlphaPrioritySeed(seed)
         ? [
             ...CURRENT_LARGE_MARGIN_ULTRA_WEAK_ALPHA_GAINS,
@@ -857,7 +899,7 @@ function evaluateStandardTrialForSeed({
         }
     }
 
-    return isWeakAlphaPrioritySeed(seed)
+    const selected = isWeakAlphaPrioritySeed(seed)
         ? bestWeakAlphaPriorityTrial ?? bestWeakAlphaRescueTrial ?? bestAcceptedTrial ?? fallbackTrial
         : bestWeakAlphaPriorityTrial ??
             (
@@ -867,6 +909,10 @@ function evaluateStandardTrialForSeed({
             ) ??
             bestWeakAlphaRescueTrial ??
             fallbackTrial;
+
+    return isWeakDarkPolarity48Seed(seed) && selected?.accepted !== true
+        ? null
+        : selected;
 }
 
 export function evaluateRestorationCandidate({
@@ -994,11 +1040,40 @@ export function evaluateRestorationCandidate({
     const strongDarkPolarityOriginalEvidence =
         originalScores.spatialScore >= DARK_POLARITY_CATALOG_MIN_ORIGINAL_SPATIAL ||
         originalScores.gradientScore >= DARK_POLARITY_CATALOG_MIN_ORIGINAL_GRADIENT;
+    const isLargeMargin48DarkPolarity =
+        provenance?.darkPolarity === true &&
+        config?.logoSize === 48 &&
+        config.marginRight >= 90 &&
+        config.marginRight <= 100 &&
+        config.marginBottom >= 90 &&
+        config.marginBottom <= 100;
+    const largeMargin48DarkPolarityEvidenceAllowed =
+        !isLargeMargin48DarkPolarity ||
+        (
+            originalScores.spatialScore >= DARK_POLARITY_48_MIN_ORIGINAL_SPATIAL &&
+            originalScores.gradientScore >= DARK_POLARITY_48_MIN_ORIGINAL_GRADIENT
+        );
+    const weakDarkPolarity48ScopeAllowed =
+        provenance?.weakDarkPolarity48 !== true ||
+        (
+            config?.logoSize === 48 &&
+            config.marginRight >= 90 &&
+            config.marginRight <= 100 &&
+            config.marginBottom >= 90 &&
+            config.marginBottom <= 100 &&
+            alphaGain <= 0.2
+        );
     const darkPolarityCatalogEvidenceAllowed =
         provenance?.darkPolarity !== true ||
         provenance?.catalogVariant !== true ||
-        strongDarkPolarityOriginalEvidence ||
-        texturePenalty <= DARK_POLARITY_CATALOG_MAX_TEXTURE_FOR_WEAK_EVIDENCE;
+        (
+            weakDarkPolarity48ScopeAllowed &&
+            largeMargin48DarkPolarityEvidenceAllowed &&
+            (
+                strongDarkPolarityOriginalEvidence ||
+                texturePenalty <= DARK_POLARITY_CATALOG_MAX_TEXTURE_FOR_WEAK_EVIDENCE
+            )
+        );
     const strongDarkPolarityNearWhiteOverrideEvidence =
         originalScores.spatialScore >= DARK_POLARITY_NEAR_WHITE_OVERRIDE_MIN_ORIGINAL_SPATIAL ||
         originalScores.gradientScore >= DARK_POLARITY_NEAR_WHITE_OVERRIDE_MIN_ORIGINAL_GRADIENT;
@@ -1320,11 +1395,35 @@ function compareSameAnchorCandidateRanking(currentBest, candidate) {
     return compareRankingKey(candidate.rankingKey, currentBest.rankingKey);
 }
 
+function shouldPreserveExactNewMarginVariant(exactCandidate, competingCandidate) {
+    const exactConfig = exactCandidate?.config ?? {};
+    const competingConfig = competingCandidate?.config ?? {};
+    const exactVariant = exactConfig.alphaVariant ?? exactCandidate?.provenance?.alphaVariant;
+    const competingVariant = competingConfig.alphaVariant ?? competingCandidate?.provenance?.alphaVariant;
+
+    if (exactCandidate?.accepted !== true || exactCandidate?.damage?.safe !== true) return false;
+    if (exactConfig.logoSize !== 96 || exactConfig.marginRight !== 192 || exactConfig.marginBottom !== 192) {
+        return false;
+    }
+    if (exactVariant !== '20260520') return false;
+    if (competingCandidate?.provenance?.sizeJitter !== true) return false;
+    if (competingConfig.marginRight !== 192 || competingConfig.marginBottom !== 192) return false;
+    if (competingVariant !== exactVariant) return false;
+
+    return !hasMuchStrongerOriginalSignal(competingCandidate, exactCandidate);
+}
+
 export function pickBetterCandidate(currentBest, candidate, minCostDelta = 0.005) {
     if (!candidate?.accepted) return currentBest;
     if (!currentBest) return candidate;
     const evaluationDecision = arbitrateCandidateByEvaluation(currentBest, candidate);
     if (evaluationDecision) return evaluationDecision;
+    if (shouldPreserveExactNewMarginVariant(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveExactNewMarginVariant(candidate, currentBest)) {
+        return candidate;
+    }
     if (shouldPreserveCatalogOriginalSignal(currentBest, candidate)) {
         return currentBest;
     }
@@ -1975,13 +2074,12 @@ function searchStandardSizeJitterCandidate({
             if (candidatePosition.x + candidatePosition.width > originalImageData.width) continue;
             if (candidatePosition.y + candidatePosition.height > originalImageData.height) continue;
 
-            const candidateAlphaMap = typeof resolveAlphaMap === 'function'
-                ? resolveAlphaMap(size)
-                : resolveAlphaMapForSize(size, {
-                    alpha48,
-                    alpha96,
-                    getAlphaMap
-                });
+            const candidateAlphaMap = resolveSizeJitterAlphaMap(seed, size, {
+                alpha48,
+                alpha96,
+                getAlphaMap,
+                resolveAlphaMap
+            });
             if (!candidateAlphaMap) continue;
 
             const candidate = evaluateRestorationCandidate({
@@ -1989,11 +2087,10 @@ function searchStandardSizeJitterCandidate({
                 alphaMap: candidateAlphaMap,
                 position: candidatePosition,
                 source: `${seed.source}+size`,
-                config: {
-                    logoSize: size,
-                    marginRight: seed.config.marginRight,
-                    marginBottom: seed.config.marginBottom
-                },
+                config: {
+                    ...seed.config,
+                    logoSize: size
+                },
                 baselineNearBlackRatio: calculateNearBlackRatio(originalImageData, candidatePosition),
                 adaptiveConfidence,
                 provenance: mergeCandidateProvenance(seed.provenance, { sizeJitter: true }),

package/src/core/geminiSizeCatalog.js

@@ -465,7 +465,6 @@ export function resolveOfficialGeminiSearchConfigEntries(
         })
         .filter(Boolean)
         .sort((a, b) => a.score - b.score);
-
     const deduped = [];
     const seen = new Set();
     for (const candidate of candidates) {

package/src/core/imageWatermarkPipeline.js

@@ -27,6 +27,14 @@ function createSelectedCandidate(best) {
     };
 }
 
+function findDarkBackgroundSupportConvergence(meta = {}) {
+    const stages = Array.isArray(meta.alphaAdjustmentStages)
+        ? meta.alphaAdjustmentStages
+        : [];
+    const convergence = stages.at(-1)?.darkBackgroundSupportConvergence;
+    return convergence?.accepted === true ? convergence : null;
+}
+
 function createRuntimeFailureResult({
     createRejectedResult,
     originalImageData,
@@ -42,6 +50,26 @@ function createRuntimeFailureResult({
     });
 }
 
+function createNoWatermarkResult({
+    createRejectedResult,
+    originalImageData,
+    collection,
+    debugTimings
+}) {
+    const selection = collection?.automaticSelection ?? collection?.fixedSelection ?? {};
+    return createRejectedResult({
+        imageData: originalImageData,
+        debugTimings,
+        reason: 'no-watermark-detected',
+        adaptiveConfidence: selection.adaptiveConfidence ?? null,
+        originalSpatialScore: selection.standardSpatialScore ?? null,
+        originalGradientScore: selection.standardGradientScore ?? null,
+        source: 'skipped',
+        decisionTier: selection.decisionTier ?? 'insufficient',
+        selectionDebug: null
+    });
+}
+
 function notifyCandidateCompleted({ options, candidate, debugTimings }) {
     if (typeof options?.onCandidateCompleted !== 'function') return;
 
@@ -55,6 +83,41 @@ function notifyCandidateCompleted({ options, candidate, debugTimings }) {
     }
 }
 
+function appendUniqueRiskFlag(flags, flag) {
+    const normalized = Array.isArray(flags) ? flags : [];
+    return normalized.includes(flag) ? normalized : [...normalized, flag];
+}
+
+function attachPresenceBestEffortMeta(meta, collection) {
+    if (collection?.bestEffortFallback !== true) return meta;
+
+    const riskFlag = 'unconfirmed-watermark-presence';
+    const decisionPath = meta?.decisionPath && typeof meta.decisionPath === 'object'
+        ? {
+            ...meta.decisionPath,
+            riskFlags: appendUniqueRiskFlag(meta.decisionPath.riskFlags, riskFlag),
+            evaluation: meta.decisionPath.evaluation &&
+                typeof meta.decisionPath.evaluation === 'object'
+                ? {
+                    ...meta.decisionPath.evaluation,
+                    riskFlags: appendUniqueRiskFlag(
+                        meta.decisionPath.evaluation.riskFlags,
+                        riskFlag
+                    )
+                }
+                : meta.decisionPath.evaluation
+        }
+        : meta?.decisionPath;
+
+    return {
+        ...meta,
+        presenceConfirmed: false,
+        bestEffortReason:
+            collection.bestEffortReason ?? 'presence-witness-unconfirmed',
+        decisionPath
+    };
+}
+
 export function runImageWatermarkPipeline({
     imageData,
     options = {},
@@ -119,6 +182,26 @@ export function runImageWatermarkPipeline({
         debugTimings.generatedCandidateCount = hypotheses.length;
         debugTimings.earlyExitReason = null;
     }
+    if (
+        collection?.presenceConfirmed === false &&
+        collection?.bestEffortFallback !== true
+    ) {
+        if (debugTimingsEnabled) {
+            debugTimings.candidateExecutionMs = 0;
+            debugTimings.executedCandidateCount = 0;
+            debugTimings.completedCandidateCount = 0;
+            debugTimings.failedCandidateCount = 0;
+            debugTimings.candidateRankingMs = 0;
+            debugTimings.earlyExitReason = 'no-watermark-detected';
+            debugTimings.totalMs = nowMs() - totalStartedAt;
+        }
+        return createNoWatermarkResult({
+            createRejectedResult,
+            originalImageData,
+            collection,
+            debugTimings
+        });
+    }
 
     const completed = [];
     const failures = [];
@@ -135,7 +218,9 @@ export function runImageWatermarkPipeline({
                 debugTimingsEnabled,
                 visualPostProcessingEnabled,
                 cleanupConfig,
-                createAcceptedPipelineDependencies,
+                createAcceptedPipelineDependencies: () => (
+                    createAcceptedPipelineDependencies(hypothesis)
+                ),
                 runAcceptedPipeline,
                 createAcceptedFinalResult
             });
@@ -148,7 +233,16 @@ export function runImageWatermarkPipeline({
                 qualitySignals: measureCandidate({
                     originalImageData,
                     candidateImageData: completedCandidate.result.imageData,
-                    hypothesis
+                    hypothesis,
+                    finalCandidate: {
+                        position: completedCandidate.pipelineState?.position,
+                        alphaMap: completedCandidate.pipelineState?.alphaMap,
+                        alphaGain: completedCandidate.pipelineState?.alphaGain,
+                        darkBackgroundSupportConvergence:
+                            findDarkBackgroundSupportConvergence(
+                                completedCandidate.result.meta
+                            )
+                    }
                 })
             };
             completed.push(candidate);
@@ -197,13 +291,14 @@ export function runImageWatermarkPipeline({
     }
 
     const candidateSummaries = createSummaries(ranked, failures);
-    const meta = attachSelectionMeta(best.result.meta, {
+    const selectionMeta = attachSelectionMeta(best.result.meta, {
         qualityStatus: best.qualitySignals?.qualityStatus,
         selectionConfidence: best.selectionConfidence,
         selectedCandidate: createSelectedCandidate(best),
         qualitySignals: best.qualitySignals,
         candidateSummaries
     });
+    const meta = attachPresenceBestEffortMeta(selectionMeta, collection);
     if (debugTimingsEnabled) {
         debugTimings.candidateRankingMs = nowMs() - rankingStartedAt;
         debugTimings.totalMs = nowMs() - totalStartedAt;

package/src/core/pipelineAcceptedExecutor.js

@@ -96,11 +96,15 @@ export function runAcceptedAlphaRepairPipeline({
                 originalGradientScore: current.originalGradientScore,
                 calculateNearBlackRatio: metrics.calculateNearBlackRatio,
                 acceptCurrentAlphaTrialResult,
-                debugTimings,
-                debugTimingsEnabled,
-                refiners: {
-                    recalibrateOverSubtractedAlpha: refiners.recalibrateOverSubtractedAlpha,
-                    fineTuneDarkCatalogAlpha: refiners.fineTuneDarkCatalogAlpha,
+                debugTimings,
+                debugTimingsEnabled,
+                refiners: {
+                    refineLargeMargin48ProfileAlphaRescue:
+                        refiners.refineLargeMargin48ProfileAlphaRescue,
+                    fineTuneEvidenceGatedLocalAlpha:
+                        refiners.fineTuneEvidenceGatedLocalAlpha,
+                    recalibrateOverSubtractedAlpha: refiners.recalibrateOverSubtractedAlpha,
+                    fineTuneDarkCatalogAlpha: refiners.fineTuneDarkCatalogAlpha,
                     fineTuneWeakPositiveResidualAlpha: refiners.fineTuneWeakPositiveResidualAlpha
                 }
             });