Delete every knob the fixed profiles cannot honor

The CLI still advertised --model, --steps, --guidance-scale, --device and a
deprecated --auto. Each pinned a value the two surviving profiles fix -- the
model stack, the per-stage distilled schedule, CFG 1.0, CUDA -- so the only
outcome any of them had was an error raised several frames below the caller,
under a message naming an internal profile. A flag whose sole result is a
refusal is worse than no flag: it advertises a capability that does not exist,
and it lets a wrapper thread a value that will silently do nothing. They are
gone from the parser, from InvisibleEngine, and from WatermarkRemover, so the
failure is now a TypeError or a Click "No such option" at the point the caller
can act on.

The install hint was wrong in the same way. is_available() checked torch and
diffusers, then told the user to install [diffusion] -- which contains neither
DiffSynth nor the Z-Image face stage both profiles run. Following the advice
produced a second, different failure. The module list and the extra name now
live once in watermark_profiles (REMOVAL_MODULES, INVISIBLE_EXTRA) and are read
by both the CLI gate and the remover's precondition, which cannot drift apart
because they are the same tuple.

The adaptive-polish default moved out of the argument parser. It was resolved by
reading Click's parameter source, which put per-profile data in the CLI layer,
left the engine declaring the opposite default (False vs True) so a library
caller and a CLI caller on one profile got different output, and lost the polish
entirely for anything that supplies the flag non-interactively. The flag is now
tri-state (default=None) and resolve_adaptive_polish owns the per-profile
answer. The seed follows the same rule: the CLI stopped pre-resolving it.

Dead code removed with it: six scan_*_video wrappers and the _scan_video helper
none of them had a caller for, PNG_METADATA_KEYS, feather_region_composite and
the remover region path that was only reachable from a no-caller convenience
wrapper, remove_watermark_batch on both layers, try_empty_device_cache, the
_generate/_run_qwen_zimage pass-through pair, self.model_id, and the _internal
PEP 562 shim that no caller ever went through. get_device now answers cuda or
cpu only: mps and xpu travelled one frame to the same CUDA-only refusal while
costing a device probe each, and that refusal now names the resolved device, so
device=None on a CUDA-less host says 'cpu' rather than 'None'. The XPU wheel
index went with them.

Docs: README, cli, installation, python-api, supported-signals,
known-limitations and module-internals all still described the removed profiles,
the CPU/MPS/XPU ladder, a `default`->`sdxl` alias, and the wrong extra.
known-limitations still listed the retired SDXL strength ladder as current.
scripts/smoke_matrix.py and real_examples_e2e.py drove --device mps.

Next release is 0.25.0, not a patch: this removes public parameters and
narrows a published extra on top of the released 0.24.0.

pre-commit: 1) maintain.sh - exit 0 (1091 tests, Pyright 0 errors, no
vulnerabilities); 2) /simplify - 4 agents, 11 findings applied, 2 skipped
(dropping the `device` parameter entirely, which raiw-app pins; folding
diffsynth into the `diffusion` extra, which video-only callers do not need);
3) docs sync - grepped every removed identifier across README, docs/, scripts/,
.claude/; updated 9 docs; 4) CLAUDE.md - added the no-error-only-knobs rule to
.claude/rules/development.md

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/remove_ai_watermarks/_internal/__init__.py

@@ -1,36 +1,15 @@
-"""Compatibility namespace for metadata and regeneration helpers.
+"""Private namespace for metadata parsing and regeneration internals.
 
-The public API (``WatermarkRemover`` / ``remove_watermark`` / ``remove_ai_metadata``)
-is exposed **lazily** via PEP 562 ``__getattr__``: importing a light submodule
-(e.g. ``_internal.c2pa`` / ``_internal.constants`` from ``identify``) must NOT eagerly pull
-``watermark_remover``, which imports torch + diffusers at module top. Keeping this
-lazy is what lets ``import remove_ai_watermarks.identify`` stay cheap (~36 MB, no
-torch) even in a full install where the ``diffusion`` extra is present --
-otherwise the mere presence of torch in the env inflated identify to ~420 MB and
-risked OOM on a 512 MB host.
+Deliberately empty. It carried a PEP 562 ``__getattr__`` re-exporting
+``WatermarkRemover`` and ``remove_ai_metadata`` as a "compatibility namespace",
+but nothing ever reached for either through this package -- every caller imports
+the submodule directly. The laziness it defended is real and still enforced, just
+elsewhere: importing a light submodule (``_internal.c2pa`` / ``_internal.constants``
+from ``identify``) must not pull ``watermark_remover``, which imports torch at
+module top. That property comes from those direct submodule imports, not from a
+shim here; a re-export in this file would be the one thing that could break it.
+
+Keep this module free of imports. ``import remove_ai_watermarks.identify`` stays
+around 36 MB even in a full install where torch is present; routing anything heavy
+through here inflated it to roughly 420 MB and risked OOM on a 512 MB host.
 """
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from remove_ai_watermarks._internal.watermark_remover import WatermarkRemover, remove_watermark
-    from remove_ai_watermarks.metadata import remove_ai_metadata
-
-__all__ = ["WatermarkRemover", "remove_ai_metadata", "remove_watermark"]
-
-
-def __getattr__(name: str) -> object:
-    """Resolve the public API on first access (PEP 562), not at package import."""
-    if name == "remove_ai_metadata":
-        # Re-export the single, robust stripper (byte-level, lossless-for-JPEG, all
-        # containers); the old legacy metadata helper implementation is retired.
-        from remove_ai_watermarks.metadata import remove_ai_metadata
-
-        return remove_ai_metadata
-    if name in ("WatermarkRemover", "remove_watermark"):
-        from remove_ai_watermarks._internal import watermark_remover
-
-        return getattr(watermark_remover, name)
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/remove_ai_watermarks/_internal/constants.py

@@ -14,9 +14,6 @@ AI_METADATA_KEYS = _tokens(
     "parameters|postprocessing|extras|workflow|prompt|Dream|SD:mode|StableDiffusionVersion|"
     "generation_time|Model|Model hash|Seed"
 )
-PNG_METADATA_KEYS = _tokens(
-    "Author|Title|Description|Copyright|Creation Time|Software|Disclaimer|Warning|Source|Comment"
-)
 AI_KEYWORDS = _tokens(
     "prompt|negative_prompt|sampler|cfg_scale|lora|diffusion|comfy|midjourney|dall-e|dalle|imagen|firefly|c2pa|chatgpt|gpt-4|sora|openai|truepic|stable_diffusion|invokeai"
 )

src/remove_ai_watermarks/_internal/sdxl_zimage_pipeline.py

@@ -30,9 +30,9 @@ from remove_ai_watermarks._internal.qwen_zimage_pipeline import (
 )
 from remove_ai_watermarks._internal.watermark_profiles import (
     CONTROLNET_CANNY_MODEL,
-    DEFAULT_MODEL_ID,
     SDXL_LIGHTNING_MODEL_ID,
     SDXL_LIGHTNING_PATTERN,
+    SDXL_MODEL_ID,
 )
 
 log = logging.getLogger(__name__)
@@ -88,7 +88,7 @@ class SdxlZImagePipeline(QwenZImagePipeline):
         controlnet = ControlNetModel.from_pretrained(CONTROLNET_CANNY_MODEL, torch_dtype=torch.float16, **token)
         vae = AutoencoderKL.from_pretrained(SDXL_VAE_MODEL_ID, torch_dtype=torch.float16, **token)
         pipe = StableDiffusionXLControlNetImg2ImgPipeline.from_pretrained(
-            DEFAULT_MODEL_ID,
+            SDXL_MODEL_ID,
             controlnet=controlnet,
             vae=vae,
             torch_dtype=torch.float16,

src/remove_ai_watermarks/_internal/tiling.py

@@ -1,11 +1,11 @@
 """Sliding-window tiled diffusion for large images.
 
