@pilio/gemini-watermark-remover 1.0.10

package/src/core/restorationMetrics.js

@@ -0,0 +1,251 @@
+import {
+    computeRegionGradientCorrelation,
+    computeRegionSpatialCorrelation
+} from './adaptiveDetector.js';
+
+const NEAR_BLACK_THRESHOLD = 5;
+const TEXTURE_REFERENCE_MARGIN = 1;
+const TEXTURE_STD_FLOOR_RATIO = 0.8;
+const TEXTURE_DARKNESS_VISIBILITY_HARD_REJECT_THRESHOLD = 1.5;
+const TEXTURE_DARKNESS_HARD_REJECT_PENALTY_THRESHOLD = 0.5;
+const TEXTURE_FLATNESS_HARD_REJECT_PENALTY_THRESHOLD = 0.2;
+const DEFAULT_HALO_MIN_ALPHA = 0.12;
+const DEFAULT_HALO_MAX_ALPHA = 0.35;
+const DEFAULT_HALO_OUTSIDE_ALPHA_MAX = 0.01;
+const DEFAULT_HALO_OUTER_MARGIN = 3;
+
+export function cloneImageData(imageData) {
+    if (typeof ImageData !== 'undefined' && imageData instanceof ImageData) {
+        return new ImageData(
+            new Uint8ClampedArray(imageData.data),
+            imageData.width,
+            imageData.height
+        );
+    }
+
+    return {
+        width: imageData.width,
+        height: imageData.height,
+        data: new Uint8ClampedArray(imageData.data)
+    };
+}
+
+export function calculateNearBlackRatio(imageData, position) {
+    let nearBlack = 0;
+    let total = 0;
+    for (let row = 0; row < position.height; row++) {
+        for (let col = 0; col < position.width; col++) {
+            const idx = ((position.y + row) * imageData.width + (position.x + col)) * 4;
+            const r = imageData.data[idx];
+            const g = imageData.data[idx + 1];
+            const b = imageData.data[idx + 2];
+            if (r <= NEAR_BLACK_THRESHOLD && g <= NEAR_BLACK_THRESHOLD && b <= NEAR_BLACK_THRESHOLD) {
+                nearBlack++;
+            }
+            total++;
+        }
+    }
+
+    return total > 0 ? nearBlack / total : 0;
+}
+
+function calculateRegionTextureStats(imageData, region) {
+    let sum = 0;
+    let sq = 0;
+    let total = 0;
+
+    for (let row = 0; row < region.height; row++) {
+        for (let col = 0; col < region.width; col++) {
+            const idx = ((region.y + row) * imageData.width + (region.x + col)) * 4;
+            const lum =
+                0.2126 * imageData.data[idx] +
+                0.7152 * imageData.data[idx + 1] +
+                0.0722 * imageData.data[idx + 2];
+            sum += lum;
+            sq += lum * lum;
+            total++;
+        }
+    }
+
+    const meanLum = total > 0 ? sum / total : 0;
+    const variance = total > 0 ? Math.max(0, sq / total - meanLum * meanLum) : 0;
+
+    return {
+        meanLum,
+        stdLum: Math.sqrt(variance)
+    };
+}
+
+export function getRegionTextureStats(imageData, region) {
+    return calculateRegionTextureStats(imageData, region);
+}
+
+export function assessAlphaBandHalo({
+    imageData,
+    position,
+    alphaMap,
+    minAlpha = DEFAULT_HALO_MIN_ALPHA,
+    maxAlpha = DEFAULT_HALO_MAX_ALPHA,
+    outsideAlphaMax = DEFAULT_HALO_OUTSIDE_ALPHA_MAX,
+    outerMargin = DEFAULT_HALO_OUTER_MARGIN
+}) {
+    let bandSum = 0;
+    let bandSq = 0;
+    let bandCount = 0;
+    let outerSum = 0;
+    let outerSq = 0;
+    let outerCount = 0;
+
+    for (let row = -outerMargin; row < position.height + outerMargin; row++) {
+        for (let col = -outerMargin; col < position.width + outerMargin; col++) {
+            const pixelX = position.x + col;
+            const pixelY = position.y + row;
+            if (pixelX < 0 || pixelY < 0 || pixelX >= imageData.width || pixelY >= imageData.height) {
+                continue;
+            }
+
+            const pixelIndex = (pixelY * imageData.width + pixelX) * 4;
+            const luminance =
+                0.2126 * imageData.data[pixelIndex] +
+                0.7152 * imageData.data[pixelIndex + 1] +
+                0.0722 * imageData.data[pixelIndex + 2];
+            const insideRegion = row >= 0 && col >= 0 && row < position.height && col < position.width;
+            const alpha = insideRegion
+                ? alphaMap[row * position.width + col]
+                : 0;
+
+            if (insideRegion && alpha >= minAlpha && alpha <= maxAlpha) {
+                bandSum += luminance;
+                bandSq += luminance * luminance;
+                bandCount++;
+                continue;
+            }
+
+            if (!insideRegion || alpha <= outsideAlphaMax) {
+                outerSum += luminance;
+                outerSq += luminance * luminance;
+                outerCount++;
+            }
+        }
+    }
+
+    const bandMeanLum = bandCount > 0 ? bandSum / bandCount : 0;
+    const outerMeanLum = outerCount > 0 ? outerSum / outerCount : 0;
+    const bandStdLum = bandCount > 0 ? Math.sqrt(Math.max(0, bandSq / bandCount - bandMeanLum * bandMeanLum)) : 0;
+    const outerStdLum = outerCount > 0 ? Math.sqrt(Math.max(0, outerSq / outerCount - outerMeanLum * outerMeanLum)) : 0;
+    const deltaLum = bandMeanLum - outerMeanLum;
+    const visibility = deltaLum / Math.max(1, outerStdLum);
+
+    return {
+        bandCount,
+        outerCount,
+        bandMeanLum,
+        outerMeanLum,
+        bandStdLum,
+        outerStdLum,
+        deltaLum,
+        positiveDeltaLum: Math.max(0, deltaLum),
+        visibility
+    };
+}
+
+function getReferenceRegion(position, imageData) {
+    const referenceY = position.y - position.height;
+    if (referenceY < 0) return null;
+
+    return {
+        x: position.x,
+        y: referenceY,
+        width: position.width,
+        height: position.height
+    };
+}
+
+export function assessReferenceTextureAlignment({
+    originalImageData,
+    referenceImageData,
+    candidateImageData,
+    position
+}) {
+    const candidateTextureStats = candidateImageData
+        ? calculateRegionTextureStats(candidateImageData, position)
+        : null;
+
+    return assessReferenceTextureAlignmentFromStats({
+        originalImageData,
+        referenceImageData,
+        candidateTextureStats,
+        position
+    });
+}
+
+export function assessReferenceTextureAlignmentFromStats({
+    originalImageData,
+    referenceImageData,
+    candidateTextureStats,
+    position
+}) {
+    const resolvedReferenceImageData = referenceImageData ?? originalImageData;
+    const referenceRegion = resolvedReferenceImageData
+        ? getReferenceRegion(position, resolvedReferenceImageData)
+        : null;
+    const referenceTextureStats = referenceRegion
+        ? calculateRegionTextureStats(resolvedReferenceImageData, referenceRegion)
+        : null;
+    const darknessPenalty = referenceTextureStats && candidateTextureStats
+        ? Math.max(0, referenceTextureStats.meanLum - candidateTextureStats.meanLum - TEXTURE_REFERENCE_MARGIN) /
+            Math.max(1, referenceTextureStats.meanLum)
+        : 0;
+    const flatnessPenalty = referenceTextureStats && candidateTextureStats
+        ? Math.max(0, referenceTextureStats.stdLum * TEXTURE_STD_FLOOR_RATIO - candidateTextureStats.stdLum) /
+            Math.max(1, referenceTextureStats.stdLum)
+        : 0;
+    const darknessVisibility = referenceTextureStats && candidateTextureStats
+        ? Math.max(0, referenceTextureStats.meanLum - candidateTextureStats.meanLum - TEXTURE_REFERENCE_MARGIN) /
+            Math.max(1, referenceTextureStats.stdLum)
+        : 0;
+    const tooDark = darknessPenalty > 0;
+    const tooFlat = flatnessPenalty > 0;
+    const visibleDarkHole = tooDark && darknessVisibility >= TEXTURE_DARKNESS_VISIBILITY_HARD_REJECT_THRESHOLD;
+    const strongDarkFlatCollapse =
+        tooDark &&
+        tooFlat &&
+        darknessPenalty >= TEXTURE_DARKNESS_HARD_REJECT_PENALTY_THRESHOLD &&
+        flatnessPenalty >= TEXTURE_FLATNESS_HARD_REJECT_PENALTY_THRESHOLD;
+
+    return {
+        referenceTextureStats,
+        candidateTextureStats,
+        darknessPenalty,
+        flatnessPenalty,
+        darknessVisibility,
+        texturePenalty: darknessPenalty * 2 + flatnessPenalty * 2,
+        tooDark,
+        tooFlat,
+        visibleDarkHole,
+        hardReject: strongDarkFlatCollapse || visibleDarkHole
+    };
+}
+
+export function scoreRegion(imageData, alphaMap, position) {
+    return {
+        spatialScore: computeRegionSpatialCorrelation({
+            imageData,
+            alphaMap,
+            region: {
+                x: position.x,
+                y: position.y,
+                size: position.width
+            }
+        }),
+        gradientScore: computeRegionGradientCorrelation({
+            imageData,
+            alphaMap,
+            region: {
+                x: position.x,
+                y: position.y,
+                size: position.width
+            }
+        })
+    };
+}

