Improve Qwen face fidelity, release 0.20.1

.github/workflows/distribute.yml

@@ -1,8 +1,9 @@
 name: Distribute on release
 
 # Fans a published GitHub Release out to the channels that need a nudge.
-# PyPI is handled by publish.yml; conda-forge is handled by its autotick bot.
-# This workflow event-drives the two channels that would otherwise be manual:
+# PyPI is handled by publish.yml; the conda-forge channel is handled by its
+# autotick bot. This workflow updates the repository recipe and event-drives
+# the two channels that would otherwise be manual:
 #   - Homebrew tap: rewrite the formula's url + sha256 to the new sdist.
 #   - HF Space: factory-rebuild so it reinstalls the latest sdist from PyPI.
 # Both wait for the freshly published sdist to appear on PyPI first, since the
@@ -87,6 +88,34 @@ jobs:
           git commit -m "remove-ai-watermarks $VERSION" || { echo "Formula already current"; exit 0; }
           git push
 
+  conda-recipe:
+    needs: resolve
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout main
+        uses: actions/checkout@v7
+        with:
+          ref: main
+      - name: Bump the repository conda recipe
+        env:
+          SHA: ${{ needs.resolve.outputs.sha }}
+          VERSION: ${{ needs.resolve.outputs.version }}
+        run: |
+          set -euo pipefail
+          python scripts/sync_conda_recipe.py --version "$VERSION" --sha256 "$SHA"
+          git diff --check
+          if git diff --quiet -- packaging/conda/recipe.yaml; then
+            echo "Conda recipe already current"
+            exit 0
+          fi
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add packaging/conda/recipe.yaml
+          git commit -m "Sync conda recipe with v$VERSION"
+          git push
+
   hf-space:
     needs: resolve
     runs-on: ubuntu-latest

CLAUDE.md

