@pilio/gemini-watermark-remover 1.0.23 → 1.0.25

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pilio/gemini-watermark-remover",
   "description": "Automatically removes watermarks from Gemini AI generated images",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [
@@ -96,7 +96,8 @@
     "release:readiness": "node scripts/create-release-readiness-report.js",
     "release:quality-gate": "pnpm compare:allenk-v2 -- --fail-on-incomplete && pnpm release:readiness -- --fail-on-not-ready",
     "release:goal-audit": "node scripts/create-release-goal-audit-report.js",
-    "release:preflight": "pnpm test && pnpm build && pnpm package:extension && pnpm release:quality-gate && pnpm release:goal-audit -- --fail-on-incomplete",
+    "release:ci-check": "node scripts/check-github-ci.js --workflow ci.yml --commit HEAD --fail-closed",
+    "release:preflight": "pnpm test && pnpm build && pnpm package:extension && pnpm release:quality-gate && pnpm release:goal-audit -- --fail-on-incomplete && pnpm release:ci-check",
     "visible-residual:loop": "node scripts/run-visible-residual-loop.js",
     "visible-residual:verify": "node scripts/verify-visible-residual-loop.js",
     "visible-residual:validate-human-review": "node scripts/validate-visible-residual-human-review.js",
@@ -112,6 +113,9 @@
     "render:skipped-crops": "node scripts/render-skipped-candidate-crops.js",
     "render:video-crops": "node scripts/render-video-crop-sheet.js",
     "analyze:video-residual": "node scripts/analyze-video-residual.js",
+    "score:video-candidates": "node scripts/score-video-watermark-candidates.js",
+    "sweep:veo-text-cleanup": "node scripts/sweep-veo-text-cleanup.js",
+    "score:video-output-residual": "node scripts/score-video-output-residual.js",
     "benchmark:video-crops": "node scripts/video-crop-benchmark.js",
     "report:video-crops": "node scripts/report-video-crop-benchmark.js",
     "diagnose:video-lowbody": "node scripts/diagnose-video-lowbody-regression.js",
@@ -144,7 +148,12 @@
     "export:allenk-fdncnn-onnx-video": "node scripts/export-allenk-fdncnn-onnx-video.js",
     "export:allenk-fdncnn-onnx-frame-video": "node scripts/export-allenk-fdncnn-onnx-frame-video.js",
     "report:allenk-fdncnn-onnx-video-evidence": "node scripts/create-allenk-fdncnn-onnx-video-evidence.js",
+    "report:allenk-catalog-audit": "node scripts/create-allenk-catalog-audit.js",
+    "report:allenk-video-binary-analysis": "node scripts/create-allenk-video-binary-analysis.js",
     "export:video-ui-preset": "node scripts/export-video-ui-preset.js",
+    "verify:video-ui-preset-output": "node scripts/verify-video-ui-preset-output.js",
+    "verify:video-ui-preset-batch": "node scripts/verify-video-ui-preset-batch.js",
+    "verify:video-regression-samples": "pnpm verify:video-ui-preset-batch -- --manifest tests/fixtures/video-regression-samples/gemini-video-regression-samples.json --output-dir .artifacts/video-regression-samples --no-screenshots --fail-on-residual",
     "render:video-comparison-grid": "node scripts/render-video-comparison-grid.js",
     "package:extension": "node scripts/package-extension-release.js",
     "cli:smoke": "node bin/gwr.mjs --help",

package/src/core/allenkFdncnnDenoise.js

@@ -1,5 +1,3 @@
-import { createAlphaGradientMask } from './alphaGradientMask.js';
-
 const ALLENK_FDNCNN_MODEL = Object.freeze({
     name: 'FDnCNN Color FP16',
     upstream: 'allenk/GeminiWatermarkTool',
@@ -20,6 +18,15 @@ function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
 
+function reflect101(index, length) {
+    if (length <= 1) return 0;
+    let value = Math.round(index);
+    while (value < 0 || value >= length) {
+        value = value < 0 ? -value : (length * 2 - value - 2);
+    }
+    return value;
+}
+
 function createGaussianKernel(sigma, radius = Math.ceil(sigma * 3)) {
     const safeSigma = Math.max(0.01, sigma);
     const safeRadius = Math.max(1, Math.round(radius));
@@ -52,7 +59,7 @@ function gaussianBlurFloatMap(source, width, height, sigma, radius = Math.ceil(s
         for (let x = 0; x < width; x++) {
             let sum = 0;
             for (let dx = -r; dx <= r; dx++) {
-                const xx = clamp(x + dx, 0, width - 1);
+                const xx = reflect101(x + dx, width);
                 sum += source[y * width + xx] * kernel[dx + r];
             }
             temp[y * width + x] = sum;
@@ -63,7 +70,7 @@ function gaussianBlurFloatMap(source, width, height, sigma, radius = Math.ceil(s
         for (let x = 0; x < width; x++) {
             let sum = 0;
             for (let dy = -r; dy <= r; dy++) {
-                const yy = clamp(y + dy, 0, height - 1);
+                const yy = reflect101(y + dy, height);
                 sum += temp[yy * width + x] * kernel[dy + r];
             }
             output[y * width + x] = sum;
@@ -123,6 +130,139 @@ function resizeSquareAlphaMapArea(sourceAlpha, sourceSize, targetWidth, targetHe
     return output;
 }
 
+function resizeSquareAlphaMapLinear(sourceAlpha, sourceSize, targetWidth, targetHeight = targetWidth) {
+    if (!sourceAlpha || sourceSize <= 0 || targetWidth <= 0 || targetHeight <= 0) {
+        return new Float32Array(0);
+    }
+    if (sourceSize === targetWidth && sourceSize === targetHeight) {
+        return new Float32Array(sourceAlpha);
+    }
+
+    const output = new Float32Array(targetWidth * targetHeight);
+    const scaleX = sourceSize / targetWidth;
+    const scaleY = sourceSize / targetHeight;
+
+    for (let y = 0; y < targetHeight; y++) {
+        const sourceY = (y + 0.5) * scaleY - 0.5;
+        const y0 = Math.floor(sourceY);
+        const y1 = y0 + 1;
+        const wy = sourceY - y0;
+
+        for (let x = 0; x < targetWidth; x++) {
+            const sourceX = (x + 0.5) * scaleX - 0.5;
+            const x0 = Math.floor(sourceX);
+            const x1 = x0 + 1;
+            const wx = sourceX - x0;
+
+            const topLeft = sourceAlpha[clamp(y0, 0, sourceSize - 1) * sourceSize + clamp(x0, 0, sourceSize - 1)] || 0;
+            const topRight = sourceAlpha[clamp(y0, 0, sourceSize - 1) * sourceSize + clamp(x1, 0, sourceSize - 1)] || 0;
+            const bottomLeft = sourceAlpha[clamp(y1, 0, sourceSize - 1) * sourceSize + clamp(x0, 0, sourceSize - 1)] || 0;
+            const bottomRight = sourceAlpha[clamp(y1, 0, sourceSize - 1) * sourceSize + clamp(x1, 0, sourceSize - 1)] || 0;
+            const top = topLeft * (1 - wx) + topRight * wx;
+            const bottom = bottomLeft * (1 - wx) + bottomRight * wx;
+
+            output[y * targetWidth + x] = top * (1 - wy) + bottom * wy;
+        }
+    }
+
+    return output;
+}
+
+function resizeSquareAlphaMapOpenCv(sourceAlpha, sourceSize, targetWidth, targetHeight = targetWidth) {
+    return targetWidth > sourceSize
+        ? resizeSquareAlphaMapLinear(sourceAlpha, sourceSize, targetWidth, targetHeight)
+        : resizeSquareAlphaMapArea(sourceAlpha, sourceSize, targetWidth, targetHeight);
+}
+
+const ALLENK_ELLIPSE_5X5 = Object.freeze([
+    [0, 0, 1, 0, 0],
+    [1, 1, 1, 1, 1],
+    [1, 1, 1, 1, 1],
+    [1, 1, 1, 1, 1],
+    [0, 0, 1, 0, 0]
+]);
+
+function dilateAllenkEllipse5x5(values, width, height) {
+    const output = new Float32Array(values.length);
+
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let maxValue = 0;
+            for (let ky = 0; ky < 5; ky++) {
+                for (let kx = 0; kx < 5; kx++) {
+                    if (!ALLENK_ELLIPSE_5X5[ky][kx]) continue;
+                    const sx = x + kx - 2;
+                    const sy = y + ky - 2;
+                    if (sx < 0 || sy < 0 || sx >= width || sy >= height) continue;
+                    maxValue = Math.max(maxValue, values[sy * width + sx] || 0);
+                }
+            }
+            output[y * width + x] = maxValue;
+        }
+    }
+
+    return output;
+}
+
+function createAllenkOpenCvGradientMask({ alphaMap, width, height, strength }) {
+    if (!alphaMap || width <= 0 || height <= 0 || alphaMap.length < width * height) {
+        return new Float32Array(0);
+    }
+
+    const gradient = new Float32Array(width * height);
+    let minGradient = Number.POSITIVE_INFINITY;
+    let maxGradient = Number.NEGATIVE_INFINITY;
+
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const top = reflect101(y - 1, height);
+            const bottom = reflect101(y + 1, height);
+            const left = reflect101(x - 1, width);
+            const right = reflect101(x + 1, width);
+            const gx = (
+                -alphaMap[top * width + left] -
+                2 * alphaMap[y * width + left] -
+                alphaMap[bottom * width + left] +
+                alphaMap[top * width + right] +
+                2 * alphaMap[y * width + right] +
+                alphaMap[bottom * width + right]
+            );
+            const gy = (
+                -alphaMap[top * width + left] -
+                2 * alphaMap[top * width + x] -
+                alphaMap[top * width + right] +
+                alphaMap[bottom * width + left] +
+                2 * alphaMap[bottom * width + x] +
+                alphaMap[bottom * width + right]
+            );
+            const value = Math.sqrt(gx * gx + gy * gy);
+            gradient[y * width + x] = value;
+            minGradient = Math.min(minGradient, value);
+            maxGradient = Math.max(maxGradient, value);
+        }
+    }
+
+    if (!Number.isFinite(minGradient) || maxGradient <= minGradient) {
+        return new Float32Array(width * height);
+    }
+
+    const normalized = new Float32Array(width * height);
+    const scale = 1 / (maxGradient - minGradient);
+    for (let i = 0; i < normalized.length; i++) {
+        normalized[i] = Math.sqrt(clamp((gradient[i] - minGradient) * scale, 0, 1));
+    }
+
+    const expanded = dilateAllenkEllipse5x5(normalized, width, height);
+    const blurred = gaussianBlurFloatMap(expanded, width, height, 2);
+    const safeStrength = Number.isFinite(strength) ? Math.max(0, strength) : 1;
+
+    for (let i = 0; i < blurred.length; i++) {
+        blurred[i] = clamp(blurred[i] * safeStrength, 0, 1);
+    }
+
+    return blurred;
+}
+
 function normalizeAllenkFdncnnOptions(options = {}) {
     const sigma = Number.isFinite(options.sigma)
         ? clamp(options.sigma, 0, ALLENK_FDNCNN_MODEL.maxSigma)
@@ -145,17 +285,14 @@ function createAllenkGradientMask({
 } = {}) {
     const sourceSize = inferSquareSize(alphaMap);
     const resizedAlphaMap = sourceSize > 0
-        ? resizeSquareAlphaMapArea(alphaMap, sourceSize, width, height)
+        ? resizeSquareAlphaMapOpenCv(alphaMap, sourceSize, width, height)
         : alphaMap;
 
-    return createAlphaGradientMask({
+    return createAllenkOpenCvGradientMask({
         alphaMap: resizedAlphaMap,
         width,
         height,
-        strength,
-        gamma: 0.5,
-        dilateRadius: 2,
-        blurSigma: 2
+        strength
     });
 }
 
@@ -188,6 +325,58 @@ function calculateAllenkPaddedRoi({ imageWidth, imageHeight, region, padding = A
     };
 }
 
+function calculateAllenkVirtualPaddedRoi({
+    imageWidth,
+    imageHeight,
+    region,
+    padding = ALLENK_FDNCNN_MODEL.defaultPadding,
+    targetWidth = null,
+    targetHeight = null
+} = {}) {
+    if (!region || imageWidth <= 0 || imageHeight <= 0 || region.width <= 0 || region.height <= 0) {
+        return null;
+    }
+
+    const safePadding = Math.max(0, Math.round(padding));
+    const x = Math.round(region.x - safePadding);
+    const y = Math.round(region.y - safePadding);
+    const defaultWidth = Math.round(region.width + safePadding * 2);
+    const defaultHeight = Math.round(region.height + safePadding * 2);
+    const width = Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : defaultWidth;
+    const height = Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : defaultHeight;
+
+    if (width < 4 || height < 4) return null;
+
+    const visibleX = clamp(x, 0, imageWidth);
+    const visibleY = clamp(y, 0, imageHeight);
+    const visibleRight = clamp(x + width, 0, imageWidth);
+    const visibleBottom = clamp(y + height, 0, imageHeight);
+    const visibleWidth = visibleRight - visibleX;
+    const visibleHeight = visibleBottom - visibleY;
+    if (visibleWidth <= 0 || visibleHeight <= 0) return null;
+
+    return {
+        x,
+        y,
+        width,
+        height,
+        inner: {
+            x: clamp(Math.round(region.x - x), 0, width),
+            y: clamp(Math.round(region.y - y), 0, height),
+            width: clamp(Math.round(region.width), 0, width),
+            height: clamp(Math.round(region.height), 0, height)
+        },
+        visible: {
+            x: visibleX,
+            y: visibleY,
+            width: visibleWidth,
+            height: visibleHeight,
+            offsetX: visibleX - x,
+            offsetY: visibleY - y
+        }
+    };
+}
+
 function calculateAllenkRuntimeRoi({
     imageWidth,
     imageHeight,
@@ -231,6 +420,59 @@ function calculateAllenkRuntimeRoi({
     };
 }
 
+function extractAllenkVirtualImageData({
+    imageData,
+    roi,
+    imageX = 0,
+    imageY = 0,
+    canvasWidth = imageData?.width || 0,
+    canvasHeight = imageData?.height || 0
+} = {}) {
+    if (
+        !imageData?.data ||
+        !roi ||
+        imageData.width <= 0 ||
+        imageData.height <= 0 ||
+        roi.width <= 0 ||
+        roi.height <= 0 ||
+        canvasWidth <= 0 ||
+        canvasHeight <= 0
+    ) {
+        return { width: 0, height: 0, data: new Uint8ClampedArray(0) };
+    }
+
+    const width = Math.max(1, Math.round(roi.width));
+    const height = Math.max(1, Math.round(roi.height));
+    const output = new Uint8ClampedArray(width * height * 4);
+    const sourceStride = imageData.data.length >= imageData.width * imageData.height * 4 ? 4 : 3;
+
+    for (let y = 0; y < height; y++) {
+        const globalY = clamp(Math.round(roi.y + y), 0, canvasHeight - 1);
+        const localY = clamp(globalY - Math.round(imageY), 0, imageData.height - 1);
+        for (let x = 0; x < width; x++) {
+            const globalX = clamp(Math.round(roi.x + x), 0, canvasWidth - 1);
+            const localX = clamp(globalX - Math.round(imageX), 0, imageData.width - 1);
+            const src = (localY * imageData.width + localX) * sourceStride;
+            const dst = (y * width + x) * 4;
+            output[dst] = imageData.data[src] || 0;
+            output[dst + 1] = imageData.data[src + 1] || 0;
+            output[dst + 2] = imageData.data[src + 2] || 0;
+            output[dst + 3] = sourceStride >= 4 ? (imageData.data[src + 3] ?? 255) : 255;
+        }
+    }
+
+    const ImageDataCtor = typeof imageData.constructor === 'function' && imageData.constructor !== Object
+        ? imageData.constructor
+        : typeof ImageData === 'function'
+            ? ImageData
+            : null;
+    if (ImageDataCtor) {
+        return new ImageDataCtor(output, width, height);
+    }
+
+    return { width, height, data: output };
+}
+
 function embedAllenkRoiWeights({ roiWeights, roiWidth, roiHeight, paddedRoi, blurSigma = 1 } = {}) {
     if (!roiWeights || !paddedRoi?.inner || roiWidth <= 0 || roiHeight <= 0) {
         return new Float32Array(0);
@@ -363,8 +605,10 @@ export {
     buildAllenkFdncnnInput,
     calculateAllenkPaddedRoi,
     calculateAllenkRuntimeRoi,
+    calculateAllenkVirtualPaddedRoi,
     convertAllenkFdncnnOutputToRgba,
     createAllenkGradientMask,
     embedAllenkRoiWeights,
+    extractAllenkVirtualImageData,
     normalizeAllenkFdncnnOptions
 };

package/src/core/allenkFdncnnOnnxExport.js

@@ -231,12 +231,13 @@ function createGraphProto({
     segments,
     inputName,
     outputName,
-    roiSize
+    roiWidth,
+    roiHeight
 }) {
     const initializers = createInitializers({ bin, segments });
     const nodes = createNodes({ segments, inputName, outputName });
-    const inputShape = [1, segments[0].inputChannels, roiSize, roiSize];
-    const outputShape = [1, segments[segments.length - 1].outputChannels, roiSize, roiSize];
+    const inputShape = [1, segments[0].inputChannels, roiHeight, roiWidth];
+    const outputShape = [1, segments[segments.length - 1].outputChannels, roiHeight, roiWidth];
 
     return {
         nodeCount: nodes.length,
@@ -275,6 +276,8 @@ function exportAllenkFdncnnOnnx({
     bin,
     weightLayout,
     roiSize = 72,
+    roiWidth = roiSize,
+    roiHeight = roiSize,
     inputName = 'fdncnn_input',
     outputName = 'fdncnn_output',
     graphName = 'allenk_fdncnn_color',
@@ -285,8 +288,11 @@ function exportAllenkFdncnnOnnx({
     if (!segments.length) {
         throw new Error('allenk FDnCNN ONNX export requires weightLayout.segments');
     }
-    if (!Number.isInteger(roiSize) || roiSize <= 0) {
-        throw new Error(`Invalid ONNX ROI size: ${roiSize}`);
+    if (!Number.isInteger(roiWidth) || roiWidth <= 0) {
+        throw new Error(`Invalid ONNX ROI width: ${roiWidth}`);
+    }
+    if (!Number.isInteger(roiHeight) || roiHeight <= 0) {
+        throw new Error(`Invalid ONNX ROI height: ${roiHeight}`);
     }
 
     const graph = createGraphProto({
@@ -295,7 +301,8 @@ function exportAllenkFdncnnOnnx({
         segments,
         inputName,
         outputName,
-        roiSize
+        roiWidth,
+        roiHeight
     });
     const model = createModelProto({
         graph: graph.bytes,
@@ -313,13 +320,15 @@ function exportAllenkFdncnnOnnx({
             graphName,
             inputName,
             outputName,
-            inputShape: [1, segments[0].inputChannels, roiSize, roiSize],
-            outputShape: [1, segments[segments.length - 1].outputChannels, roiSize, roiSize],
+            inputShape: [1, segments[0].inputChannels, roiHeight, roiWidth],
+            outputShape: [1, segments[segments.length - 1].outputChannels, roiHeight, roiWidth],
             nodeCount: graph.nodeCount,
             convolutionNodeCount: segments.length,
             reluNodeCount: segments.filter((segment, index) => index < segments.length - 1 && segment.activationType === 1).length,
             initializerCount: graph.initializerCount,
-            roiSize
+            roiSize: roiWidth === roiHeight ? roiWidth : null,
+            roiWidth,
+            roiHeight
         }
     };
 }

package/src/core/candidateSelector.js

@@ -139,7 +139,7 @@ const PREVIEW_TEMPLATE_ALIGN_SHIFTS = [-1, -0.5, 0, 0.5, 1];
 const PREVIEW_TEMPLATE_ALIGN_SCALES = [0.985, 1, 1.015];
 const PREVIEW_ANCHOR_GAIN_SKIP_RESIDUAL_THRESHOLD = 0.22;
 const PREVIEW_ANCHOR_GAIN_SKIP_GRADIENT_THRESHOLD = 0.24;
-const CORE_ALPHA_PRIORITY_GAINS = Object.freeze([0.6, 1, 1.15, 1.3, 0.45, 0.7, 0.85, 0.55]);
+const CORE_ALPHA_PRIORITY_GAINS = Object.freeze([0.6, 1, 1.1, 1.15, 1.3, 0.45, 0.7, 0.85, 0.55]);
 const CURRENT_LARGE_MARGIN_ULTRA_WEAK_ALPHA_GAINS = Object.freeze([0.25, 0.3, 0.35, 0.4]);
 const STANDARD_ANCHOR_WEAK_ALPHA_RESCUE_GAINS = Object.freeze([0.55, 0.7, 0.85]);
 const STANDARD_ANCHOR_WEAK_RESCUE_MAX_SPATIAL = 0.35;
@@ -1044,6 +1044,24 @@ export function pickBetterCandidate(currentBest, candidate, minCostDelta = 0.005
     if (shouldPreserveStrongCanonical96AgainstWeakCurrentLargeMargin(candidate, currentBest)) {
         return candidate;
     }
+    if (shouldPreserveStrongCanonical96AgainstWeakNewMargin(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveStrongCanonical96AgainstWeakNewMargin(candidate, currentBest)) {
+        return candidate;
+    }
+    if (shouldPreserveStandardAlphaCanonical96AgainstDarkGain(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveStandardAlphaCanonical96AgainstDarkGain(candidate, currentBest)) {
+        return candidate;
+    }
+    if (shouldPreserveBalancedAlphaCanonical96(currentBest, candidate)) {
+        return currentBest;
+    }
+    if (shouldPreserveBalancedAlphaCanonical96(candidate, currentBest)) {
+        return candidate;
+    }
     if (shouldPreferCatalogOriginalSignal(candidate, currentBest)) {
         return candidate;
     }
@@ -1198,6 +1216,16 @@ function isDefault96GeometryCandidate(candidate) {
         candidate.config.marginBottom === 64;
 }
 
+function isNewMargin96Candidate(candidate) {
+    return isStandardCandidateSource(candidate) &&
+        candidate?.provenance?.localShift !== true &&
+        candidate?.provenance?.sizeJitter !== true &&
+        candidate?.provenance?.previewAnchor !== true &&
+        candidate?.config?.logoSize === 96 &&
+        candidate.config.marginRight === 192 &&
+        candidate.config.marginBottom === 192;
+}
+
 function shouldPreserveStrongCanonical96AgainstWeakCurrentLargeMargin(currentBest, candidate) {
     if (!isCanonicalDefault96Candidate(currentBest)) return false;
     if (!isCurrentLargeMarginCatalogCandidate(candidate)) return false;
@@ -1238,6 +1266,111 @@ function shouldPreserveStrongCanonical96AgainstWeakCurrentLargeMargin(currentBes
         candidateHasWeakOriginalSignal;
 }
 
+function shouldPreserveStrongCanonical96AgainstWeakNewMargin(currentBest, candidate) {
+    if (!isCanonicalDefault96Candidate(currentBest)) return false;
+    if (!isNewMargin96Candidate(candidate)) return false;
+
+    const currentSpatial = Number(currentBest.originalSpatialScore);
+    const currentGradient = Number(currentBest.originalGradientScore);
+    const candidateSpatial = Number(candidate.originalSpatialScore);
+    const candidateGradient = Number(candidate.originalGradientScore);
+    if (
+        !Number.isFinite(currentSpatial) ||
+        !Number.isFinite(currentGradient) ||
+        !Number.isFinite(candidateSpatial) ||
+        !Number.isFinite(candidateGradient)
+    ) {
+        return false;
+    }
+
+    const currentHasStrongCanonicalSignal =
+        currentSpatial >= 0.55 &&
+        currentGradient >= 0.2;
+    const candidateHasStrongNewMarginSignal =
+        candidateSpatial >= 0.55 &&
+        candidateGradient >= 0.3;
+    const candidateHasWeakOrMuchWeakerSignal =
+        candidateSpatial < STANDARD_VALIDATION_MIN_ORIGINAL_SPATIAL_SCORE ||
+        candidateGradient < STANDARD_VALIDATION_MIN_ORIGINAL_GRADIENT_SCORE ||
+        (
+            candidateSpatial <= currentSpatial - STRONG_ORIGINAL_SIGNAL_SPATIAL_ADVANTAGE &&
+            candidateGradient <= currentGradient - STRONG_ORIGINAL_SIGNAL_GRADIENT_ADVANTAGE
+        );
+
+    return currentHasStrongCanonicalSignal &&
+        !candidateHasStrongNewMarginSignal &&
+        candidateHasWeakOrMuchWeakerSignal;
+}
+
+function isBalancedCanonical96AlphaGain(candidate) {
+    const alphaGain = Number(candidate?.alphaGain);
+    return Number.isFinite(alphaGain) && alphaGain >= 1 && alphaGain <= 1.1;
+}
+
+function shouldPreserveStandardAlphaCanonical96AgainstDarkGain(currentBest, candidate) {
+    if (!sameCandidateAnchor(currentBest, candidate)) return false;
+    if (!isCanonicalDefault96Candidate(currentBest)) return false;
+
+    const currentAlphaGain = Number(currentBest?.alphaGain);
+    const candidateAlphaGain = Number(candidate?.alphaGain);
+    if (
+        !Number.isFinite(currentAlphaGain) ||
+        !Number.isFinite(candidateAlphaGain) ||
+        currentAlphaGain !== 1 ||
+        candidateAlphaGain <= 1 ||
+        candidate?.tooDark !== true
+    ) {
+        return false;
+    }
+
+    const originalSpatial = Number(currentBest.originalSpatialScore);
+    const originalGradient = Number(currentBest.originalGradientScore);
+    const currentSpatial = Number(currentBest.processedSpatialScore);
+    const currentGradient = Number(currentBest.processedGradientScore);
+    if (
+        !Number.isFinite(originalSpatial) ||
+        !Number.isFinite(originalGradient) ||
+        !Number.isFinite(currentSpatial) ||
+        !Number.isFinite(currentGradient)
+    ) {
+        return false;
+    }
+
+    return originalSpatial >= 0.55 &&
+        originalGradient >= 0.2 &&
+        currentSpatial >= 0 &&
+        currentSpatial <= 0.35 &&
+        Math.max(0, currentGradient) <= 0.08;
+}
+
+function shouldPreserveBalancedAlphaCanonical96(currentBest, candidate) {
+    if (!sameCandidateAnchor(currentBest, candidate)) return false;
+    if (!isCanonicalDefault96Candidate(currentBest)) return false;
+    if (!isBalancedCanonical96AlphaGain(currentBest)) return false;
+
+    const candidateAlphaGain = Number(candidate?.alphaGain);
+    if (!Number.isFinite(candidateAlphaGain) || candidateAlphaGain <= 1.1) return false;
+
+    const originalSpatial = Number(currentBest.originalSpatialScore);
+    const originalGradient = Number(currentBest.originalGradientScore);
+    const currentSpatial = Number(currentBest.processedSpatialScore);
+    const currentGradient = Number(currentBest.processedGradientScore);
+    if (
+        !Number.isFinite(originalSpatial) ||
+        !Number.isFinite(originalGradient) ||
+        !Number.isFinite(currentSpatial) ||
+        !Number.isFinite(currentGradient)
+    ) {
+        return false;
+    }
+
+    return originalSpatial >= 0.55 &&
+        originalGradient >= 0.2 &&
+        currentSpatial >= 0 &&
+        currentSpatial <= 0.22 &&
+        Math.max(0, currentGradient) <= 0.1;
+}
+
 function hasWeakDriftEvidence(candidate) {
     const candidateSpatial = Number(candidate?.originalSpatialScore);
     const candidateGradient = Number(candidate?.originalGradientScore);

package/src/core/watermarkProcessor.js

@@ -22,8 +22,12 @@ import { createSelectionDebugSummary } from './selectionDebug.js';
 import {
     calculateWatermarkPosition,
     detectWatermarkConfig,
-    resolveInitialStandardConfig
-} from './watermarkConfig.js';
+    resolveInitialStandardConfig
+} from './watermarkConfig.js';
+import {
+    blurAlphaMap,
+    buildPreviewNeighborhoodPrior
+} from './previewAlphaCalibration.js';
 
 const RESIDUAL_RECALIBRATION_THRESHOLD = 0.5;
 const MIN_SUPPRESSION_FOR_SKIP_RECALIBRATION = 0.18;
@@ -36,6 +40,7 @@ const SUBPIXEL_REFINE_SCALES = [0.99, 1, 1.01];
 const ALPHA_PARAMETER_GROUPS = Object.freeze([
     { name: 'gemini-weak-alpha-202606', alphaGain: 0.6, standardPriority: true },
     { name: 'gemini-standard-alpha', alphaGain: 1, standardPriority: true },
+    { name: 'gemini-balanced-strong-alpha-202606', alphaGain: 1.1 },
     { name: 'gemini-strong-alpha-202606', alphaGain: 1.15 },
     { name: 'gemini-strong-alpha-high-202606', alphaGain: 1.3 },
     { name: 'weak-alpha-extra-conservative', alphaGain: 0.45 },
@@ -136,6 +141,21 @@ const PREVIEW_BACKGROUND_CLEANUP_MIN_RESIDUAL = 0.3;
 const PREVIEW_BACKGROUND_CLEANUP_MAX_BORDER_STD = 24;
 const PREVIEW_BACKGROUND_CLEANUP_PAD = 8;
 const PREVIEW_BACKGROUND_CLEANUP_PRIOR_RADIUS = 10;
+const SMOOTH_PRIOR_LOCATED_MIN_SIZE = 80;
+const SMOOTH_PRIOR_LOCATED_MAX_SIZE = 160;
+const SMOOTH_PRIOR_LOCATED_MIN_BORDER_MEAN = 120;
+const SMOOTH_PRIOR_LOCATED_MIN_SPATIAL = 0.25;
+const SMOOTH_PRIOR_LOCATED_MAX_GRADIENT = 0.22;
+const SMOOTH_PRIOR_LOCATED_MIN_SPATIAL_IMPROVEMENT = 0.16;
+const SMOOTH_PRIOR_LOCATED_MAX_GRADIENT_DRIFT = 0.05;
+const SMOOTH_PRIOR_LOCATED_MIN_ARTIFACT_IMPROVEMENT = 0.025;
+const SMOOTH_PRIOR_LOCATED_MAX_ACCEPTED_GRADIENT = 0.18;
+const SMOOTH_PRIOR_LOCATED_PRESETS = Object.freeze([
+    { radius: 24, threshold: 0, blurRadius: 0, strength: 0.75, gamma: 0.45 },
+    { radius: 36, threshold: 0, blurRadius: 0, strength: 0.75, gamma: 0.45 },
+    { radius: 24, threshold: 0.01, blurRadius: 0, strength: 0.75, gamma: 0.45 },
+    { radius: 36, threshold: 0.01, blurRadius: 0, strength: 0.75, gamma: 0.45 }
+]);
 const OVER_SUBTRACTION_SPATIAL_THRESHOLD = -0.25;
 const OVER_SUBTRACTION_GRADIENT_THRESHOLD = 0.35;
 const OVER_SUBTRACTION_MIN_ABS_SPATIAL_IMPROVEMENT = 0.08;
@@ -1370,7 +1390,7 @@ function expandPosition(position, imageData, pad) {
     };
 }
 
-function measureOuterBorderLuminanceStd(imageData, position, margin = 10) {
+function measureOuterBorderLuminanceStats(imageData, position, margin = 10) {
     let sum = 0;
     let sq = 0;
     let count = 0;
@@ -1399,16 +1419,219 @@ function measureOuterBorderLuminanceStd(imageData, position, margin = 10) {
         }
     }
 
-    if (count <= 0) return Number.POSITIVE_INFINITY;
+    if (count <= 0) {
+        return {
+            mean: Number.POSITIVE_INFINITY,
+            std: Number.POSITIVE_INFINITY,
+            count
+        };
+    }
 
     const mean = sum / count;
-    return Math.sqrt(Math.max(0, sq / count - mean * mean));
+    return {
+        mean,
+        std: Math.sqrt(Math.max(0, sq / count - mean * mean)),
+        count
+    };
+}
+
+function measureOuterBorderLuminanceStd(imageData, position, margin = 10) {
+    return measureOuterBorderLuminanceStats(imageData, position, margin).std;
+}
+
+function clamp01(value) {
+    if (!Number.isFinite(value)) return 0;
+    if (value <= 0) return 0;
+    if (value >= 1) return 1;
+    return value;
 }
 
 function clampChannel(value) {
     return Math.max(0, Math.min(255, Math.round(value)));
 }
 
+function estimateAlphaMapFromBackgroundPrior({
+    originalImageData,
+    priorImageData,
+    position,
+    threshold,
+    blurRadius
+}) {
+    const alphaMap = new Float32Array(position.width * position.height);
+
+    for (let row = 0; row < position.height; row++) {
+        for (let col = 0; col < position.width; col++) {
+            const localIndex = row * position.width + col;
+            const pixelIndex = ((position.y + row) * originalImageData.width + position.x + col) * 4;
+            let estimatedAlpha = 0;
+
+            for (let channel = 0; channel < 3; channel++) {
+                const denominator = 255 - priorImageData.data[pixelIndex + channel];
+                if (denominator <= 2) continue;
+
+                estimatedAlpha = Math.max(
+                    estimatedAlpha,
+                    (originalImageData.data[pixelIndex + channel] - priorImageData.data[pixelIndex + channel]) / denominator
+                );
+            }
+
+            alphaMap[localIndex] = Math.min(0.9, clamp01((estimatedAlpha - threshold) * 1.2));
+        }
+    }
+
+    return blurRadius > 0
+        ? blurAlphaMap(alphaMap, position.width, blurRadius)
+        : alphaMap;
+}
+
+function applyEstimatedPriorBlend({
+    sourceImageData,
+    priorImageData,
+    estimatedAlphaMap,
+    position,
+    strength,
+    gamma
+}) {
+    const candidate = cloneImageData(sourceImageData);
+
+    for (let row = 0; row < position.height; row++) {
+        for (let col = 0; col < position.width; col++) {
+            const localIndex = row * position.width + col;
+            const alpha = estimatedAlphaMap[localIndex];
+            if (alpha <= 0.005) continue;
+
+            const blend = clamp01(Math.pow(alpha, gamma) * strength);
+            if (blend <= 0.005) continue;
+
+            const pixelIndex = ((position.y + row) * sourceImageData.width + position.x + col) * 4;
+            for (let channel = 0; channel < 3; channel++) {
+                candidate.data[pixelIndex + channel] = clampChannel(
+                    sourceImageData.data[pixelIndex + channel] * (1 - blend) +
+                    priorImageData.data[pixelIndex + channel] * blend
+                );
+            }
+        }
+    }
+
+    return candidate;
+}
+
+function refineSmoothLocatedResidualWithEstimatedPrior({
+    originalImageData,
+    currentImageData,
+    alphaMap,
+    position,
+    source,
+    alphaGain,
+    baselineSpatialScore,
+    baselineGradientScore
+}) {
+    if (
+        typeof source !== 'string' ||
+        !source.includes('located-aggressive') ||
+        position?.width < SMOOTH_PRIOR_LOCATED_MIN_SIZE ||
+        position?.width > SMOOTH_PRIOR_LOCATED_MAX_SIZE ||
+        baselineSpatialScore < SMOOTH_PRIOR_LOCATED_MIN_SPATIAL ||
+        baselineGradientScore > SMOOTH_PRIOR_LOCATED_MAX_GRADIENT
+    ) {
+        return null;
+    }
+
+    const borderStats = measureOuterBorderLuminanceStats(originalImageData, position, 16);
+    if (borderStats.mean < SMOOTH_PRIOR_LOCATED_MIN_BORDER_MEAN) {
+        return null;
+    }
+
+    const baselineArtifacts = assessRemovalDiffArtifacts({
+        originalImageData,
+        candidateImageData: currentImageData,
+        alphaMap,
+        position,
+        alphaGain
+    });
+    const baselineArtifactCost = Number(baselineArtifacts?.visualArtifactCost);
+    if (!Number.isFinite(baselineArtifactCost)) return null;
+
+    let best = null;
+    const priorByRadius = new Map();
+
+    for (const preset of SMOOTH_PRIOR_LOCATED_PRESETS) {
+        let priorImageData = priorByRadius.get(preset.radius);
+        if (!priorImageData) {
+            priorImageData = buildPreviewNeighborhoodPrior({
+                previewImageData: originalImageData,
+                position,
+                radius: preset.radius
+            });
+            priorByRadius.set(preset.radius, priorImageData);
+        }
+
+        const estimatedAlphaMap = estimateAlphaMapFromBackgroundPrior({
+            originalImageData,
+            priorImageData,
+            position,
+            threshold: preset.threshold,
+            blurRadius: preset.blurRadius
+        });
+        const candidateImageData = applyEstimatedPriorBlend({
+            sourceImageData: currentImageData,
+            priorImageData,
+            estimatedAlphaMap,
+            position,
+            strength: preset.strength,
+            gamma: preset.gamma
+        });
+        const spatialScore = computeRegionSpatialCorrelation({
+            imageData: candidateImageData,
+            alphaMap,
+            region: { x: position.x, y: position.y, size: position.width }
+        });
+        const gradientScore = computeRegionGradientCorrelation({
+            imageData: candidateImageData,
+            alphaMap,
+            region: { x: position.x, y: position.y, size: position.width }
+        });
+        const artifacts = assessRemovalDiffArtifacts({
+            originalImageData,
+            candidateImageData,
+            alphaMap,
+            position,
+            alphaGain
+        });
+        const artifactCost = Number(artifacts?.visualArtifactCost);
+        if (!Number.isFinite(artifactCost)) continue;
+
+        const spatialImprovement = Math.abs(baselineSpatialScore) - Math.abs(spatialScore);
+        const gradientDrift = gradientScore - baselineGradientScore;
+        const artifactImprovement = baselineArtifactCost - artifactCost;
+        if (
+            spatialImprovement < SMOOTH_PRIOR_LOCATED_MIN_SPATIAL_IMPROVEMENT ||
+            gradientDrift > SMOOTH_PRIOR_LOCATED_MAX_GRADIENT_DRIFT ||
+            artifactImprovement < SMOOTH_PRIOR_LOCATED_MIN_ARTIFACT_IMPROVEMENT ||
+            gradientScore > SMOOTH_PRIOR_LOCATED_MAX_ACCEPTED_GRADIENT
+        ) {
+            continue;
+        }
+
+        const cost = Math.abs(spatialScore) * 0.75 +
+            Math.max(0, gradientScore) * 0.9 +
+            artifactCost * 0.5;
+        if (!best || cost < best.cost) {
+            best = {
+                imageData: candidateImageData,
+                spatialScore,
+                gradientScore,
+                cost,
+                artifactCost,
+                borderStats,
+                preset
+            };
+        }
+    }
+
+    return best;
+}
+
 function averageStripColor(imageData, {
     xFrom,
     xTo,
@@ -1873,6 +2096,53 @@ function refineLocatedAggressiveRemoval({
     return best;
 }
 
+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);
+    if (
+        !Number.isFinite(resolvedAlphaGain) ||
+        !Number.isFinite(originalSpatial) ||
+        !Number.isFinite(originalGradient) ||
+        !Number.isFinite(currentSpatial) ||
+        !Number.isFinite(currentGradient)
+    ) {
+        return false;
+    }
+
+    const cleanStandardAlpha =
+        resolvedAlphaGain <= 1 &&
+        currentSpatial >= 0 &&
+        currentSpatial <= 0.35 &&
+        Math.max(0, currentGradient) <= 0.08;
+    const cleanBalancedAlpha =
+        resolvedAlphaGain <= 1.1 &&
+        currentSpatial >= 0 &&
+        currentSpatial <= 0.22 &&
+        Math.max(0, currentGradient) <= 0.1;
+
+    return originalSpatial >= 0.55 &&
+        originalGradient >= 0.2 &&
+        (cleanStandardAlpha || cleanBalancedAlpha);
+}
+
 function shouldRelocateSmallFixedLocalAnchor({
     source,
     config,
@@ -2784,9 +3054,23 @@ export function processWatermarkImageData(imageData, options = {}) {
     }
 
     const locatedAggressiveStartedAt = nowMs();
+    const locatedAggressiveResidualVisibility = assessWatermarkResidualVisibility({
+        imageData: finalImageData,
+        position,
+        alphaMap
+    });
     if (
         options.locatedAggressiveRemoval !== false &&
-        smallFixedLocalRelocated?.residualVisibility?.visible !== false
+        smallFixedLocalRelocated?.residualVisibility?.visible !== false &&
+        locatedAggressiveResidualVisibility?.visible !== false &&
+        !shouldSkipLocatedAggressiveForCleanCanonical96({
+            config,
+            alphaGain,
+            originalSpatialScore,
+            originalGradientScore,
+            currentSpatialScore: finalProcessedSpatialScore,
+            currentGradientScore: finalProcessedGradientScore
+        })
     ) {
         const aggressiveRefined = refineLocatedAggressiveRemoval({
             originalImageData,
@@ -2835,10 +3119,42 @@ export function processWatermarkImageData(imageData, options = {}) {
                 : `${source}+located-aggressive`;
         }
     }
+
+    const smoothPriorStartedAt = nowMs();
+    const smoothPriorRefined = refineSmoothLocatedResidualWithEstimatedPrior({
+        originalImageData,
+        currentImageData: finalImageData,
+        alphaMap,
+        position,
+        source,
+        alphaGain,
+        baselineSpatialScore: finalProcessedSpatialScore,
+        baselineGradientScore: finalProcessedGradientScore
+    });
+    if (smoothPriorRefined) {
+        recordAlphaAdjustmentStage({
+            stage: 'smooth-located-estimated-prior',
+            fromAlphaGain: alphaGain,
+            toAlphaGain: alphaGain,
+            beforeSpatialScore: finalProcessedSpatialScore,
+            beforeGradientScore: finalProcessedGradientScore,
+            afterSpatialScore: smoothPriorRefined.spatialScore,
+            afterGradientScore: smoothPriorRefined.gradientScore,
+            suppressionGain: originalSpatialScore - smoothPriorRefined.spatialScore,
+            cost: smoothPriorRefined.cost,
+            allowSameAlphaGain: true
+        });
+        finalImageData = smoothPriorRefined.imageData;
+        finalProcessedSpatialScore = smoothPriorRefined.spatialScore;
+        finalProcessedGradientScore = smoothPriorRefined.gradientScore;
+        suppressionGain = originalSpatialScore - finalProcessedSpatialScore;
+        source = `${source}+smooth-prior`;
+    }
     if (debugTimingsEnabled) {
         debugTimings.previewEdgeCleanupMs = previewEdgeCleanupElapsedMs;
         debugTimings.smallPreviewRefinementMs = nowMs() - smallPreviewRefinementStartedAt;
         debugTimings.locatedAggressiveRemovalMs = nowMs() - locatedAggressiveStartedAt;
+        debugTimings.smoothPriorCleanupMs = nowMs() - smoothPriorStartedAt;
         debugTimings.totalMs = nowMs() - totalStartedAt;
     }