package/src/core/selectionDebug.js

@@ -0,0 +1,47 @@
+function normalizeConfig(config) {
+    if (!config || typeof config !== 'object') return null;
+    const { logoSize, marginRight, marginBottom } = config;
+    if (![logoSize, marginRight, marginBottom].every(Number.isFinite)) {
+        return null;
+    }
+    return { logoSize, marginRight, marginBottom };
+}
+
+function normalizePosition(position) {
+    if (!position || typeof position !== 'object') return null;
+    const { x, y, width, height } = position;
+    if (![x, y, width, height].every(Number.isFinite)) {
+        return null;
+    }
+    return { x, y, width, height };
+}
+
+export function createSelectionDebugSummary({
+    selectedTrial,
+    selectionSource = null,
+    initialConfig = null,
+    initialPosition = null
+} = {}) {
+    if (!selectedTrial) return null;
+
+    const candidateSource = typeof selectionSource === 'string' && selectionSource
+        ? selectionSource
+        : (typeof selectedTrial.source === 'string' ? selectedTrial.source : null);
+
+    return {
+        candidateSource,
+        initialConfig: normalizeConfig(initialConfig),
+        initialPosition: normalizePosition(initialPosition),
+        finalConfig: normalizeConfig(selectedTrial.config),
+        finalPosition: normalizePosition(selectedTrial.position),
+        texturePenalty: Number.isFinite(selectedTrial.texturePenalty) ? selectedTrial.texturePenalty : null,
+        tooDark: selectedTrial.tooDark === true,
+        tooFlat: selectedTrial.tooFlat === true,
+        hardReject: selectedTrial.hardReject === true,
+        usedCatalogVariant: selectedTrial.provenance?.catalogVariant === true,
+        usedSizeJitter: selectedTrial.provenance?.sizeJitter === true,
+        usedLocalShift: selectedTrial.provenance?.localShift === true,
+        usedAdaptive: selectedTrial.provenance?.adaptive === true,
+        usedPreviewAnchor: selectedTrial.provenance?.previewAnchor === true
+    };
+}