@@ -73,7 +73,7 @@ Compact map. The full per-module detail (design decisions, tuned thresholds, cal
 - `invisible_watermark.py` — decodes the OPEN DWT-DCT watermarks (SD / SDXL / FLUX) via `imwatermark` (extra `detect`, pulls torch). Fragile two ways: (1) does not survive JPEG re-encode/resize; (2) **carrier-fragile on a broad class of pristine images** -- a clean encode->decode round-trip recovers 48/48 on chatgpt/firefly/random but FAILS (28-39/48, below the `_MATCH_48`=44 gate) on the FLUX fox, doubao, a flat FLUX generation, AND a clean synthetic flat fill with no watermark. The failure does NOT track texture; it goes with a degenerate **all-ones decode that is a CARRIER ARTIFACT, not a watermark** (synthetic clean image reproduces it). So `detect_invisible_watermark` is **positive-only**: trust a hit; a `None` is inconclusive unless a same-carrier positive-control embed first recovers >=44. Verified 2026-06-19; full caveat in `docs/watermarking-landscape.md`.
 - `trustmark_detector.py` — Adobe TrustMark open decoder (extra `trustmark`). Do NOT remove the JPEG re-encode false-positive gate — a lone TrustMark hit without it is almost always content noise.
 - `noai/watermark_remover.py` — `WatermarkRemover` with four diffusion pipelines selected by the explicit `pipeline` ctor arg, never inferred from `model_id`: `sdxl` (plain SDXL img2img), `controlnet` (SDXL + canny ControlNet, **the compatibility and cost DEFAULT since 2026-06-09**), `qwen` (Qwen-Image 20B img2img), and `qwen-zimage` (delegates to the fixed two-stage runtime below). Removal comes from img2img strength. Both SDXL loaders pass `add_watermarker=False`; diffusers otherwise re-stamps an open SDXL DWT-DCT watermark. Qwen's certified floors and fidelity results remain as documented below. The base `qwen` profile stays the manual text lane; `qwen-zimage` is the recommended high-quality manual mode, especially for face identity, while remaining experimental rather than an auto-router.
-- `noai/qwen_zimage_pipeline.py` — CUDA-only Qwen-Image-2512 Lightning + DiffSynth Canny full-frame regeneration, followed by YuNet face boxes, SAM masks, and Z-Image Turbo regeneration from original face crops. Ports both adaptive denoise formulas from Synthid-Bypass v2. The active upstream face path is YOLO + SAM; this port keeps its center-point and box prompts, proposal selection, detector-box intersection, crop factor, and paste feather while replacing YOLO with YuNet to avoid an AGPL runtime. The port is architectural, not bit-identical: it uses full safetensors instead of GGUF, DiffSynth samplers instead of the Comfy sampler pairs, and no latent detailer feather. DiffSynth input pixels, Canny control, and explicit dimensions must share the same /16 grid. SAM pixels follow the model dtype, geometric prompts stay float32, and bfloat16 outputs convert through float32 before NumPy. The YuNet download verifies its SHA-256. Separate `qwen-zimage` extra; fixed four-step global and eight-step face schedules; no custom `--model`; `--tile` applies only to the global stage, followed by one full-frame face stage; CLI adaptive polish defaults off. GPUs with at least 64 GiB VRAM keep the face stack resident, while smaller devices retain CPU offload. Fixed prompt embeddings are cached only when they do not depend on an edit image. The exact seed-0 release candidate passed the corresponding provider-oracle checks; broader seeded text, face, and tiled-output certification remains open.
+- `noai/qwen_zimage_pipeline.py` — CUDA-only Qwen-Image-2512 Lightning + DiffSynth Canny full-frame regeneration, followed by YuNet face boxes, SAM masks, and Z-Image Turbo regeneration from original face crops. Ports both adaptive denoise formulas from Synthid-Bypass v2, then scales the face result by 0.5 because this runtime lacks the reference latent noise-mask feather and uses a different sampler/compositing path; paired face evaluations and both provider oracles certified the scaled value while the global stage stayed unchanged. The active upstream face path is YOLO + SAM; this port keeps its center-point and box prompts, proposal selection, detector-box intersection, crop factor, and paste feather while replacing YOLO with YuNet to avoid an AGPL runtime. The port is architectural, not bit-identical: it uses full safetensors instead of GGUF, DiffSynth samplers instead of the Comfy sampler pairs, and no latent detailer feather. DiffSynth input pixels, Canny control, and explicit dimensions must share the same /16 grid. SAM pixels follow the model dtype, geometric prompts stay float32, and bfloat16 outputs convert through float32 before NumPy. The YuNet download verifies its SHA-256. Separate `qwen-zimage` extra; fixed four-step global and eight-step face schedules; no custom `--model`; `--tile` applies only to the global stage, followed by one full-frame face stage; CLI adaptive polish defaults off. `InvisibleEngine.preload(global_only=True)` warms Qwen and YuNet while leaving Z-Image and SAM lazy until a face is detected; the default `preload()` remains a full preload. GPUs with at least 64 GiB VRAM keep the face stack resident, while smaller devices retain CPU offload. Fixed prompt embeddings are cached only when they do not depend on an edit image. The exact seed-0 release candidate passed the corresponding provider-oracle checks; broader seeded text, face, and tiled-output certification remains open.
 - `noai/tiling.py` — sliding-window tiled diffusion for large inputs (CLI `--tile`). The SDXL, ControlNet, and base Qwen paths branch to `run_tiled` when `tile` is set AND the long side exceeds `tile_size`, refactoring the single-pass `_generate` into a per-tile `_generate_one` (the ControlNet edge map is rebuilt per tile inside it). `qwen-zimage` instead calls `run_tiled` only around its global Qwen stage, blends the tiles, then runs one full-frame face stage. Pure helpers `plan_tiles` (uniform-size tiles, last one flush to the edge) and `feather_weights` (strictly-positive separable taper -> partition-of-unity blend) are unit-tested without the model. Also home to `feather_region_composite(base, regenerated, box, *, feather)` — the pure region-targeted compositor for **AI-enhanced composites** (`ai_source_kind == "enhanced"`): blends the regenerated AI box back over the original with a feathered seam, leaving the real photo OUTSIDE the box pixel-exact. It backs `WatermarkRemover.remove_watermark(region=...)` (regenerate ONLY the AI region, not the whole frame); the no-model lossless region path stays `region_eraser.erase`. New tile/region-blend tuning goes in these pure helpers; do not inline blend math into the runner.
 - `auto_config.py` + the content-detection layer were REMOVED 2026-06-09; `--auto` is a deprecated no-op (controlnet is the default pipeline and adaptive polish is ON by default for the original profiles, while `qwen-zimage` leaves it off to preserve the upstream two-stage output).
 - `upscaler.py` — optional Real-ESRGAN pre-diffusion super-resolution for small inputs (extra `esrgan`, spandrel only). Manual opt-in; the default `--upscaler` stays `lanczos` and the engine always falls back to Lanczos on absence/error. ESRGAN can degrade faces and thin text.

docs/module-internals.md

@@ -266,6 +266,10 @@ is the source of truth for:
 - the minimum viable step calculation.
 
 The current profiles are `controlnet`, `sdxl`, `qwen`, and `qwen-zimage`.
+For serverless cold starts, `InvisibleEngine.preload(global_only=True)` loads the
+mandatory Qwen stage and YuNet while leaving the optional Z-Image and SAM face
+stack lazy until a face is detected. The default `preload()` still loads every
+stage.
 `default` is a legacy alias for `sdxl`. There is no content-dependent automatic
 router.
 
@@ -308,6 +312,14 @@ The profile rejects a custom model identifier. Its global and face model stack
 is fixed by the implementation. When tiling is enabled, only the global stage
 is tiled; the face stage runs once after the tiles are blended.
 
+The resolution and largest-face adaptive formulas remain exact ports of the
+reference workflow. The face stage applies half the reference result because
+this port uses a different sampler and composites regenerated SAM pixels rather
+than using the reference latent inpaint mask and noise feather. Paired face
+evaluations favored this scale on identity, perceptual distance, and full-image
+similarity, and the exact OpenAI and Gemini candidates both passed their
+matching provider oracle. The global stage stays unchanged.
+
 Regression coverage:
 
 - [`test_qwen_zimage_pipeline.py`](../tests/test_qwen_zimage_pipeline.py)

docs/release-and-distribution.md

@@ -43,6 +43,7 @@ PyPI API token from the repository.
 waits for the matching source distribution to appear on PyPI, then:
 
 - updates the Homebrew tap formula URL and SHA-256;
+- updates the repository conda recipe version and source-distribution SHA-256;
 - triggers a factory rebuild of the Hugging Face Space.
 
 The workflow can also be started manually with an optional version input.
@@ -52,6 +53,12 @@ If a distribution job fails because a repository or Hugging Face credential is
 invalid, rotate the corresponding GitHub secret and rerun the failed job. A
 manual Homebrew formula update is the fallback when its automation is blocked.
 
+The conda job uses the published artifact rather than a locally built archive
+as the hash source and commits the resulting recipe change to `main`. Runtime
+dependency mapping remains review-controlled: keep it aligned with the core
+dependencies in `pyproject.toml`, and document any conda-forge package that is
+unavailable and must be omitted.
+
 ## Source distribution boundary
 
 The wheel includes the package under `src/`.
@@ -69,10 +76,13 @@ The package uses hatchling through the unpinned `hatchling` build requirement in
 ## Other channels
 
 The repository includes a conda recipe under `packaging/conda/recipe.yaml`.
-Keep its runtime dependencies aligned with `pyproject.toml`.
 
-The ComfyUI nodes are maintained and versioned separately from this package.
-A library release does not by itself publish a new ComfyUI node version.
+The ComfyUI nodes are maintained and versioned in their own repository. Its
+scheduled workflow detects a newer PyPI library release, updates the dependency
+floor, runs compatibility tests, bumps the node patch version, and publishes to
+the ComfyUI Registry only when those tests pass. The library release event does
+not publish the node package directly, so the registry update follows on that
+schedule rather than inside `distribute.yml`.
 
 ## Release verification
 
@@ -82,4 +92,6 @@ After publication, verify:
 - the package version matches the tag;
 - the Homebrew formula points to the new source distribution;
 - the distribution workflow completed successfully;
+- the repository's conda recipe matches the published version and source
+  distribution;
 - a clean install can run `remove-ai-watermarks --version`.

packaging/conda/recipe.yaml

@@ -1,7 +1,7 @@
 schema_version: 1
 
 context:
-  version: "0.10.1"
+  version: "0.20.0"
   python_min: "3.10"
 
 package:
@@ -10,7 +10,7 @@ package:
 
 source:
   url: https://pypi.org/packages/source/r/remove-ai-watermarks/remove_ai_watermarks-${{ version }}.tar.gz
-  sha256: ec92b450363d947cd897f0b75c18e75c2988ff79314ea247333ba892470b5a77
+  sha256: 28eb7aaeace7cfa50fe158ed6da72a4afa526d4be11e9f9c614b90edbaccf0b4
 
 build:
   noarch: python
@@ -25,11 +25,15 @@ requirements:
   run:
     - python >=${{ python_min }}
     - pillow >=10.0.0
+    - pillow-heif >=0.13.0
     - piexif >=1.1.3
     - numpy >=1.24.0
     - py-opencv >=4.8.0
     - click >=8.0.0
     - python-dotenv >=1.0.0
+    # c2pa-python is a core PyPI dependency but is not packaged on conda-forge.
+    # The guarded import falls back to the built-in C2PA byte scanner when it is
+    # absent. Add it here once a c2pa-python feedstock exists.
 
 tests:
   - python:
@@ -48,12 +52,11 @@ about:
   homepage: https://github.com/wiltodelta/remove-ai-watermarks
   summary: Remove visible and invisible AI watermarks from images
   description: |
-    Detect and remove visible AI watermarks (Gemini / Nano Banana sparkle,
-    ByteDance Doubao and Jimeng, Samsung Galaxy AI) and strip AI-provenance
-    metadata (C2PA, EXIF, IPTC, PNG text chunks) from images. The core package
-    covers the identify / metadata / visible / erase command surface; optional
-    pip extras add SynthID diffusion removal and additional invisible-watermark
-    detectors.
+    Detect and remove registered visible AI-provenance marks and strip
+    AI-provenance metadata (C2PA, EXIF, IPTC, and PNG text chunks) from images.
+    The core package covers the identify, metadata, visible, and erase command
+    surface. Optional pip extras add SynthID diffusion removal and additional
+    invisible-watermark detectors.
   license: Apache-2.0
   license_file: LICENSE
   repository: https://github.com/wiltodelta/remove-ai-watermarks

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "remove-ai-watermarks"
-version = "0.20.0"
+version = "0.20.1"
 description = "AI watermark remover: strip visible and invisible AI watermarks (Gemini / Nano Banana sparkle, SynthID) and provenance metadata (C2PA, EXIF) from images"
 readme = "README.md"
 requires-python = ">=3.10.1"

scripts/sync_conda_recipe.py

@@ -0,0 +1,53 @@
+"""Update the conda recipe to a published package version and sdist hash."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import re
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+_VERSION_LINE = re.compile(r'^  version: "[^"]+"$', re.MULTILINE)
+_SHA256_LINE = re.compile(r"^  sha256: [0-9a-f]{64}$", re.MULTILINE)
+
+
+def update_recipe(text: str, *, version: str, sha256: str) -> str:
+    """Return recipe text with exactly one context version and source hash updated."""
+    if not version or any(char.isspace() for char in version):
+        raise ValueError("version must be a non-empty value without whitespace")
+    if re.fullmatch(r"[0-9a-f]{64}", sha256) is None:
+        raise ValueError("sha256 must be 64 lowercase hexadecimal characters")
+
+    updated, version_count = _VERSION_LINE.subn(f'  version: "{version}"', text)
+    updated, sha_count = _SHA256_LINE.subn(f"  sha256: {sha256}", updated)
+    if version_count != 1 or sha_count != 1:
+        raise ValueError(
+            "expected exactly one context version and one source sha256 "
+            f"(found version={version_count}, sha256={sha_count})"
+        )
+    return updated
+
+
+def main() -> None:
+    """Update the selected recipe in place."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--version", required=True)
+    parser.add_argument("--sha256", required=True)
+    parser.add_argument(
+        "--recipe",
+        type=Path,
+        default=Path("packaging/conda/recipe.yaml"),
+    )
+    args = parser.parse_args()
+
+    original = args.recipe.read_text()
+    updated = update_recipe(original, version=args.version, sha256=args.sha256)
+    args.recipe.write_text(updated)
+    log.info("Updated %s to version %s", args.recipe, args.version)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+    main()

