@pilio/gemini-watermark-remover 1.0.20 → 1.0.21

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pilio/gemini-watermark-remover",
   "description": "Automatically removes watermarks from Gemini AI generated images",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [
@@ -45,6 +45,10 @@
       "types": "./src/sdk/node.d.ts",
       "import": "./src/sdk/node.js"
     },
+    "./video": {
+      "types": "./src/sdk/video.d.ts",
+      "import": "./src/sdk/video.js"
+    },
     "./runtime-browser": {
       "types": "./src/runtime/browser.d.ts",
       "import": "./src/runtime/browser.js"
@@ -65,10 +69,14 @@
   "devDependencies": {
     "@types/node": "^24.6.0",
     "esbuild": "^0.24.0",
+    "onnxruntime-web": "^1.26.0",
     "playwright": "^1.58.2",
     "sharp": "^0.34.5",
     "typescript": "^5.9.3"
   },
+  "dependencies": {
+    "mediabunny": "^1.46.0"
+  },
   "scripts": {
     "dev": "node build.js",
     "build": "node build.js --prod",
@@ -84,12 +92,69 @@
     "probe:real-page:compare": "node scripts/real-page-pixel-compare.js",
     "benchmark:samples": "node scripts/sample-benchmark.js",
     "benchmark:userscript": "node scripts/userscript-benchmark.js",
+    "compare:allenk-v2": "node scripts/create-allenk-v2-comparison-report.js",
+    "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",
+    "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",
+    "visible-residual:create-gold-manifest": "node scripts/create-visible-residual-gold-manifest.js",
+    "visible-residual:review-status": "node scripts/report-visible-residual-review-progress.js",
+    "visible-residual:apply-focused-batch": "node scripts/apply-visible-residual-focused-review-batch.js",
+    "visible-residual:review-worksheet": "node scripts/create-visible-residual-review-worksheet.js",
+    "visible-residual:admission-report": "node scripts/create-visible-residual-admission-report.js",
+    "visible-residual:goal-audit": "node scripts/create-visible-residual-goal-audit-report.js",
+    "visible-residual:cluster-report": "node scripts/create-visible-residual-cluster-report.js",
+    "visible-residual:geometry-audit": "node scripts/audit-visible-residual-geometry.js",
     "scan:sample-watermarks": "node scripts/scan-sample-watermarks.js",
     "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",
+    "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",
+    "lab:video-frames": "node scripts/run-video-frame-backend-lab.js",
+    "lab:allenk-fdncnn-onnx-frames": "node scripts/run-allenk-fdncnn-onnx-frame-lab.js",
+    "lab:video-alpha-profile": "node scripts/run-video-alpha-profile-lab.js",
+    "lab:video-temporal-residual": "node scripts/run-video-temporal-residual-lab.js",
+    "fit:video-alpha-shape": "node scripts/fit-video-alpha-shape.js",
+    "gate:video-alpha-shape": "node scripts/gate-video-alpha-shape-candidates.js",
+    "gate:video-denoise": "node scripts/gate-video-denoise-candidates.js",
+    "gate:video-delivery": "node scripts/run-video-delivery-gate.js",
+    "report:video-alpha-policy-evidence": "node scripts/create-video-alpha-policy-evidence-report.js",
+    "report:video-frame-lab": "node scripts/report-video-frame-lab-sweep.js",
+    "report:video-review-pack": "node scripts/create-video-review-pack.js",
+    "report:video-review-index": "node scripts/create-video-review-index.js",
+    "report:video-review-screenshot": "node scripts/create-video-review-screenshot.js",
+    "report:video-review-thumbnail-sheet": "node scripts/create-video-review-thumbnail-sheet.js",
+    "report:video-dashboard-screenshot": "node scripts/create-video-review-screenshot.js --html .artifacts/video-delivery-dashboard/latest-video-dashboard.html --output .artifacts/video-delivery-dashboard/latest-video-dashboard.png --report .artifacts/video-delivery-dashboard/latest-video-dashboard-screenshot.json",
+    "report:video-review-decision": "node scripts/create-video-review-decision-report.js",
+    "report:video-acceptance-quickstart": "node scripts/create-video-acceptance-quickstart.js",
+    "report:video-pending-review-decision": "node scripts/create-video-pending-review-decision.js",
+    "report:video-alpha-policy-review-pack": "node scripts/create-video-alpha-policy-review-pack.js",
+    "report:video-light-polish-review-pack": "node scripts/create-video-light-polish-review-pack.js",
+    "report:video-polish-sweep-review-pack": "node scripts/create-video-polish-sweep-review-pack.js",
+    "report:video-delivery-dashboard": "node scripts/create-video-delivery-dashboard.js",
+    "report:video-goal-status": "node scripts/create-video-goal-status-report.js",
+    "report:video-delivery-bundle": "node scripts/create-video-delivery-bundle.js",
+    "verify:video-delivery-bundle": "node scripts/verify-video-delivery-bundle.js",
+    "export:video-backend": "node scripts/export-video-backend-variant.js",
+    "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",
+    "export:video-ui-preset": "node scripts/export-video-ui-preset.js",
+    "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",
     "serve": "pnpm dlx serve dist",
     "export:samples": "node scripts/export-fixed-samples.js",
-    "calibrate:preview-alpha": "node scripts/calibrate-preview-alpha.js"
+    "calibrate:preview-alpha": "node scripts/calibrate-preview-alpha.js",
+    "extract:allenk-fdncnn": "node scripts/extract-allenk-fdncnn-model.js",
+    "export:allenk-fdncnn-onnx": "node scripts/export-allenk-fdncnn-onnx.js",
+    "smoke:allenk-fdncnn-onnx-runtime": "node scripts/smoke-allenk-fdncnn-onnx-runtime.js",
+    "report:allenk-fdncnn-browser-spike": "node scripts/create-allenk-fdncnn-browser-spike-report.js",
+    "report:allenk-fdncnn-runtime-seam": "node scripts/create-allenk-fdncnn-runtime-seam-report.js"
   }
 }

