Implement push queue DLQ

docs/asynchronous-outbound-messaging-design.md

@@ -597,6 +597,30 @@ that would normally be dropped by the `PushPolicy::DropIfFull` or
 part of the application is then responsible for consuming from the DLQ to
 inspect, log, and potentially retry these failed messages.
 
+The following sequence diagram illustrates how frames are routed when a DLQ is
+configured:
+
+```mermaid
+sequenceDiagram
+    participant Producer
+    participant PushHandle
+    participant HighPrioQueue
+    participant DLQ as DeadLetterQueue
+    Producer->>PushHandle: try_push(frame, priority, DropIfFull)
+    PushHandle->>HighPrioQueue: try_send(frame)
+    alt Queue full
+        PushHandle->>DLQ: try_send(frame)
+        alt DLQ full
+            PushHandle->>PushHandle: log error (frame lost)
+        else DLQ has space
+            DLQ-->>PushHandle: frame accepted
+        end
+    else Queue has space
+        HighPrioQueue-->>PushHandle: frame accepted
+    end
+    PushHandle-->>Producer: Ok or logs
+```
+
 ### 5.3 Typed protocol errors
 
 `WireframeError` distinguishes transport failures from protocol logic errors. A

docs/asynchronous-outbound-messaging-roadmap.md

@@ -44,7 +44,7 @@ design documents.
   ([Design §5][design-errors]).
 - [x] **Per-connection rate limiting** on pushes via a token bucket
   ([Resilience Guide §4.1][resilience-rate]).
-- [ ] **Optional Dead Letter Queue** for full queues
+- [x] **Optional Dead Letter Queue** for full queues
   ([Design §5.2][design-dlq]).
 
 ## 4. Observability and Quality Assurance

docs/hardening-wireframe-a-guide-to-production-resilience.md

@@ -242,7 +242,8 @@ token-bucket algorithm is ideal.
 use wireframe::push::PushQueues;
 
 // Configure a connection to allow at most 100 pushes per second.
-let (queues, handle) = PushQueues::<Frame>::bounded_with_rate(8, 8, Some(100));
+let (queues, handle) =
+    PushQueues::<Frame>::bounded_with_rate(8, 8, Some(100)).unwrap();
 
 // Passing `None` disables rate limiting entirely:
 let (_unlimited, _handle) = PushQueues::<Frame>::bounded_no_rate_limit(8, 8);

docs/rust-testing-with-rstest-fixtures.md

@@ -540,10 +540,10 @@ When using `#[once]`, there are critical warnings:
    the end of the test suite. This makes `#[once]` fixtures best suited for
    truly passive data or resources whose cleanup is managed by the operating
    system upon process exit.
-1. **Functional Limitations:** `#[once]` fixtures cannot be `async` functions
+2. **Functional Limitations:** `#[once]` fixtures cannot be `async` functions
    and cannot be generic functions (neither with generic type parameters nor
    using `impl Trait` in arguments or return types).
-1. **Attribute Propagation:** `rstest` macros currently drop `#[expect]`
+3. **Attribute Propagation:** `rstest` macros currently drop `#[expect]`
    attributes. If you rely on lint expectations, use `#[allow]` instead to
    silence false positives.
 
@@ -1168,13 +1168,13 @@ The following table summarizes key differences:
 **Table 1:** `rstest` **vs. Standard Rust** `#[test]` **for Fixture Management
 and Parameterization**
 
-| Feature | Standard #[test] Approach | rstest Approach |
+| Feature                                                       | Standard #[test] Approach                                     | rstest Approach                                                                  |
 | ------------------------------------------------------------- | ------------------------------------------------------------- | -------------------------------------------------------------------------------- |
