@pilio/gemini-watermark-remover 1.0.39 → 1.0.41

package/src/core/pipelineInitialSelection.js

@@ -13,8 +13,8 @@ import {
 import { calculateNearBlackRatio } from './restorationMetrics.js';
 import { resolveGeminiWatermarkSearchCatalogEntries } from './geminiSizeCatalog.js';
 import { measureOutputResidualLocalization } from './outputResidualLocalization.js';
-import { hasReliableStandardWatermarkSignal } from './watermarkPresence.js';
-import { shouldPreferFullStrengthNewMarginVariant } from './candidateEvaluation.js';
+import { hasReliableStandardWatermarkSignal } from './watermarkPresence.js';
+import { shouldPreferFullStrengthNewMarginVariant } from './candidateEvaluation.js';
 
 const AGGRESSIVE_FALLBACK_MAX_ABS_SPATIAL = 0.22;
 const AGGRESSIVE_FALLBACK_MAX_NEAR_BLACK_INCREASE = 0.05;
@@ -218,9 +218,9 @@ function createExact48R96SourceWitnessRescueTrial({
         },
         alphaMap: alpha48,
         alphaGain: 1,
-        provenance: {
-            catalogVariant: true,
-            catalogFamily: catalogEntry.metadata.family,
+        provenance: {
+            catalogVariant: true,
+            catalogFamily: catalogEntry.metadata.family,
             catalogSourcePriority: catalogEntry.metadata.sourcePriority,
             catalogEvidenceGate: catalogEntry.metadata.evidenceGate
         }
@@ -337,7 +337,7 @@ function createExact96R192SourceWitnessRescueTrial({
             )
         )
     );
-    const sourceLocalization = measureOutputResidualLocalization({
+    const sourceLocalization = measureOutputResidualLocalization({
         imageData: originalImageData,
         alphaMap,
         position,
@@ -371,53 +371,53 @@ function createExact96R192SourceWitnessRescueTrial({
         return null;
     }
 
-    const baselineNearBlackRatio = calculateNearBlackRatio(
-        originalImageData,
-        position
-    );
-    const provenance = {
-        catalogVariant: true,
-        alphaVariant: '20260520',
-        catalogFamily: catalogEntry.metadata.family,
-        catalogSourcePriority: catalogEntry.metadata.sourcePriority,
-        catalogEvidenceGate: catalogEntry.metadata.evidenceGate,
-        sourceWitnessRescue: true,
-        sourceWitnessReason: EXACT_96_R192_SOURCE_WITNESS_REASON,
-        sourceWitnessGate: {
-            spatialSignedTarget: spatialSignal,
-            spatialPercentile,
-            gradientSignedTarget: gradientSignal,
-            twoSidedEdgeProminence:
-                sourceLocalization.twoSidedEdgeProminence,
-            twoSidedEdgePercentile:
-                sourceLocalization.twoSidedEdgePercentile
-        }
-    };
-    const createRescueTrial = (alphaGain) => evaluateRestorationCandidate({
-        originalImageData,
-        alphaMap,
-        position,
-        source: 'standard+catalog+source-witness-rescue',
-        config: catalogEntry.config,
-        baselineNearBlackRatio,
-        alphaGain,
-        provenance,
-        includeImageData: false
-    });
-    const conservativeTrial = createRescueTrial(EXACT_96_R192_SOURCE_WITNESS_GAIN);
-    const fullStrengthTrial = spatialSignal > 0 ? createRescueTrial(1) : null;
-    const rescueTrial = fullStrengthTrial &&
-        shouldPreferFullStrengthNewMarginVariant(fullStrengthTrial, conservativeTrial)
-        ? fullStrengthTrial
-        : conservativeTrial;
-    if (
-        acceptedEligibleTrials.length > 0 &&
-        !hasDriftedDarkPolaritySelection &&
-        rescueTrial !== fullStrengthTrial
-    ) {
-        return null;
-    }
-    return measurePresenceLocalization(
+    const baselineNearBlackRatio = calculateNearBlackRatio(
+        originalImageData,
+        position
+    );
+    const provenance = {
+        catalogVariant: true,
+        alphaVariant: '20260520',
+        catalogFamily: catalogEntry.metadata.family,
+        catalogSourcePriority: catalogEntry.metadata.sourcePriority,
+        catalogEvidenceGate: catalogEntry.metadata.evidenceGate,
+        sourceWitnessRescue: true,
+        sourceWitnessReason: EXACT_96_R192_SOURCE_WITNESS_REASON,
+        sourceWitnessGate: {
+            spatialSignedTarget: spatialSignal,
+            spatialPercentile,
+            gradientSignedTarget: gradientSignal,
+            twoSidedEdgeProminence:
+                sourceLocalization.twoSidedEdgeProminence,
+            twoSidedEdgePercentile:
+                sourceLocalization.twoSidedEdgePercentile
+        }
+    };
+    const createRescueTrial = (alphaGain) => evaluateRestorationCandidate({
+        originalImageData,
+        alphaMap,
+        position,
+        source: 'standard+catalog+source-witness-rescue',
+        config: catalogEntry.config,
+        baselineNearBlackRatio,
+        alphaGain,
+        provenance,
+        includeImageData: false
+    });
+    const conservativeTrial = createRescueTrial(EXACT_96_R192_SOURCE_WITNESS_GAIN);
+    const fullStrengthTrial = spatialSignal > 0 ? createRescueTrial(1) : null;
+    const rescueTrial = fullStrengthTrial &&
+        shouldPreferFullStrengthNewMarginVariant(fullStrengthTrial, conservativeTrial)
+        ? fullStrengthTrial
+        : conservativeTrial;
+    if (
+        acceptedEligibleTrials.length > 0 &&
+        !hasDriftedDarkPolaritySelection &&
+        rescueTrial !== fullStrengthTrial
+    ) {
+        return null;
+    }
+    return measurePresenceLocalization(
         originalImageData,
         rescueTrial
     ).repeatedTemplateCollision
@@ -425,6 +425,78 @@ function createExact96R192SourceWitnessRescueTrial({
         : rescueTrial;
 }
 
+function getPositiveSourceEvidenceScore(trial) {
+    const spatial = Number(trial?.originalSpatialScore);
+    const gradient = Number(trial?.originalGradientScore);
+    return Math.max(
+        Number.isFinite(spatial) ? spatial : Number.NEGATIVE_INFINITY,
+        Number.isFinite(gradient) ? gradient : Number.NEGATIVE_INFINITY
+    );
+}
+
+function findCanonical96CatalogPriorTrial({
+    fixedSelection,
+    automaticSelection,
+    catalogPriorConfig
+}) {
+    if (
+        catalogPriorConfig?.logoSize !== 96 ||
+        catalogPriorConfig.marginRight !== 64 ||
+        catalogPriorConfig.marginBottom !== 64
+    ) {
+        return null;
+    }
+
+    const trials = [fixedSelection, automaticSelection]
+        .flatMap((selection) => [
+            ...(selection?.candidatePool ?? []),
+            selection?.selectedTrial
+        ])
+        .filter(Boolean);
+    const canonicalTrial = trials.find((trial) => (
+        trial.config?.logoSize === 96 &&
+        trial.config.marginRight === 64 &&
+        trial.config.marginBottom === 64 &&
+        !trial.config.alphaVariant &&
+        trial.provenance?.darkPolarity !== true &&
+        trial.alphaGain === 1
+    ));
+    if (!canonicalTrial) return null;
+
+    return {
+        ...canonicalTrial,
+        source: `${canonicalTrial.source ?? 'standard'}+catalog-prior-best-effort`,
+        provenance: {
+            ...canonicalTrial.provenance,
+            sourceWitnessRescue: true,
+            sourceWitnessReason: 'canonical-96-prior-over-weaker-r192',
+            catalogPriorBestEffort: true
+        }
+    };
+}
+
+function selectExact96SourceWitnessTrial({
+    r192Trial,
+    fixedSelection,
+    automaticSelection,
+    catalogPriorConfig
+}) {
+    if (!r192Trial) return null;
+    const canonicalTrial = findCanonical96CatalogPriorTrial({
+        fixedSelection,
+        automaticSelection,
+        catalogPriorConfig
+    });
+    if (
+        !canonicalTrial ||
+        getPositiveSourceEvidenceScore(canonicalTrial) <=
+            getPositiveSourceEvidenceScore(r192Trial)
+    ) {
+        return r192Trial;
+    }
+    return canonicalTrial;
+}
+
 function isSafeAggressiveFallbackSelection(selection) {
     const trial = selection?.selectedTrial;
     const spatial = Number(trial?.processedSpatialScore);
@@ -989,9 +1061,15 @@ export function collectInitialWatermarkCandidates(input = {}) {
                 fixedSelection,
                 automaticSelection
             });
+    const exact96SourceWitnessTrial = selectExact96SourceWitnessTrial({
+        r192Trial: exact96R192SourceWitnessRescueTrial,
+        fixedSelection,
+        automaticSelection,
+        catalogPriorConfig: input.catalogPriorConfig
+    });
     const sourceWitnessRescueTrial =
         exact48R96SourceWitnessRescueTrial ??
-        exact96R192SourceWitnessRescueTrial;
+        exact96SourceWitnessTrial;
     const bestEffortSelections = presenceConfirmed ||
         sourceWitnessRescueTrial
         ? []
@@ -1201,9 +1279,9 @@ export function collectInitialWatermarkCandidates(input = {}) {
     const hypotheses = [...preferredHypotheses, ...retainedAlternatives]
         .map((hypothesis) => ({
             ...hypothesis,
-            presenceStatus: !presenceConfirmed && sourceWitnessRescueTrial
-                ? 'source-witness'
-                : bestEffortFallback
+            presenceStatus: !presenceConfirmed && sourceWitnessRescueTrial
+                ? 'source-witness'
+                : bestEffortFallback
                 ? 'selector-only'
                 : 'confirmed',
             discoveryRole:
@@ -1229,8 +1307,8 @@ export function collectInitialWatermarkCandidates(input = {}) {
         hypotheses,
         presenceConfirmed,
         bestEffortFallback,
-        bestEffortReason: bestEffortFallback && sourceWitnessRescueTrial
-            ? sourceWitnessRescueTrial.provenance?.sourceWitnessReason ??
+        bestEffortReason: bestEffortFallback && sourceWitnessRescueTrial
+            ? sourceWitnessRescueTrial.provenance?.sourceWitnessReason ??
                 'source-witness'
             : bestEffortFallback
             ? 'presence-witness-unconfirmed'

package/src/core/watermarkProcessor.js

@@ -309,12 +309,12 @@ 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 CANONICAL_96_MODERATE_SIGNAL_MIN_ORIGINAL_SPATIAL = 0.4;
-const CANONICAL_96_MODERATE_SIGNAL_MIN_ORIGINAL_GRADIENT = 0.1;
-const CANONICAL_96_MODERATE_SIGNAL_MAX_CURRENT_SPATIAL = 0.26;
-const CANONICAL_96_MODERATE_SIGNAL_MAX_CURRENT_GRADIENT = 0.04;
-const FULL_STRENGTH_NEW_MARGIN_MIN_ORIGINAL_GRADIENT = 0.08;
-const FULL_STRENGTH_NEW_MARGIN_MAX_CURRENT_GRADIENT = 0.1;
+const CANONICAL_96_MODERATE_SIGNAL_MIN_ORIGINAL_SPATIAL = 0.4;
+const CANONICAL_96_MODERATE_SIGNAL_MIN_ORIGINAL_GRADIENT = 0.1;
+const CANONICAL_96_MODERATE_SIGNAL_MAX_CURRENT_SPATIAL = 0.26;
+const CANONICAL_96_MODERATE_SIGNAL_MAX_CURRENT_GRADIENT = 0.04;
+const FULL_STRENGTH_NEW_MARGIN_MIN_ORIGINAL_GRADIENT = 0.08;
+const FULL_STRENGTH_NEW_MARGIN_MAX_CURRENT_GRADIENT = 0.1;
 const CANONICAL_96_POSITIVE_HALO_RESCUE_MIN_ORIGINAL_SPATIAL = 0.4;
 const CANONICAL_96_POSITIVE_HALO_RESCUE_MIN_ORIGINAL_GRADIENT = 0.3;
 const CANONICAL_96_POSITIVE_HALO_RESCUE_MAX_ABS_CURRENT_SPATIAL = 0.12;
@@ -3722,28 +3722,28 @@ function shouldSkipLocatedAggressiveForCleanCanonical96({
         return false;
     }
 
-    const cleanExactNewMarginVariant =
-        config?.logoSize === 96 &&
-        config.marginRight === 192 &&
+    const cleanExactNewMarginVariant =
+        config?.logoSize === 96 &&
+        config.marginRight === 192 &&
         config.marginBottom === 192 &&
         config.alphaVariant === '20260520' &&
         resolvedAlphaGain <= 1.3 &&
         originalSpatial >= 0.18 &&
         originalSpatial < 0.4 &&
         originalGradient >= 0.05 &&
-        originalGradient < 0.08;
-    if (cleanExactNewMarginVariant) return true;
-
-    const cleanFullStrengthNewMarginVariant =
-        config?.logoSize === 96 &&
-        config.marginRight === 192 &&
-        config.marginBottom === 192 &&
-        config.alphaVariant === '20260520' &&
-        resolvedAlphaGain === 1 &&
-        originalSpatial > 0 &&
-        originalGradient >= FULL_STRENGTH_NEW_MARGIN_MIN_ORIGINAL_GRADIENT &&
-        currentGradient <= FULL_STRENGTH_NEW_MARGIN_MAX_CURRENT_GRADIENT;
-    if (cleanFullStrengthNewMarginVariant) return true;
+        originalGradient < 0.08;
+    if (cleanExactNewMarginVariant) return true;
+
+    const cleanFullStrengthNewMarginVariant =
+        config?.logoSize === 96 &&
+        config.marginRight === 192 &&
+        config.marginBottom === 192 &&
+        config.alphaVariant === '20260520' &&
+        resolvedAlphaGain === 1 &&
+        originalSpatial > 0 &&
+        originalGradient >= FULL_STRENGTH_NEW_MARGIN_MIN_ORIGINAL_GRADIENT &&
+        currentGradient <= FULL_STRENGTH_NEW_MARGIN_MAX_CURRENT_GRADIENT;
+    if (cleanFullStrengthNewMarginVariant) return true;
 
     if (
         config?.logoSize !== 96 ||

package/src/sdk/node.d.ts

@@ -1,56 +1,56 @@
-import type { ImageDataRemovalResult, RemoveOptions, WatermarkMeta } from './index.js';
-export type {
-    VideoBufferRemovalOptions,
-    VideoBufferRemovalResult,
-    VideoFileRemovalOptions,
-    VideoFileRemovalResult,
-    VideoProcessingProgress,
-    VideoRemovalMeta
-} from './video.js';
-
-export interface NodeCodecContext {
-    mimeType: string;
-    filePath?: string;
-    meta?: WatermarkMeta;
-}
-
-export interface NodeBufferRemovalOptions extends Omit<RemoveOptions, 'engine'> {
-    mimeType?: string;
-    filePath?: string;
-    decodeImageData: (
-        input: Buffer | Uint8Array | ArrayBuffer,
-        context: NodeCodecContext
-    ) => Promise<ImageDataRemovalResult['imageData']> | ImageDataRemovalResult['imageData'];
-    encodeImageData: (
-        imageData: ImageDataRemovalResult['imageData'],
-        context: NodeCodecContext
-    ) => Promise<Buffer | Uint8Array | ArrayBuffer> | Buffer | Uint8Array | ArrayBuffer;
-}
-
-export interface NodeFileRemovalOptions extends NodeBufferRemovalOptions {
-    outputPath?: string | null;
-}
-
-export interface NodeBufferRemovalResult extends ImageDataRemovalResult {
-    buffer: Buffer;
-}
-
-export interface NodeFileRemovalResult extends NodeBufferRemovalResult {
-    outputPath: string | null;
-}
-
-export function inferMimeTypeFromPath(filePath: string): string;
-export function removeWatermarkFromBuffer(
-    inputBuffer: Buffer | Uint8Array | ArrayBuffer,
-    options: NodeBufferRemovalOptions
-): Promise<NodeBufferRemovalResult>;
-export function removeWatermarkFromFile(
-    inputPath: string,
-    options: NodeFileRemovalOptions
-): Promise<NodeFileRemovalResult>;
-export {
-    inferVideoMimeTypeFromPath,
-    isVideoMimeType,
-    removeVideoWatermarkFromBuffer,
-    removeVideoWatermarkFromFile
-} from './video.js';
+import type { ImageDataRemovalResult, RemoveOptions, WatermarkMeta } from './index.js';
+export type {
+    VideoBufferRemovalOptions,
+    VideoBufferRemovalResult,
+    VideoFileRemovalOptions,
+    VideoFileRemovalResult,
+    VideoProcessingProgress,
+    VideoRemovalMeta
+} from './video.js';
+
+export interface NodeCodecContext {
+    mimeType: string;
+    filePath?: string;
+    meta?: WatermarkMeta;
+}
+
+export interface NodeBufferRemovalOptions extends Omit<RemoveOptions, 'engine'> {
+    mimeType?: string;
+    filePath?: string;
+    decodeImageData: (
+        input: Buffer | Uint8Array | ArrayBuffer,
+        context: NodeCodecContext
+    ) => Promise<ImageDataRemovalResult['imageData']> | ImageDataRemovalResult['imageData'];
+    encodeImageData: (
+        imageData: ImageDataRemovalResult['imageData'],
+        context: NodeCodecContext
+    ) => Promise<Buffer | Uint8Array | ArrayBuffer> | Buffer | Uint8Array | ArrayBuffer;
+}
+
+export interface NodeFileRemovalOptions extends NodeBufferRemovalOptions {
+    outputPath?: string | null;
+}
+
+export interface NodeBufferRemovalResult extends ImageDataRemovalResult {
+    buffer: Buffer;
+}
+
+export interface NodeFileRemovalResult extends NodeBufferRemovalResult {
+    outputPath: string | null;
+}
+
+export function inferMimeTypeFromPath(filePath: string): string;
+export function removeWatermarkFromBuffer(
+    inputBuffer: Buffer | Uint8Array | ArrayBuffer,
+    options: NodeBufferRemovalOptions
+): Promise<NodeBufferRemovalResult>;
+export function removeWatermarkFromFile(
+    inputPath: string,
+    options: NodeFileRemovalOptions
+): Promise<NodeFileRemovalResult>;
+export {
+    inferVideoMimeTypeFromPath,
+    isVideoMimeType,
+    removeVideoWatermarkFromBuffer,
+    removeVideoWatermarkFromFile
+} from './video.js';

package/src/sdk/video.d.ts

@@ -1,24 +1,24 @@
-export interface VideoRemovalMeta {
+export interface VideoRemovalMeta {
     status?: string;
     denoiseBackend?: string;
     actualDenoiseBackend?: string;
     actualControls?: Record<string, unknown>;
     pagePath?: string;
     [key: string]: unknown;
-}
-
-export interface VideoProcessingProgress {
-    tone: string;
-    status: string;
-    progressText: string;
-    progress: number | null;
-    phase: string | null;
-    processedFrames: number | null;
-    frameEstimate: number | null;
-    aiDenoiseFrames: number | null;
-    aiReuseFrames: number | null;
-    elapsedMs: number;
-}
+}
+
+export interface VideoProcessingProgress {
+    tone: string;
+    status: string;
+    progressText: string;
+    progress: number | null;
+    phase: string | null;
+    processedFrames: number | null;
+    frameEstimate: number | null;
+    aiDenoiseFrames: number | null;
+    aiReuseFrames: number | null;
+    elapsedMs: number;
+}
 
 export interface VideoFileProcessorContext {
     outputPath?: string | null;
@@ -32,10 +32,10 @@ export interface VideoFileProcessorContext {
     residualCleanupStrength?: number;
     videoBitrate?: number;
     adaptiveAlpha?: boolean;
-    alphaGain?: number;
-    alphaProfile?: string;
-    onProgress?: (progress: VideoProcessingProgress) => void;
-}
+    alphaGain?: number;
+    alphaProfile?: string;
+    onProgress?: (progress: VideoProcessingProgress) => void;
+}
 
 export interface VideoBufferProcessorContext extends Omit<VideoFileProcessorContext, 'filePath'> {
     filePath?: string;
@@ -57,10 +57,10 @@ export interface VideoFileRemovalOptions {
     residualCleanupStrength?: number;
     videoBitrate?: number;
     adaptiveAlpha?: boolean;
-    alphaGain?: number;
-    alphaProfile?: string;
-    onProgress?: (progress: VideoProcessingProgress) => void;
-    processVideoFile?: (
+    alphaGain?: number;
+    alphaProfile?: string;
+    onProgress?: (progress: VideoProcessingProgress) => void;
+    processVideoFile?: (
         inputPath: string,
         context: VideoFileProcessorContext
     ) => Promise<VideoProcessorResult> | VideoProcessorResult;

package/src/sdk/video.js

@@ -2,14 +2,14 @@ import path from 'node:path';
 import { createReadStream } from 'node:fs';
 import { createServer } from 'node:http';
 import { access, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import {
-    DEFAULT_VIDEO_TIMEOUT_MS,
-    configureVideoPageTimeouts,
-    waitForVideoProcessing
-} from './videoProgress.js';
-
-const DEFAULT_VIDEO_DENOISE_BACKEND = 'allenk-fdncnn-browser-spike';
+import { fileURLToPath } from 'node:url';
+import {
+    DEFAULT_VIDEO_TIMEOUT_MS,
+    configureVideoPageTimeouts,
+    waitForVideoProcessing
+} from './videoProgress.js';
+
+const DEFAULT_VIDEO_DENOISE_BACKEND = 'allenk-fdncnn-browser-spike';
 
 function normalizeBufferLike(value) {
     if (Buffer.isBuffer(value)) return value;
@@ -204,11 +204,11 @@ async function processVideoWithPreviewPage(inputPath, options = {}) {
         edgeDenoiseStrength,
         residualCleanupStrength,
         videoBitrate,
-        adaptiveAlpha = false,
-        alphaGain,
-        alphaProfile,
-        onProgress
-    } = options;
+        adaptiveAlpha = false,
+        alphaGain,
+        alphaProfile,
+        onProgress
+    } = options;
 
     if (!isHttpUrl(pagePath)) {
         await assertReadableFile(pagePath, 'Video preview page');
@@ -220,8 +220,8 @@ async function processVideoWithPreviewPage(inputPath, options = {}) {
     const browser = await chromium.launch({ headless: true });
     try {
         return await withLocalVideoPreviewPage(pagePath, async (pageUrl) => {
-            const page = await browser.newPage();
-            configureVideoPageTimeouts(page);
+            const page = await browser.newPage();
+            configureVideoPageTimeouts(page);
             await page.goto(pageUrl);
             await page.locator('#fileInput').setInputFiles(inputPath);
             await page.evaluate((value) => {
@@ -271,10 +271,10 @@ async function processVideoWithPreviewPage(inputPath, options = {}) {
             }
 
             await page.locator('#processBtn').click();
-            const { status, tone } = await waitForVideoProcessing(page, {
-                timeoutMs,
-                onProgress
-            });
+            const { status, tone } = await waitForVideoProcessing(page, {
+                timeoutMs,
+                onProgress
+            });
             if (tone !== 'success') {
                 throw new Error(status || 'Video export failed');
             }