package/src/cli/gwrCli.js

@@ -2,7 +2,7 @@ import { runRemoveCommand } from './gwrRemoveCommand.js';
 
 export async function main(argv, io) {
   if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
-    io.stdout.write('Usage: gwr remove <input> [--output <file> | --out-dir <dir>] [--overwrite] [--json]\n');
+    io.stdout.write('Usage: gwr remove <input> [--output <file> | --out-dir <dir>] [--overwrite] [--json] [--video-page <url-or-file>]\n');
     return 0;
   }
 

package/src/cli/gwrRemoveCommand.js

@@ -1,10 +1,16 @@
 import path from 'node:path';
 import { mkdir, readdir, stat } from 'node:fs/promises';
 
-import { inferMimeTypeFromPath, removeWatermarkFromFile } from '../sdk/node.js';
+import {
+  inferMimeTypeFromPath,
+  inferVideoMimeTypeFromPath,
+  isVideoMimeType,
+  removeVideoWatermarkFromFile,
+  removeWatermarkFromFile
+} from '../sdk/node.js';
 
 const REMOVE_USAGE =
-  'Usage: gwr remove <input> [--output <file> | --out-dir <dir>] [--overwrite] [--json]';
+  'Usage: gwr remove <input> [--output <file> | --out-dir <dir>] [--overwrite] [--json] [--video-page <url-or-file>]';
 
 export async function runRemoveCommand(argv, io) {
   if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
@@ -18,15 +24,7 @@ export async function runRemoveCommand(argv, io) {
     return 2;
   }
 
-  const codec = await resolveCodecOptions(options).catch((error) => {
-    io.stderr.write(`${error.message}\n`);
-    return null;
-  });
-  if (!codec) {
-    return 2;
-  }
-
-  const commandOptions = { ...options, codec };
+  const commandOptions = { ...options, imageCodecPromise: null };
   const inputStats = await stat(commandOptions.input).catch(() => null);
   if (!inputStats) {
     io.stderr.write(`Input not found: ${commandOptions.input}\n`);
@@ -64,7 +62,11 @@ function parseRemoveArgs(argv) {
     overwrite: false,
     json: false,
     decoder: null,
-    encoder: null
+    encoder: null,
+    videoPage: null,
+    videoDenoiseBackend: null,
+    videoTimeoutMs: null,
+    allowLowConfidence: false
   };
 
   let parseOptions = true;
@@ -116,6 +118,30 @@ function parseRemoveArgs(argv) {
       continue;
     }
 
+    if (token === '--video-page') {
+      const parsed = parseOptionValue(argv, index, '--video-page');
+      if (!parsed.ok) return parsed;
+      options.videoPage = parsed.value;
+      index = parsed.index;
+      continue;
+    }
+
+    if (token === '--video-denoise-backend') {
+      const parsed = parseOptionValue(argv, index, '--video-denoise-backend');
+      if (!parsed.ok) return parsed;
+      options.videoDenoiseBackend = parsed.value;
+      index = parsed.index;
+      continue;
+    }
+
+    if (token === '--video-timeout-ms') {
+      const parsed = parseOptionValue(argv, index, '--video-timeout-ms');
+      if (!parsed.ok) return parsed;
+      options.videoTimeoutMs = Number(parsed.value);
+      index = parsed.index;
+      continue;
+    }
+
     if (token === '--overwrite') {
       options.overwrite = true;
       continue;
@@ -126,6 +152,11 @@ function parseRemoveArgs(argv) {
       continue;
     }
 
+    if (token === '--allow-low-confidence') {
+      options.allowLowConfidence = true;
+      continue;
+    }
+
     return { ok: false, error: `Unknown option: ${token}` };
   }
 
@@ -145,6 +176,10 @@ function parseRemoveArgs(argv) {
     return { ok: false, error: '--decoder and --encoder must be used together.' };
   }
 
+  if (options.videoTimeoutMs !== null && (!Number.isFinite(options.videoTimeoutMs) || options.videoTimeoutMs <= 0)) {
+    return { ok: false, error: '--video-timeout-ms must be a positive number.' };
+  }
+
   return options;
 }
 
@@ -301,17 +336,50 @@ async function processOneFile(inputPath, outputPath, options) {
   }
 
   await mkdir(path.dirname(outputPath), { recursive: true });
+  if (isVideoPath(inputPath) || isVideoPath(outputPath)) {
+    const result = await removeVideoWatermarkFromFile(inputPath, {
+      outputPath,
+      mimeType: inferVideoMimeTypeFromPath(outputPath || inputPath),
+      pagePath: options.videoPage || undefined,
+      denoiseBackend: options.videoDenoiseBackend || undefined,
+      timeoutMs: Number.isFinite(options.videoTimeoutMs) && options.videoTimeoutMs > 0
+        ? options.videoTimeoutMs
+        : undefined,
+      allowLowConfidence: options.allowLowConfidence
+    });
+
+    return {
+      input: inputPath,
+      output: outputPath,
+      kind: 'video',
+      meta: result.meta
+    };
+  }
+
+  const codec = await getImageCodec(options);
   const mimeType = inferMimeTypeFromPath(outputPath);
   const result = await removeWatermarkFromFile(inputPath, {
     outputPath,
     mimeType,
-    decodeImageData: options.codec.decodeImageData,
-    encodeImageData: options.codec.encodeImageData
+    decodeImageData: codec.decodeImageData,
+    encodeImageData: codec.encodeImageData
   });
 
   return {
     input: inputPath,
     output: outputPath,
+    kind: 'image',
     meta: result.meta
   };
 }