package/src/core/watermarkConfig.js

@@ -0,0 +1,146 @@
+import { computeRegionSpatialCorrelation, interpolateAlphaMap } from './adaptiveDetector.js';
+import {
+    resolveOfficialGeminiSearchConfigs,
+    resolveOfficialGeminiWatermarkConfig
+} from './geminiSizeCatalog.js';
+
+/**
+ * Detect watermark configuration based on image size
+ * @param {number} imageWidth - Image width
+ * @param {number} imageHeight - Image height
+ * @returns {Object} Watermark configuration {logoSize, marginRight, marginBottom}
+ */
+export function detectWatermarkConfig(imageWidth, imageHeight) {
+    const officialConfig = resolveOfficialGeminiWatermarkConfig(imageWidth, imageHeight);
+    if (officialConfig) {
+        return { ...officialConfig };
+    }
+
+    // Gemini's historical default rules:
+    // If both image width and height are greater than 1024, use 96×96 watermark
+    // Otherwise, use 48×48 watermark
+    if (imageWidth > 1024 && imageHeight > 1024) {
+        return {
+            logoSize: 96,
+            marginRight: 64,
+            marginBottom: 64
+        };
+    }
+
+    return {
+        logoSize: 48,
+        marginRight: 32,
+        marginBottom: 32
+    };
+}
+
+/**
+ * Calculate watermark position in image based on image size and watermark configuration
+ * @param {number} imageWidth - Image width
+ * @param {number} imageHeight - Image height
+ * @param {Object} config - Watermark configuration {logoSize, marginRight, marginBottom}
+ * @returns {Object} Watermark position {x, y, width, height}
+ */
+export function calculateWatermarkPosition(imageWidth, imageHeight, config) {
+    const { logoSize, marginRight, marginBottom } = config;
+
+    return {
+        x: imageWidth - marginRight - logoSize,
+        y: imageHeight - marginBottom - logoSize,
+        width: logoSize,
+        height: logoSize
+    };
+}
+
+function getStandardConfig(size) {
+    return size === 96
+        ? { logoSize: 96, marginRight: 64, marginBottom: 64 }
+        : { logoSize: 48, marginRight: 32, marginBottom: 32 };
+}
+
+function getAlphaMapForConfig(config, alpha48, alpha96) {
+    if (!config) return null;
+    if (config.logoSize === 48) return alpha48;
+    if (config.logoSize === 96) return alpha96;
+    return alpha96 ? interpolateAlphaMap(alpha96, 96, config.logoSize) : null;
+}
+
+function isRegionInsideImage(imageData, region) {
+    return region.x >= 0 &&
+        region.y >= 0 &&
+        region.x + region.width <= imageData.width &&
+        region.y + region.height <= imageData.height;
+}
+
+/**
+ * Resolve initial standard config by comparing 48/96 template correlation scores.
+ * This helps when fixed size rules mismatch newer Gemini output layouts.
+ */
+export function resolveInitialStandardConfig({
+    imageData,
+    defaultConfig,
+    alpha48,
+    alpha96,
+    minSwitchScore = 0.25,
+    minScoreDelta = 0.08
+}) {
+    if (!imageData || !defaultConfig || !alpha48 || !alpha96) return defaultConfig;
+
+    const fallbackConfig = getStandardConfig(48);
+    const primaryConfig = defaultConfig.logoSize === 96 ? getStandardConfig(96) : fallbackConfig;
+    const alternateConfig = defaultConfig.logoSize === 96 ? fallbackConfig : getStandardConfig(96);
+    const candidateConfigs = [primaryConfig, alternateConfig];
+
+    for (const officialConfig of resolveOfficialGeminiSearchConfigs(imageData.width, imageData.height, {
+        limit: 1
+    })) {
+        if (!candidateConfigs.some((candidate) => (
+            candidate.logoSize === officialConfig.logoSize &&
+            candidate.marginRight === officialConfig.marginRight &&
+            candidate.marginBottom === officialConfig.marginBottom
+        ))) {
+            candidateConfigs.push(officialConfig);
+        }
+    }
+
+    let bestConfig = null;
+    let bestScore = Number.NEGATIVE_INFINITY;
+
+    for (const candidateConfig of candidateConfigs) {
+        const candidateRegion = calculateWatermarkPosition(
+            imageData.width,
+            imageData.height,
+            candidateConfig
+        );
+        if (!isRegionInsideImage(imageData, candidateRegion)) continue;
+
+        const alphaMap = getAlphaMapForConfig(candidateConfig, alpha48, alpha96);
+        if (!alphaMap) continue;
+
+        const candidateScore = computeRegionSpatialCorrelation({
+            imageData,
+            alphaMap,
+            region: {
+                x: candidateRegion.x,
+                y: candidateRegion.y,
+                size: candidateRegion.width
+            }
+        });
+
+        if (!bestConfig) {
+            bestConfig = candidateConfig;
+            bestScore = candidateScore;
+            continue;
+        }
+
+        if (
+            candidateScore >= minSwitchScore &&
+            candidateScore > bestScore + minScoreDelta
+        ) {
+            bestConfig = candidateConfig;
+            bestScore = candidateScore;
+        }
+    }
+
+    return bestConfig ?? defaultConfig;
+}

