@pilio/gemini-watermark-remover 1.0.31 → 1.0.32

package/dist/video-app.js

@@ -1,5 +1,5 @@
 /*!
- * @pilio/gemini-watermark-remover v1.0.31+bf77e39
+ * @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.31",
+  "version": "1.0.32",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [

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/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();
@@ -659,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,
@@ -874,7 +899,7 @@ function evaluateStandardTrialForSeed({
         }
     }
 
-    return isWeakAlphaPrioritySeed(seed)
+    const selected = isWeakAlphaPrioritySeed(seed)
         ? bestWeakAlphaPriorityTrial ?? bestWeakAlphaRescueTrial ?? bestAcceptedTrial ?? fallbackTrial
         : bestWeakAlphaPriorityTrial ??
             (
@@ -884,6 +909,10 @@ function evaluateStandardTrialForSeed({
             ) ??
             bestWeakAlphaRescueTrial ??
             fallbackTrial;
+
+    return isWeakDarkPolarity48Seed(seed) && selected?.accepted !== true
+        ? null
+        : selected;
 }
 
 export function evaluateRestorationCandidate({
@@ -1011,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;

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
                 }
             });

package/src/core/pipelineAlphaStageSpecs.js

@@ -27,12 +27,92 @@ export function createFineAlphaTrialSequenceSpecs({
     refiners = {}
 } = {}) {
     const {
+        refineLargeMargin48ProfileAlphaRescue,
+        fineTuneEvidenceGatedLocalAlpha,
         recalibrateOverSubtractedAlpha,
         fineTuneDarkCatalogAlpha,
         fineTuneWeakPositiveResidualAlpha
     } = refiners;
 
+    const evidenceGatedStages = [];
+    if (typeof refineLargeMargin48ProfileAlphaRescue === 'function') {
+        evidenceGatedStages.push({
+            stage: 'large-margin-48-profile-alpha-rescue',
+            strategy: 'large-margin-48-profile-alpha',
+            createTrial: () => {
+                const state = readPipelineAlphaState(readState);
+                return typeof refineLargeMargin48ProfileAlphaRescue === 'function'
+                    ? refineLargeMargin48ProfileAlphaRescue({
+                        originalImageData,
+                        currentImageData: state.finalImageData,
+                        currentAlphaMap: state.alphaMap,
+                        currentPosition: state.position,
+                        currentConfig: state.config,
+                        currentSpatialScore: state.finalProcessedSpatialScore,
+                        currentGradientScore: state.finalProcessedGradientScore,
+                        currentAlphaGain: state.alphaGain,
+                        originalSpatialScore,
+                        originalGradientScore
+                    })
+                    : null;
+            },
+            acceptCurrentAlphaTrialResult,
+            source: () => {
+                const source = readPipelineAlphaState(readState).source;
+                return source.includes('+profile-alpha-rescue')
+                    ? source
+                    : `${source}+profile-alpha-rescue`;
+            },
+            stageExtras: (result) => ({
+                profileExponent: result.profileExponent
+            })
+        });
+    }
+    if (typeof fineTuneEvidenceGatedLocalAlpha === 'function') {
+        evidenceGatedStages.push({
+            stage: 'evidence-gated-local-alpha-search',
+            strategy: 'evidence-gated-local-alpha',
+            createTrial: () => {
+                const state = readPipelineAlphaState(readState);
+                return typeof fineTuneEvidenceGatedLocalAlpha === 'function'
+                    ? fineTuneEvidenceGatedLocalAlpha({
+                        originalImageData,
+                        currentImageData: state.finalImageData,
+                        alphaMap: state.alphaMap,
+                        position: state.position,
+                        currentSpatialScore: state.finalProcessedSpatialScore,
+                        currentGradientScore: state.finalProcessedGradientScore,
+                        currentAlphaGain: state.alphaGain,
+                        originalSpatialScore,
+                        originalGradientScore,
+                        originalNearBlackRatio: resolveNearBlackRatio({
+                            calculateNearBlackRatio,
+                            imageData: originalImageData,
+                            position: state.position
+                        })
+                    })
+                    : null;
+            },
+            acceptCurrentAlphaTrialResult,
+            source: () => {
+                const source = readPipelineAlphaState(readState).source;
+                return source.includes('+fine-alpha')
+                    ? source
+                    : `${source}+fine-alpha`;
+            },
+            stageExtras: (result) => ({
+                localSearchTrigger: result.localSearchTrigger,
+                darkBackgroundSupportConvergence:
+                    result.darkBackgroundSupportConvergence ?? null
+            }),
+            debugTimings,
+            timingKey: debugTimingsEnabled ? 'localAlphaSearchMs' : null,
+            nowMs
+        });
+    }
+
     return [
+        ...evidenceGatedStages,
         {
             stage: 'over-subtraction-recalibration',
             strategy: 'over-subtraction-fine-alpha',
@@ -105,6 +185,7 @@ export function createFineAlphaTrialSequenceSpecs({
                 return typeof fineTuneWeakPositiveResidualAlpha === 'function'
                     ? fineTuneWeakPositiveResidualAlpha({
                         originalImageData,
+                        currentImageData: state.finalImageData,
                         alphaMap: state.alphaMap,
                         position: state.position,
                         currentSpatialScore: state.finalProcessedSpatialScore,

package/src/core/pipelineAlphaTraceContract.js

@@ -21,13 +21,15 @@ export function normalizeAlphaAdjustmentStageForTrace(stagePayload = {}) {
         profileExponent = null,
         alphaStrategy = null,
         repairStrategy = null,
-        allowSameAlphaGain = false
+        allowSameAlphaGain = false,
+        ...stageExtras
     } = stagePayload;
 
     if (!stage || !Number.isFinite(fromAlphaGain) || !Number.isFinite(toAlphaGain)) return null;
     if (!allowSameAlphaGain && Math.abs(fromAlphaGain - toAlphaGain) < 0.0001) return null;
 
     return {
+        ...stageExtras,
         stage,
         fromAlphaGain,
         toAlphaGain,