+
+function isVideoPath(filePath) {
+  return isVideoMimeType(inferVideoMimeTypeFromPath(filePath));
+}
+
+async function getImageCodec(options) {
+  if (!options.imageCodecPromise) {
+    options.imageCodecPromise = resolveCodecOptions(options);
+  }
+  return options.imageCodecPromise;
+}

package/src/core/adaptiveDetector.js

@@ -7,6 +7,8 @@ import { resolveGeminiWatermarkSearchConfigs } from './geminiSizeCatalog.js';
 
 const DEFAULT_THRESHOLD = 0.35;
 const EPSILON = 1e-8;
+const REFERENCE_WATERMARK_SIZE = 96;
+const MIN_COARSE_ADJUSTED_SCORE = 0.08;
 
 const clamp = (v, min, max) => Math.max(min, Math.min(max, v));
 
@@ -172,6 +174,23 @@ function createScaleList(minSize, maxSize) {
     return [...set].sort((a, b) => a - b);
 }
 
+export function computeSizeAdjustedConfidence(confidence, size, referenceSize = REFERENCE_WATERMARK_SIZE) {
+    if (
+        !Number.isFinite(confidence) ||
+        !Number.isFinite(size) ||
+        !Number.isFinite(referenceSize) ||
+        size <= 0 ||
+        referenceSize <= 0
+    ) {
+        return 0;
+    }
+
+    // NCC tends to favor tiny templates. A cube-root penalty keeps that bias in
+    // check without crushing legitimate preview-tier watermarks.
+    const sizeWeight = Math.min(1, Math.cbrt(size / referenceSize));
+    return confidence * sizeWeight;
+}
+
 function buildSeedConfigs(width, height, defaultConfig) {
     // Start adaptive search from both the coarse default anchor and any
     // catalog-projected anchors for official or near-official Gemini sizes.
@@ -407,7 +426,7 @@ export function detectAdaptiveWatermarkRegion({
             size: seedCandidate.size,
             x: seedCandidate.x,
             y: seedCandidate.y,
-            adjustedScore: seedCandidate.confidence * Math.min(1, Math.sqrt(seedCandidate.size / 96))
+            adjustedScore: computeSizeAdjustedConfidence(seedCandidate.confidence, seedCandidate.size)
         });
     }
 