-| Fixture Injection | Manual calls to setup functions within each test. | Fixture name as argument in #[rstest] function; fixture defined with #[fixture]. |
-| Parameterized Tests (Specific Cases) | Loop inside one test, or multiple distinct #[test] functions. | #[case(...)] attributes on #[rstest] function. |
-| Parameterized Tests (Value Combinations) | Nested loops inside one test, or complex manual generation. | #[values(...)] attributes on arguments of #[rstest] function. |
-| Async Fixture Setup | Manual async block and .await calls inside test. | async fn fixtures, with #[future] and #[awt] for ergonomic `.await`ing. |
-| Reusing Parameter Sets | Manual duplication of cases or custom helper macros. | rstest_reuse crate with #[template] and #[apply] attributes. |
+| Fixture Injection                                             | Manual calls to setup functions within each test.             | Fixture name as argument in #[rstest] function; fixture defined with #[fixture]. |
+| Parameterized Tests (Specific Cases)                          | Loop inside one test, or multiple distinct #[test] functions. | #[case(...)] attributes on #[rstest] function.                                   |
+| Parameterized Tests (Value Combinations)                      | Nested loops inside one test, or complex manual generation.   | #[values(...)] attributes on arguments of #[rstest] function.                    |
+| Async Fixture Setup                                           | Manual async block and .await calls inside test.              | async fn fixtures, with #[future] and #[awt] for ergonomic `.await`ing.          |
+| Reusing Parameter Sets                                        | Manual duplication of cases or custom helper macros.          | rstest_reuse crate with #[template] and #[apply] attributes.                     |
 
 This comparison highlights how `rstest`'s attribute-based, declarative approach
 streamlines common testing patterns, reducing manual effort and improving the
@@ -1335,20 +1335,20 @@ provided by `rstest`:
 
 **Table 2: Key** `rstest` **Attributes Quick Reference**
 
-| Attribute | Core Purpose |
+| Attribute                    | Core Purpose                                                                                 |
 | ---------------------------- | -------------------------------------------------------------------------------------------- |
-| #[rstest] | Marks a function as an rstest test; enables fixture injection and parameterization. |
-| #[fixture] | Defines a function that provides a test fixture (setup data or services). |
-| #[case(...)] | Defines a single parameterized test case with specific input values. |
-| #[values(...)] | Defines a list of values for an argument, generating tests for each value or combination. |
-| #[once] | Marks a fixture to be initialized only once and shared (as a static reference) across tests. |
-| #[future] | Simplifies async argument types by removing impl Future boilerplate. |
-| #[awt] | (Function or argument level) Automatically .awaits future arguments in async tests. |
-| #[from(original_name)] | Allows renaming an injected fixture argument in the test function. |
-| #[with(...)] | Overrides default arguments of a fixture for a specific test. |
-| #[default(...)] | Provides default values for arguments within a fixture function. |
-| #[timeout(...)] | Sets a timeout for an asynchronous test. |
-| #[files("glob_pattern",...)] | Injects file paths (or contents, with mode=) matching a glob pattern as test arguments. |
+| #[rstest]                    | Marks a function as an rstest test; enables fixture injection and parameterization.          |
+| #[fixture]                   | Defines a function that provides a test fixture (setup data or services).                    |
+| #[case(...)]                 | Defines a single parameterized test case with specific input values.                         |
+| #[values(...)]               | Defines a list of values for an argument, generating tests for each value or combination.    |
+| #[once]                      | Marks a fixture to be initialized only once and shared (as a static reference) across tests. |
+| #[future]                    | Simplifies async argument types by removing impl Future boilerplate.                         |
+| #[awt]                       | (Function or argument level) Automatically .awaits future arguments in async tests.          |
+| #[from(original_name)]       | Allows renaming an injected fixture argument in the test function.                           |
+| #[with(...)]                 | Overrides default arguments of a fixture for a specific test.                                |
+| #[default(...)]              | Provides default values for arguments within a fixture function.                             |
+| #[timeout(...)]              | Sets a timeout for an asynchronous test.                                                     |
+| #[files("glob_pattern",...)] | Injects file paths (or contents, with mode=) matching a glob pattern as test arguments.      |
 
 By mastering `rstest`, Rust developers can significantly elevate the quality and
 efficiency of their testing practices, leading to more reliable and maintainable