src/remove_ai_watermarks/__init__.py

@@ -25,7 +25,7 @@ _os.environ.setdefault("TRANSFORMERS_VERBOSITY", "error")
 _warnings.filterwarnings("ignore", message=r".*ImageProcessorFast.*")
 
 
-__version__ = "0.20.0"
+__version__ = "0.20.1"
 
 __all__ = ["__version__", "remove_visible", "visible_provenance"]
 

src/remove_ai_watermarks/invisible_engine.py

@@ -139,9 +139,14 @@ class InvisibleEngine:
         )
         self._progress_callback = progress_callback
 
-    def preload(self) -> None:
-        """Eagerly load the pipeline so download progress is visible."""
-        self._remover.preload()
+    def preload(self, *, global_only: bool = False) -> None:
+        """Eagerly load the pipeline so download progress is visible.
+
+        For ``qwen-zimage``, ``global_only=True`` loads the mandatory Qwen stage
+        and leaves the optional Z-Image and SAM face stack lazy until a face is
+        detected. Other profiles have no optional stage and ignore the flag.
+        """
+        self._remover.preload(global_only=global_only)
 
     def _esrgan_upscale(self, image: Any, target: tuple[int, int]) -> Any:
         """Upscale a PIL image to ``target`` with Real-ESRGAN, else Lanczos.

src/remove_ai_watermarks/noai/qwen_zimage_pipeline.py

@@ -10,7 +10,8 @@ This profile ports the two-stage architecture used by cebeuq/Synthid-Bypass:
 
 The runtime intentionally uses permissively licensed YuNet instead of the reference
 workflow's Ultralytics detector. All diffusion and segmentation models remain the same
-model families and the denoise formulas are direct ports of the reference custom node.
+model families. The adaptive formulas are direct ports, while the face result is scaled
+for this runtime's different sampler and mask-compositing path.
 """
 
 # DiffSynth, torch, transformers, and cv2 expose mostly untyped tensor/array APIs.
