freesolo-flash-dev 1.2.70__tar.gz → 1.2.88__tar.gz

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.88}/Dockerfile.worker

@@ -59,15 +59,15 @@ RUN pip install --no-cache-dir \
     "wandb>=0.17" \
     "flash-linear-attention @ git+https://github.com/fla-org/flash-linear-attention.git@9c8e42e762fce087c27b673af4922795d9edb85e" \
     "flash-qla==0.1.2" \
-    "tilelang==0.1.11" \
-    "apache-tvm-ffi==0.1.11" \
+    "tilelang==0.1.9" \
+    "apache-tvm-ffi==0.1.9" \
     "hf_transfer" \
     "freesolo>=0.4.1" \
     "runpod"
 # Gated-DeltaNet (Qwen3.5/3.6) runs on flash-linear-attention's Triton kernels. On consumer cards
 # (Ampere/Ada/Blackwell) the Triton path is correct. On Hopper (sm90) fla's GDN chunk_bwd is
 # miscomputed with Triton>=3.4 (fla #640) — the fix is fla's TILELANG backend (correct there), so
-# we bake the pinned tilelang==0.1.11 + apache-tvm-ffi==0.1.11 (0.1.12 double-registers TVM-FFI ->
+# we bake the pinned tilelang==0.1.9 + apache-tvm-ffi==0.1.9 (0.1.12 double-registers TVM-FFI ->
 # `import tilelang` aborts) and KEEP fla on every arch; flash.engine.worker.perf._ensure_fla_fastpath_on_hopper
 # ensures the tilelang backend is live on sm90 before any model import. The INVERSE holds on
 # B200/sm100: THERE the tilelang chunk_bwd_dqkwg miscomputes gradients while the Triton path is
@@ -79,6 +79,13 @@ RUN pip install --no-cache-dir \
 # seq16384 12.6x / 1.9x, loss matches to 1.8e-4. fla is from git: the PyPI wheel is a broken stub
 # (no fla.modules). The git URL is PINNED to a commit (not the moving default branch) for
 # reproducible image builds; keep this sha in lockstep with the worker dependencies in flash/providers/_lifecycle/worker.py.
+# tilelang is 0.1.9, not the newest release: flash-qla (added for the sm90 GDN backend) hard-requires
+# tilelang==0.1.9 AND apache-tvm-ffi==0.1.9, so 0.1.11 made this layer unsatisfiable and every image
+# build failed from 2026-08-12 until the downgrade. 0.1.11 was only ever "latest stable at the time"
+# (the pin exists for determinism, not to dodge a 0.1.9 defect), and the version predates flash-qla.
+# Keep all four sites in lockstep -- both installs here, capabilities.py, and perf's TILELANG_PIN --
+# because perf fails CLOSED: a resolved version != TILELANG_PIN deletes fla and drops sm90 to the
+# pure-PyTorch fallback, which is correct but far slower.
 
 # FlashAttention: PREFER a prebuilt wheel. There is no OFFICIAL Dao-AILab wheel for torch 2.10 yet,
 # but community CI publishes matching wheels (cu128/torch2.10/cp312); CI passes one as FLASH_ATTN_SPEC
@@ -334,8 +341,8 @@ RUN printf '%s\n' "numpy==2.2.6" "xgrammar==0.1.25" "vllm==0.19.1" "transformers
         cachetools uvicorn fastapi torchvision tqdm pyarrow \
         "flash-linear-attention @ git+https://github.com/fla-org/flash-linear-attention.git@9c8e42e762fce087c27b673af4922795d9edb85e" \
         "flash-qla==0.1.2" \
-        "tilelang==0.1.11" \
-        "apache-tvm-ffi==0.1.11" \
+        "tilelang==0.1.9" \
+        "apache-tvm-ffi==0.1.9" \
     && rm -f /tmp/verl-overrides.txt \
     && uv cache clean
 

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.70
+Version: 1.2.88
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.88}/flash/adapters/fused_experts.py

@@ -14,6 +14,8 @@ from flash.adapters.lora_rank import (
 )
 from flash.core.catalog import get_model
 
