@camstack/addon-pipeline 1.2.103 → 1.2.104

package/dist/stream-broker/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-BdgcF1lL.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-ZaqZ17-x.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/dist/{worker-protocol-DDpliBIW.mjs → worker-protocol-Bz7-sMZC.mjs}

@@ -1,4 +1,4 @@
-import { _ as NativeLeaseSettingsSchema, g as NativeLeaseAdmissionSchema, u as DEFAULT_NATIVE_LEASE_SETTINGS } from "./dist-Ccmt3fGJ.mjs";
+import { _ as NativeLeaseAdmissionSchema, d as DEFAULT_NATIVE_LEASE_SETTINGS, v as NativeLeaseSettingsSchema } from "./dist-D9sltFoR.mjs";
 //#region src/session-decode/native-lease-config.ts
 /**
 * Resolution of the native-frame hold / tile knobs for one decode worker.

package/dist/{worker-protocol-BePduZVV.js → worker-protocol-D_0q_4Le.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-C11WuNUP.js");
+const require_dist = require("./dist-gLAVhbvO.js");
 //#region src/session-decode/native-lease-config.ts
 /**
 * Resolution of the native-frame hold / tile knobs for one decode worker.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.103",
+  "version": "1.2.104",
   "description": "Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",

package/python/inference_pool.py

@@ -522,6 +522,154 @@ def _init_runtime(runtime: str, device: str = "") -> None:
         raise ValueError(f"Unknown runtime: {runtime}")
 
 
+# ---------------------------------------------------------------------------
+# Batch capability is a HARDWARE FACT, not a setting (D202)
+# ---------------------------------------------------------------------------
+# Whether a compiled graph may keep a DYNAMIC batch axis is decided here, from
+# the (engine, device) pair, at the moment of load — never per model, never by
+# an operator, never in a conversion script. The conversion scripts and the
+# model-studio convert path both emit dynamic-batch graphs (`ov.convert_model`
+# preserves the ONNX dynamic axis), and the same artifact is loaded on CPU, iGPU,
+# NPU and ANE nodes — so the artifact cannot know, and only the loader does.
+#
+# The one target that refuses: the Intel NPU. Its Level-Zero compiler rejects a
+# dynamic dimension outright ("Got negative shape dim bound: '-1'", then
+# ZE_RESULT_ERROR_INVALID_ARGUMENT). Found live 2026-08-20 on the hub, and the
+# symptom is the trap — a pool load failure is a RETRY, not an error the caller
+# sees, so an NPU-pinned node repeated "Loading step variant" forever and looked
+# busy rather than broken. Under AUTO it is quieter and just as wrong: the NPU
+# candidate silently loses every dynamic-batch model to the GPU fallback.
+#
+# This is COMPILE shape only. The pool's runtime request grouping (`batch_mode`
+# / `max_batch_size`, and the CoreML stacked-tensor fast path gated on the
+# export's own RangeDim) is a separate, untouched optimisation.
+STATIC_BATCH_PIN = 1
+
+
+def _static_batch_required(runtime: str, device: str) -> bool:
+    """THE authority: does this (engine, device) pair refuse a dynamic shape?
+
+    Pure — no OpenVINO import, so it is unit-testable in a bare sandbox.
+
+      openvino + NPU  -> True  (Level-Zero rejects any dynamic dim)
+      openvino + CPU/GPU -> False
+      onnxruntime     -> False (every EP we ship handles dynamic axes)
+      coreml          -> False (a RangeDim export is exactly what the batched
+                                ANE dispatch path reads; pinning would delete it)
+      edgetpu         -> False (a tflite graph is static by construction)
+    """
+    if runtime != "openvino":
+        return False
+    return device.strip().upper().startswith("NPU")
+
+
+def _static_batch_plan(
+    shapes: "list[list[int | None] | None]",
+) -> "tuple[dict[int, list[int]], list[int]]":
+    """Pure. Given each input's dims (``None`` = dynamic axis, ``None`` for the
+    whole entry = unreadable), return ``(plan, unpinnable)``:
+
+      plan       {input_index: static_dims} for inputs whose BATCH axis is
+                 dynamic and whose every other axis is already static.
+      unpinnable [input_index] for inputs carrying a dynamic axis that is NOT
+                 the batch — there is no value we are allowed to invent for a
+                 spatial dim, so the caller compiles as-is and SAYS SO rather
+                 than letting the failure be silent.
+    """
+    plan: "dict[int, list[int]]" = {}
+    unpinnable: "list[int]" = []
+    for index, dims in enumerate(shapes):
+        if dims is None:
+            unpinnable.append(index)
+            continue
+        if len(dims) == 0:
+            continue
+        if any(d is None for d in dims[1:]):
+            unpinnable.append(index)
+            continue
+        if dims[0] is not None:
+            continue  # already a static batch — the rule pins dynamic axes only
+        plan[index] = [STATIC_BATCH_PIN] + [int(d) for d in dims[1:] if d is not None]
+    return plan, unpinnable
+
+
+def _pin_batch_for_device(core: Any, source: Any, path: str, device: str) -> Any:
+    """OpenVINO applicator of {@link _static_batch_required}.
+
+    Returns what `compile_model` should be handed for `device`: the untouched
+    `source` when the target accepts a dynamic shape (or the graph is already
+    static), otherwise a model RESHAPED to a static batch of
+    {@link STATIC_BATCH_PIN}. `source` is either the IR path (the plain load
+    path) or an already-built model object (the PrePostProcessor path); the pin
+    is applied to whichever, and it only ever touches axis 0, so a PPP model's
+    rewritten uint8 NHWC input survives it. Every outcome is logged — the
+    derivation must be readable in the pool stderr.
+
+    (`_ov_dim_to_int` is defined further down with the other OV shape helpers.)
+    """
+    name = os.path.basename(path)
+    if not _static_batch_required("openvino", device):
+        return source
+    try:
+        model = core.read_model(path) if isinstance(source, str) else source
+    except Exception as exc:
+        sys.stderr.write(
+            f"OpenVINO: {device} needs a static shape but re-reading {name} failed "
+            f"({exc}); compiling the source as-is\n"
+        )
+        sys.stderr.flush()
+        return source
+
+    shapes: "list[list[int | None] | None]" = []
+    for inp in model.inputs:
+        try:
+            pshape = inp.get_partial_shape()
+            shapes.append([_ov_dim_to_int(pshape[i]) for i in range(len(pshape))])
+        except Exception:
+            shapes.append(None)
+
+    plan, unpinnable = _static_batch_plan(shapes)
+    if unpinnable:
+        sys.stderr.write(
+            f"OpenVINO: {name} has a DYNAMIC NON-BATCH axis on input(s) {unpinnable} "
+            f"and {device} refuses dynamic dims — no value may be invented for a "
+            f"spatial axis, so this compile is expected to fail\n"
+        )
+        sys.stderr.flush()
+    if not plan:
+        sys.stderr.write(
+            f"OpenVINO: batch shape for {name} on {device} — already static, no "
+            f"reshape (derived from engine+device)\n"
+        )
+        sys.stderr.flush()
+        return source
+    try:
+        from openvino import PartialShape
+
+        # `Model.reshape` mutates IN PLACE, and on the PrePostProcessor path
+        # `source` IS the model object the compile loop reuses for the NEXT
+        # candidate. Pinning it directly would leak this NPU-only decision into
+        # the GPU/CPU fallback — a candidate that accepts a dynamic shape would
+        # silently get the pinned graph. So reshape a CLONE and leave `source`
+        # exactly as the caller built it.
+        model = model.clone() if not isinstance(source, str) else model
+        model.reshape({index: PartialShape(dims) for index, dims in plan.items()})
+    except Exception as exc:
+        sys.stderr.write(
+            f"OpenVINO: static-batch reshape of {name} for {device} failed ({exc}); "
+            f"compiling the source as-is\n"
+        )
+        sys.stderr.flush()
+        return source
+    sys.stderr.write(
+        f"OpenVINO: batch shape for {name} on {device} — PINNED to "
+        f"{STATIC_BATCH_PIN} on input(s) {sorted(plan)} because the target refuses "
+        f"a dynamic dim (derived from engine+device, not configured)\n"
+    )
+    sys.stderr.flush()
+    return model
+
+
 def _load_model(slot: ModelSlot, config: dict) -> None:
     """Load a model into a slot using the active runtime. Thin adapter per backend."""
     slot.config = dict(config)
@@ -667,8 +815,16 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
         last_exc: Optional[BaseException] = None
         for candidate in candidates:
             try:
+                # Batch capability is derived from THIS candidate, not from the
+                # artifact and not from a setting (D202): a graph with a dynamic
+                # batch axis is reshaped static before it can reach a compiler
+                # that refuses dynamic dims (the Intel NPU), and is handed over
+                # untouched to every other target.
+                candidate_source = _pin_batch_for_device(
+                    core, compile_source, path, candidate,
+                )
                 compiled = core.compile_model(
-                    compile_source, device_name=candidate, config=ov_config,
+                    candidate_source, device_name=candidate, config=ov_config,
                 )
                 ov_device = candidate
                 break
@@ -867,6 +1023,15 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
             slot.config["_input_shape"] = session.get_inputs()[0].shape
         except Exception:
             pass
+        # Declared input DTYPE. super-gradients / Frigate YOLO-NAS exports bake
+        # their preprocessing into the graph and take `tensor(uint8)` — the
+        # preprocess must feed raw uint8 pixels, not the float32 [0,1] tensor
+        # (a hard onnxruntime type error otherwise).
+        try:
+            if session.get_inputs()[0].type == "tensor(uint8)":
+                slot.config["_input_dtype"] = "uint8"
+        except Exception:
+            pass
 
         def predict(inp_dict: dict) -> dict:
             outputs = session.run(output_names, inp_dict)
@@ -1300,6 +1465,33 @@ def _preprocess(img: Image.Image, config: dict) -> tuple[dict, float, tuple[int,
             if bench_fid is not None:
                 _bench_preprocess_cache[(bench_fid, input_size)] = result
             return result
+        # uint8-input ONNX models: super-gradients / Frigate YOLO-NAS exports
+        # bake the /255 preprocessing INTO the graph and declare a uint8 input
+        # tensor. Feeding the historical float32 [0,1] tensor is a hard
+        # onnxruntime type error, so feed raw uint8 pixels in the declared
+        # layout instead (`_input_dtype` is captured at session load).
+        if config.get("_input_dtype") == "uint8" and input_channels == 3:
+            in_side = max(input_w, input_h)
+            if preprocess_mode == "letterbox":
+                canvas, scale_val, pad = letterbox_image(img, in_side)
+            else:
+                canvas = (
+                    img
+                    if img.size == (input_w, input_h)
+                    else img.resize((input_w, input_h), Image.BILINEAR)
+                )
+                scale_val, pad = 1.0, (0, 0)
+            pix = np.asarray(canvas, dtype=np.uint8)
+            if pix.ndim == 2:
+                pix = np.stack([pix] * 3, axis=-1)
+            if _is_channels_last(config.get("_input_shape")):
+                input_dict[input_name] = pix[np.newaxis]
+            else:
+                input_dict[input_name] = pix.transpose(2, 0, 1)[np.newaxis]
+            result = (input_dict, scale_val, pad)
+            if bench_fid is not None:
+                _bench_preprocess_cache[(bench_fid, input_size)] = result
+            return result
         if input_channels == 1:
             # Grayscale CTC recognizer (EasyOCR plate-OCR): aspect-preserving
             # resize + edge-pad + [-1,1] norm → [1,1,H,W]. NOT the squared

package/python/postprocessors/__init__.py

@@ -10,10 +10,12 @@ from .arcface import postprocess_arcface
 from .clip import postprocess_clip
 from .softmax import postprocess_softmax
 from .ctc import postprocess_ctc
+from .plate_slots import postprocess_plate_slots
 from .saliency import postprocess_saliency
 from .yamnet import postprocess_yamnet
 from .ssd import postprocess_ssd
 from .rfdetr import postprocess_rfdetr
+from .yolonas import postprocess_yolonas
 
 POSTPROCESSORS = {
     "yolo": postprocess_yolo,
@@ -23,8 +25,10 @@ POSTPROCESSORS = {
     "clip": postprocess_clip,
     "softmax": postprocess_softmax,
     "ctc": postprocess_ctc,
+    "plate-slots": postprocess_plate_slots,
     "saliency": postprocess_saliency,
     "yamnet": postprocess_yamnet,
     "ssd": postprocess_ssd,
     "rfdetr": postprocess_rfdetr,
+    "yolonas": postprocess_yolonas,
 }

package/python/postprocessors/ctc.py

@@ -246,6 +246,37 @@ def _rescore_for_grammar(
     return text, False
 
 
+# Glyphs the recognizer emits for a plate's physical registration seal.
+SEAL_GLYPHS = frozenset(".:;,*-'`\"·")
+
+
+def _strip_seal_glyph(text: str, region: str) -> "str | None":
+    """Return the normalised plate when `text` is a conforming read carrying ONE
+    interior seal glyph; ``None`` otherwise (caller applies the normal gate).
+
+    Narrow by construction: exactly one seal-like glyph, never at either end,
+    nothing else non-alphanumeric left over, and the normalised remainder must
+    match the region grammar. A read that does not become a legal plate is not
+    rescued.
+    """
+    pattern_src = PLATE_GRAMMARS.get(region)
+    if pattern_src is None:
+        return None
+    seals = [i for i, c in enumerate(text) if c in SEAL_GLYPHS]
+    if len(seals) != 1:
+        return None
+    pos = seals[0]
+    if pos == 0 or pos == len(text) - 1:
+        return None
+    stripped = text[:pos] + text[pos + 1 :]
+    if any(not (c.isalnum() or c.isspace()) for c in stripped):
+        return None
+    normalised = "".join(c for c in stripped.upper() if c.isalnum())
+    if re.match(pattern_src, normalised) is None:
+        return None
+    return normalised
+
+
 def postprocess_ctc(
     predictions: dict,
     config: dict,
@@ -318,6 +349,27 @@ def postprocess_ctc(
     has_symbol_glyph = region != "off" and any(
         not (c.isalnum() or c.isspace()) for c in text
     )
+    # …except the SEAL. A German plate physically carries a registration seal
+    # between the district code and the letter group, and the recognizer
+    # transcribes that badge as a punctuation glyph ('.', ':', '-', …). Once the
+    # quad warp (2026-08-20) started delivering legible strips, the correct
+    # decodes arrived as "DN.D7578" / "DN-P 1091" / "DN:HF 974" and this gate
+    # threw away every one of them — the warp scored 1/21 instead of 4/21 on the
+    # cam-617 ground-truth set purely because of this line.
+    #
+    # The exemption is deliberately narrow: EXACTLY ONE seal-like glyph, strictly
+    # INTERIOR, and the remainder must CONFORM to the region grammar. Noise
+    # cannot be laundered by it — the 2026-07-22 junk ("6ou.2x", "[miv4o)") has
+    # either the wrong count, the wrong position, or no conforming remainder.
+    if has_symbol_glyph:
+        repaired = _strip_seal_glyph(text, region)
+        if repaired is not None:
+            return {
+                "kind": "text",
+                "text": repaired,
+                "confidence": round(confidence, 4),
+                "formatValid": True,
+            }
     if alnum_count < min_len or confidence < min_conf or has_symbol_glyph:
         return {
             "kind": "text",

package/python/postprocessors/plate_slots.py

@@ -0,0 +1,180 @@
+"""Fixed-slot license-plate recognition postprocessor.
+
+Used for: `cct-s-v2-global` (fast-plate-ocr), the plate-OCR default since
+2026-08-20.
+
+Input: the `plate` head, ``[1, PLATE_SLOTS, VOCAB]`` (or the flattened
+``[1, PLATE_SLOTS * VOCAB]``) — an INDEPENDENT softmax per character position,
+already normalised inside the graph.
+Output: ``{"kind": "text", "text": "DNRO309", "confidence": 0.99,
+"formatValid": true}`` — the same StepOutput shape the CTC path produces, so
+nothing downstream (the label writer, the D186 per-track vote) changes.
+
+Why this is not `ctc.py`
+------------------------
+The two readers fail in opposite directions and that dictates opposite gates.
+
+A CTC recognizer fed noise collapses toward the blank: the decode comes out one
+or two characters long, which is why "at least `minTextLength` alphanumerics"
+was a sound plausibility gate for `vgg_english_g2`. A fixed-slot reader has no
+blank. It runs `PLATE_SLOTS` classification heads and every one of them picks a
+winner, on a plate, on a bumper, on an OSD weather band. Length carries no
+information here — `minTextLength` would admit literally every ROI the detector
+ever hands over.
+
+What DOES separate them is calibration, and only at the weakest position. On the
+39-crop cam-617 ground-truth set (21 plates, 9 vehicles, 18 junk ROIs) every
+correct read has a minimum per-character probability of 0.80 or better, while no
+junk ROI reaches it; the misreads that do get close are wrong in exactly one
+slot, and that slot is the one that dips. The MEAN hides this — six confident
+glyphs and one guess still average ~0.9 — so the gate reads the MINIMUM.
+
+Second gate: the region grammar (`plateRegion`, shared with `ctc.py` so there is
+one German plate pattern in this codebase, not two). Here a non-conforming read
+is DROPPED rather than kept-and-annotated. That differs from the CTC path on
+purpose: this alphabet is 36 alphanumerics plus a pad, so it cannot emit the
+"obviously not a plate" shapes (`[miv4o)`, `6ou.2`) that made an annotated read
+worth storing — a non-conforming read here is a confident misread, which is the
+one thing that must never reach a label.
+
+No confusable rescoring
+-----------------------
+`ctc.py` repairs a grammar failure by substituting 0↔O, 1↔I, 5↔S… That machinery
+exists because `vgg_english_g2` decodes from a 97-glyph English charset where
+case and punctuation are live classes. This alphabet has neither, so the only
+surviving confusion is 0↔O — and, run over the 39-crop set at the shipped
+operating point, the rescorer fires on zero crops. An unfired repair path is a
+path nothing verifies, so it is not here. If a future set shows it firing, take
+it from `ctc.py`: `_rescore_for_grammar` is already position/probability
+indexed, and a slot index is exactly the "aligned timestep" it wants.
+"""
+import re
+
+import numpy as np
+
+from .ctc import ABSENT_PLATE_REGION, PLATE_GRAMMARS
+
+# The `cct_s_v2_global_plate_config.yaml` contract, published beside the weights.
+# Class indices are positions in this string; a drift re-maps every glyph.
+PLATE_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_"
+PLATE_PAD_CHAR = "_"
+PLATE_SLOTS = 10
+
+# Minimum probability the WEAKEST emitted character must carry.
+#
+# 0.75 is not a round number picked for taste — it is the centre of the band
+# that separates the two populations on the cam-617 set WITH THE INFERENCE
+# PRECISION SPREAD INCLUDED. Taking, per crop, the worst case across ONNX fp32,
+# OpenVINO fp16 and CoreML: the highest-scoring junk ROI that also conforms to
+# the German grammar reaches 0.728, and the lowest-scoring correct plate that
+# still has to be read sits at 0.779. Anything inside (0.728, 0.779) stores
+# every one of those plates and none of that junk on every engine.
+#
+# The band matters because a plate recognizer does not get to choose its
+# arithmetic: OpenVINO's CPU default inference precision is fp16, an Intel NPU
+# has no other option, and a marginal crop's weakest character moves by as much
+# as 0.16 between engines. A floor chosen from one engine's numbers would be a
+# different filter on the next node.
+#
+# The two sides of the band are not symmetric, which is why 0.75 leans up. Too
+# LOW stores a wrong plate, and nothing downstream can undo that. Too HIGH
+# silences a marginal read — and the step runs up to `maxPerTrack` times per
+# track with the reads voted (D186), so the next frame gets another go.
+#
+# Config-overridable (`minCharProbability`).
+DEFAULT_MIN_CHAR_PROBABILITY = 0.75
+
+# Name of the plate head in the published graph. The region head (`region`,
+# [1,66]) rides along; it is NOT consulted — at this floor every junk ROI it
+# would have caught is already below the confidence gate, and a second gate
+# nothing removes is a second thing to keep true.
+PLATE_OUTPUT_NAME = "plate"
+
+
+def _select_plate_logits(predictions: dict) -> np.ndarray:
+    """Return the plate head as ``[PLATE_SLOTS, VOCAB]``.
+
+    By NAME first — the graph has two outputs and dict ordering is not a
+    contract. By SHAPE as the fallback, so an engine whose exporter dropped the
+    tensor names still decodes the right head rather than the region logits.
+    """
+    vocab = len(PLATE_ALPHABET)
+    expected = PLATE_SLOTS * vocab
+    candidate = predictions.get(PLATE_OUTPUT_NAME)
+    if candidate is None:
+        for value in predictions.values():
+            array = np.asarray(value)
+            if array.size == expected:
+                candidate = array
+                break
+    if candidate is None:
+        raise ValueError(
+            f"no plate head in predictions {sorted(predictions)}: "
+            f"expected an output of {expected} values"
+        )
+    array = np.asarray(candidate, dtype=np.float32)
+    if array.size != expected:
+        raise ValueError(
+            f"plate head has {array.size} values, expected "
+            f"{PLATE_SLOTS}x{vocab}={expected}"
+        )
+    return array.reshape(PLATE_SLOTS, vocab)
+
+
+def postprocess_plate_slots(
+    predictions: dict,
+    config: dict,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple[int, int],
+) -> dict:
+    """Per-slot argmax decode + confidence floor + region grammar."""
+    probs = _select_plate_logits(predictions)
+    alphabet = str(config.get("plateAlphabet") or PLATE_ALPHABET)
+    pad_char = str(config.get("platePadChar") or PLATE_PAD_CHAR)
+    min_char_prob = float(
+        config.get("minCharProbability", DEFAULT_MIN_CHAR_PROBABILITY)
+    )
+    region = str(config.get("plateRegion", ABSENT_PLATE_REGION))
+
+    winners = np.argmax(probs, axis=-1)
+    scores = probs[np.arange(len(winners)), winners]
+    decoded = "".join(alphabet[int(i)] for i in winners)
+
+    # Trailing pad is the model's length signal; strip it and keep the scores of
+    # the glyphs that survive aligned with them.
+    text = decoded.rstrip(pad_char)
+    kept = [float(s) for s in scores[: len(text)]]
+    confidence = round(float(np.mean(kept)), 4) if kept else 0.0
+
+    def silent() -> dict:
+        return {"kind": "text", "text": "", "confidence": confidence}
+
+    if not text:
+        return silent()
+    # A pad the model placed BETWEEN glyphs is a refusal at a position it
+    # believes exists — never a plate, and never something to paper over.
+    if pad_char in text:
+        return silent()
+    if min(kept) < min_char_prob:
+        return silent()
+
+    pattern_src = PLATE_GRAMMARS.get(region) if region != "off" else None
+    if pattern_src is None:
+        # No grammar for this region (or rescoring disabled): the read stands on
+        # the confidence gate alone, and says so.
+        return {
+            "kind": "text",
+            "text": text,
+            "confidence": confidence,
+            "formatValid": False,
+        }
+    if re.match(pattern_src, text) is None:
+        return silent()
+    return {
+        "kind": "text",
+        "text": text,
+        "confidence": confidence,
+        "formatValid": True,
+    }

package/python/postprocessors/test_ctc.py

@@ -382,3 +382,42 @@ def test_region_off_still_returns_the_raw_read():
     out = _read("dn Ro 3o9", {"plateRegion": "off"})
     assert out["text"] == "dn Ro 3o9"
     assert "formatValid" not in out
+
+
+# ---------------------------------------------------------------------------
+# Seal tolerance (2026-08-20)
+# ---------------------------------------------------------------------------
+def test_seal_glyph_between_district_and_letters_is_not_junk():
+    """A German plate carries a physical SEAL between the district code and the
+    letter group, and the recognizer transcribes it as a punctuation glyph.
+
+    Measured on the 2026-08-20 cam-617 ground-truth set (21 crops, 9 vehicles):
+    with the quad warp in front of the reader, the correct decodes are
+    ``DN.D7578``, ``DN-P 1091``, ``DN:HF 974`` — the plate, exactly, plus the
+    seal. The blanket symbol gate returned '' for every one of them, which is
+    why the warp alone scored 1/21 instead of 4/21. ONE interior seal glyph is
+    dropped, and the read is accepted only if what remains CONFORMS to the
+    region grammar — so it can never launder noise.
+    """
+    for raw, expected in (("DN.D7578", "DND7578"), ("DN-P1091", "DNP1091"), ("DN:HF974", "DNHF974")):
+        out = _read(raw)
+        assert out["text"] == expected, raw
+        assert out["formatValid"] is True, raw
+
+
+def test_seal_tolerance_does_not_rescue_non_conforming_noise():
+    """The rescue is grammar-gated: the live junk of 2026-07-22 stays rejected."""
+    for junk in ("6OU.2X", "[MIV4O)", "A.B", "12.34"):
+        assert _read(junk)["text"] == "", junk
+
+
+def test_seal_tolerance_needs_exactly_one_interior_symbol():
+    # Two symbols, or a symbol at either end, is hallucination — not a seal.
+    for junk in ("DN.D.7578", ".DND7578", "DND7578."):
+        assert _read(junk)["text"] == "", junk
+
+
+def test_seal_tolerance_is_off_when_region_is_off():
+    # 'off' preserves the historical decode byte-for-byte.
+    idx = _indices("DN.D7578")
+    assert _decode(idx, {"plateRegion": "off"})["text"] == "DN.D7578"