package/src/core/watermarkDecisionPolicy.js

@@ -0,0 +1,163 @@
+// Keep detector thresholds, processed-meta attribution, and UI classification
+// on the same vocabulary so "removed", "validated", and "Gemini-like" do not
+// diverge across modules.
+const STANDARD_DIRECT_MATCH_MIN_SPATIAL_SCORE = 0.3;
+const STANDARD_DIRECT_MATCH_MIN_GRADIENT_SCORE = 0.12;
+const STANDARD_STRONG_GRADIENT_DIRECT_MATCH_MIN_SPATIAL_SCORE = 0.295;
+const STANDARD_STRONG_GRADIENT_DIRECT_MATCH_MIN_GRADIENT_SCORE = 0.45;
+
+const ADAPTIVE_DIRECT_MATCH_MIN_CONFIDENCE = 0.5;
+const ADAPTIVE_DIRECT_MATCH_MIN_SPATIAL_SCORE = 0.45;
+const ADAPTIVE_DIRECT_MATCH_MIN_GRADIENT_SCORE = 0.12;
+const ADAPTIVE_DIRECT_MATCH_MIN_SIZE = 40;
+const ADAPTIVE_DIRECT_MATCH_MAX_SIZE = 192;
+
+const ATTRIBUTION_MIN_SIZE = 24;
+const ATTRIBUTION_MAX_SIZE = 192;
+const ATTRIBUTION_MAX_RESIDUAL_SCORE = 0.2;
+const ATTRIBUTION_MIN_SUPPRESSION_GAIN = 0.25;
+const ATTRIBUTION_MIN_SPATIAL_SCORE = 0.22;
+const ATTRIBUTION_MIN_VALIDATED_SPATIAL_SCORE = 0.2;
+const ATTRIBUTION_MIN_VALIDATED_SUPPRESSION_GAIN = 0.3;
+const ATTRIBUTION_MIN_ADAPTIVE_CONFIDENCE = 0.35;
+const ATTRIBUTION_MIN_ADAPTIVE_SUPPRESSION_GAIN = 0.16;
+
+function toFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function isPositionSized(position) {
+    const width = toFiniteNumber(position?.width);
+    const height = toFiniteNumber(position?.height);
+    return width !== null && height !== null;
+}
+
+export function classifyStandardWatermarkSignal({ spatialScore, gradientScore }) {
+    const spatial = toFiniteNumber(spatialScore);
+    const gradient = toFiniteNumber(gradientScore);
+
+    if (spatial === null || gradient === null) {
+        return { tier: 'insufficient' };
+    }
+
+    if (
+        (
+            spatial >= STANDARD_DIRECT_MATCH_MIN_SPATIAL_SCORE &&
+            gradient >= STANDARD_DIRECT_MATCH_MIN_GRADIENT_SCORE
+        ) ||
+        (
+            spatial >= STANDARD_STRONG_GRADIENT_DIRECT_MATCH_MIN_SPATIAL_SCORE &&
+            gradient >= STANDARD_STRONG_GRADIENT_DIRECT_MATCH_MIN_GRADIENT_SCORE
+        )
+    ) {
+        return { tier: 'direct-match' };
+    }
+
+    if (spatial > 0 || gradient > 0) {
+        return { tier: 'needs-validation' };
+    }
+
+    return { tier: 'insufficient' };
+}
+
+export function classifyAdaptiveWatermarkSignal(adaptiveResult) {
+    if (!adaptiveResult || adaptiveResult.found !== true) {
+        return { tier: 'insufficient' };
+    }
+
+    const confidence = toFiniteNumber(adaptiveResult.confidence);
+    const spatial = toFiniteNumber(adaptiveResult.spatialScore);
+    const gradient = toFiniteNumber(adaptiveResult.gradientScore);
+    const size = toFiniteNumber(adaptiveResult?.region?.size);
+
+    if (
+        confidence === null ||
+        spatial === null ||
+        gradient === null ||
+        size === null
+    ) {
+        return { tier: 'insufficient' };
+    }
+
+    if (
+        confidence >= ADAPTIVE_DIRECT_MATCH_MIN_CONFIDENCE &&
+        spatial >= ADAPTIVE_DIRECT_MATCH_MIN_SPATIAL_SCORE &&
+        gradient >= ADAPTIVE_DIRECT_MATCH_MIN_GRADIENT_SCORE &&
+        size >= ADAPTIVE_DIRECT_MATCH_MIN_SIZE &&
+        size <= ADAPTIVE_DIRECT_MATCH_MAX_SIZE
+    ) {
+        return { tier: 'direct-match' };
+    }
+
+    if (
+        size >= ADAPTIVE_DIRECT_MATCH_MIN_SIZE &&
+        size <= ADAPTIVE_DIRECT_MATCH_MAX_SIZE &&
+        gradient >= ADAPTIVE_DIRECT_MATCH_MIN_GRADIENT_SCORE &&
+        (confidence > 0 || spatial > 0)
+    ) {
+        return { tier: 'needs-validation' };
+    }
+
+    return { tier: 'insufficient' };
+}
+
+export function classifyGeminiAttributionFromWatermarkMeta(watermarkMeta) {
+    if (!watermarkMeta || typeof watermarkMeta !== 'object') {
+        return { tier: 'insufficient' };
+    }
+    if (watermarkMeta.applied === false) {
+        return { tier: 'insufficient' };
+    }
+
+    const size = toFiniteNumber(watermarkMeta.size);
+    if (size === null || size < ATTRIBUTION_MIN_SIZE || size > ATTRIBUTION_MAX_SIZE) {
+        return { tier: 'insufficient' };
+    }
+    if (!isPositionSized(watermarkMeta.position)) {
+        return { tier: 'insufficient' };
+    }
+
+    const detection = watermarkMeta.detection || {};
+    const adaptiveConfidence = toFiniteNumber(detection.adaptiveConfidence);
+    const originalSpatialScore = toFiniteNumber(detection.originalSpatialScore);
+    const processedSpatialScore = toFiniteNumber(detection.processedSpatialScore);
+    const suppressionGain = toFiniteNumber(detection.suppressionGain);
+    const source = typeof watermarkMeta.source === 'string' ? watermarkMeta.source : '';
+
+    // Adaptive/direct evidence is strongest, validated-match requires both a
+    // validated source path and measurable suppression, and safe-removal keeps
+    // "looks removable" separate from "confident Gemini attribution".
+    if (
+        adaptiveConfidence !== null &&
+        suppressionGain !== null &&
+        adaptiveConfidence >= ATTRIBUTION_MIN_ADAPTIVE_CONFIDENCE &&
+        suppressionGain >= ATTRIBUTION_MIN_ADAPTIVE_SUPPRESSION_GAIN
+    ) {
+        return { tier: 'adaptive-match' };
+    }
+
+    if (
+        source.includes('validated') &&
+        originalSpatialScore !== null &&
+        processedSpatialScore !== null &&
+        suppressionGain !== null &&
+        originalSpatialScore >= ATTRIBUTION_MIN_VALIDATED_SPATIAL_SCORE &&
+        processedSpatialScore <= ATTRIBUTION_MAX_RESIDUAL_SCORE &&
+        suppressionGain >= ATTRIBUTION_MIN_VALIDATED_SUPPRESSION_GAIN
+    ) {
+        return { tier: 'validated-match' };
+    }
+
+    if (
+        originalSpatialScore !== null &&
+        processedSpatialScore !== null &&
+        suppressionGain !== null &&
+        originalSpatialScore >= ATTRIBUTION_MIN_SPATIAL_SCORE &&
+        processedSpatialScore <= ATTRIBUTION_MAX_RESIDUAL_SCORE &&
+        suppressionGain >= ATTRIBUTION_MIN_SUPPRESSION_GAIN
+    ) {
+        return { tier: 'safe-removal' };
+    }
+
+    return { tier: 'insufficient' };
+}