+_LORA_FACTOR_PATTERN = re.compile(r"\.lora_[AB]\.")
+_LORA_PARAMETER = "weight"
 _QWEN36_MODEL_ID = "Qwen/Qwen3.6-35B-A3B"
 _QWEN36_EXPERT_TARGET_PARAMETERS = (
     "mlp.experts.gate_up_proj",
@@ -31,7 +33,7 @@ _FUSED_EXPERT_SYNTHETIC_MODULES = frozenset({"experts", "base_layer"})
 _FUSED_EXPERT_WRAPPER_MODULES = ("mlp.experts", "mlp.experts.base_layer")
 _INVALID_FUSED_LOCATION = object()
 
-_LoraTensor = tuple[str, str, str, str, tuple[int, ...]]
+_LoraTensor = tuple[str, str, str, tuple[int, ...]]
 _LoraPair = tuple[tuple[int, ...], tuple[int, ...]]
 
 
@@ -166,12 +168,13 @@ def has_complete_fused_expert_tensors(
     expected = _expected_fused_expert_rungs(config, model_id)
     if expected is None:
         return False
+    lora_keys = {key: shape for key, shape in tensors.items() if _LORA_FACTOR_PATTERN.search(key)}
     parsed = [
         tensor
-        for key, shape in tensors.items()
+        for key, shape in lora_keys.items()
         if (tensor := _parse_lora_tensor(key, shape)) is not None
     ]
-    if len({adapter_name for _, _, adapter_name, _, _ in parsed}) != 1:
+    if len(parsed) != len(lora_keys):
         return False
     return _has_complete_fused_rungs(parsed, expected, model_id) and _has_ordinary_evidence(
         parsed, config, expected
@@ -179,7 +182,17 @@ def has_complete_fused_expert_tensors(
 
 
 def _parse_lora_tensor(key: str, shape: tuple[int, ...]) -> _LoraTensor | None:
-    """Parse one canonical PEFT LoRA tensor key."""
+    """Parse one canonical PEFT LoRA tensor key.
+
+    Accept exactly the grammar PEFT writes: a bare ``lora_A.weight`` leaf with no adapter
+    namespace. ``get_peft_model_state_dict`` documents stripping the namespace on save, verl's
+    merger reproduces that strip, and ``_insert_adapter_name_into_state_dict`` re-inserts it on
+    load, so the stripped form is the only spelling that round-trips. Verified against peft 0.19.1:
+    ``...lora_A.weight`` loads as ``...lora_A.default.weight`` and matches the live module, while a
+    file that already carries the namespace loads as ``...lora_A.default.default.weight`` and
+    matches nothing. Since one grammar is accepted, the adapter namespace is no longer part of the
+    parsed identity.
+    """
     matches = [
         (factor, infix) for factor, infix in (("A", ".lora_A."), ("B", ".lora_B.")) if infix in key
     ]
@@ -187,13 +200,9 @@ def _parse_lora_tensor(key: str, shape: tuple[int, ...]) -> _LoraTensor | None:
         return None
     factor, infix = matches[0]
     module_path, _, leaf = key.partition(infix)
-    leaf_parts = leaf.split(".")
-    if not module_path or len(leaf_parts) != 2:
+    if not module_path or module_path.endswith(".") or leaf != _LORA_PARAMETER:
         return None
-    adapter_name, parameter = leaf_parts
-    if not adapter_name or parameter != "weight":
-        return None
-    return module_path, factor, adapter_name, key, shape
+    return module_path, factor, key, shape
 
 
 def _expected_fused_expert_rungs(
@@ -237,31 +246,25 @@ def _expected_fused_expert_rungs(
 def _has_complete_fused_rungs(
     tensors: list[_LoraTensor], expected: Mapping[str, Mapping[str, _LoraPair]], model_id: str
 ) -> bool:
-    """Validate every concrete fused owner, rung, namespace, and factor shape."""
+    """Validate every concrete fused owner, rung, and factor shape."""
     model = get_model(model_id)
     for owner, expected_rungs in expected.items():
-        factors: dict[str, dict[str, dict[str, dict[str, tuple[int, ...]]]]] = {}
-        for module_path, factor, adapter_name, _key, shape in tensors:
+        factors: dict[str, dict[str, dict[str, tuple[int, ...]]]] = {}
+        for module_path, factor, _key, shape in tensors:
             location = _fused_tensor_location(module_path, owner, frozenset(expected_rungs))
             if location is _INVALID_FUSED_LOCATION:
                 return False
             if location is None:
                 continue
             instance, rung = location
-            factors.setdefault(instance, {}).setdefault(rung, {}).setdefault(adapter_name, {})[
-                factor
-            ] = shape
+            factors.setdefault(instance, {}).setdefault(rung, {})[factor] = shape
         if not factors:
             return False
         for seen_rungs in factors.values():
             if set(seen_rungs) != set(expected_rungs):
                 return False
             for rung, expected_pair in expected_rungs.items():
-                namespaces = seen_rungs[rung]
-                if len(namespaces) != 1:
-                    return False
-                seen_factors = next(iter(namespaces.values()))
-                if _lora_pair_shapes(seen_factors) != expected_pair:
+                if _lora_pair_shapes(seen_rungs[rung]) != expected_pair:
                     return False
         expert_layers = {
             prefix
@@ -303,28 +306,27 @@ def _has_ordinary_evidence(
     config: Mapping[str, Any],
     fused_rungs: Mapping[str, Mapping[str, _LoraPair]],
 ) -> bool:
-    """Validate concrete ordinary target evidence with per-module ranks and namespaces."""
+    """Validate concrete ordinary target evidence with per-module ranks."""
     modules = config.get("target_modules")
     all_linear = modules == "all-linear"
     targets = () if all_linear else tuple(modules) if isinstance(modules, list) else ()
-    groups: dict[str, dict[str, dict[str, tuple[str, tuple[int, ...]]]]] = {}
+    groups: dict[str, dict[str, tuple[str, tuple[int, ...]]]] = {}
     evidence: set[str] = set()
-    for module_path, factor, adapter_name, key, shape in tensors:
+    for module_path, factor, key, shape in tensors:
         if _is_fused_rung(module_path, fused_rungs):
             continue
         matched = tuple(target for target in targets if _anchored_suffix_match(module_path, target))
         if not all_linear and not matched:
             continue
         evidence.update(matched)
-        groups.setdefault(module_path, {}).setdefault(adapter_name, {})[factor] = (key, shape)
+        groups.setdefault(module_path, {})[factor] = (key, shape)
     if not groups or (not all_linear and evidence != set(targets)):
         return False
 
     declared = declared_lora_ranks(config)
-    for module_path, namespaces in groups.items():
-        if len(namespaces) != 1 or _rank_for_module(module_path, declared) is None:
+    for module_path, factors in groups.items():
+        if _rank_for_module(module_path, declared) is None:
             return False
-        factors = next(iter(namespaces.values()))
         if set(factors) != {"A", "B"}:
             return False
         for key, shape in factors.values():

{freesolo_flash_dev-1.2.70 → freesolo_flash_dev-1.2.88}/flash/cli/scaffold/TRAINING.md

@@ -140,6 +140,11 @@ def load_environment(**kwargs) -> MyEnv:
 For tool use, dialogue, or games, subclass `EnvironmentMultiTurn` instead and drive the
 conversation across turns. The reward is the same `RewardResult` contract either way.
 
+If the environment class can return image-bearing user observations from `step_episode`, declare
+`image_observations = True` on that class. This is a class capability, not a TOML setting: Flash uses
+it to reject a text-only model or OPD teacher before model work. Set it only for environments that
+can actually emit images. The capability does not by itself enable per-turn image rollout wiring.
+
 ### 2. Publish the environment
 
 A managed run references a **published** environment by id — so push your folder first:

freesolo_flash_dev-1.2.88/flash/content/image_descriptors.py

@@ -0,0 +1,363 @@
+"""bounded parsing and validation for managed image descriptors."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import io
+import json
+import re
+import warnings
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+_EXIF_ORIENTATION_TAG = 274
+_EXIF_TRANSPOSED_ORIENTATIONS = frozenset({5, 6, 7, 8})
+_MIME_TO_FORMAT = {
+    "image/jpeg": "JPEG",
+    "image/png": "PNG",
+    "image/webp": "WEBP",
+}
+_FORMAT_TO_MIME = {image_format: mime for mime, image_format in _MIME_TO_FORMAT.items()}
+_DATA_URI_RE = re.compile(r"\Adata:(image/[^;,]+);base64,(.*)\Z", re.DOTALL)
+_MODE_BYTES_PER_PIXEL = {
+    "1": 1,
+    "L": 1,
+    "P": 1,
+    "I;16": 2,
+    "I;16B": 2,
+    "I;16L": 2,
+    "LA": 2,
+    "La": 2,
+    "RGB": 3,
+    "YCbCr": 3,
+    "LAB": 3,
+    "HSV": 3,
+    "RGBA": 4,
+    "RGBa": 4,
+    "CMYK": 4,
+    "I": 4,
+    "F": 4,
+}
+RGB_BYTES_PER_PIXEL = 3
+# decoding one image costs its own buffer plus a transient RGB conversion, so the worst mode
+# sets the bytes-per-pixel a pixel budget has to assume. exported because the per-image pixel cap
+# is derived from it: a cap the decoded-memory guard would always reject is not a limit.
+WORST_BYTES_PER_PIXEL = max(_MODE_BYTES_PER_PIXEL.values()) + 2 * RGB_BYTES_PER_PIXEL
+
+
+@dataclass(frozen=True)
+class ImageDescriptorLimits:
+    max_images: int
+    max_source_bytes: int
+    max_total_source_bytes: int
+    max_width: int
+    max_height: int
+    max_pixels: int
+    max_total_decoded_bytes: int
+    max_data_uri_header_bytes: int
+    max_descriptor_bytes: int
+
+
+@dataclass(frozen=True)
+class ValidatedImageDescriptor:
+    data: bytes
+    data_uri: str
+    source_bytes: int
+    decoded_peak_bytes: int
+    width: int
+    height: int
+
+    @property
+    def pixels(self) -> int:
+        return self.width * self.height
+
+
+def descriptor_size(value: str) -> int:
+    return len(value.encode("utf-8"))
+
+
+def descriptor(kind: str, value: str, *, max_descriptor_bytes: int) -> str:
+    encoded = json.dumps({"kind": kind, "value": value}, separators=(",", ":"), sort_keys=True)
+    size = descriptor_size(encoded)
+    if size > max_descriptor_bytes:
+        raise ValueError(
+            f"encoded image descriptor exceeds the {max_descriptor_bytes}-byte limit ({size} bytes)"
+        )
+    return encoded
+
+
+def parse_descriptor(raw: str) -> tuple[str, str]:
+    try:
+        value = json.loads(raw)
+    except (TypeError, json.JSONDecodeError) as exc:
+        raise ValueError("invalid internal image descriptor") from exc
+    if not isinstance(value, dict) or set(value) != {"kind", "value"}:
+        raise ValueError("invalid internal image descriptor")
+    kind = value["kind"]
+    payload = value["value"]
+    if not isinstance(kind, str) or not isinstance(payload, str):
+        raise ValueError("invalid internal image descriptor")
+    return kind, payload
+
+
+def check_source_size(size: int, *, max_source_bytes: int) -> None:
+    if size > max_source_bytes:
+        raise ValueError(f"image source exceeds the {max_source_bytes}-byte limit ({size} bytes)")
+
+
+def decode_data_uri(uri: str, limits: ImageDescriptorLimits) -> tuple[bytes, str]:
+    comma = uri.find(",")
+    header = uri if comma < 0 else uri[:comma]
+    if len(header.encode("utf-8")) > limits.max_data_uri_header_bytes:
+        raise ValueError(
+            f"image data URI header exceeds the {limits.max_data_uri_header_bytes}-byte limit"
+        )
+    match = _DATA_URI_RE.fullmatch(uri)
+    if match is None:
+        if not uri.startswith("data:"):
+            raise ValueError("image source must use a data URI")
+        if ";base64," not in uri:
+            raise ValueError("image data URI must use base64 encoding")
+        raise ValueError("image data URI must use the exact data:image/...;base64,... format")
+    mime, payload = match.groups()
+    expected_format = _MIME_TO_FORMAT.get(mime)
+    if expected_format is None:
+        raise ValueError(f"image data URI uses unsupported MIME type {mime!r}")
+    max_encoded_size = ((limits.max_source_bytes + 2) // 3) * 4
+    if len(payload) > max_encoded_size:
+        check_source_size(
+            limits.max_source_bytes + 1,
+            max_source_bytes=limits.max_source_bytes,
+        )
+    try:
+        data = base64.b64decode(payload, validate=True)
+    except (binascii.Error, ValueError) as exc:
+        raise ValueError("image data URI contains invalid base64 data") from exc
+    check_source_size(len(data), max_source_bytes=limits.max_source_bytes)
+    return data, expected_format
+
+
+def package_image_path(
+    value: str, package_root: Path | None, limits: ImageDescriptorLimits
+) -> Path:
+    if package_root is None:
+        raise ValueError("relative image paths require an extracted environment package root")
+    candidate = Path(value)
+    if candidate.is_absolute():
+        raise ValueError("image paths must be relative to the environment package root")
+    root = package_root.resolve()
+    dataset_root = (root / "dataset").resolve()
+    resolved = (root / candidate).resolve()
+    if resolved != dataset_root and dataset_root not in resolved.parents:
+        raise ValueError("image paths must stay inside the environment package dataset/ directory")
+    if not resolved.is_file():
+        raise ValueError(f"image path does not exist: {value!r}")
+    check_source_size(resolved.stat().st_size, max_source_bytes=limits.max_source_bytes)
+    return resolved
+
+
+def validate_dimensions(width: int, height: int, limits: ImageDescriptorLimits) -> int:
+    if width <= 0 or height <= 0:
+        raise ValueError("image width and height must be positive")
+    if width > limits.max_width or height > limits.max_height:
+        raise ValueError(
+            f"image dimensions {width}x{height} exceed the "
+            f"{limits.max_width}x{limits.max_height} limit"
+        )
+    pixels = width * height
+    if pixels > limits.max_pixels:
+        raise ValueError(
+            f"image has {pixels} pixels, exceeding the {limits.max_pixels}-pixel limit"
+        )
+    return pixels
+
+
+def _oriented_dimensions(image: Any, width: int, height: int) -> tuple[int, int]:
+    try:
+        orientation = image.getexif().get(_EXIF_ORIENTATION_TAG)
+    except (AttributeError, TypeError, ValueError, SyntaxError):
+        orientation = None
+    if orientation in _EXIF_TRANSPOSED_ORIENTATIONS:
+        return height, width
+    return width, height
+
+
+def inspect_image_metadata(
+    data: bytes,
+    limits: ImageDescriptorLimits,
+    *,
+    expected_format: str | None = None,
+) -> tuple[int, int, int, str]:
+    try:
+        from PIL import Image
+    except ImportError as exc:
+        raise RuntimeError("Pillow is required for multimodal image training") from exc
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", Image.DecompressionBombWarning)
+            with Image.open(io.BytesIO(data)) as image:
+                image_format = str(image.format or "").upper()
+                if image_format not in _FORMAT_TO_MIME:
+                    raise ValueError("image source must be a static PNG, JPEG, or WebP image")
+                if expected_format is not None and image_format != expected_format:
+                    raise ValueError(
+                        f"image data URI MIME type does not match its {image_format} format"
+                    )
+                if getattr(image, "n_frames", 1) != 1:
+                    raise ValueError("image source must be a static single-frame image")
+                stored_width, stored_height = image.size
+                pixels = validate_dimensions(stored_width, stored_height, limits)
+                decoded_peak_bytes = pixels * (
+                    _MODE_BYTES_PER_PIXEL.get(image.mode, 4) + 2 * RGB_BYTES_PER_PIXEL
+                )
+                image.verify()
+            with Image.open(io.BytesIO(data)) as orientation_probe:
+                width, height = _oriented_dimensions(
+                    orientation_probe,
+                    stored_width,
+                    stored_height,
+                )
+                validate_dimensions(width, height, limits)
+            return decoded_peak_bytes, width, height, image_format
+    except ValueError:
+        raise
+    except Exception as exc:
+        raise ValueError("image source is not a valid image") from exc
+
+
+def inspect_image_bytes(data: bytes, limits: ImageDescriptorLimits) -> tuple[int, int, int]:
+    decoded_peak_bytes, width, height, _image_format = inspect_image_metadata(data, limits)
+    return decoded_peak_bytes, width, height
+
+
+def canonical_data_uri(data: bytes, image_format: str) -> str:
+    media_type = _FORMAT_TO_MIME.get(image_format)
+    if media_type is None:
+        raise ValueError("image source must be a static PNG, JPEG, or WebP image")
+    return f"data:{media_type};base64,{base64.b64encode(data).decode('ascii')}"
+
+
+def descriptor_source_size(
+    encoded: str,
+    package_root: str | Path | None,
+    limits: ImageDescriptorLimits,
+) -> int:
+    kind, value = parse_descriptor(encoded)
+    if kind == "bytes":
+        return len(base64.b64decode(value, validate=True))
+    if kind == "data_uri":
+        return len(decode_data_uri(value, limits)[0])
+    if kind == "path":
+        root = Path(package_root) if package_root else None
+        return package_image_path(value, root, limits).stat().st_size
+    raise ValueError("invalid internal image descriptor kind")
+
+
+def read_descriptor_source(
+    encoded: str,
+    package_root: str | Path | None,
+    limits: ImageDescriptorLimits,
+) -> bytes:
+    kind, value = parse_descriptor(encoded)
+    if kind == "bytes":
+        try:
+            data = base64.b64decode(value, validate=True)
+        except binascii.Error as exc:
+            raise ValueError("invalid internal byte image descriptor") from exc
+    elif kind == "data_uri":
+        data = decode_data_uri(value, limits)[0]
+    elif kind == "path":
+        root = Path(package_root) if package_root else None
+        data = package_image_path(value, root, limits).read_bytes()
+    else:
+        raise ValueError("invalid internal image descriptor kind")
+    check_source_size(len(data), max_source_bytes=limits.max_source_bytes)
+    return data
+
+
+def validate_image_descriptor_data(
+    encoded: str,
+    data: bytes,
+    limits: ImageDescriptorLimits,
+    *,
+    decode_pixels: bool,
+    pixel_decoder: Callable[[bytes], None],
+) -> ValidatedImageDescriptor:
+    kind, value = parse_descriptor(encoded)
+    expected_format = decode_data_uri(value, limits)[1] if kind == "data_uri" else None
+    decoded_peak_bytes, width, height, image_format = inspect_image_metadata(
+        data,
+        limits,
+        expected_format=expected_format,
+    )
+    if decode_pixels:
+        pixel_decoder(data)
+    return ValidatedImageDescriptor(
+        data=data,
+        data_uri=canonical_data_uri(data, image_format),
+        source_bytes=len(data),
+        decoded_peak_bytes=decoded_peak_bytes,
+        width=width,
+        height=height,
+    )
+
+
+def validate_image_descriptor(
+    encoded: str,
+    package_root: str | Path | None,
+    limits: ImageDescriptorLimits,
+    *,
+    decode_pixels: bool,
+    pixel_decoder: Callable[[bytes], None],
+) -> ValidatedImageDescriptor:
+    data = read_descriptor_source(encoded, package_root, limits)
+    return validate_image_descriptor_data(
+        encoded,
+        data,
+        limits,
+        decode_pixels=decode_pixels,
+        pixel_decoder=pixel_decoder,
+    )
+
+
+def validate_image_descriptors(
+    descriptors: list[str] | tuple[str, ...],
+    package_root: str | Path | None,
+    limits: ImageDescriptorLimits,
+    *,
+    pixel_decoder: Callable[[bytes], None],
+) -> list[ValidatedImageDescriptor]:
+    if len(descriptors) > limits.max_images:
+        raise ValueError(
+            f"example contains {len(descriptors)} images, exceeding the "
+            f"{limits.max_images}-image limit"
+        )
+    validated: list[ValidatedImageDescriptor] = []
+    source_bytes = 0
+    prior_pixels = 0
+    for encoded in descriptors:
+        item = validate_image_descriptor(
+            encoded,
+            package_root,
+            limits,
+            decode_pixels=False,
+            pixel_decoder=pixel_decoder,
+        )
+        source_bytes += item.source_bytes
+        if source_bytes > limits.max_total_source_bytes:
+            raise ValueError(
+                f"example image sources exceed the {limits.max_total_source_bytes}-byte limit"
+            )
+        decoded_bytes = RGB_BYTES_PER_PIXEL * prior_pixels + item.decoded_peak_bytes
+        if decoded_bytes > limits.max_total_decoded_bytes:
+            raise ValueError(
+                f"example decoded images exceed the {limits.max_total_decoded_bytes}-byte limit"
+            )
+        prior_pixels += item.pixels
+        validated.append(item)
+    for item in validated:
+        pixel_decoder(item.data)
+    return validated