@@ -9,6 +9,35 @@ The envelope wire format is versioned separately by `meta.schema_version`
 
 ## [Unreleased]
 
+### Fixed
+- **`bq-schema-version` pre-decode gate on the SQS, Azure Service Bus, Kafka and Artemis
+  transports** (`pop`). The broker's schema-version property is read **before** the body is
+  decoded (broker-bindings §3.7 / §4.7 / §6.7 / §7.7), mirroring the existing Pulsar gate:
+  a missing or blank value (empty or only ASCII whitespace) takes the normal path; anything
+  else is compared untrimmed to `"1"` and a mismatch is returned with the raw body and the
+  reserved route `babelqueue:unsupported-schema-version:<v>` (version percent-escaped) without
+  decoding it. SQS/ASB/Kafka read `bq-schema-version`, Artemis `bq_schema_version`
+  (ADR-0017); ASB and Artemis also accept an integer `1` (a `bool` is not `1`). The conformance suite now reads each binding's
+  `schema_version_gate` table (including Pulsar's). No wire change.
+- **A version-gated delivery is dead-lettered directly, never retried.** `BabelQueue` now
+  sends a message under the reserved gate route straight to the DLQ (reason `unknown_urn`,
+  body untouched) when `dead_letter` is enabled and drops it otherwise, regardless of
+  `max_attempts` / `on_unknown_urn`. A retry would re-publish through paths that rebuild the
+  version header from the (valid) body (ASB/Kafka/Artemis) or never advance the attempt
+  counter (SQS), letting the gate be bypassed or the message loop. Applies to Pulsar too
+  (previously it retried up to `max_attempts` first).
+  If the dead-letter write itself fails, the message is still never retried: it is left
+  unacknowledged (an error is logged) so the broker redelivers it and the gate rejects it again
+  (SQS at the visibility timeout, Azure Service Bus at lock expiry, Artemis when the link or
+  connection closes). Kafka commits offsets cumulatively, so merely not acknowledging the
+  record would lose it once a later record is committed: `KafkaTransport` now `seek`s the
+  partition back to the failed record's offset so it is polled again and the dead-letter write
+  is retried (no commit moves past it).
+- New optional `Rewinder` protocol (`rewind(message)`), implemented by `KafkaTransport` and
+  exported from `babelqueue`; the runtime calls it after a failed version-gate dead-letter write
+  and then pauses briefly (1 s) before the next poll.
+  The rejected version is capped at 64 characters plus `...` in the log and the route.
+
 ## [1.15.0] - 2026-10-10
 
 ### Added
 
@@ -124,6 +124,43 @@ app.run()                               # consume forever (Ctrl-C to stop)
   the message unchanged once `shutdown_timeout` expires. Delivery is
   **at-least-once** — keep handlers idempotent (see the idempotency helper).
 
+### Unsupported `schema_version` (SQS, Azure Service Bus, Kafka, Artemis, Pulsar)
+
+These transports read the binding's schema-version property (`bq-schema-version`; Artemis
+`bq_schema_version`) **before** decoding the body. A missing or blank value (empty or only
+ASCII whitespace) follows the normal path; any other value must be exactly `"1"` (compared
+untrimmed; Azure Service Bus and Artemis also accept the integer `1`). A message carrying
+anything else is not decoded: it reaches the runtime on the reserved route
+`babelqueue:unsupported-schema-version:<v>` (the version percent-escaped) and is **never
+retried** — it goes straight to the dead-letter queue (reason `unknown_urn`, the body kept
+verbatim) when `dead_letter` is enabled, and is dropped otherwise, whatever `max_attempts` is.
+It does not depend on a broker `RedrivePolicy`. If the dead-letter write fails the message is
+left unacknowledged (an error is logged), is never retried and never reaches a handler; the
+dead-letter write is attempted again when the broker brings it back, which depends on the
+broker:
+
+- **SQS** — redelivered when the visibility timeout expires.
+- **Azure Service Bus** — redelivered when the message lock expires.
+- **Artemis** — an unsettled AMQP 1.0 delivery is returned only when the link or connection
+  closes, so it stays unsettled until then.
+- **Kafka** — offsets are committed cumulatively per partition, so merely skipping the commit
+  would lose the record once a later one is committed. The transport therefore implements
+  the optional `Rewinder` protocol: it `seek`s the partition back to the failed record's
+  offset and pauses `_rewind_pause` (1 s by default, so an unavailable DLQ is not hammered)
+  before the record is polled again; the gate rejects it again and the dead-letter write
+  is retried. While the dead-letter write keeps failing (for example the `.dlq` topic is not
+  writable) the partition **stalls on that record** (head-of-line blocking, consumer lag
+  grows) and the worker waits the pause on every attempt, which also delays its other
+  partitions and queues. The commit does not move past the record as long as the seek
+  succeeds; if the seek itself fails, an error naming the topic, partition and offset is
+  logged and a later commit on that partition may skip the record, so recover it by hand from
+  that offset. If the partition was lost to a rebalance, the new owner resumes from the last
+  committed offset and the record is not lost.
+- **Pulsar** — acknowledgement is per message; the unacknowledged message is redelivered by
+  the broker.
+
+A warning naming the version (cut at 64 characters plus `...`) and queue is logged.
+
 ### SQS release and poison messages
 
 On a handler failure, unknown-URN `release` or shutdown release, the SQS
 