package/src/core/watermarkDisplay.js

@@ -0,0 +1,60 @@
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+
+function isValidPosition(position) {
+    if (!position) return false;
+    return isFiniteNumber(position.x) &&
+        isFiniteNumber(position.y) &&
+        isFiniteNumber(position.width) &&
+        isFiniteNumber(position.height);
+}
+
+function buildConfigFromPosition(item, size, position) {
+    if (!item?.originalImg) return null;
+
+    return {
+        logoSize: size,
+        marginRight: item.originalImg.width - position.x - position.width,
+        marginBottom: item.originalImg.height - position.y - position.height
+    };
+}
+
+export function isConfirmedWatermarkDecision(item) {
+    const decisionTier = item?.processedMeta?.decisionTier;
+    if (typeof decisionTier === 'string') {
+        return decisionTier !== 'insufficient';
+    }
+
+    return item?.processedMeta?.applied !== false;
+}
+
+/**
+ * Resolve watermark info for UI display.
+ * Prefer processed runtime metadata and fallback to static estimate.
+ */
+export function resolveDisplayWatermarkInfo(item, estimatedInfo) {
+    const processedMeta = item?.processedMeta;
+    const position = processedMeta?.position;
+
+    if (isValidPosition(position)) {
+        const size = isFiniteNumber(processedMeta.size) ? processedMeta.size : position.width;
+        if (isFiniteNumber(size)) {
+            return {
+                size,
+                position,
+                config: processedMeta.config || buildConfigFromPosition(item, size, position),
+                source: processedMeta.source || 'processed',
+                decisionTier: processedMeta.decisionTier || null
+            };
+        }
+    }
+
+    if (!estimatedInfo) return null;
+
+    return {
+        ...estimatedInfo,
+        source: 'estimated',
+        decisionTier: null
+    };
+}