@pilio/gemini-watermark-remover 1.0.30 → 1.0.31

package/dist/video-app.js

@@ -1,5 +1,5 @@
 /*!
- * @pilio/gemini-watermark-remover v1.0.30+d4717dc
+ * @pilio/gemini-watermark-remover v1.0.31+bf77e39
  * 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.31",
   "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/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

@@ -496,6 +496,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,
@@ -1320,11 +1337,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 +2016,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 +2029,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/watermarkProcessor.js

@@ -2644,38 +2644,50 @@ function refineLocatedAggressiveRemoval({
     return best;
 }
 
-function shouldSkipLocatedAggressiveForCleanCanonical96({
+function shouldSkipLocatedAggressiveForCleanCanonical96({
     config,
     alphaGain,
     originalSpatialScore,
     originalGradientScore,
-    currentSpatialScore,
-    currentGradientScore
-}) {
-    if (
-        config?.logoSize !== 96 ||
-        config.marginRight !== 64 ||
-        config.marginBottom !== 64
-    ) {
-        return false;
-    }
-
-    const resolvedAlphaGain = Number(alphaGain);
-    const originalSpatial = Number(originalSpatialScore);
-    const originalGradient = Number(originalGradientScore);
-    const currentSpatial = Number(currentSpatialScore);
-    const currentGradient = Number(currentGradientScore);
+    currentSpatialScore,
+    currentGradientScore
+}) {
+    const resolvedAlphaGain = Number(alphaGain);
+    const originalSpatial = Number(originalSpatialScore);
+    const originalGradient = Number(originalGradientScore);
+    const currentSpatial = Number(currentSpatialScore);
+    const currentGradient = Number(currentGradientScore);
     if (
         !Number.isFinite(resolvedAlphaGain) ||
         !Number.isFinite(originalSpatial) ||
         !Number.isFinite(originalGradient) ||
         !Number.isFinite(currentSpatial) ||
         !Number.isFinite(currentGradient)
-    ) {
-        return false;
-    }
-
-    const cleanStandardAlpha =
+    ) {
+        return false;
+    }
+
+    const cleanExactNewMarginVariant =
+        config?.logoSize === 96 &&
+        config.marginRight === 192 &&
+        config.marginBottom === 192 &&
+        config.alphaVariant === '20260520' &&
+        resolvedAlphaGain <= 1.3 &&
+        originalSpatial >= 0.18 &&
+        originalSpatial < 0.4 &&
+        originalGradient >= 0.05 &&
+        originalGradient < 0.08;
+    if (cleanExactNewMarginVariant) return true;
+
+    if (
+        config?.logoSize !== 96 ||
+        config.marginRight !== 64 ||
+        config.marginBottom !== 64
+    ) {
+        return false;
+    }
+
+    const cleanStandardAlpha =
         resolvedAlphaGain <= 1 &&
         currentSpatial >= 0 &&
         currentSpatial <= 0.35 &&

package/src/shared/pageImageReplacement.js

@@ -1089,8 +1089,10 @@ export async function processPageImageSource({
   fetchBlobFromBackgroundImpl = fetchBlobFromBackground
 }) {
   const treatAsPreviewSource = shouldTreatPageImageSourceAsPreview(imageElement, sourceUrl);
-  if (treatAsPreviewSource) {
-    if (!isBlobPageImageSource(sourceUrl) && isGeminiDisplayPreviewAssetUrl(sourceUrl)) {
+  const canFallBackToPreviewProcessing = !isBlobPageImageSource(sourceUrl)
+    && isGeminiDisplayPreviewAssetUrl(sourceUrl);
+  if (treatAsPreviewSource || canFallBackToPreviewProcessing) {
+    if (canFallBackToPreviewProcessing) {
       try {
         return await processOriginalPageImageSource({
           sourceUrl,
@@ -1105,8 +1107,8 @@ export async function processPageImageSource({
           rejectPreviewAspectMismatch: true
         });
       } catch {
-        // Fall back to the preview-specific path when the original-quality fetch
-        // is unavailable, invalid, or blocked in the current page context.
+        // Fall back to the preview-specific path when original-quality
+        // acquisition is unavailable, invalid, or blocked.
       }
     }
 

package/src/userscript/index.js

@@ -207,11 +207,16 @@ export async function initGeminiWatermarkRemoverUserscript() {
     };
     const handleProcessedBlobResolved = (payload = {}) => {
       const resolvedActionContext = resolveCompatibleActionContextFromPayload(payload);
+      const isClipboardResult = resolvedActionContext?.action === 'clipboard';
       storeProcessedBlobResolved(payload, {
-        slot: 'full',
-        processedFrom: resolvedActionContext?.action === 'clipboard'
-          ? 'original-clipboard'
-          : 'original-download'
+        slot: isClipboardResult ? 'preview' : 'full',
+        processedFrom: isClipboardResult ? 'original-clipboard' : 'original-download'
+      });
+    };
+    const handleClipboardFallbackBlobResolved = (payload = {}) => {
+      storeProcessedBlobResolved(payload, {
+        slot: 'preview',
+        processedFrom: 'clipboard-fallback'
       });
     };
     const downloadIntentGate = createGeminiDownloadIntentGate({
@@ -270,7 +275,7 @@ export async function initGeminiWatermarkRemoverUserscript() {
     const disposeClipboardHook = installGeminiClipboardImageHook(targetWindow, {
       getActionContext: () => downloadIntentGate.getRecentActionContext(),
       imageSessionStore: imageSessionStore,
-      onProcessedBlobResolved: handleProcessedBlobResolved,
+      onProcessedBlobResolved: handleClipboardFallbackBlobResolved,
       onActionCriticalFailure: handleActionCriticalFailure,
       processClipboardImageBlob: (blob, { actionContext } = {}) => (
         processClipboardImageBlobAtBestPath(blob, { actionContext })