@@ -34,6 +34,7 @@
     InMemoryTransport,
     ReceivedMessage,
     Redeliverer,
+    Rewinder,
     RoutedPublisher,
     Transport,
 )
@@ -53,6 +54,7 @@
     "ReceivedMessage",
     "HeaderPublisher",
     "Redeliverer",
+    "Rewinder",
     "RoutedPublisher",
     "BabelQueueError",
     "UnknownUrnError",
 
@@ -43,6 +43,7 @@ def on_order_created(data, meta):
     HeaderPublisher,
     ReceivedMessage,
     Redeliverer,
+    Rewinder,
     Transport,
     make_transport,
     publish_keeping_route,
@@ -111,6 +112,7 @@ def __init__(
         self.shutdown_timeout = float(shutdown_timeout)
         self._handlers: Dict[str, Handler] = {}
         self._stop = threading.Event()
+        self._rewind_pause = 1.0  # seconds to wait before a rewound gated message is re-polled
         self._phase = _IDLE
         self._last_phase = _IDLE
         self._signalled = False
@@ -295,6 +297,20 @@ def dispatch(self, received: ReceivedMessage) -> None:
                 self._phase = _SETTLING
             except Exception as exc:  # noqa: BLE001 - one bad message must not kill the loop
                 self._phase = _SETTLING
+                if received.route_urn.startswith(_UNSUPPORTED_SCHEMA_ROUTE_PREFIX):
+                    # A version-gated delivery never takes the generic retry path, even when its
+                    # dead-letter write fails: a retry re-publish may rebuild the version header
+                    # from the (valid) body and walk the message past the gate into a handler.
+                    # It is left unacked; the broker (or a rewind, for cumulative-offset brokers
+                    # such as Kafka) brings it back and the gate rejects it again.
+                    logger.error(
+                        "Dead-lettering a version-gated message on queue %r failed; it was NOT "
+                        "retried or acknowledged; it will come back and the dead-letter write will be retried.",
+                        received.queue,
+                        exc_info=exc,
+                    )
+                    self._rewind_unsettled(received)
+                    return
                 self._retry_or_dead_letter(received, envelope, exc)
             else:
                 # Outside the handler's try: a failed ack is not a handler failure, so it must
@@ -417,6 +433,23 @@ def _ack_settled(self, received: ReceivedMessage) -> None:
                 exc_info=True,
             )
 
