@pilio/gemini-watermark-remover 1.0.21 → 1.0.23

package/README.md

@@ -1,32 +1,34 @@
-[中文文档](README_zh.md)
-
-> 🔥 Tired of Gemini watermarks? Try the more powerful **GPT Image 2** at [pilio.ai](https://pilio.ai) — free for a limited time.
-
-# Gemini Watermark Remover — Lossless Watermark Removal Tool
-
-An open-source tool to **remove Gemini watermarks** from AI-generated images with high-fidelity, reproducible results on supported outputs. Built with pure JavaScript, the engine uses a mathematically exact **Reverse Alpha Blending** algorithm instead of unpredictable AI inpainting.
-
-> **🚀 Looking for the `Online Gemini Watermark Remover (Recommended)`? Try [geminiwatermarkremover.io](https://geminiwatermarkremover.io/)** — free, no install, works directly in your browser.
->
-> 💡 Got watermarks that Gemini Watermark Remover can't handle? Try the general-purpose AI watermark remover: [pilio.ai/image-watermark-remover](https://pilio.ai/image-watermark-remover)
-
-<p align="center">
+[中文文档](README_zh.md)
+
+> 🔥 Tired of Gemini watermarks? Try the more powerful **GPT Image 2** at [pilio.ai](https://pilio.ai) — free for a limited time.
+
+# Gemini Watermark Remover — Lossless Watermark Removal Tool
+
+An open-source tool to **remove Gemini watermarks** from AI-generated images with high-fidelity, reproducible results on supported outputs. Built with pure JavaScript, the engine uses a mathematically exact **Reverse Alpha Blending** algorithm instead of unpredictable AI inpainting.
+
+> **🚀 Looking for the `Online Gemini Watermark Remover (Recommended)`? Try [geminiwatermarkremover.io](https://geminiwatermarkremover.io/)** — free, no install, works directly in your browser.
+>
+> 💡 Got watermarks that Gemini Watermark Remover can't handle? Try the general-purpose AI watermark remover: [pilio.ai/image-watermark-remover](https://pilio.ai/image-watermark-remover)
+
+<p align="center">
   <a href="https://geminiwatermarkremover.io/"><img src="https://img.shields.io/badge/🛠️_Online_Tool-geminiwatermarkremover.io-blue?style=for-the-badge" alt="Online Tool"></a>&nbsp;
+  <a href="https://geminiwatermarkremover.io/video"><img src="https://img.shields.io/badge/🎬_Video_Remover-New!-ff6b6b?style=for-the-badge" alt="Video Watermark Remover"></a>&nbsp;
   <a href="https://chromewebstore.google.com/detail/gemini-watermark-remover/cjlmnfcfnofnglkphbcdclbpimdjkmdf"><img src="https://img.shields.io/badge/🧩_Chrome_Extension-Install-blueviolet?style=for-the-badge" alt="Chrome Extension"></a>&nbsp;
   <a href="https://geminiwatermarkremover.io/userscript/gemini-watermark-remover.user.js"><img src="https://img.shields.io/badge/🐒_Userscript-Install-green?style=for-the-badge" alt="Userscript"></a>&nbsp;
   <a href="https://pilio.ai/image-watermark-remover"><img src="https://img.shields.io/badge/🧹_General_Remover-pilio.ai-gray?style=for-the-badge" alt="General Watermark Remover"></a>
 </p>
-
-<p align="center">
-  <img src="https://count.getloli.com/@gemini-watermark-remover?name=gemini-watermark-remover&theme=minecraft&padding=7&offset=0&align=top&scale=1&pixelated=1&darkmode=auto" width="400">
-</p>
-
-## Features
-
-- ✅ **100% Local Processing** - All image processing happens locally in your browser or on your machine. Nothing is uploaded.
-- ✅ **Mathematical Precision** - Based on the Reverse Alpha Blending formula, not "hallucinating" AI models.
-- ✅ **Auto-Detection** - Automatically identifies watermark size and position using Gemini's known output catalog and local anchor search.
+
+<p align="center">
+  <img src="https://count.getloli.com/@gemini-watermark-remover?name=gemini-watermark-remover&theme=minecraft&padding=7&offset=0&align=top&scale=1&pixelated=1&darkmode=auto" width="400">
+</p>
+
+## Features
+
+- ✅ **100% Local Processing** - All image processing happens locally in your browser or on your machine. Nothing is uploaded.
+- ✅ **Mathematical Precision** - Based on the Reverse Alpha Blending formula, not "hallucinating" AI models.
+- ✅ **Auto-Detection** - Automatically identifies watermark size and position using Gemini's known output catalog and local anchor search.
 - ✅ **Flexible Usage** - Online tool for quick use, Chrome extension or userscript for seamless Gemini page integration, CLI and Skill for scripting and automation.
+- ✅ **Video Support** - Remove watermarks from Gemini-generated videos at [geminiwatermarkremover.io/video](https://geminiwatermarkremover.io/video).
 - ✅ **Cross-Platform** - Works in modern browsers (Chrome, Firefox, Safari, Edge) and Node.js environments.
 
 ## Gemini Watermark Removal Examples
@@ -66,6 +68,17 @@ For all users — the fastest and easiest way to remove Gemini watermarks from i
 3. The engine will automatically process and remove the watermark.
 4. Download the cleaned image.
 
+### Online Video Watermark Remover (New!)
+
+For Gemini-generated **videos** with visible watermarks:
+
+1. Open **[geminiwatermarkremover.io/video](https://geminiwatermarkremover.io/video)**.
+2. Upload or drag-and-drop your Gemini-generated video.
+3. The tool will automatically detect and remove the watermark from the video.
+4. Download the cleaned video.
+
+> **Note**: Video watermark removal runs entirely in your browser — no files are uploaded to any server.
+
 ### Chrome Extension
 
 Use this if you do not want a userscript manager but still want automatic Gemini page integration for previews, copy, and download actions.
@@ -371,6 +384,7 @@ gemini-watermark-remover/
 ## Limitations
 
 - Only removes **Gemini visible watermarks** <small>(the semi-transparent logo in bottom-right)</small>
+- Supports both **image** and **video** watermark removal — video processing is available via the [online tool](https://geminiwatermarkremover.io/video)
 - Does not remove invisible/steganographic watermarks. <small>[(Learn more about SynthID)](https://support.google.com/gemini/answer/16722517)</small>
 - Designed for Gemini's current visible watermark pattern <small>(validated against this repo through April 2026)</small>
 

package/README_zh.md

@@ -12,6 +12,7 @@
 
 <p align="center">
   <a href="https://geminiwatermarkremover.io/"><img src="https://img.shields.io/badge/🛠️_在线工具-geminiwatermarkremover.io-blue?style=for-the-badge" alt="在线工具"></a>&nbsp;
+  <a href="https://geminiwatermarkremover.io/video"><img src="https://img.shields.io/badge/🎬_视频去水印-New!-ff6b6b?style=for-the-badge" alt="视频去水印"></a>&nbsp;
   <a href="https://chromewebstore.google.com/detail/gemini-watermark-remover/cjlmnfcfnofnglkphbcdclbpimdjkmdf"><img src="https://img.shields.io/badge/🧩_Chrome插件-安装-blueviolet?style=for-the-badge" alt="Chrome 插件"></a>&nbsp;
   <a href="https://geminiwatermarkremover.io/userscript/gemini-watermark-remover.user.js"><img src="https://img.shields.io/badge/🐒_油猴脚本-安装-green?style=for-the-badge" alt="油猴脚本"></a>&nbsp;
   <a href="https://pilio.ai/image-watermark-remover"><img src="https://img.shields.io/badge/🧹_通用去水印-pilio.ai-gray?style=for-the-badge" alt="通用去水印"></a>
@@ -27,6 +28,7 @@
 - ✅ **数学精确** - 基于反向 Alpha 混合算法，而非 AI 修复模型
 - ✅ **自动检测** - 基于 Gemini 已知输出尺寸目录和局部锚点搜索，自动识别水印大小与位置
 - ✅ **灵活使用** - 在线工具快速上手、Chrome 插件或油猴脚本无缝集成 Gemini 页面、CLI 和 Skill 支持脚本化与自动化
+- ✅ **视频支持** - 支持去除 Gemini 生成视频中的水印，访问 [geminiwatermarkremover.io/video](https://geminiwatermarkremover.io/video) 即可使用
 - ✅ **跨平台** - 支持现代浏览器（Chrome、Firefox、Safari、Edge）和 Node.js 环境
 
 ## Gemini 去水印效果示例
@@ -66,6 +68,17 @@
 3. 图片会自动开始处理，移除水印
 4. 下载处理后的图片
 
+### 在线视频去水印工具（新功能！）
+
+针对带有可见水印的 Gemini 生成**视频**：
+
+1. 浏览器打开 **[geminiwatermarkremover.io/video](https://geminiwatermarkremover.io/video)**
+2. 拖拽或点击选择带水印的 Gemini 生成视频
+3. 工具会自动检测并去除视频中的水印
+4. 下载处理后的视频
+
+> **说明**：视频去水印处理完全在浏览器本地完成，不会上传任何文件到服务器。
+
 ### Chrome 插件
 
 适合不想安装油猴脚本、但希望在 Gemini 页面里实时自动处理预览图、复制和下载动作的用户。
@@ -371,6 +384,7 @@ gemini-watermark-remover/
 ## 局限性
 
 - 只去除了 **Gemini 可见的水印**<small>（即右下角的半透明 Logo）</small>
+- 同时支持**图片**和**视频**水印去除 — 视频处理请使用[在线工具](https://geminiwatermarkremover.io/video)
 - 无法去除隐形或隐写水印。<small>[（了解更多关于 SynthID 的信息）](https://support.google.com/gemini/answer/16722517)</small>
 - 针对 Gemini 当前的可见水印模式设计<small>（本仓库验证范围截至 2026 年 4 月）</small>
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pilio/gemini-watermark-remover",
   "description": "Automatically removes watermarks from Gemini AI generated images",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [

package/src/core/allenkFdncnnDenoise.js

@@ -188,6 +188,49 @@ function calculateAllenkPaddedRoi({ imageWidth, imageHeight, region, padding = A
     };
 }
 
+function calculateAllenkRuntimeRoi({
+    imageWidth,
+    imageHeight,
+    region,
+    padding = ALLENK_FDNCNN_MODEL.defaultPadding,
+    targetWidth = null,
+    targetHeight = null
+} = {}) {
+    const padded = calculateAllenkPaddedRoi({ imageWidth, imageHeight, region, padding });
+    if (!padded) return null;
+
+    const safeTargetWidth = Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : null;
+    const safeTargetHeight = Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : null;
+    if (
+        !safeTargetWidth ||
+        !safeTargetHeight ||
+        imageWidth < safeTargetWidth ||
+        imageHeight < safeTargetHeight ||
+        padded.width > safeTargetWidth ||
+        padded.height > safeTargetHeight
+    ) {
+        return padded;
+    }
+
+    const centerX = region.x + region.width / 2;
+    const centerY = region.y + region.height / 2;
+    const x = clamp(Math.round(centerX - safeTargetWidth / 2), 0, imageWidth - safeTargetWidth);
+    const y = clamp(Math.round(centerY - safeTargetHeight / 2), 0, imageHeight - safeTargetHeight);
+
+    return {
+        x,
+        y,
+        width: safeTargetWidth,
+        height: safeTargetHeight,
+        inner: {
+            x: clamp(Math.round(region.x - x), 0, safeTargetWidth),
+            y: clamp(Math.round(region.y - y), 0, safeTargetHeight),
+            width: clamp(Math.round(region.width), 0, safeTargetWidth),
+            height: clamp(Math.round(region.height), 0, safeTargetHeight)
+        }
+    };
+}
+
 function embedAllenkRoiWeights({ roiWeights, roiWidth, roiHeight, paddedRoi, blurSigma = 1 } = {}) {
     if (!roiWeights || !paddedRoi?.inner || roiWidth <= 0 || roiHeight <= 0) {
         return new Float32Array(0);
@@ -319,6 +362,7 @@ export {
     blendAllenkDenoisedRoi,
     buildAllenkFdncnnInput,
     calculateAllenkPaddedRoi,
+    calculateAllenkRuntimeRoi,
     convertAllenkFdncnnOutputToRgba,
     createAllenkGradientMask,
     embedAllenkRoiWeights,

package/src/core/geminiSizeCatalog.js

@@ -240,6 +240,35 @@ function createV2SmallVariantConfig(width, height) {
     return x >= 0 && y >= 0 ? config : null;
 }
 
+function createProjectedConfig(baseConfig, scaleX, scaleY, { minLogoSize, maxLogoSize, roundLogoSize = Math.round }) {
+    if (!baseConfig) return null;
+
+    return {
+        logoSize: clamp(
+            roundLogoSize(baseConfig.logoSize * ((scaleX + scaleY) / 2)),
+            minLogoSize,
+            maxLogoSize
+        ),
+        marginRight: Math.max(8, Math.round(baseConfig.marginRight * scaleX)),
+        marginBottom: Math.max(8, Math.round(baseConfig.marginBottom * scaleY)),
+        ...(baseConfig.alphaVariant ? { alphaVariant: baseConfig.alphaVariant } : {})
+    };
+}
+
+function getNearOfficialProjectionConfigs(entry, baseConfig) {
+    const configs = [{ config: baseConfig, family: 'near-official-projected', source: `${entry.width}x${entry.height}` }];
+    if (entry?.modelFamily === 'gemini-3.x-image' && entry.resolutionTier === '1k') {
+        configs.push({
+            config: GEMINI_3X_CURRENT_1K_LARGE_MARGIN_WATERMARK_CONFIG,
+            family: 'near-official-current-large-margin',
+            source: `${entry.width}x${entry.height}-large-margin`,
+            roundLogoSize: Math.ceil
+        });
+    }
+
+    return configs;
+}
+
 export function matchOfficialGeminiImageSize(width, height) {
     const normalizedWidth = normalizeDimension(width);
     const normalizedHeight = normalizeDimension(height);
@@ -389,9 +418,9 @@ export function resolveOfficialGeminiSearchConfigEntries(
     // this only proposes search seeds; later validation still decides safety.
     const targetAspectRatio = normalizedWidth / normalizedHeight;
     const candidates = OFFICIAL_GEMINI_IMAGE_SIZES
-        .map((entry) => {
+        .flatMap((entry) => {
             const baseConfig = getEntryConfig(entry);
-            if (!baseConfig) return null;
+            if (!baseConfig) return [];
 
             const scaleX = normalizedWidth / entry.width;
             const scaleY = normalizedHeight / entry.height;
@@ -400,35 +429,39 @@ export function resolveOfficialGeminiSearchConfigEntries(
             const relativeAspectRatioDelta = Math.abs(targetAspectRatio - entryAspectRatio) / entryAspectRatio;
             const scaleMismatchRatio = Math.abs(scaleX - scaleY) / Math.max(scaleX, scaleY);
 
-            if (relativeAspectRatioDelta > maxRelativeAspectRatioDelta) return null;
-            if (scaleMismatchRatio > maxScaleMismatchRatio) return null;
-
-            const config = {
-                logoSize: clamp(Math.round(baseConfig.logoSize * scale), minLogoSize, maxLogoSize),
-                marginRight: Math.max(8, Math.round(baseConfig.marginRight * scaleX)),
-                marginBottom: Math.max(8, Math.round(baseConfig.marginBottom * scaleY))
-            };
-
-            const x = normalizedWidth - config.marginRight - config.logoSize;
-            const y = normalizedHeight - config.marginBottom - config.logoSize;
-            if (x < 0 || y < 0) return null;
-
-            return {
-                config,
-                metadata: {
-                    family: 'near-official-projected',
-                    sourcePriority: 4,
-                    evidenceGate: 'required',
-                    modelFamily: entry.modelFamily,
-                    resolutionTier: entry.resolutionTier,
-                    aspectRatio: entry.aspectRatio,
-                    source: `${entry.width}x${entry.height}`
-                },
-                score:
-                    relativeAspectRatioDelta * 100 +
-                    scaleMismatchRatio * 20 +
-                    Math.abs(Math.log2(Math.max(scale, 1e-6)))
-            };
+            if (relativeAspectRatioDelta > maxRelativeAspectRatioDelta) return [];
+            if (scaleMismatchRatio > maxScaleMismatchRatio) return [];
+
+            return getNearOfficialProjectionConfigs(entry, baseConfig)
+                .map((projection) => {
+                    const config = createProjectedConfig(projection.config, scaleX, scaleY, {
+                        minLogoSize,
+                        maxLogoSize,
+                        roundLogoSize: projection.roundLogoSize
+                    });
+
+                    const x = normalizedWidth - config.marginRight - config.logoSize;
+                    const y = normalizedHeight - config.marginBottom - config.logoSize;
+                    if (x < 0 || y < 0) return null;
+
+                    return {
+                        config,
+                        metadata: {
+                            family: projection.family,
+                            sourcePriority: 4,
+                            evidenceGate: 'required',
+                            modelFamily: entry.modelFamily,
+                            resolutionTier: entry.resolutionTier,
+                            aspectRatio: entry.aspectRatio,
+                            source: projection.source
+                        },
+                        score:
+                            relativeAspectRatioDelta * 100 +
+                            scaleMismatchRatio * 20 +
+                            Math.abs(Math.log2(Math.max(scale, 1e-6)))
+                    };
+                })
+                .filter(Boolean);
         })
         .filter(Boolean)
         .sort((a, b) => a.score - b.score);

package/src/core/watermarkProcessor.js

@@ -149,7 +149,11 @@ const WEAK_ALPHA_FINE_TUNE_MAX_GRADIENT_INCREASE = 0.08;
 const STRONG_POSITIVE_FINE_TUNE_MIN_ORIGINAL_SPATIAL = 0.75;
 const STRONG_POSITIVE_FINE_TUNE_MIN_ORIGINAL_GRADIENT = 0.65;
 const STRONG_POSITIVE_FINE_TUNE_MIN_CURRENT_SPATIAL = 0.3;
+const STRONG_POSITIVE_FINE_TUNE_MID_GAINS = Object.freeze([0.7, 0.85]);
 const STRONG_POSITIVE_FINE_TUNE_EXTRA_GAINS = Object.freeze([0.95, 1]);
+const STRONG_POSITIVE_FINE_TUNE_MAX_ACCEPTED_SPATIAL = 0.12;
+const STRONG_POSITIVE_FINE_TUNE_MAX_ACCEPTED_GRADIENT = 0.25;
+const STRONG_POSITIVE_FINE_TUNE_MAX_POSITIVE_HALO_LUM = 4;
 const CATALOG_ALPHA_DARK_FINE_TUNE_MIN_ORIGINAL_SPATIAL = 0.6;
 const CATALOG_ALPHA_DARK_FINE_TUNE_MIN_ORIGINAL_GRADIENT = 0.45;
 const CATALOG_ALPHA_DARK_FINE_TUNE_MAX_NEGATIVE_RESIDUAL = -0.12;
@@ -164,6 +168,15 @@ const SMALL_PREVIEW_REFINEMENT_MIN_CURRENT_SPATIAL = 0.04;
 const SMALL_PREVIEW_REFINEMENT_MAX_CURRENT_GRADIENT = 0.08;
 const FIRST_PASS_SIGN_FLIP_GRADIENT_THRESHOLD = 0.08;
 const FIRST_PASS_SIGN_FLIP_MIN_GRADIENT_DROP = 0.2;
+const SMALL_ANCHOR_RELOCATION_MIN_SIZE = 40;
+const SMALL_ANCHOR_RELOCATION_MAX_SIZE = 56;
+const SMALL_ANCHOR_RELOCATION_SIZE_DELTA = 5;
+const SMALL_ANCHOR_RELOCATION_MARGIN_DELTA = 10;
+const SMALL_ANCHOR_RELOCATION_MIN_CURRENT_GRADIENT = 0.24;
+const SMALL_ANCHOR_RELOCATION_MAX_ACCEPTED_SPATIAL = 0.14;
+const SMALL_ANCHOR_RELOCATION_MAX_ACCEPTED_GRADIENT = 0.24;
+const SMALL_ANCHOR_RELOCATION_MIN_ORIGINAL_SPATIAL = 0.32;
+const SMALL_ANCHOR_RELOCATION_MIN_SUPPRESSION_GAIN = 0.22;
 
 function nowMs() {
     if (typeof globalThis.performance?.now === 'function') {
@@ -560,12 +573,16 @@ function fineTuneWeakPositiveResidualAlpha({
         alphaGainCandidates.add(alphaGain);
     }
 
-    if (
+    const shouldTryStrongPositiveFineTune =
         currentSpatialScore >= STRONG_POSITIVE_FINE_TUNE_MIN_CURRENT_SPATIAL &&
         originalSpatialScore >= STRONG_POSITIVE_FINE_TUNE_MIN_ORIGINAL_SPATIAL &&
-        originalGradientScore >= STRONG_POSITIVE_FINE_TUNE_MIN_ORIGINAL_GRADIENT
-    ) {
-        for (const alphaGain of STRONG_POSITIVE_FINE_TUNE_EXTRA_GAINS) {
+        originalGradientScore >= STRONG_POSITIVE_FINE_TUNE_MIN_ORIGINAL_GRADIENT;
+
+    if (shouldTryStrongPositiveFineTune) {
+        for (const alphaGain of [
+            ...STRONG_POSITIVE_FINE_TUNE_MID_GAINS,
+            ...STRONG_POSITIVE_FINE_TUNE_EXTRA_GAINS
+        ]) {
             alphaGainCandidates.add(alphaGain);
         }
     }
@@ -597,17 +614,22 @@ function fineTuneWeakPositiveResidualAlpha({
         });
         const absSpatialImprovement = Math.abs(currentSpatialScore) - Math.abs(spatialScore);
         const gradientIncrease = gradientScore - currentGradientScore;
-        if (
+        const strongPositiveClearsResidual = shouldTryStrongPositiveFineTune &&
+            Math.abs(spatialScore) <= STRONG_POSITIVE_FINE_TUNE_MAX_ACCEPTED_SPATIAL &&
+            gradientScore <= STRONG_POSITIVE_FINE_TUNE_MAX_ACCEPTED_GRADIENT &&
+            (artifacts?.halo?.positiveDeltaLum ?? Number.POSITIVE_INFINITY) <= STRONG_POSITIVE_FINE_TUNE_MAX_POSITIVE_HALO_LUM;
+        if (!strongPositiveClearsResidual && (
             absSpatialImprovement < WEAK_ALPHA_FINE_TUNE_MIN_ABS_SPATIAL_IMPROVEMENT ||
             gradientIncrease > WEAK_ALPHA_FINE_TUNE_MAX_GRADIENT_INCREASE
-        ) {
+        )) {
             continue;
         }
 
         const cost = artifacts
             ? artifacts.visualArtifactCost + Math.max(0, gradientIncrease) * 0.25
             : Math.abs(spatialScore) + Math.max(0, gradientIncrease) * 0.25 + nearBlackRatio * 2;
-        if (!best || cost < best.cost) {
+        const clearsResidual = strongPositiveClearsResidual;
+        if (!best || (clearsResidual && !best.clearsResidual) || (clearsResidual === best.clearsResidual && cost < best.cost)) {
             best = {
                 imageData: candidate,
                 alphaGain,
@@ -615,7 +637,8 @@ function fineTuneWeakPositiveResidualAlpha({
                 gradientScore,
                 nearBlackRatio,
                 suppressionGain: originalSpatialScore - spatialScore,
-                cost
+                cost,
+                clearsResidual
             };
         }
     }
@@ -1850,6 +1873,198 @@ function refineLocatedAggressiveRemoval({
     return best;
 }
 
+function shouldRelocateSmallFixedLocalAnchor({
+    source,
+    config,
+    position,
+    currentGradientScore,
+    currentResidualVisibility
+}) {
+    const sourceText = String(source || '');
+    if (!sourceText.includes('fixed-local')) return false;
+    if (
+        !position ||
+        position.width !== position.height ||
+        position.width < SMALL_ANCHOR_RELOCATION_MIN_SIZE ||
+        position.width > SMALL_ANCHOR_RELOCATION_MAX_SIZE
+    ) {
+        return false;
+    }
+    if (
+        !config ||
+        config.logoSize < SMALL_ANCHOR_RELOCATION_MIN_SIZE ||
+        config.logoSize > SMALL_ANCHOR_RELOCATION_MAX_SIZE
+    ) {
+        return false;
+    }
+    if (!currentResidualVisibility?.visible) return false;
+    return currentResidualVisibility.visiblePositiveHalo === true ||
+        currentGradientScore >= SMALL_ANCHOR_RELOCATION_MIN_CURRENT_GRADIENT;
+}
+
+function resolveRelocationAlphaMap({ size, currentAlphaMap, currentPosition, alpha96, getAlphaMap }) {
+    if (size === currentPosition?.width) return currentAlphaMap;
+    if (typeof getAlphaMap === 'function') {
+        const resolved = getAlphaMap(size);
+        if (resolved) return resolved;
+    }
+    return interpolateAlphaMap(alpha96, 96, size);
+}
+
+function buildSmallAnchorRelocationCandidate({
+    originalImageData,
+    alphaMap,
+    size,
+    marginRight,
+    marginBottom,
+    alphaGain
+}) {
+    const position = {
+        x: originalImageData.width - marginRight - size,
+        y: originalImageData.height - marginBottom - size,
+        width: size,
+        height: size
+    };
+    if (
+        position.x < 0 ||
+        position.y < 0 ||
+        position.x + size > originalImageData.width ||
+        position.y + size > originalImageData.height
+    ) {
+        return null;
+    }
+
+    const originalSpatialScore = computeRegionSpatialCorrelation({
+        imageData: originalImageData,
+        alphaMap,
+        region: { x: position.x, y: position.y, size }
+    });
+    if (originalSpatialScore < SMALL_ANCHOR_RELOCATION_MIN_ORIGINAL_SPATIAL) {
+        return null;
+    }
+
+    const originalGradientScore = computeRegionGradientCorrelation({
+        imageData: originalImageData,
+        alphaMap,
+        region: { x: position.x, y: position.y, size }
+    });
+    const candidateImageData = cloneImageData(originalImageData);
+    removeWatermark(candidateImageData, alphaMap, position, { alphaGain });
+    const spatialScore = computeRegionSpatialCorrelation({
+        imageData: candidateImageData,
+        alphaMap,
+        region: { x: position.x, y: position.y, size }
+    });
+    const gradientScore = computeRegionGradientCorrelation({
+        imageData: candidateImageData,
+        alphaMap,
+        region: { x: position.x, y: position.y, size }
+    });
+    const suppressionGain = originalSpatialScore - spatialScore;
+    if (
+        Math.abs(spatialScore) > SMALL_ANCHOR_RELOCATION_MAX_ACCEPTED_SPATIAL ||
+        gradientScore > SMALL_ANCHOR_RELOCATION_MAX_ACCEPTED_GRADIENT ||
+        suppressionGain < SMALL_ANCHOR_RELOCATION_MIN_SUPPRESSION_GAIN
+    ) {
+        return null;
+    }
+
+    const residualVisibility = assessWatermarkResidualVisibility({
+        imageData: candidateImageData,
+        position,
+        alphaMap
+    });
+    if (residualVisibility.visible) return null;
+
+    return {
+        imageData: candidateImageData,
+        alphaMap,
+        position,
+        config: { logoSize: size, marginRight, marginBottom },
+        alphaGain,
+        originalSpatialScore,
+        originalGradientScore,
+        spatialScore,
+        gradientScore,
+        suppressionGain,
+        residualVisibility,
+        cost: Math.abs(spatialScore) * 0.8 +
+            Math.max(0, gradientScore) * 0.75 +
+            Math.max(0, residualVisibility.positiveHaloLum ?? 0) * 0.01
+    };
+}
+
+function refineSmallFixedLocalAnchorGeometry({
+    originalImageData,
+    currentAlphaMap,
+    currentPosition,
+    currentConfig,
+    currentSource,
+    currentGradientScore,
+    currentResidualVisibility,
+    alpha96,
+    getAlphaMap
+}) {
+    if (!shouldRelocateSmallFixedLocalAnchor({
+        source: currentSource,
+        config: currentConfig,
+        position: currentPosition,
+        currentGradientScore,
+        currentResidualVisibility
+    })) {
+        return null;
+    }
+
+    const currentSize = currentConfig.logoSize ?? currentPosition.width;
+    const currentMarginRight = currentConfig.marginRight;
+    const currentMarginBottom = currentConfig.marginBottom;
+    if (![currentSize, currentMarginRight, currentMarginBottom].every(Number.isFinite)) {
+        return null;
+    }
+
+    let best = null;
+    const minSize = Math.max(SMALL_ANCHOR_RELOCATION_MIN_SIZE, currentSize);
+    const maxSize = Math.min(SMALL_ANCHOR_RELOCATION_MAX_SIZE, currentSize + SMALL_ANCHOR_RELOCATION_SIZE_DELTA);
+    const minMarginRight = Math.max(0, currentMarginRight - SMALL_ANCHOR_RELOCATION_MARGIN_DELTA);
+    const maxMarginRight = currentMarginRight + SMALL_ANCHOR_RELOCATION_MARGIN_DELTA;
+    const minMarginBottom = Math.max(0, currentMarginBottom - SMALL_ANCHOR_RELOCATION_MARGIN_DELTA);
+    const maxMarginBottom = currentMarginBottom + SMALL_ANCHOR_RELOCATION_MARGIN_DELTA;
+
+    for (let size = minSize; size <= maxSize; size++) {
+        const alphaMap = resolveRelocationAlphaMap({
+            size,
+            currentAlphaMap,
+            currentPosition,
+            alpha96,
+            getAlphaMap
+        });
+        if (!alphaMap) continue;
+
+        for (let marginRight = minMarginRight; marginRight <= maxMarginRight; marginRight++) {
+            for (let marginBottom = minMarginBottom; marginBottom <= maxMarginBottom; marginBottom++) {
+                const candidateY = originalImageData.height - marginBottom - size;
+                if (candidateY > currentPosition.y + 1) continue;
+                for (const candidateAlphaGain of ALPHA_GAIN_CANDIDATES) {
+                    const candidate = buildSmallAnchorRelocationCandidate({
+                        originalImageData,
+                        alphaMap,
+                        size,
+                        marginRight,
+                        marginBottom,
+                        alphaGain: candidateAlphaGain
+                    });
+                    if (!candidate) continue;
+                    if (!best || candidate.cost < best.cost) {
+                        best = candidate;
+                    }
+                }
+            }
+        }
+    }
+
+    return best;
+}
+
 export function processWatermarkImageData(imageData, options = {}) {
     const totalStartedAt = nowMs();
     const debugTimingsEnabled = options.debugTimings === true;
@@ -2526,8 +2741,53 @@ export function processWatermarkImageData(imageData, options = {}) {
         source = `${source}+small-preview-refine`;
     }
 
+    const smallFixedLocalResidualVisibility = assessWatermarkResidualVisibility({
+        imageData: finalImageData,
+        position,
+        alphaMap
+    });
+    const smallFixedLocalRelocated = refineSmallFixedLocalAnchorGeometry({
+        originalImageData,
+        currentAlphaMap: alphaMap,
+        currentPosition: position,
+        currentConfig: config,
+        currentSource: source,
+        currentGradientScore: finalProcessedGradientScore,
+        currentResidualVisibility: smallFixedLocalResidualVisibility,
+        alpha96,
+        getAlphaMap: options.getAlphaMap
+    });
+    if (smallFixedLocalRelocated) {
+        recordAlphaAdjustmentStage({
+            stage: 'small-fixed-local-anchor-relocation',
+            fromAlphaGain: alphaGain,
+            toAlphaGain: smallFixedLocalRelocated.alphaGain,
+            beforeSpatialScore: finalProcessedSpatialScore,
+            beforeGradientScore: finalProcessedGradientScore,
+            afterSpatialScore: smallFixedLocalRelocated.spatialScore,
+            afterGradientScore: smallFixedLocalRelocated.gradientScore,
+            suppressionGain: smallFixedLocalRelocated.suppressionGain,
+            cost: smallFixedLocalRelocated.cost,
+            allowSameAlphaGain: true
+        });
+        finalImageData = smallFixedLocalRelocated.imageData;
+        alphaMap = smallFixedLocalRelocated.alphaMap;
+        position = smallFixedLocalRelocated.position;
+        config = smallFixedLocalRelocated.config;
+        alphaGain = smallFixedLocalRelocated.alphaGain;
+        originalSpatialScore = smallFixedLocalRelocated.originalSpatialScore;
+        originalGradientScore = smallFixedLocalRelocated.originalGradientScore;
+        finalProcessedSpatialScore = smallFixedLocalRelocated.spatialScore;
+        finalProcessedGradientScore = smallFixedLocalRelocated.gradientScore;
+        suppressionGain = smallFixedLocalRelocated.suppressionGain;
+        source = `${source}+small-anchor-relocated`;
+    }
+
     const locatedAggressiveStartedAt = nowMs();
-    if (options.locatedAggressiveRemoval !== false) {
+    if (
+        options.locatedAggressiveRemoval !== false &&
+        smallFixedLocalRelocated?.residualVisibility?.visible !== false
+    ) {
         const aggressiveRefined = refineLocatedAggressiveRemoval({
             originalImageData,
             currentImageData: finalImageData,