@@ -64,6 +65,11 @@ GLOBAL_CFG = 1.0
 FACE_CFG = 1.0
 GLOBAL_CONTROLNET_SCALE = 1.0
 RESIDENT_FACE_MODEL_MIN_VRAM_GIB = 64.0
+# The reference face denoise assumes its ComfyUI detailer sampler, latent
+# noise-mask feather, and inpaint path. Applying that value unchanged to this
+# DiffSynth crop-regeneration port over-processes faces. Paired public-fixture
+# measurements and both provider oracles certified half the reference value.
+FACE_DENOISE_SCALE = 0.5
 
 # The source graph uses normalized Canny thresholds 0.05 and 0.25. OpenCV takes
 # byte thresholds, so round 255*x to the matching integer values.
@@ -767,12 +773,13 @@ class QwenZImagePipeline:
             log.warning("SAM face-mask refinement failed (%s); using box-derived ellipse masks", exc)
             return _ellipse_masks(boxes, image.size)
 
-    def preload(self) -> None:
-        """Eagerly load both diffusion stages and the face segmentation model."""
+    def preload(self, *, global_only: bool = False) -> None:
+        """Eagerly load the mandatory stage and, by default, the face stack."""
         self._load_qwen()
-        self._load_zimage()
-        self._load_sam()
         _yunet_model_path()