+    def _rewind_unsettled(self, received: ReceivedMessage) -> None:
+        """Make a deliberately unsettled message come back (cumulative-offset brokers such as Kafka
+        would otherwise lose it when a later record on the partition is committed), after a short
+        pause so an unavailable DLQ is not hammered in a hot loop."""
+        if not isinstance(self.transport, Rewinder):
+            return
+        try:
+            self.transport.rewind(received)
+        except Exception:  # noqa: BLE001 - reported, never kills the loop
+            logger.error(
+                "Failed to rewind an unsettled version-gated message on queue %r.",
+                received.queue,
+                exc_info=True,
+            )
+            return
+        self._stop.wait(self._rewind_pause)
+
     def _release_unprocessed(self, received: ReceivedMessage) -> None:
         """Release a message whose handler never completed (shutdown): unchanged body, no
         backoff, and the runtime adds no ``attempts`` increment. A broker that counts
@@ -440,23 +473,35 @@ def _route_unknown(self, urn: str, received: ReceivedMessage, envelope: Mapping[
         if strategy == UnknownUrnStrategy.DELETE:
             self._ack_settled(received)
             return
-        # A transport's version-gated delivery, an undecodable body or a body naming no URN can
-        # never gain a handler, so releasing it unchanged would redeliver it forever. It takes the
-        # bounded FAIL path instead (retry up to max_attempts, then dead-letter or drop); only a
-        # genuinely unknown URN keeps the verbatim release.
-        gated = received.route_urn.startswith(_UNSUPPORTED_SCHEMA_ROUTE_PREFIX)
-        poison = gated or not urn
-        if strategy == UnknownUrnStrategy.RELEASE and not poison:
+        # A transport's version-gated delivery (unsupported ``bq-schema-version``) can never gain
+        # a handler and must not be retried: a retry re-publishes through paths that may rebuild
+        # the version header from the (valid) body, or never advance the attempt counter, so the
+        # gate would be bypassed or the message would loop. It goes straight to the DLQ (or is
+        # dropped when no DLQ is configured).
+        if received.route_urn.startswith(_UNSUPPORTED_SCHEMA_ROUTE_PREFIX):
+            self._settle_version_gated(received, envelope)
+            return
+        # An undecodable body or a body naming no URN can never gain a handler either, so
+        # releasing it unchanged would redeliver it forever. It takes the bounded FAIL path
+        # instead (retry up to max_attempts, then dead-letter or drop); only a genuinely unknown
+        # URN keeps the verbatim release.
+        if strategy == UnknownUrnStrategy.RELEASE and urn:
             self._release(received, received.body, self.unknown_urn_release_delay)
             return
         if strategy == UnknownUrnStrategy.DEAD_LETTER:
             self._dead_letter(received, dict(envelope), "unknown_urn", None)
             return
         # FAIL (and RELEASE of a poison message) — surfaced through the retry/dead-letter path
-        # (never kills the loop). A gated delivery names its reserved route (the rejected version).
-        raise UnknownUrnError(
-            f"No handler mapped for URN [{urn or (received.route_urn if gated else '') or '(empty)'}]."
-        )
+        # (never kills the loop).
+        raise UnknownUrnError(f"No handler mapped for URN [{urn or '(empty)'}].")
+
+    def _settle_version_gated(self, received: ReceivedMessage, envelope: Mapping[str, Any]) -> None:
+        """Dead-letter a version-gated delivery directly (no retry); drop it when no DLQ is set."""
+        if self.dead_letter_enabled or self.on_unknown_urn == UnknownUrnStrategy.DEAD_LETTER:
+            error = UnknownUrnError(f"No handler mapped for URN [{received.route_urn}].")
+            self._dead_letter(received, dict(envelope), "unknown_urn", error)
+            return
+        self._ack_settled(received)
 
     def _retry_or_dead_letter(
         self, received: ReceivedMessage, envelope: Dict[str, Any], exc: BaseException
@@ -500,7 +545,8 @@ def _dead_letter(
 #: Reserved ``ReceivedMessage.route_urn`` prefix a transport uses to hand over a delivery it
 #: version-gated (broker-bindings §5.7 step 3, e.g. the pulsar transport's ``bq-schema-version``
 #: check). Not a ``urn:babel:`` URN, so no handler owns it. Must equal
-#: ``pulsar_transport.UNSUPPORTED_SCHEMA_ROUTE_PREFIX`` (locked by a test); never reaches the wire.
+#: ``UNSUPPORTED_SCHEMA_ROUTE_PREFIX`` of the pulsar, sqs, asb, kafka and artemis transports (locked
+#: by a test); never reaches the wire. A delivery under it is dead-lettered directly, never retried.
 _UNSUPPORTED_SCHEMA_ROUTE_PREFIX = "babelqueue:unsupported-schema-version:"
 
 
 
@@ -32,10 +32,24 @@
 
 from __future__ import annotations
 
+import logging
+import re
 from typing import Any, Dict, Optional
+from urllib.parse import quote
 
-from .codec import EnvelopeCodec, parse_envelope
-from .transport import ReceivedMessage, Transport
+from .codec import SCHEMA_VERSION, EnvelopeCodec, parse_envelope
+from .transport import ReceivedMessage, Transport, truncate_declared_version
+
+_logger = logging.getLogger("babelqueue.artemis")
+
+#: A blank ``bq_schema_version``: empty or only ASCII whitespace (space, \t, \n, \v, \f, \r) — the
+#: same set in every SDK (GR-5). Deliberately not ``str.strip()``, which also strips U+001C-U+001F,
+#: U+0085, U+00A0, U+2028, U+3000 ...
+_BLANK_ASCII_PATTERN = re.compile(r"[ \t\n\x0b\x0c\r]*")
+#: Prefix of the reserved ``route_urn`` a version-gated message is delivered under. It is not a
+#: ``urn:babel:`` URN, so no handler can legitimately own it; the runtime reports it as an
+#: unknown URN, which names the rejected ``bq_schema_version``.
+UNSUPPORTED_SCHEMA_ROUTE_PREFIX = "babelqueue:unsupported-schema-version:"
 
 JMS_TYPE_ANNOTATION = "x-opt-jms-type"
 APP_ID = "babelqueue"
@@ -187,6 +201,33 @@ def _delivery_count(message: Any) -> int:
         except (TypeError, ValueError):  # pragma: no cover - defensive
             return 0
 
+    @staticmethod
+    def _unsupported_schema_version(properties: Any) -> Optional[str]:
+        """The §7.7 step-3 gate on the ``bq_schema_version`` application property (underscores —
+        ADR-0017): the offending raw value, or ``None``.
+
+        A missing property, a null value or a blank value (the empty string or only ASCII
+        whitespace — the same set in every SDK, GR-5, not ``str.strip()``) is not gated: the usual
+        decode path runs. A ``bytes`` value is decoded as UTF-8. A present value is accepted only
+        when it is exactly the core's supported ``SCHEMA_VERSION``: the string ``"1"`` or the
+        integer ``1`` (a ``bool`` is not an integer here, though it is one in Python); ``"2"``,
+        ``"x"``, ``"01"``, ``" 1"``, ``0``, ``2``, ``1.5``, ``True`` and any other type are
+        rejected."""
+        if not isinstance(properties, dict):
+            return None
+        raw = properties.get("bq_schema_version")
+        if raw is None:
+            return None
+        if isinstance(raw, (bytes, bytearray)):
+            raw = bytes(raw).decode("utf-8", "replace")
+        if isinstance(raw, str):
+            if _BLANK_ASCII_PATTERN.fullmatch(raw) is not None or raw == str(SCHEMA_VERSION):
+                return None
+            return raw
+        if isinstance(raw, int) and not isinstance(raw, bool) and raw == SCHEMA_VERSION:
+            return None
+        return str(raw)
+
     @staticmethod
     def _payload(message: Any) -> str:
         body = getattr(message, "body", None)
@@ -212,6 +253,26 @@ def pop(self, queue: str, timeout: float = 1.0) -> Optional[ReceivedMessage]:
             raise
         if message is None:  # pragma: no cover - defensive (real client raises instead)
             return None
+        # §7.7 step 3: gate on the ``bq_schema_version`` property BEFORE any body decode (the
+        # attempts reconcile below decodes the body). A rejected message keeps its raw body and the
+        # reserved route; the runtime then dead-letters it directly (no retry).
+        unsupported = truncate_declared_version(
+            self._unsupported_schema_version(getattr(message, "properties", None))
+        )
+        if unsupported is not None:
+            _logger.warning(
+                "Artemis message on %r carries unsupported bq_schema_version %r (supported: %s); "
+                "not decoding it.",
+                queue,
+                unsupported,
+                SCHEMA_VERSION,
+            )
+            return ReceivedMessage(
+                body=self._payload(message),
+                queue=queue,
+                handle=receiver,
+                route_urn=UNSUPPORTED_SCHEMA_ROUTE_PREFIX + quote(unsupported, safe=""),
+            )
         body = self._reconcile(self._payload(message), self._delivery_count(message))
         return ReceivedMessage(body=body, queue=queue, handle=receiver)