-The img2img / ControlNet pipeline denoises the WHOLE image in one forward pass,
-so it OOMs on MPS/GPU above ~2K (issue #10). Tiling splits the image into
-overlapping tiles -- each kept near SDXL's ~1024 training size -- regenerates
-each tile independently, and feather-blends the overlaps. The result retains the
-input's native dimensions without an explicit ``--max-resolution`` downscale, but
-it is not pixel-lossless because every tile is regenerated.
+The global stage denoises the WHOLE image in one forward pass, so it OOMs on a
+GPU above ~2K (issue #10). Tiling splits the image into overlapping tiles -- each
+kept near the ~1024 training size -- regenerates each tile independently, and
+feather-blends the overlaps. The result retains the input's native dimensions
+without an explicit ``--max-resolution`` downscale, but it is not pixel-lossless
+because every tile is regenerated.
 
 The geometry (``plan_tiles``) and the blend weighting (``feather_weights``) are
 pure functions, unit-tested without the diffusion model. ``run_tiled`` is the
@@ -100,59 +100,6 @@ def feather_weights(width: int, height: int, overlap: int) -> NDArray[Any]:
     return weights
 
 
-def feather_region_composite(
-    base: NDArray[Any],
-    regenerated: NDArray[Any],
-    box: tuple[int, int, int, int],
-    *,
-    feather: int = 64,
-) -> NDArray[Any]:
-    """Composite ``regenerated`` over ``base`` inside ``box`` only, feathering the seam.
-
-    For AI-ENHANCED composites (digitalSourceType ``compositeWithTrainedAlgorithmicMedia``):
-    the diffusion remover regenerates the whole frame, but only the AI-composited
-    REGION should change -- the rest is a real photo that must be preserved. This
-    blends the regenerated pixels in over ``box = (x, y, w, h)`` with a separable
-    linear taper of ``feather`` px at the box edges, so the result equals ``base``
-    EXACTLY outside the box and ramps smoothly (no hard seam) at the boundary.
-
-    Pure and model-free (unit-tested): ``base`` and ``regenerated`` must be the same
-    shape (H x W, or H x W x C). The output preserves ``base``'s dtype. ``feather`` is
-    clamped to half the box on each axis, so a small region still tapers symmetrically;
-    ``feather=0`` is a hard-edged paste.
-    """
-    import numpy as np
-
-    if base.shape != regenerated.shape:
-        raise ValueError(f"shape mismatch: base {base.shape} vs regenerated {regenerated.shape}")
-    h, w = base.shape[:2]
-    x, y, bw, bh = box
-    x0, y0 = max(0, x), max(0, y)
-    x1, y1 = min(w, x + bw), min(h, y + bh)
-    out = base.copy()
-    if x1 <= x0 or y1 <= y0:
-        return out  # empty / off-image box -> nothing regenerated
-
-    def taper(n: int) -> NDArray[Any]:
-        win = np.ones(n, dtype=np.float32)
-        f = min(max(feather, 0), n // 2)
-        if f > 0:
-            ramp = (np.arange(f, dtype=np.float32) + 1.0) / (f + 1.0)  # in (0, 1), 0 at the edge
-            win[:f] = ramp
-            win[n - f :] = ramp[::-1]
-        return win
-
-    rh, rw = y1 - y0, x1 - x0
-    wmap = np.outer(taper(rh), taper(rw))  # ~0 at the box edge, 1 in the interior
-    if base.ndim == 3:
-        wmap = wmap[:, :, None]
-    roi_base = base[y0:y1, x0:x1].astype(np.float32)
-    roi_gen = regenerated[y0:y1, x0:x1].astype(np.float32)
-    blended = roi_base * (1.0 - wmap) + roi_gen * wmap
-    out[y0:y1, x0:x1] = np.clip(blended, 0, 255).astype(base.dtype)
-    return out
-
-
 def run_tiled(
     generate_tile: Callable[[PILImage.Image], PILImage.Image],
     image: PILImage.Image,

src/remove_ai_watermarks/_internal/watermark_profiles.py

@@ -17,8 +17,10 @@ if TYPE_CHECKING:
     from pathlib import Path
 
 # SDXL base is no longer a profile of its own, but it is still the global stage of
-# sdxl-zimage, so the checkpoint id stays.
-DEFAULT_MODEL_ID = "stabilityai/stable-diffusion-xl-base-1.0"
+# sdxl-zimage, so the checkpoint id stays. Named for what it is rather than
+# ``DEFAULT_MODEL_ID``: there is no user-selectable model any more, so "default"
+# implied an override that both profiles reject.
+SDXL_MODEL_ID = "stabilityai/stable-diffusion-xl-base-1.0"
 CONTROLNET_CANNY_MODEL = "xinsir/controlnet-canny-sdxl-1.0"
 
 QWEN_ZIMAGE_PROFILE = "qwen-zimage"
@@ -26,14 +28,27 @@ SDXL_ZIMAGE_PROFILE = "sdxl-zimage"
 DEFAULT_PROFILE = QWEN_ZIMAGE_PROFILE
 PROFILE_CHOICES = (QWEN_ZIMAGE_PROFILE, SDXL_ZIMAGE_PROFILE)
 
+# The modules a real removal run needs, and the extra that installs them. Both live
+# here, in the only profile module that imports nothing heavy, because the CLI's
+# availability gate and the remover's own precondition must agree: when they drifted,
+# the CLI passed on a torch+diffusers environment and the run then died at the
+# DiffSynth face stage, telling the user to install an extra that does not contain it.
+REMOVAL_MODULES = ("torch", "diffusers", "diffsynth")
+INVISIBLE_EXTRA = "remove-ai-watermarks[qwen-zimage]"
+
+# qwen-zimage's output already matches the input's detail level, so polishing it is a
+# no-op at best. sdxl-zimage's global pass leaves the softer output the polish exists
+# for. This is per-profile data, not a CLI concern: the flag defaults to None so that
+# "the user did not choose" stays a value rather than an inference from Click state.
+PROFILE_ADAPTIVE_POLISH = {QWEN_ZIMAGE_PROFILE: False, SDXL_ZIMAGE_PROFILE: True}
+
 SDXL_LIGHTNING_MODEL_ID = "ByteDance/SDXL-Lightning"
 SDXL_LIGHTNING_PATTERN = "sdxl_lightning_4step_lora.safetensors"
 
-# Both profiles run the same distilled four-step schedule, and both are certified at a
-# fixed seed because SynthID removal near the strength floor is seed-dependent.
-PROFILE_STEPS = 4
+# Both profiles are certified at a fixed seed because SynthID removal near the
+# strength floor is seed-dependent. The step count and CFG are not settable at all --
+# each stage owns them (``GLOBAL_STEPS`` / ``FACE_STEPS`` in qwen_zimage_pipeline).
 PROFILE_SEED = 0
-PROFILE_CFG = 1.0
 
 # sdxl-zimage runs the qwen-zimage recipe on an SDXL global stage, and strength is
 # architecture-bound: at Qwen's 0.154 an SDXL global pass leaves SynthID on a native
@@ -77,16 +92,18 @@ def normalize_profile(profile: str) -> str:
     return _ALIASES.get(value, value)
 
 
-def resolve_steps(num_inference_steps: int | None) -> int:
-    """Return an explicit step count or the distilled four-step default."""
-    return PROFILE_STEPS if num_inference_steps is None else num_inference_steps
-
-
 def resolve_seed(seed: int | None) -> int:
     """Keep both profiles reproducible by default."""
     return PROFILE_SEED if seed is None else seed
 
 
+def resolve_adaptive_polish(adaptive_polish: bool | None, pipeline: str) -> bool:
+    """Return an explicit polish choice, or the profile's calibrated default."""
+    if adaptive_polish is not None:
+        return adaptive_polish
+    return PROFILE_ADAPTIVE_POLISH.get(normalize_profile(pipeline), True)
+
+
 def strength_default_help() -> str:
     """Describe the live default policy without duplicating its values."""
     return (

src/remove_ai_watermarks/_internal/watermark_remover.py

@@ -3,7 +3,6 @@
 # pyright: reportUnknownMemberType=false, reportUnknownArgumentType=false, reportUnknownVariableType=false, reportUnknownParameterType=false, reportMissingTypeArgument=false, reportMissingTypeStubs=false, reportMissingImports=false, reportArgumentType=false, reportAssignmentType=false, reportReturnType=false, reportCallIssue=false, reportIndexIssue=false, reportOperatorIssue=false, reportOptionalMemberAccess=false, reportOptionalCall=false, reportOptionalSubscript=false, reportOptionalOperand=false, reportAttributeAccessIssue=false, reportPrivateImportUsage=false, reportPrivateUsage=false, reportInvalidTypeForm=false, reportConstantRedefinition=false, reportUnnecessaryComparison=false
 from __future__ import annotations
 
-import contextlib
 import logging
 import os
 import subprocess
@@ -12,16 +11,13 @@ from typing import TYPE_CHECKING, Any
 from PIL import Image
 
 from remove_ai_watermarks._internal.watermark_profiles import (
-    DEFAULT_MODEL_ID,
     DEFAULT_PROFILE,
-    PROFILE_CFG,
+    INVISIBLE_EXTRA,
     PROFILE_CHOICES,
-    PROFILE_STEPS,
-    QWEN_ZIMAGE_PROFILE,
+    REMOVAL_MODULES,
     SDXL_ZIMAGE_PROFILE,
     normalize_profile,
     resolve_seed,
-    resolve_steps,
     resolve_strength,
 )
 from remove_ai_watermarks.optional_deps import module_available
@@ -32,13 +28,6 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-# Both two-stage profiles share the face stage, the four-step schedule, CFG 1.0, the
-# fixed model stack and the native-resolution contract; only the global model differs.
-_ZIMAGE_STACKS = {
-    QWEN_ZIMAGE_PROFILE: "Qwen-Image-2512 and Z-Image",
-    SDXL_ZIMAGE_PROFILE: "SDXL and Z-Image",
-}
-
 try:
     import torch
 
@@ -47,18 +36,20 @@ except ImportError:
     torch = None  # type: ignore[assignment]
     _HAS_TORCH = False
 
-_HAS_DIFFUSERS = module_available("diffusers")
+# Probed once at import. ``torch`` is imported above rather than probed because this
+# module needs the object, not just the answer.
+_HAS_REMOVAL_MODULES = module_available(*(name for name in REMOVAL_MODULES if name != "torch"))
 
 
 def is_watermark_removal_available() -> bool:
-    """Return whether the standard diffusion runtime can be imported."""
-    return _HAS_TORCH and _HAS_DIFFUSERS
+    """Return whether the full removal runtime can be imported."""
+    return _HAS_TORCH and _HAS_REMOVAL_MODULES
 
 
 def _ensure_watermark_deps() -> None:
     if not is_watermark_removal_available():
         raise ImportError(
-            "Invisible watermark regeneration requires the 'diffusion' extra. Install remove-ai-watermarks[diffusion]."
+            f"Invisible watermark regeneration requires the 'qwen-zimage' extra: pip install {INVISIBLE_EXTRA}."
         )
 
 
@@ -75,26 +66,9 @@ def _has_nvidia_gpu() -> bool:
     return True
 
 
-def try_empty_device_cache(device: str) -> None:
-    """Ask Torch to release cached accelerator memory when the backend supports it.
-
-    Moved here when ``img2img_runner`` was deleted: the runner and its MPS recovery
-    path went with the CPU/MPS profiles, leaving this as that module's only content.
-    Silent by design -- it runs in cleanup paths where a raise would replace the real
-    error.
-    """
-    if not _HAS_TORCH:
-        return
-    backend = getattr(torch, device, None)  # type: ignore[union-attr]
-    empty_cache = getattr(backend, "empty_cache", None)
-    if callable(empty_cache):
-        with contextlib.suppress(Exception):
-            empty_cache()
-
-
-def _backend_works(device: str) -> bool:
+def _cuda_works() -> bool:
     try:
-        probe = torch.tensor([1.0], device=device)  # type: ignore[union-attr]
+        probe = torch.tensor([1.0], device="cuda")  # type: ignore[union-attr]
         _ = probe + probe
     except (AssertionError, RuntimeError):
         return False
@@ -102,33 +76,28 @@ def _backend_works(device: str) -> bool:
 
 
 def get_device() -> str:
-    """Select CUDA, XPU, MPS, or CPU in that order when each backend is usable."""
+    """Return ``"cuda"`` when a usable CUDA backend is present, else ``"cpu"``.
+
+    Deliberately binary. Both profiles are CUDA-only, so an XPU or MPS answer would
+    only travel one frame further to the same refusal in :class:`WatermarkRemover`,
+    while costing a probe on each. ``"cpu"`` here means "no CUDA", which is exactly
+    what that refusal reports.
+    """
     if not _HAS_TORCH:
         return "cpu"
-    if torch.cuda.is_available() and _backend_works("cuda"):  # type: ignore[union-attr]
+    if torch.cuda.is_available() and _cuda_works():  # type: ignore[union-attr]
         return "cuda"
-    xpu = getattr(torch, "xpu", None)
-    if xpu is not None and xpu.is_available() and _backend_works("xpu"):
-        return "xpu"
     if _has_nvidia_gpu():
         logger.warning("NVIDIA GPU detected, but the installed PyTorch build has no working CUDA backend")
-    mps = getattr(getattr(torch, "backends", None), "mps", None)
-    if mps is not None and mps.is_available():
-        return "mps"
     return "cpu"
 
 
 class WatermarkRemover:
     """Load one regeneration profile and write a metadata-clean raster output."""
 
-    DEFAULT_MODEL_ID = DEFAULT_MODEL_ID
-    _DEVICES = frozenset({"cuda"})
-
     def __init__(
         self,
-        model_id: str | None = None,
         device: str | None = None,
-        torch_dtype: Any = None,
         progress_callback: Callable[[str], None] | None = None,
         hf_token: str | None = None,
         pipeline: str = DEFAULT_PROFILE,
@@ -138,31 +107,25 @@ class WatermarkRemover:
         self.model_profile = normalize_profile(pipeline)
         if self.model_profile not in PROFILE_CHOICES:
             raise ValueError(f"Unsupported pipeline '{pipeline}'. Use one of: {', '.join(PROFILE_CHOICES)}.")
-        if model_id is not None:
-            raise ValueError(
-                f"The {self.model_profile} profile uses a fixed {_ZIMAGE_STACKS[self.model_profile]} model stack."
-            )
-        self.model_id = (
-            "Qwen/Qwen-Image-2512 + Tongyi-MAI/Z-Image-Turbo"
-            if self.model_profile == QWEN_ZIMAGE_PROFILE
-            else f"{DEFAULT_MODEL_ID} + Tongyi-MAI/Z-Image-Turbo"
-        )
+        # There is no ``model_id`` parameter and no ``model_id`` attribute: each
+        # profile pins a fixed model stack, and the dtype below is bound to that
+        # stack's weights. Both used to be constructor overrides that existed only to
+        # be rejected or to break the run, and the attribute only existed to echo the
+        # rejected value back.
         _ensure_watermark_deps()
         selected_device = (device or get_device()).casefold()
         self.device = get_device() if selected_device == "auto" else selected_device
         # CUDA is a precondition of the object, not of the run. Both profiles raise on
         # any other device, so accepting one here only defers a guaranteed failure to
         # model-load time, several layers down and under the wrong profile's name.
-        if self.device not in self._DEVICES:
+        if self.device != "cuda":
             raise ValueError(
-                f"Invisible-watermark removal is CUDA-only, so '{device}' cannot run it. "
+                f"Invisible-watermark removal is CUDA-only, so '{self.device}' cannot run it. "
                 "Both remaining profiles need an NVIDIA GPU. Visible-mark removal and "
                 "every identify command still run on CPU."
             )
 
-        if torch_dtype is not None:
-            self.torch_dtype = torch_dtype
-        elif self.model_profile == SDXL_ZIMAGE_PROFILE:
+        if self.model_profile == SDXL_ZIMAGE_PROFILE:
             # SDXL ships fp16 weights and an fp16-safe VAE; bf16 would give up the
             # variant without buying anything on this architecture.
             self.torch_dtype = torch.float16  # type: ignore[union-attr]
@@ -175,18 +138,13 @@ class WatermarkRemover:
         self._progress_callback = progress_callback
         self._qwen_zimage_pipeline: Any = None
 
-    def _set_progress(self, message: str) -> None:
-        if self._progress_callback is not None:
-            with contextlib.suppress(Exception):
-                self._progress_callback(message)
-
     def preload(self, *, global_only: bool = False) -> None:
         """Materialize the selected model stack before the first request."""
         self._load_qwen_zimage_pipeline().preload(global_only=global_only)
 
     def _load_qwen_zimage_pipeline(self) -> Any:
         if self._qwen_zimage_pipeline is None:
-            if getattr(self, "model_profile", QWEN_ZIMAGE_PROFILE) == SDXL_ZIMAGE_PROFILE:
+            if self.model_profile == SDXL_ZIMAGE_PROFILE:
                 from remove_ai_watermarks._internal.sdxl_zimage_pipeline import (
                     SdxlZImagePipeline as _Pipeline,
                 )
@@ -206,44 +164,6 @@ class WatermarkRemover:
             )
         return self._qwen_zimage_pipeline
 
-    def _run_qwen_zimage(
-        self,
-        init_image: Image.Image,
-        strength: float,
-        seed: int | None,
-        *,
-        tile: bool = False,
-        tile_size: int = 1024,
-        tile_overlap: int = 128,
-    ) -> Image.Image:
-        return self._load_qwen_zimage_pipeline().run(
-            init_image,
-            strength=strength,
-            seed=seed,
-            tile=tile,
-            tile_size=tile_size,
-            tile_overlap=tile_overlap,
-        )
-
-    def _generate(
-        self,
-        image: Image.Image,
-        strength: float,
-        seed: int | None,
-        *,
-        tile: bool,
-        tile_size: int,
-        tile_overlap: int,
-    ) -> Image.Image:
-        return self._run_qwen_zimage(
-            image,
-            strength,
-            seed,
-            tile=tile,
-            tile_size=tile_size,
-            tile_overlap=tile_overlap,
-        )
-
     def _write_output(self, image: Image.Image, output_path: Path) -> None:
         import numpy as np
 
@@ -262,17 +182,18 @@ class WatermarkRemover:
         image_path: Path,
         output_path: Path | None = None,
         strength: float | None = None,
-        num_inference_steps: int | None = None,
-        guidance_scale: float | None = None,
         seed: int | None = None,
         vendor: str | None = None,
         tile: bool = False,
         tile_size: int = 1024,
         tile_overlap: int = 128,
-        region: tuple[int, int, int, int] | None = None,
-        region_feather: int = 64,
     ) -> Path:
-        """Regenerate image pixels and write the result without AI metadata."""
+        """Regenerate image pixels and write the result without AI metadata.
+
+        Step count and CFG are not parameters. Each stage of both profiles is a
+        distilled schedule that owns its own, so the only thing a caller-supplied
+        value could do is break the run or be rejected.
+        """
         if not image_path.exists():
             raise FileNotFoundError(f"Image not found: {image_path}")
         destination = output_path or image_path
@@ -283,82 +204,13 @@ class WatermarkRemover:
         if not 0.0 <= resolved_strength <= 1.0:
             raise ValueError(f"Strength must be between 0.0 and 1.0, got {resolved_strength}")
 
-        # Both profiles are distilled four-step schedules at CFG 1.0. Anything else is
-        # a caller error rather than a knob, so it is rejected instead of coerced.
-        steps = resolve_steps(num_inference_steps)
-        if steps != PROFILE_STEPS:
-            raise ValueError(f"The {self.model_profile} profile requires {PROFILE_STEPS} steps.")
-        if guidance_scale is not None and guidance_scale != PROFILE_CFG:
-            raise ValueError(f"The {self.model_profile} profile requires CFG {PROFILE_CFG}.")
-
-        result = self._generate(
+        result = self._load_qwen_zimage_pipeline().run(
             source,
-            resolved_strength,
-            resolve_seed(seed),
+            strength=resolved_strength,
+            seed=resolve_seed(seed),
             tile=tile,
             tile_size=tile_size,
             tile_overlap=tile_overlap,
         )
-
-        if region is not None:
-            import numpy as np
-
-            from remove_ai_watermarks._internal.tiling import feather_region_composite
-
-            if result.size != source.size:
-                result = result.resize(source.size, Image.Resampling.LANCZOS)
-            merged = feather_region_composite(
-                np.asarray(source),
-                np.asarray(result.convert("RGB")),
-                region,
-                feather=region_feather,
-            )
-            result = Image.fromarray(merged)
-
         self._write_output(result, destination)
         return destination
-
-    def remove_watermark_batch(
-        self,
-        input_dir: Path,
-        output_dir: Path,
-        strength: float | None = None,
-        num_inference_steps: int | None = None,
-        extensions: tuple[str, ...] = (".png", ".jpg", ".jpeg", ".webp"),
-    ) -> list[Path]:
-        """Process matching files in a directory, logging and continuing on failures."""
-        if not input_dir.exists():
-            raise FileNotFoundError(f"Input directory not found: {input_dir}")
-        output_dir.mkdir(parents=True, exist_ok=True)
-        outputs: list[Path] = []
-        candidates = sorted(path for path in input_dir.iterdir() if path.suffix.casefold() in extensions)
-        for source in candidates:
-            try:
-                outputs.append(self.remove_watermark(source, output_dir / source.name, strength, num_inference_steps))
-            except Exception as error:
-                logger.error("Failed to process %s: %s", source, error)
-            finally:
-                try_empty_device_cache(self.device)
-        return outputs
-
-
-def remove_watermark(
-    image_path: Path,
-    output_path: Path | None = None,
-    strength: float | None = None,
-    model_id: str | None = None,
-    device: str | None = None,
-    hf_token: str | None = None,
-    region: tuple[int, int, int, int] | None = None,
-) -> Path:
-    """Convenience wrapper using the default ControlNet profile."""
-    from remove_ai_watermarks._internal.watermark_profiles import vendor_for_strength
-
-    remover = WatermarkRemover(model_id=model_id, device=device, hf_token=hf_token)
-    return remover.remove_watermark(
-        image_path,
-        output_path,
-        strength,
-        vendor=vendor_for_strength(image_path),
-        region=region,
-    )

src/remove_ai_watermarks/cli.py

@@ -25,10 +25,8 @@ from remove_ai_watermarks._internal.constants import SUPPORTED_FORMATS
 from remove_ai_watermarks._internal.utils import is_supported_format
 from remove_ai_watermarks._internal.watermark_profiles import (
     DEFAULT_PROFILE,
+    INVISIBLE_EXTRA,
     PROFILE_CHOICES,
-    QWEN_ZIMAGE_PROFILE,
-    resolve_seed,
-    resolve_steps,
     resolve_strength,
     strength_default_help,
     vendor_for_strength,
@@ -184,23 +182,14 @@ _unsharp_option = click.option(
     "--unsharp", type=float, default=0.0, help="Unsharp-mask sharpening strength (0 = off, typical: 0.3-0.8)."
 )
 
-_auto_option = click.option(
-    "--auto",
-    is_flag=True,
-    default=False,
-    help="DEPRECATED: it no longer selects a pipeline. It now only requests the "
-    "adaptive polish, which the two-stage profiles otherwise leave off to keep their "
-    "output untouched. Prefer --adaptive-polish.",
-)
-
 _adaptive_polish_option = click.option(
     "--adaptive-polish/--no-adaptive-polish",
-    default=True,
+    default=None,
     help="Restore the input's detail level after removal (capped unsharp + edge-masked grain "
-    "targeting the input's sharpness, sparing text), countering the over-smoothed look. ON by "
-    "default except for qwen-zimage, whose upstream-matching output is left unchanged; it "
-    "self-limits where there is no detail deficit (text/flat graphics). Pass --adaptive-polish "
-    "or --no-adaptive-polish to override. Independent of --unsharp/--humanize.",
+    "targeting the input's sharpness, sparing text), countering the over-smoothed look. "
+    "Unset follows the profile: ON for sdxl-zimage, OFF for qwen-zimage, whose "
+    "upstream-matching output is left unchanged. It self-limits where there is no detail "
+    "deficit (text/flat graphics). Independent of --unsharp/--humanize.",
 )
 
 
@@ -230,23 +219,11 @@ def _tile_options(f: Any) -> Any:
     )(f)
 
 
-# HuggingFace model + CFG knobs, shared by the diffusion commands (invisible/all/batch)
-# so the surface stays identical across them.
-_model_option = click.option(
-    "--model",
-    type=str,
-    default=None,
-    help="HuggingFace model ID. Both profiles pin a fixed model stack, so anything "
-    "other than the default is rejected rather than silently ignored.",
-)
-_guidance_scale_option = click.option(
-    "--guidance-scale",
-    type=float,
-    default=None,
-    help="Classifier-free guidance scale (CFG). Both profiles are distilled and fix "
-    "CFG at 1.0, so any other value is rejected.",
-)
-
+# There is deliberately no --model, --steps, --guidance-scale or --device option.
+# Each profile pins a fixed model stack, a distilled per-stage schedule, CFG 1.0 and
+# CUDA; every one of those knobs existed only so the library could reject it several
+# layers down. A flag whose sole outcome is an error is worse than no flag at all --
+# it advertises a capability that does not exist.
 
 # The two-stage profiles are the only ones left. The former controlnet, sdxl, qwen and
 # default profiles were removed rather than kept as a CPU path: none matched this
@@ -276,6 +253,23 @@ _strength_option = click.option(
     default=None,
     help=f"Denoising strength (0.0-1.0). Default: {strength_default_help()}.",
 )
+_seed_option = click.option(
+    "--seed",
+    type=int,
+    default=None,
+    help="Random seed for reproducibility. Default 0: both profiles are certified "
+    "at a fixed seed, because SynthID removal near the strength floor is seed-dependent.",
+)
+_hf_token_option = click.option("--hf-token", type=str, default=None, help="HuggingFace API token.")
+_humanize_option = click.option(
+    "--humanize", type=float, default=0.0, help="Analog Humanizer film grain intensity (0 = off, typical: 2.0-6.0)."
+)
+_max_resolution_option = click.option(
+    "--max-resolution",
+    type=int,
+    default=0,
+    help="Cap long side (px) before diffusion; 0 = native and preserves the most detail. Raise only on GPU OOM.",
+)
 _force_option = click.option(
     "--force/--no-force",
     default=False,
@@ -323,41 +317,6 @@ _visible_sensitivity_option = click.option(
 )
 
 
-def _resolve_auto_polish(auto: bool, adaptive_polish: bool) -> bool:
-    """Warn on the retired ``--auto`` flag, returning ``adaptive_polish`` unchanged.
-
-    ``--auto`` used to plan the pipeline + polish from content detection. There is now
-    only one default pipeline, and the content detectors were removed, so the flag
-    survives purely as a polish request: it emits a deprecation warning and passes
-    ``adaptive_polish`` through, with an explicit ``--no-adaptive-polish`` still winning.
-    """
-    if auto:
-        click.echo(
-            "Warning: --auto is deprecated and now does nothing (the adaptive polish it "
-            "enabled is ON by default). Use --no-adaptive-polish to turn the polish off.",
-            err=True,
-        )
-    return adaptive_polish
-
-
-def _resolve_profile_polish(auto: bool, adaptive_polish: bool, pipeline: str) -> bool:
-    """Keep the upstream qwen-zimage output unchanged unless polish was explicit.
-
-    ``--auto`` counts as explicit. It is deprecated, but it is still a request for the
-    polish, and once qwen-zimage became the DEFAULT pipeline the source check below
-    would otherwise have silently turned that flag into a no-op for every caller.
-    """
-    adaptive_polish = _resolve_auto_polish(auto, adaptive_polish)
-    if pipeline != QWEN_ZIMAGE_PROFILE or auto:
-        return adaptive_polish
-    ctx = click.get_current_context(silent=True)
-    if ctx is None:
-        return adaptive_polish
-    if ctx.get_parameter_source("adaptive_polish") == click.core.ParameterSource.DEFAULT:
-        return False
-    return adaptive_polish
-
-
 def _visible_provenance(path: Path | None) -> frozenset[str]:
     """Vendor keys local metadata confirms, the EVIDENCE that drives ``auto``
     sensitivity. Thin wrapper over the public :func:`api.visible_provenance` (one
@@ -833,40 +792,13 @@ def cmd_erase(
     "-o", "--output", type=click.Path(path_type=Path), default=None, help="Output path (default: <source>_clean.<ext>)."
 )
 @_strength_option
-@click.option(
-    "--steps",
-    type=int,
-    default=None,
-    help="Number of denoising steps. Both profiles are distilled four-step schedules, so 4 is the only accepted value.",
-)
 @_pipeline_option
-@click.option(
-    "--device",
-    type=click.Choice(["auto", "cpu", "mps", "cuda", "xpu"]),
-    default="auto",
-    help="Inference device.",
-)
-@click.option(
-    "--seed",
-    type=int,
-    default=None,
-    help="Random seed for reproducibility. Default: 0 for qwen-zimage, random otherwise.",
-)
-@click.option("--hf-token", type=str, default=None, help="HuggingFace API token.")
-@click.option(
-    "--humanize", type=float, default=0.0, help="Analog Humanizer film grain intensity (0 = off, typical: 2.0-6.0)."
-)
-@click.option(
-    "--max-resolution",
-    type=int,
-    default=0,
-    help="Cap long side (px) before diffusion; 0 = native and preserves the most detail. Raise only on GPU/MPS OOM.",
-)
+@_seed_option
+@_hf_token_option
+@_humanize_option
+@_max_resolution_option
 @_controlnet_scale_option
 @_unsharp_option
-@_model_option
-@_guidance_scale_option
-@_auto_option
 @_adaptive_polish_option
 @_tile_options
 @_force_option
@@ -877,19 +809,14 @@ def cmd_invisible(
     source: Path,
     output: Path | None,
     strength: float | None,
-    steps: int | None,
     pipeline: str,
-    device: str,
     seed: int | None,
     hf_token: str | None,
     humanize: float,
     unsharp: float,
     max_resolution: int,
     controlnet_scale: float,
-    model: str | None,
-    guidance_scale: float | None,
-    auto: bool,
-    adaptive_polish: bool,
+    adaptive_polish: bool | None,
     tile: bool,
     tile_size: int,
     tile_overlap: int,
@@ -898,29 +825,24 @@ def cmd_invisible(
 ) -> None:
     """Remove invisible AI watermarks (SynthID, StableSignature, TreeRing).
 
-    Uses diffusion-based regeneration. Requires GPU for reasonable speed.
-    Requires the [diffusion] extra: pip install 'remove-ai-watermarks[diffusion]'
+    Regenerates the pixels with the two-stage diffusion profile. CUDA-only:
+    pip install 'remove-ai-watermarks[qwen-zimage]'
     """
     from remove_ai_watermarks.invisible_engine import is_available as invisible_available
 
     if not invisible_available():
         console.print(
-            "Error: Diffusion dependencies not installed.\n"
-            "  Install them with: pip install 'remove-ai-watermarks[diffusion]'"
+            "Error: the invisible-removal dependencies are not installed.\n"
+            f"  Install them with: pip install {INVISIBLE_EXTRA}"
         )
         raise SystemExit(1)
 
     from remove_ai_watermarks.invisible_engine import InvisibleEngine
 
     source = _validate_image(source)
-    steps = resolve_steps(steps)
-    seed = resolve_seed(seed)
-    adaptive_polish = _resolve_profile_polish(auto, adaptive_polish, pipeline)
     if output is None:
         output = source.with_stem(source.stem + "_clean")
 
-    device_str = None if device == "auto" else device
-
     # Gate BEFORE building the engine: skip the destructive regeneration when no
     # invisible AI watermark is locally detectable (it would only degrade a clean
     # image -- dominant paid score-0 cause), so the common skip path pays nothing for
@@ -932,8 +854,6 @@ def cmd_invisible(
         console.print(f"  {msg}")
 
     engine = InvisibleEngine(
-        model_id=model,
-        device=device_str,
         pipeline=pipeline,
         hf_token=hf_token,
         progress_callback=progress_cb,
@@ -946,15 +866,13 @@ def cmd_invisible(
     vendor = vendor_for_strength(source)
     console.print(f"  Input:    {source.name}")
     console.print(f"  Pipeline: {pipeline}")
-    console.print(f"  Strength: {_resolved_strength_for_display(source, strength, vendor, pipeline)}  Steps: {steps}")
+    console.print(f"  Strength: {_resolved_strength_for_display(source, strength, vendor, pipeline)}")
 
     t0 = time.monotonic()
     result_path = engine.remove_watermark(
         image_path=source,
         output_path=output,
         strength=strength,
-        num_inference_steps=steps,
-        guidance_scale=guidance_scale,
         seed=seed,
         humanize=humanize,
         unsharp=unsharp,
@@ -1516,40 +1434,13 @@ def cmd_identify(ctx: click.Context, source: Path, no_visible: bool, as_json: bo
 @_visible_backend_option
 @_visible_sensitivity_option
 @_strength_option
-@click.option(
-    "--steps",
-    type=int,
-    default=None,
-    help="Number of denoising steps. Both profiles are distilled four-step schedules, so 4 is the only accepted value.",
-)
 @_pipeline_option
-@_model_option
-@click.option(
-    "--device",
-    type=click.Choice(["auto", "cpu", "mps", "cuda", "xpu"]),
-    default="auto",
-    help="Inference device.",
-)
-@click.option(
-    "--seed",
-    type=int,
-    default=None,
-    help="Random seed for reproducibility. Default: 0 for qwen-zimage, random otherwise.",
-)
-@click.option("--hf-token", type=str, default=None, help="HuggingFace API token.")
-@click.option(
-    "--humanize", type=float, default=0.0, help="Analog Humanizer film grain intensity (0 = off, typical: 2.0-6.0)."
-)
-@click.option(
-    "--max-resolution",
-    type=int,
-    default=0,
-    help="Cap long side (px) before diffusion; 0 = native and preserves the most detail. Raise only on GPU/MPS OOM.",
-)
+@_seed_option
+@_hf_token_option
+@_humanize_option
+@_max_resolution_option
 @_controlnet_scale_option
 @_unsharp_option
-@_guidance_scale_option
-@_auto_option
 @_adaptive_polish_option
 @_tile_options
 @_force_option
@@ -1562,19 +1453,14 @@ def cmd_all(
     backend: str,
     sensitivity: str,
     strength: float | None,
-    steps: int | None,
     pipeline: str,
-    model: str | None,
-    device: str,
     seed: int | None,
     hf_token: str | None,
     humanize: float,
     unsharp: float,
     max_resolution: int,
     controlnet_scale: float,
-    guidance_scale: float | None,
-    auto: bool,
-    adaptive_polish: bool,
+    adaptive_polish: bool | None,
     tile: bool,
     tile_size: int,
     tile_overlap: int,
@@ -1592,9 +1478,6 @@ def cmd_all(
     """
     _banner()
     source = _validate_image(source)
-    steps = resolve_steps(steps)
-    seed = resolve_seed(seed)
-    adaptive_polish = _resolve_profile_polish(auto, adaptive_polish, pipeline)
 
     if output is None:
         output = source.with_stem(source.stem + "_clean")
@@ -1649,7 +1532,7 @@ def cmd_all(
             synthid_skipped = True
             console.print(
                 "    Warning: Skipped - GPU dependencies not installed.\n"
-                "    Install them with: pip install 'remove-ai-watermarks[diffusion]'"
+                f"    Install them with: pip install {INVISIBLE_EXTRA}"
             )
         elif _should_skip_invisible_scrub(force, source):
             # No locally-detectable invisible watermark -> skip the destructive
@@ -1666,14 +1549,10 @@ def cmd_all(
         else:
             from remove_ai_watermarks.invisible_engine import InvisibleEngine
 
-            device_str = None if device == "auto" else device
-
             def progress_cb(msg: str) -> None:
                 console.print(f"    {msg}")
 
             inv_engine = InvisibleEngine(
-                model_id=model,
-                device=device_str,
                 pipeline=pipeline,
                 hf_token=hf_token,
                 progress_callback=progress_cb,
@@ -1685,15 +1564,11 @@ def cmd_all(
             # already lost its C2PA to the visible-removal pass, so reading it would
             # always resolve to the unknown-vendor default.
             vendor = vendor_for_strength(source)
-            console.print(
-                f"    Strength: {_resolved_strength_for_display(source, strength, vendor, pipeline)}  Steps: {steps}"
-            )
+            console.print(f"    Strength: {_resolved_strength_for_display(source, strength, vendor, pipeline)}")
             inv_engine.remove_watermark(
                 image_path=tmp_path,
                 output_path=tmp_path,
                 strength=strength,
-                num_inference_steps=steps,
-                guidance_scale=guidance_scale,
                 seed=seed,
                 humanize=humanize,
                 unsharp=unsharp,
@@ -1753,7 +1628,7 @@ def cmd_all(
             "  visible mark and metadata were stripped.\n"
             "\n"
             "  Install the extra and rerun to remove it:\n"
-            "    pip install 'remove-ai-watermarks[diffusion]'\n"
+            f"    pip install {INVISIBLE_EXTRA}\n"
             "  ====================================================================="
         )
         raise SystemExit(1)
@@ -1775,15 +1650,13 @@ class _BatchOptions:
     """Validated processing options shared by every image in one batch.
 
     Click necessarily exposes these as individual command parameters, but the
-    processing core should receive one coherent value instead of a 21-argument
+    processing core should receive one coherent value instead of a long positional
     call. Keeping the object immutable also makes it safe to reuse while the
     batch caches model instances in ``ctx.obj``.
     """
 
     strength: float | None
-    steps: int
     pipeline: str
-    device: str
     seed: int | None
     hf_token: str | None
     humanize: float
@@ -1792,9 +1665,8 @@ class _BatchOptions:
     unsharp: float = 0.0
     max_resolution: int = 0
     controlnet_scale: float = 1.0
-    model: str | None = None
-    guidance_scale: float | None = None
-    adaptive_polish: bool = False
+    # None means "the user did not choose"; the library resolves it per profile.
+    adaptive_polish: bool | None = None
     tile: bool = False
     tile_size: int = 1024
     tile_overlap: int = 128
@@ -1828,8 +1700,6 @@ def _run_batch_invisible(
         engines = ctx.obj.setdefault("_inv_engines", {})
         if options.pipeline not in engines:
             engines[options.pipeline] = InvisibleEngine(
-                model_id=options.model,
-                device=None if options.device == "auto" else options.device,
                 pipeline=options.pipeline,
                 hf_token=options.hf_token,
                 controlnet_conditioning_scale=options.controlnet_scale,
@@ -1839,8 +1709,6 @@ def _run_batch_invisible(
             img_path if mode == "invisible" else out_path,
             out_path,
             strength=options.strength,
-            num_inference_steps=options.steps,
-            guidance_scale=options.guidance_scale,
             seed=options.seed,
             humanize=options.humanize,
             unsharp=options.unsharp,
@@ -1948,42 +1816,15 @@ def _process_batch_image(
     "--mode", type=click.Choice(["visible", "invisible", "metadata", "all"]), default="visible", help="Processing mode."
 )
 @_strength_option
-@click.option(
-    "--steps",
-    type=int,
-    default=None,
-    help="Number of denoising steps. Both profiles are distilled four-step schedules, so 4 is the only accepted value.",
-)
 @_visible_backend_option
 @_visible_sensitivity_option
-@click.option(
-    "--humanize", type=float, default=0.0, help="Analog Humanizer film grain intensity (0 = off, typical: 2.0-6.0)."
-)
+@_humanize_option
 @_pipeline_option
-@click.option(
-    "--device",
-    type=click.Choice(["auto", "cpu", "mps", "cuda", "xpu"]),
-    default="auto",
-    help="Inference device.",
-)
-@click.option(
-    "--seed",
-    type=int,
-    default=None,
-    help="Random seed for reproducibility. Default: 0 for qwen-zimage, random otherwise.",
-)
-@click.option("--hf-token", type=str, default=None, help="HuggingFace API token.")
-@click.option(
-    "--max-resolution",
-    type=int,
-    default=0,
-    help="Cap long side (px) before diffusion; 0 = native and preserves the most detail. Raise only on GPU/MPS OOM.",
-)
+@_seed_option
+@_hf_token_option
+@_max_resolution_option
 @_unsharp_option
 @_controlnet_scale_option
-@_model_option
-@_guidance_scale_option
-@_auto_option
 @_adaptive_polish_option
 @_tile_options
 @_force_option
@@ -1995,9 +1836,7 @@ def cmd_batch(
     mode: str,
     output_dir: Path | None,
     strength: float | None,
-    steps: int | None,
     pipeline: str,
-    device: str,
     seed: int | None,
     hf_token: str | None,
     backend: str,
@@ -2006,10 +1845,7 @@ def cmd_batch(
     unsharp: float,
     max_resolution: int,
     controlnet_scale: float,
-    model: str | None,
-    guidance_scale: float | None,
-    auto: bool,
-    adaptive_polish: bool,
+    adaptive_polish: bool | None,
     tile: bool,
     tile_size: int,
     tile_overlap: int,
@@ -2032,14 +1868,9 @@ def cmd_batch(
     console.print(f"  Found {len(images)} images in {directory}")
     console.print(f"  Output -> {output_dir}")
     console.print(f"  Mode: {mode}")
-    adaptive_polish = _resolve_profile_polish(auto, adaptive_polish, pipeline)
-    steps = resolve_steps(steps)
-    seed = resolve_seed(seed)
     options = _BatchOptions(
         strength=strength,
-        steps=steps,
         pipeline=pipeline,
-        device=device,
         seed=seed,
         hf_token=hf_token,
         humanize=humanize,
@@ -2048,8 +1879,6 @@ def cmd_batch(
         unsharp=unsharp,
         max_resolution=max_resolution,
         controlnet_scale=controlnet_scale,
-        model=model,
-        guidance_scale=guidance_scale,
         adaptive_polish=adaptive_polish,
         tile=tile,
         tile_size=tile_size,
@@ -2103,7 +1932,7 @@ def cmd_batch(
             f"\n  WARNING: the invisible (SynthID) watermark was NOT removed on "
             f"{synthid_skipped_count} image(s) -- the GPU dependencies are not installed, "
             f"so those outputs still carry the invisible watermark.\n"
-            f"  Install the extra and rerun: pip install 'remove-ai-watermarks[diffusion]'"
+            f"  Install the extra and rerun: pip install {INVISIBLE_EXTRA}"
         )
 
     # Non-zero exit so a wrapping service detects an incomplete/failed run (batch used

src/remove_ai_watermarks/invisible_engine.py

@@ -1,7 +1,7 @@
 """Diffusion engine for regenerating images that carry invisible AI watermarks.
 
-This module requires the 'gpu' extra dependencies:
-    uv pip install 'remove-ai-watermarks[diffusion]'
+Requires the 'qwen-zimage' extra and a CUDA device:
+    uv pip install 'remove-ai-watermarks[qwen-zimage]'
 """
 
 # cv2/torch boundary: this engine wraps cv2 (resize/imwrite/cvtColor) and the
@@ -16,13 +16,11 @@ import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from ._internal.watermark_profiles import (
-    DEFAULT_MODEL_ID as DEFAULT_SDXL_MODEL_ID,
-)
 from ._internal.watermark_profiles import (
     DEFAULT_PROFILE,
+    REMOVAL_MODULES,
+    resolve_adaptive_polish,
     resolve_seed,
-    resolve_steps,
 )
 
 if TYPE_CHECKING:
@@ -42,10 +40,15 @@ logger = logging.getLogger(__name__)
 
 
 def is_available() -> bool:
-    """Check if invisible watermark removal dependencies are installed."""
+    """Whether the dependencies for a real removal run are installed.
+
+    Shares :data:`REMOVAL_MODULES` with the remover's own precondition so the two
+    cannot drift. When they did, a torch+diffusers-only environment passed this gate
+    and then died at the DiffSynth face stage.
+    """
     from .optional_deps import module_available
 
-    return module_available("diffusers", "torch")
+    return module_available(*REMOVAL_MODULES)
 
 
 def _target_size(width: int, height: int, max_resolution: int) -> tuple[int, int] | None:
@@ -79,13 +82,8 @@ class InvisibleEngine:
     to break watermark patterns, and reconstructs via reverse diffusion.
     """
 
-    # SDXL base is the default since May 2026; the vendor-adaptive strength
-    # removes the current SynthID (see watermark_profiles + docs/synthid.md).
-    DEFAULT_MODEL_ID = DEFAULT_SDXL_MODEL_ID
-
     def __init__(
         self,
-        model_id: str | None = None,
         device: str | None = None,
         pipeline: str = DEFAULT_PROFILE,
         hf_token: str | None = None,
@@ -96,8 +94,9 @@ class InvisibleEngine:
         """Initialize the invisible watermark removal engine.
 
         Args:
-            model_id: HuggingFace model ID. None = use the SDXL base default.
-            device: Device for inference (auto/cpu/mps/cuda/xpu). None = auto.
+            device: Device for inference. Both profiles are CUDA-only, so the
+                usable values are "cuda" and None/"auto" (which detects it);
+                anything else raises rather than falling back.
             pipeline: Pipeline profile, one of "qwen-zimage" (DEFAULT;
                 Qwen-Image-2512 Lightning + Canny, then SAM-masked Z-Image face repair)
                 or "sdxl-zimage" (the same recipe and the same face stage on an SDXL
@@ -116,11 +115,7 @@ class InvisibleEngine:
 
         from remove_ai_watermarks._internal.watermark_remover import WatermarkRemover
 
-        # Pass model_id through untouched. Substituting DEFAULT_MODEL_ID for None here
-        # meant the engine always supplied a model the remover is required to reject,
-        # so EVERY construction raised once that check tightened to "is not None".
         self._remover = WatermarkRemover(
-            model_id=model_id,
             device=device,
             progress_callback=progress_callback,
             hf_token=hf_token,
@@ -144,14 +139,12 @@ class InvisibleEngine:
         image_path: Path,
         output_path: Path | None = None,
         strength: float | None = None,
-        num_inference_steps: int | None = None,
-        guidance_scale: float | None = None,
         seed: int | None = None,
         humanize: float = 0.0,
         max_resolution: int = 0,
         vendor: str | None = None,
         unsharp: float = 0.0,
-        adaptive_polish: bool = False,
+        adaptive_polish: bool | None = None,
         tile: bool = False,
         tile_size: int = 1024,
         tile_overlap: int = 128,
@@ -161,27 +154,26 @@ class InvisibleEngine:
         Args:
             image_path: Path to the watermarked image.
             output_path: Output path (None = overwrite source).
-            strength: Denoising strength (0.0-1.0). None -> the vendor-adaptive
-                default.
-            num_inference_steps: Number of denoising steps. None keeps the existing
-                100-step library default, except qwen-zimage uses its required
-                four-step Lightning schedule.
-            guidance_scale: Classifier-free guidance scale.
-            seed: Random seed for reproducibility. None resolves to 0 for
-                qwen-zimage and stays random for the other profiles.
+            strength: Denoising strength (0.0-1.0). None -> the profile's calibrated
+                default (resolution-adaptive for qwen-zimage, vendor-adaptive for
+                sdxl-zimage).
+            seed: Random seed for reproducibility. None resolves to 0, because both
+                profiles are certified at a fixed seed.
             humanize: Intensity of Analog Humanizer film grain (0 = off).
             unsharp: Final unsharp-mask sharpening strength (0 = off, default).
                 Applied last to counter the soft / over-smoothed look of the
                 diffusion pass; ~0.5-0.8 is a safe range, higher risks edge halos.
-            adaptive_polish: When True (the CLI default), restore the input's detail
-                level in the softened output: a capped unsharp + edge-masked grain
-                targeting the input's Laplacian variance. Self-limiting -- a no-op when
-                the output already meets the input's detail level (text/flat graphics),
-                so it only acts on over-smoothed photo/face texture. Runs LAST.
+            adaptive_polish: Restore the input's detail level in the softened
+                output: a capped unsharp + edge-masked grain targeting the input's
+                Laplacian variance. Self-limiting -- a no-op when the output already
+                meets the input's detail level (text/flat graphics), so it only acts on
+                over-smoothed photo/face texture. Runs LAST. None (the default) follows
+                the profile: off for qwen-zimage, on for sdxl-zimage. This resolves
+                through the same ``resolve_adaptive_polish`` the CLI uses, so a library
+                caller and a CLI caller on one profile get the same output.
             max_resolution: Cap the long side (px) before diffusion. 0 (default)
-                = no cap. Set a positive value only to bound GPU/MPS memory on
-                very large inputs (it reintroduces a lossy downscale->upscale
-                round-trip).
+                = no cap. Set a positive value only to bound GPU memory on very large
+                inputs (it reintroduces a lossy downscale->upscale round-trip).
             tile: Process the diffusion pass in overlapping tiles instead of one
                 forward pass. This retains the input's native dimensions instead
                 of applying ``max_resolution``, but each tile is still regenerated.
@@ -194,8 +186,8 @@ class InvisibleEngine:
         """
         import tempfile
 
-        num_inference_steps = resolve_steps(num_inference_steps)
         seed = resolve_seed(seed)
+        adaptive_polish = resolve_adaptive_polish(adaptive_polish, self._remover.model_profile)
 
         from PIL import Image, ImageOps
 
@@ -243,8 +235,6 @@ class InvisibleEngine:
                 image_path=image_path,
                 output_path=output_path,
                 strength=strength,
-                num_inference_steps=num_inference_steps,
-                guidance_scale=guidance_scale,
                 seed=seed,
                 vendor=vendor,
                 tile=tile,
@@ -315,21 +305,3 @@ class InvisibleEngine:
             # _tmp_path is always set above (we persist the image unconditionally).
             if _tmp_path.exists():
                 _tmp_path.unlink()
-
-    def remove_watermark_batch(
-        self,
-        input_dir: Path,
-        output_dir: Path,
-        strength: float | None = None,
-        steps: int | None = None,
-    ) -> list[Path]:
-        """Remove invisible watermarks from all images in a directory."""
-        if steps is None:
-            profile = getattr(self._remover, "model_profile", None)
-            steps = 4 if profile in {"qwen-zimage", "sdxl-zimage"} else 50
-        return self._remover.remove_watermark_batch(
-            input_dir=input_dir,
-            output_dir=output_dir,
-            strength=strength,
-            num_inference_steps=steps,
-        )

src/remove_ai_watermarks/video_visible.py

@@ -1138,14 +1138,6 @@ def _scan_video_detectors(
     }
 
 
-def _scan_video(
-    source: Path,
-    detector: Any,
-) -> VideoScan:
-    """Decode a video once and collect one untrusted candidate per frame."""
-    return _scan_video_detectors(source, {"selected": detector})["selected"]
-
-
 def scan_video_marks(
     source: Path,
     marks: tuple[str, ...] = VIDEO_VISIBLE_MARKS,
@@ -1181,36 +1173,6 @@ def scan_video_marks(
     )
 
 
-def scan_sora_video(source: Path) -> VideoScan:
-    """Decode a video once and collect one untrusted Sora candidate per frame."""
-    return _scan_video(source, detect_sora_frame)
-
-
-def scan_veo_video(source: Path) -> VideoScan:
-    """Decode a video once and collect one untrusted Veo candidate per frame."""
-    return _scan_video(source, detect_veo_frame)
-
-
-def scan_seedance_video(source: Path) -> VideoScan:
-    """Decode a video once and collect one untrusted Seedance candidate per frame."""
-    return _scan_video(source, detect_seedance_frame)
-
-
-def scan_dola_video(source: Path) -> VideoScan:
-    """Decode a video once and collect one untrusted Dola candidate per frame."""
-    return _scan_video(source, detect_dola_frame)
-
-
-def scan_hailuo_video(source: Path) -> VideoScan:
-    """Decode a video once and collect one untrusted Hailuo candidate per frame."""
-    return _scan_video(source, detect_hailuo_frame)
-
-
-def scan_kling_video(source: Path) -> VideoScan:
-    """Decode a video once and collect one untrusted Kling candidate per frame."""
-    return _scan_video(source, detect_kling_frame)
-
-
 def _mask_for_region(
     frame_bgr: NDArray[Any],
     region: Region,