@@ -424,8 +443,8 @@ export function detectAdaptiveWatermarkRegion({
                 if (!score) continue;
 
                 // Prefer sizes close to known watermark scales to avoid tiny-template bias.
-                const adjustedScore = score.confidence * Math.min(1, Math.sqrt(size / 96));
-                if (adjustedScore < 0.08) continue;
+                const adjustedScore = computeSizeAdjustedConfidence(score.confidence, size);
+                if (adjustedScore < MIN_COARSE_ADJUSTED_SCORE) continue;
 
                 pushTopK({
                     size,

package/src/core/allenkFdncnnDenoise.js

@@ -0,0 +1,326 @@
+import { createAlphaGradientMask } from './alphaGradientMask.js';
+
+const ALLENK_FDNCNN_MODEL = Object.freeze({
+    name: 'FDnCNN Color FP16',
+    upstream: 'allenk/GeminiWatermarkTool',
+    license: 'MIT',
+    runtime: 'NCNN',
+    inputBlob: 0,
+    outputBlob: 20,
+    inputLayout: '[R, G, B, sigma] CHW float32',
+    outputLayout: '[R, G, B] CHW float32',
+    defaultSigma: 25,
+    defaultStrength: 0.85,
+    defaultPadding: 16,
+    maxSigma: 150,
+    maxStrength: 3
+});
+
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+
+function createGaussianKernel(sigma, radius = Math.ceil(sigma * 3)) {
+    const safeSigma = Math.max(0.01, sigma);
+    const safeRadius = Math.max(1, Math.round(radius));
+    const kernel = new Float32Array(safeRadius * 2 + 1);
+    let sum = 0;
+
+    for (let i = -safeRadius; i <= safeRadius; i++) {
+        const value = Math.exp(-(i * i) / (2 * safeSigma * safeSigma));
+        kernel[i + safeRadius] = value;
+        sum += value;
+    }
+
+    for (let i = 0; i < kernel.length; i++) {
+        kernel[i] /= sum;
+    }
+
+    return { kernel, radius: safeRadius };
+}
+
+function gaussianBlurFloatMap(source, width, height, sigma, radius = Math.ceil(sigma * 3)) {
+    if (!source || width <= 0 || height <= 0 || !Number.isFinite(sigma) || sigma <= 0) {
+        return new Float32Array(source || 0);
+    }
+
+    const { kernel, radius: r } = createGaussianKernel(sigma, radius);
+    const temp = new Float32Array(source.length);
+    const output = new Float32Array(source.length);
+
+    for (let y = 0; y < height; y++) {
+        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);
+                sum += source[y * width + xx] * kernel[dx + r];
+            }
+            temp[y * width + x] = sum;
+        }
+    }
+
+    for (let y = 0; y < height; y++) {
+        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);
+                sum += temp[yy * width + x] * kernel[dy + r];
+            }
+            output[y * width + x] = sum;
+        }
+    }
+
+    return output;
+}
+
+function inferSquareSize(alphaMap) {
+    const size = Math.round(Math.sqrt(alphaMap?.length || 0));
+    return size > 0 && size * size === alphaMap.length ? size : 0;
+}
+
+function resizeSquareAlphaMapArea(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 yStart = y * scaleY;
+        const yEnd = (y + 1) * scaleY;
+        const y0 = Math.floor(yStart);
+        const y1 = Math.ceil(yEnd);
+
+        for (let x = 0; x < targetWidth; x++) {
+            const xStart = x * scaleX;
+            const xEnd = (x + 1) * scaleX;
+            const x0 = Math.floor(xStart);
+            const x1 = Math.ceil(xEnd);
+
+            let sum = 0;
+            let areaSum = 0;
+            for (let sy = y0; sy < y1; sy++) {
+                if (sy < 0 || sy >= sourceSize) continue;
+                const wy = Math.max(0, Math.min(yEnd, sy + 1) - Math.max(yStart, sy));
+                for (let sx = x0; sx < x1; sx++) {
+                    if (sx < 0 || sx >= sourceSize) continue;
+                    const wx = Math.max(0, Math.min(xEnd, sx + 1) - Math.max(xStart, sx));
+                    const area = wx * wy;
+                    sum += sourceAlpha[sy * sourceSize + sx] * area;
+                    areaSum += area;
+                }
+            }
+
+            output[y * targetWidth + x] = areaSum > 0 ? sum / areaSum : 0;
+        }
+    }
+
+    return output;
+}
+
+function normalizeAllenkFdncnnOptions(options = {}) {
+    const sigma = Number.isFinite(options.sigma)
+        ? clamp(options.sigma, 0, ALLENK_FDNCNN_MODEL.maxSigma)
+        : ALLENK_FDNCNN_MODEL.defaultSigma;
+    const strength = Number.isFinite(options.strength)
+        ? clamp(options.strength, 0, ALLENK_FDNCNN_MODEL.maxStrength)
+        : ALLENK_FDNCNN_MODEL.defaultStrength;
+    const padding = Number.isFinite(options.padding)
+        ? Math.max(0, Math.round(options.padding))
+        : ALLENK_FDNCNN_MODEL.defaultPadding;
+
+    return { sigma, strength, padding };
+}
+
+function createAllenkGradientMask({
+    alphaMap,
+    width,
+    height = width,
+    strength = ALLENK_FDNCNN_MODEL.defaultStrength
+} = {}) {
+    const sourceSize = inferSquareSize(alphaMap);
+    const resizedAlphaMap = sourceSize > 0
+        ? resizeSquareAlphaMapArea(alphaMap, sourceSize, width, height)
+        : alphaMap;
+
+    return createAlphaGradientMask({
+        alphaMap: resizedAlphaMap,
+        width,
+        height,
+        strength,
+        gamma: 0.5,
+        dilateRadius: 2,
+        blurSigma: 2
+    });
+}
+
+function calculateAllenkPaddedRoi({ imageWidth, imageHeight, region, padding = ALLENK_FDNCNN_MODEL.defaultPadding } = {}) {
+    if (!region || imageWidth <= 0 || imageHeight <= 0 || region.width <= 0 || region.height <= 0) {
+        return null;
+    }
+
+    const safePadding = Math.max(0, Math.round(padding));
+    const x = clamp(Math.round(region.x - safePadding), 0, imageWidth);
+    const y = clamp(Math.round(region.y - safePadding), 0, imageHeight);
+    const right = clamp(Math.round(region.x + region.width + safePadding), 0, imageWidth);
+    const bottom = clamp(Math.round(region.y + region.height + safePadding), 0, imageHeight);
+    const width = right - x;
+    const height = bottom - y;
+
+    if (width < 4 || height < 4) 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)
+        }
+    };
+}
+
+function embedAllenkRoiWeights({ roiWeights, roiWidth, roiHeight, paddedRoi, blurSigma = 1 } = {}) {
+    if (!roiWeights || !paddedRoi?.inner || roiWidth <= 0 || roiHeight <= 0) {
+        return new Float32Array(0);
+    }
+
+    const weights = new Float32Array(paddedRoi.width * paddedRoi.height);
+    const inner = paddedRoi.inner;
+
+    for (let y = 0; y < roiHeight; y++) {
+        const py = inner.y + y;
+        if (py < 0 || py >= paddedRoi.height) continue;
+
+        for (let x = 0; x < roiWidth; x++) {
+            const px = inner.x + x;
+            if (px < 0 || px >= paddedRoi.width) continue;
+            weights[py * paddedRoi.width + px] = clamp(roiWeights[y * roiWidth + x] || 0, 0, 1);
+        }
+    }
+
+    return gaussianBlurFloatMap(weights, paddedRoi.width, paddedRoi.height, blurSigma);
+}
+
+function buildAllenkFdncnnInput({ imageData, sigma = ALLENK_FDNCNN_MODEL.defaultSigma } = {}) {
+    if (!imageData?.data || imageData.width <= 0 || imageData.height <= 0) {
+        return new Float32Array(0);
+    }
+
+    const { width, height, data } = imageData;
+    const pixelCount = width * height;
+    const input = new Float32Array(pixelCount * 4);
+    const sigmaNorm = clamp(sigma, 0, ALLENK_FDNCNN_MODEL.maxSigma) / 255;
+    const stride = data.length >= pixelCount * 4 ? 4 : 3;
+
+    for (let i = 0; i < pixelCount; i++) {
+        const src = i * stride;
+        input[i] = (data[src] || 0) / 255;
+        input[pixelCount + i] = (data[src + 1] || 0) / 255;
+        input[pixelCount * 2 + i] = (data[src + 2] || 0) / 255;
+        input[pixelCount * 3 + i] = sigmaNorm;
+    }
+
+    return input;
+}
+
+function convertAllenkFdncnnOutputToRgba({ output, width, height, alpha = 255 } = {}) {
+    if (!output || width <= 0 || height <= 0) {
+        return new Uint8ClampedArray(0);
+    }
+
+    const pixelCount = width * height;
+    const rgba = new Uint8ClampedArray(pixelCount * 4);
+
+    for (let i = 0; i < pixelCount; i++) {
+        rgba[i * 4] = Math.round(clamp(output[i] || 0, 0, 1) * 255);
+        rgba[i * 4 + 1] = Math.round(clamp(output[pixelCount + i] || 0, 0, 1) * 255);
+        rgba[i * 4 + 2] = Math.round(clamp(output[pixelCount * 2 + i] || 0, 0, 1) * 255);
+        rgba[i * 4 + 3] = alpha;
+    }
+
+    return rgba;
+}
+
+function getLocalMeanRgb(data, width, height, x, y, channel) {
+    let sum = 0;
+    let count = 0;
+    for (let dy = -1; dy <= 1; dy++) {
+        const yy = y + dy;
+        if (yy < 0 || yy >= height) continue;
+        for (let dx = -1; dx <= 1; dx++) {
+            const xx = x + dx;
+            if (xx < 0 || xx >= width) continue;
+            sum += data[(yy * width + xx) * 4 + channel];
+            count++;
+        }
+    }
+    return count > 0 ? sum / count : data[(y * width + x) * 4 + channel];
+}
+
+function blendAllenkDenoisedRoi({
+    originalData,
+    denoisedData,
+    weights,
+    width = 0,
+    height = 0,
+    preserveHighpassStrength = 0
+} = {}) {
+    if (!originalData || !denoisedData || !weights || originalData.length !== denoisedData.length) {
+        return new Uint8ClampedArray(originalData || 0);
+    }
+
+    const output = new Uint8ClampedArray(originalData);
+    const pixelCount = Math.min(weights.length, Math.floor(originalData.length / 4));
+    const canPreserveHighpass = (
+        Number.isFinite(preserveHighpassStrength) &&
+        preserveHighpassStrength > 0 &&
+        Number.isFinite(width) &&
+        Number.isFinite(height) &&
+        width > 0 &&
+        height > 0 &&
+        width * height <= pixelCount
+    );
+
+    for (let pixel = 0; pixel < pixelCount; pixel++) {
+        const weight = clamp(weights[pixel] || 0, 0, 1);
+        if (weight <= 0) continue;
+
+        const idx = pixel * 4;
+        const x = canPreserveHighpass ? pixel % width : 0;
+        const y = canPreserveHighpass ? Math.floor(pixel / width) : 0;
+        const highpassGain = canPreserveHighpass
+            ? Math.min(0.28, weight * preserveHighpassStrength)
+            : 0;
+        for (let c = 0; c < 3; c++) {
+            const blended = (
+                originalData[idx + c] * (1 - weight) + denoisedData[idx + c] * weight
+            );
+            const highpass = highpassGain > 0
+                ? clamp(originalData[idx + c] - getLocalMeanRgb(originalData, width, height, x, y, c), -14, 14)
+                : 0;
+            output[idx + c] = Math.round(clamp(blended + highpass * highpassGain, 0, 255));
+        }
+    }
+
+    return output;
+}
+
+export {
+    ALLENK_FDNCNN_MODEL,
+    blendAllenkDenoisedRoi,
+    buildAllenkFdncnnInput,
+    calculateAllenkPaddedRoi,
+    convertAllenkFdncnnOutputToRgba,
+    createAllenkGradientMask,
+    embedAllenkRoiWeights,
+    normalizeAllenkFdncnnOptions
+};