+        if not global_only:
+            self._load_zimage()
+            self._load_sam()
 
     def _run_global(self, image: Image.Image, strength: float, seed: int | None) -> Image.Image:
         pipe, controlnet_input_cls = self._load_qwen()
@@ -892,7 +899,7 @@ class QwenZImagePipeline:
             self._progress("No faces detected; keeping the Qwen global result.")
             return global_result
         masks = self._sam_masks(image, boxes)
-        face_strength = largest_face_denoise(boxes, image.size)
+        face_strength = largest_face_denoise(boxes, image.size) * FACE_DENOISE_SCALE
         return self._run_faces(
             image,
             global_result,

src/remove_ai_watermarks/noai/watermark_remover.py

@@ -442,10 +442,13 @@ class WatermarkRemover:
 
     # ── Preload ──────────────────────────────────────────────────────
 
-    def preload(self) -> None:
-        """Eagerly load the pipeline so download progress bars are visible."""
+    def preload(self, *, global_only: bool = False) -> None:
+        """Eagerly load the pipeline so download progress bars are visible.
+
+        ``global_only`` applies to qwen-zimage, whose face stage is optional.
+        """
         if self.model_profile == QWEN_ZIMAGE_PROFILE:
-            self._load_qwen_zimage_pipeline().preload()
+            self._load_qwen_zimage_pipeline().preload(global_only=global_only)
         elif self.model_profile == "qwen":
             self._load_qwen_pipeline()
         elif self.model_profile == "controlnet":

tests/test_invisible_engine.py

@@ -35,6 +35,14 @@ class TestInvisibleEngineInit:
         # SDXL base became the default in May 2026 (defeats SynthID v2).
         assert InvisibleEngine.DEFAULT_MODEL_ID == "stabilityai/stable-diffusion-xl-base-1.0"
 
+    def test_preload_forwards_global_only(self):
+        engine = object.__new__(InvisibleEngine)
+        engine._remover = SimpleNamespace(preload=lambda **kwargs: setattr(engine, "_preload_kwargs", kwargs))
+
+        engine.preload(global_only=True)
+
+        assert engine._preload_kwargs == {"global_only": True}
+
 
 class TestNativeOutputSize:
     """Model-side latent-grid rounding must not change the public output size."""

tests/test_qwen_zimage_pipeline.py

@@ -435,11 +435,76 @@ def test_qwen_tiling_runs_global_tiles_then_one_full_frame_face_stage(monkeypatc
     assert all(strength == pytest.approx(resolution_adaptive_denoise(1500, 1500)) for _, strength, _ in global_calls)
     assert all(seed == 0 for _, _, seed in global_calls)
     face_stage.assert_called_once()
+    # Keep this literal independent from the runtime helper: the port deliberately
+    # uses half the upstream face denoise because it lacks the reference latent
+    # noise-mask feather and uses a different sampler/runtime.
+    assert face_stage.call_args.kwargs["strength"] == pytest.approx(0.0296296296)
     assert face_stage.call_args.args[0] is image
     assert face_stage.call_args.args[1].size == image.size
     assert result.size == image.size
 
 
+def test_global_only_preload_skips_face_models(monkeypatch):
+    from remove_ai_watermarks.noai.qwen_zimage_pipeline import QwenZImagePipeline
+
+    runtime = QwenZImagePipeline(device="cuda", torch_dtype="bf16")
+    qwen = MagicMock()
+    zimage = MagicMock()
+    sam = MagicMock()
+    yunet = MagicMock()
+    monkeypatch.setattr(runtime, "_load_qwen", qwen)
+    monkeypatch.setattr(runtime, "_load_zimage", zimage)
+    monkeypatch.setattr(runtime, "_load_sam", sam)
+    monkeypatch.setattr(
+        "remove_ai_watermarks.noai.qwen_zimage_pipeline._yunet_model_path",
+        yunet,
+    )
+
+    runtime.preload(global_only=True)
+
+    qwen.assert_called_once_with()
+    zimage.assert_not_called()
+    sam.assert_not_called()
+    yunet.assert_called_once_with()
+
+
+def test_full_preload_still_loads_face_models(monkeypatch):
+    from remove_ai_watermarks.noai.qwen_zimage_pipeline import QwenZImagePipeline
+
+    runtime = QwenZImagePipeline(device="cuda", torch_dtype="bf16")
+    qwen = MagicMock()
+    zimage = MagicMock()
+    sam = MagicMock()
+    yunet = MagicMock()
+    monkeypatch.setattr(runtime, "_load_qwen", qwen)
+    monkeypatch.setattr(runtime, "_load_zimage", zimage)
+    monkeypatch.setattr(runtime, "_load_sam", sam)
+    monkeypatch.setattr(
+        "remove_ai_watermarks.noai.qwen_zimage_pipeline._yunet_model_path",
+        yunet,
+    )
+
+    runtime.preload()
+
+    qwen.assert_called_once_with()
+    zimage.assert_called_once_with()
+    sam.assert_called_once_with()
+    yunet.assert_called_once_with()
+
+
+def test_watermark_remover_forwards_global_only_preload(monkeypatch):
+    from remove_ai_watermarks.noai.watermark_remover import WatermarkRemover
+
+    runtime = MagicMock()
+    remover = WatermarkRemover.__new__(WatermarkRemover)
+    remover.model_profile = "qwen-zimage"
+    monkeypatch.setattr(remover, "_load_qwen_zimage_pipeline", lambda: runtime)
+
+    remover.preload(global_only=True)
+
+    runtime.preload.assert_called_once_with(global_only=True)
+
+
 def test_qwen_zimage_rejects_runtime_knobs_that_change_fixed_graph(tmp_path, monkeypatch):
     from remove_ai_watermarks.noai.watermark_remover import WatermarkRemover
 

tests/test_sync_conda_recipe.py

@@ -0,0 +1,41 @@
+"""Tests for the release-time conda recipe synchronizer."""
+
+from __future__ import annotations
+
+import pytest
+
+from scripts.sync_conda_recipe import update_recipe
+
+_OLD_SHA = "a" * 64
+_NEW_SHA = "b" * 64
+_RECIPE = f"""\
+schema_version: 1
+
+context:
+  version: "1.2.3"
+
+source:
+  sha256: {_OLD_SHA}
+"""
+
+
+def test_update_recipe_replaces_version_and_hash() -> None:
+    updated = update_recipe(_RECIPE, version="2.0.0", sha256=_NEW_SHA)
+
+    assert '  version: "2.0.0"' in updated
+    assert f"  sha256: {_NEW_SHA}" in updated
+    assert "1.2.3" not in updated
+    assert _OLD_SHA not in updated
+
+
+@pytest.mark.parametrize("sha256", ["", "A" * 64, "f" * 63, "not-a-hash"])
+def test_update_recipe_rejects_invalid_hash(sha256: str) -> None:
+    with pytest.raises(ValueError, match="sha256"):
+        update_recipe(_RECIPE, version="2.0.0", sha256=sha256)
+
+
+def test_update_recipe_rejects_ambiguous_recipe() -> None:
+    duplicate = _RECIPE + f"\nsource_two:\n  sha256: {_OLD_SHA}\n"
+
+    with pytest.raises(ValueError, match="exactly one"):
+        update_recipe(duplicate, version="2.0.0", sha256=_NEW_SHA)

uv.lock

@@ -3187,7 +3187,7 @@ wheels = [
 
 [[package]]
 name = "remove-ai-watermarks"
-version = "0.20.0"
+version = "0.20.1"
 source = { editable = "." }
 dependencies = [
     { name = "c2pa-python" },