diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c70b6ad1cf3..5fb2f91f80d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -67,7 +67,7 @@ Releases are cut separately; bump only when asked. Each package's version lives
- **Rust**: release-plz owns crate versions and Rust dependency requirements.
- **JavaScript**: `js/*/package.json` packages with a `scripts.release` entry (skip private ones like `@moq/clock`, `@moq/wasm`), plus the matching workspace version in `bun.lock`.
-- **Python**: `py/moq-rs/pyproject.toml` only; `py/moq-ffi` follows the `moq-ffi-v*` tag and Rust crate.
+- **Python**: `py/moq-rs/pyproject.toml`, plus the matching `moq-rs` entry in the root `uv.lock`; `py/moq-ffi` follows the `moq-ffi-v*` tag and Rust crate.
- **Swift**: `swift/VERSION`. **Kotlin**: `moq.version` in `kt/gradle.properties`. **Dart**: `version` in `dart/moq/pubspec.yaml`. Their FFI counterparts track the Rust crate.
- **Go**: `go/wrapper/VERSION` holds a human-owned `MAJOR.MINOR` line; CI derives the patch, so only edit it for a breaking API. Leave the placeholder FFI version in `go.mod` alone.
-- **OBS**: the plugin takes the `libmoq` crate's version (`cpp/obs/CMakeLists.txt`), so release-plz owns it.
+- **OBS**: release builds take their version from the `libmoq-v*` tag that release-plz cuts for the `libmoq` crate (`cpp/obs/build.sh --libmoq-release`), not from any manifest, so there is nothing to bump.
diff --git a/doc/lib/py/index.md b/doc/lib/py/index.md
index 109d8bab30d..609f957aee3 100644
--- a/doc/lib/py/index.md
+++ b/doc/lib/py/index.md
@@ -71,7 +71,7 @@ asyncio.run(main())
For already-encoded live output, call `audio.flush(timestamp_us)` after each `audio.write_frame` with the same broadcast-clock PTS. It samples the transport handoff for catalog jitter. File, pipe, and network imports should omit `flush`; raw-pixel and PCM encoders inside the binding measure their own output.
-Call `audio.discontinuity()` when the source seeks, pauses, or changes its time base. It publishes a timeline marker and restarts handoff measurement without lowering advertised jitter. Resume with timestamps that continue forward on the broadcast media clock; this does not permit timestamp rewinds. On a video track, resume with a keyframe: a delta frame before it fails.
+Call `audio.discontinuity()` when the source seeks, pauses, or changes its time base. It publishes a timeline marker and restarts handoff measurement without lowering advertised jitter. Resume with timestamps that continue forward on the broadcast media clock; this does not permit timestamp rewinds. On a track from `publish_video` or `publish_video_on_track`, resume with a keyframe: a delta frame before it fails.
The three advertising operations, as the other bindings spell them:
`client.create_broadcast(path)` (or `OriginProducer.create_broadcast`) returns
diff --git a/doc/lib/swift/index.md b/doc/lib/swift/index.md
index f9a6f6263bb..8cc2695afe1 100644
--- a/doc/lib/swift/index.md
+++ b/doc/lib/swift/index.md
@@ -57,7 +57,7 @@ session.shutdown()
For already-encoded live output, call `audio.flush(timestampUs:)` after `writeFrame` with the same broadcast-clock PTS. It measures catalog jitter at the transport handoff. File, pipe, and network imports should omit `flush`; built-in encoders observe their own output.
-Call `audio.discontinuity()` when the source seeks, pauses, or changes its time base. It publishes a timeline marker and restarts handoff measurement without lowering advertised jitter. Resume with timestamps that continue forward on the broadcast media clock; this does not permit timestamp rewinds. On a video track, resume with a keyframe: a delta frame before it fails.
+Call `audio.discontinuity()` when the source seeks, pauses, or changes its time base. It publishes a timeline marker and restarts handoff measurement without lowering advertised jitter. Resume with timestamps that continue forward on the broadcast media clock; this does not permit timestamp rewinds. On a track from `publishVideo`, resume with a keyframe: a delta frame before it fails.
The three advertising operations: `session.publish.createBroadcast(path:)`
returns an unannounced producer, invisible to everyone; `broadcast.announce(route:)` /
diff --git a/js/net/src/stream.test.ts b/js/net/src/stream.test.ts
index b84af33f501..8ecdede0ca5 100644
--- a/js/net/src/stream.test.ts
+++ b/js/net/src/stream.test.ts
@@ -444,6 +444,20 @@ test("Reader decode rejects a stream that ends inside a message", async () => {
await expect(reader.decode(sized)).rejects.toThrow("unexpected end of stream");
});
+test("Reader refuses an oversized value even when it is already buffered", async () => {
+ const size = 64 * 1024 * 1024 + 1;
+ const buffer = new Uint8Array(4 + size);
+ buffer.set([0x84, 0x00, 0x00, 0x01]); // the 4-byte varint for size
+ await expect(new Reader(undefined, buffer).string()).rejects.toThrow("exceeds max size");
+ await expect(new Reader(undefined, buffer.subarray(4)).read(size)).rejects.toThrow("exceeds max size");
+});
+
+test("Reader refuses a buffered decode whose fields together exceed the max size", async () => {
+ const half = 32 * 1024 * 1024;
+ const reader = new Reader(undefined, new Uint8Array(2 * half + 1));
+ await expect(reader.decode((c) => [c.read(half), c.read(half + 1)])).rejects.toThrow("exceeds max size");
+});
+
/** A stream reset as a transport delivers one: the peer's code, and nothing else useful. */
class Reset extends Error {
readonly source = "stream" as const;
diff --git a/js/net/src/stream.ts b/js/net/src/stream.ts
index 5848accad26..8093e4495c1 100644
--- a/js/net/src/stream.ts
+++ b/js/net/src/stream.ts
@@ -446,6 +446,9 @@ export class Cursor {
#ensure(size: number) {
const need = this.#offset + size;
+ // Checked here too, and on the whole decode like the fill, since bytes that are already
+ // buffered never reach the fill.
+ if (need > MAX_READ_SIZE) throw new Error(`read size ${need} exceeds max size ${MAX_READ_SIZE}`);
if (need > this.#buffer.byteLength) throw new Short(need);
}
diff --git a/quest/m1/README.md b/quest/m1/README.md
index 1798728a6da..f95890302b9 100644
--- a/quest/m1/README.md
+++ b/quest/m1/README.md
@@ -32,6 +32,7 @@ transport, benchmark tooling); worktrees isolate commits, not semantics.
- [Remove finish](/quest/m1/broadcast-remove.md) - on dev, the deprecated broadcast end APIs are gone and `closed()` carries no cause
- [CLI inspection](/quest/m1/cli-inspect/README.md) - `moq ls` lists what is live and `moq fetch` reads a group over MoQ, and a guide shows how to inspect a relay
- [Session close](/quest/m1/session-close.md) - a graceful session end withdraws announces and waits one second for the ack
+- [Drain before close](/quest/m1/drain-before-close.md) - a closing client delivers its queued stream finishes, so `moq import` ends the catalog cleanly over a real relay
- [Close codes](/quest/m1/close-codes.md) - a client sees the peer's application close code over WebSocket and raw QUIC, like WebTransport
- [Raw stream codes](/quest/m1/raw-stream-codes.md) - raw QUIC stream resets and stops carry the application's code, not an HTTP/3-mapped one
- [JS caught up](/quest/m1/js-announce-caught-up.md) - @moq/net's announce consumer says when the initial set has landed, like Rust
@@ -48,13 +49,14 @@ transport, benchmark tooling); worktrees isolate commits, not semantics.
- [moq play decode schedule](/quest/m1/play-decode-schedule.md) - `moq play` video keeps valid pictures across rewinds, reordering deeper than 100 ms, and decoder batches larger than three
- [moqsrc stop](/quest/m1/moqsrc-stop.md) - moqsrc's stop blocks until its session ends, without deadlocking on a blocked pad push
- [More tests under load](/quest/m1/test-flakes-2.md) - the second round of load-only failures, fixed at the cause
+- [Interop contention](/quest/m1/interop-contention.md) - two `just test interop --all` matrices pass side by side, and `just test harness` runs from a clean checkout
- [UnknownSession log flood](/quest/m1/unknown-session-logs.md) - streams reset before their WebTransport header stop being reported as UnknownSession at WARN
- [Merge queue](/quest/m1/merge-queue.md) - the required checks run on `merge_group`, so a stale green check can no longer break main
- [Wire compatibility](/quest/m1/wire-compat.md) - a nightly run tests this checkout against the last published release for tokens, session wire, and catalog/container
- [Accept-side flags](/quest/m1/cli-given-flags.md) - dial-only and local verbs refuse every `--listen-*` flag instead of ignoring it
- [JS catalog path](/quest/m1/js-catalog-path.md) - `@moq/net` broadcast consumers expose their path and `Catalog.watch` rejects escaping references, like Rust
- [Full codec string](/quest/m1/publish-codec-string.md) - browser-published video carries the encoder's full RFC 6381 codec string, so native players decode it
-- [TS export jitter](/quest/m1/ts-export-jitter.md) - the video reorder bound follows later catalogs and observed reordering, so a late B-frame never reorders TS output
+- [TS export jitter](/quest/m1/ts-export-jitter.md) - the video reorder bound follows later catalogs and the declared reorder depth, so a late B-frame never reorders TS output; an undeclared stream can reorder once per new maximum depth
- [TS import shared shift](/quest/m1/ts-import-shared-shift.md) - unflagged loop wraps move audio and video by one shift, so A/V sync holds across wraps
- [PipeWire duplicate cameras](/quest/m1/pipewire-dup-cameras.md) - a webcam lists once with PipeWire enabled
- [Catalog wall clock](/quest/m1/catalog-wall-clock.md) - `Clock::wall_clock` keeps the catalog's full precision instead of truncating to milliseconds
@@ -104,7 +106,6 @@ transport, benchmark tooling); worktrees isolate commits, not semantics.
- [Own the QUIC stack](/quest/m1/quic/README.md) - the moq-noq fork carries
ACK progress, reliable reset, hierarchical scheduling, deadlines, probing,
keep-alive, peer limits, careful resume, ECN, and qmux
-- [BBR idle burst](/quest/m1/bbr-idle-burst.md) - a BBRv3 burst after a long idle paces near the learned bandwidth, proven by a fork regression
- [P2P](/quest/m1/p2p/README.md) - opted-in clients serve each other over data channels and iroh while the relay stays the rendezvous and the fallback, under application policy
- [One port](/quest/m1/one-port/README.md) - a relay speaks QUIC, STUN, WebRTC media, and SRT on one UDP port and HTTP, RTMP, and RTMPS on one TCP port
- [Signed priority](/quest/m1/signed-priority.md) - on dev, every API priority is an `i8` with 0 as the unset midpoint, and hang's built-ins sit above it
@@ -120,6 +121,7 @@ transport, benchmark tooling); worktrees isolate commits, not semantics.
- [#3126](/quest/m1/3126-moq-bench-every-readme-example-fails-to-parse-and.md) - moq-bench reports per-interval latency percentiles so the ramp leaves the steady state
- [Relay session bench](/quest/m1/bench-relay.md) - the same scenario through moq-relay's own connection handling
- [Bench coverage](/quest/m1/bench-coverage.md) - Criterion targets for moq-mux containers, the hang catalog, moq-auth verification, and moq-pattern matching
+- [Stats producer bench](/quest/m1/stats-producer-bench.md) - the stats drain and encode cost per tick, swept over held paths and tiers and run nightly
- [Relay profiling](/quest/m1/performance-profiles.md) - reproducible CPU and allocation captures under the existing workloads
- [Browser benchmarks](/quest/m1/browser-benchmarks.md) - measure JS transport, container, decode, and render costs in an identified browser
- [Generated @moq/net](/quest/m1/rs2ts/README.md) - the browser runs moq-net as TypeScript generated from the Rust source, retiring js/net's hand-written protocol and model code
diff --git a/quest/m1/bbr-idle-burst.md b/quest/m1/bbr-idle-burst.md
deleted file mode 100644
index 480cbad8304..00000000000
--- a/quest/m1/bbr-idle-burst.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# [S] BBR idle burst
-
-## Goal
-
-After a long keep-alive-only idle, a BBRv3 (`delay`) sender paces its next
-burst near the bandwidth it learned before, not at one packet per RTT. A
-regression test proves it.
-
-## Plan
-
-- The likely fix already shipped: moq-dev/noq#5 tells the controller of
- starvation before the next send, released in moq-noq 1.3.1 and pinned by
- #4206. The reporter ran 1.3.0. Nobody has reproduced the stall on either.
-- In the fork, add a virtual-time transport test: learn the bandwidth, run
- keep-alive only for about five minutes, send 250 KB, and assert the pacing
- rate stays at or above about 0.9x the earlier max bandwidth. It must fail on
- 1.3.0 and pass on 1.3.1. The existing label tests do not check the rate.
-- If 1.3.1 still stalls, find the remaining cause (a stale `bw_shortterm` or a
- ProbeRTT effect after idle) and fix it in the fork. Dropping the estimate
- after long idle is a policy change for the m2 study, not this quest.
-- The `iroh` feature uses upstream noq, which lacks the fix; offering it there
- belongs to the upstream quest.
-
-## Closes
-
-- [#4219](https://github.com/moq-dev/moq/issues/4219) - the first send after an idle period is paced at a trickle
-
-## Related
-
-- [Upstream the fork](/quest/m1/quic/upstream.md) - offer the starvation fix to n0-computer/noq
-- [BBR3 app-limited](/quest/m2/quic-bbr-app-limited.md) - broader media measurements
diff --git a/quest/m1/data-capture-bindings.md b/quest/m1/data-capture-bindings.md
index 11f969227f8..dcb3ecc3ddd 100644
--- a/quest/m1/data-capture-bindings.md
+++ b/quest/m1/data-capture-bindings.md
@@ -5,7 +5,8 @@
A moq-ffi publisher, and every wrapper over it (Python, Swift, Kotlin, Go,
Dart), can pass a capture time with a JSON or binary snapshot `update` or
stream `append`, so its data tracks advertise `delay` and `jitter` like a Rust
-publisher's. Leaving it out keeps today's behaviour. `moq-json`'s `window`
+publisher's. Leaving it out keeps today's behaviour. The Go and Python
+wrappers gain the binary snapshot and stream producers they lack. `moq-json`'s `window`
producer takes a capture time too. Settled scope: moq-ffi and its wrappers,
not libmoq.
@@ -30,13 +31,19 @@ not libmoq.
stream producers do. Nothing in `moq-mux` publishes window mode, so there is
no estimator to feed.
- Wrappers follow per the cross-package sync table, each with a test that a
- past capture time is accepted and a future one refused. Update
+ past capture time is accepted and a future one refused.
+- Go (`go/wrapper/moq`) and Python (`py/moq-rs`) wrap only the JSON
+ producers; [#4137](https://github.com/moq-dev/moq/pull/4137) added
+ `publish_binary_snapshot` / `publish_binary_stream` to moq-ffi without
+ them. Add hand-written binary wrappers there, capture time included, so
+ the capture tests cover binary too. The maintainer asked for this. Update
`doc/lib/{py,swift,kt,go,dart}`.
Public API: breaking, so it lands on `dev`. A new parameter on the generated
`update` and `append` breaks every published binding caller (Go, for one, has
no optional arguments), and a `_with_x` twin is ruled out. The broadcast clock
-`now()` is additive; `window::Producer::push` accepts `Timed`, source-compatible.
+`now()` and the Go and Python binary producers are additive;
+`window::Producer::push` accepts `Timed`, source-compatible.
Wire: none.
## Related
diff --git a/quest/m1/drain-before-close.md b/quest/m1/drain-before-close.md
new file mode 100644
index 00000000000..f24ff82b571
--- /dev/null
+++ b/quest/m1/drain-before-close.md
@@ -0,0 +1,40 @@
+# [M] Deliver queued stream data before a client closes
+
+## Goal
+
+A process that finishes its tracks and then closes its `moq_tokio::Client`
+delivers what it already queued, including each stream's FIN, before the
+connection closes, bounded by a deadline. `moq import` at stdin EOF is the
+consumer: a subscriber over a real relay sees the catalog finish instead of
+`Error::Dropped`.
+
+## Plan
+
+- [#4303](https://github.com/moq-dev/moq/pull/4303) made `moq import` finish
+ the catalog at EOF, but only in-process: over a real session the process
+ exits and the close discards the queued finish.
+ [#4287](https://github.com/moq-dev/moq/pull/4287) added `Client::close`,
+ which sends the CONNECTION_CLOSE but does not wait for stream data.
+- A QUIC close discards unacknowledged stream data, so the session has to
+ wait until its open send streams are written, finished, and acknowledged,
+ not only handed to the transport. The pending group and control writes live
+ in moq-net's session tasks; the transport wait lives in moq-tokio.
+- Bound the wait so a stalled peer cannot hang an exiting process. Share the
+ deadline and the graceful path with
+ [Session close](/quest/m1/session-close.md), which waits for announce
+ acknowledgements the same way; `abort` and drop stay immediate.
+- Cover every backend `Client::close` covers, and say which do not drain
+ (WebSocket and iroh end on drop today).
+- Regression tests: a moq-tokio test, shaped like
+ `noq_client_close_reaches_server`, where the client finishes a track and
+ closes on a runtime dropped right after, and the server's subscriber reads
+ the finish rather than a drop. Then a CLI test piping a file through
+ `moq import` to a relay.
+
+Public API: likely additive (`Client::close` gains the drain, or a graceful
+close sits beside `abort`). Wire: none.
+
+## Related
+
+- [Session close](/quest/m1/session-close.md) - the graceful end that withdraws announces
+- [Graceful relay drains](/quest/m1/drain/README.md) - the server-side drain over GOAWAY
diff --git a/quest/m1/go-mirror-delivery.md b/quest/m1/go-mirror-delivery.md
index 4575713a8be..df439a1d7bd 100644
--- a/quest/m1/go-mirror-delivery.md
+++ b/quest/m1/go-mirror-delivery.md
@@ -5,7 +5,7 @@
A recommendation, with a prototype, for delivering the Go binding's
staticlibs without committing them to git. `moq-dev/moq-go-ffi` commits
them straight into git today, at 60.2 MiB for linux, 52.7 for windows, and
-39.1 for darwin. That puts the largest file at 60% of GitHub's 100 MB push
+39.1 for darwin. That puts the largest file at 60% of GitHub's 100 MiB per-file
limit, and each release adds about 210 MiB of history.
## Plan
diff --git a/quest/m1/interop-contention.md b/quest/m1/interop-contention.md
new file mode 100644
index 00000000000..f1bb5fe6e37
--- /dev/null
+++ b/quest/m1/interop-contention.md
@@ -0,0 +1,29 @@
+# [S] Interop matrices run side by side
+
+## Goal
+
+Two `just test interop --all` matrices can run at once on one machine, even
+from one checkout, and both pass. `just test harness` runs from a clean
+checkout.
+
+## Plan
+
+[#4228](https://github.com/moq-dev/moq/pull/4228) fixed the port
+reservations and the canvas-blocked pause click, and stages Go per run. What
+remains:
+
+- Under two concurrent matrices, `python -> js` and `go -> js` sometimes stall
+ the browser subscriber: the Pause control never appears within 30 s. It
+ was not seen in a single run. Find the cause (CPU starvation of headless
+ Chromium, a shared resource, or a real stall) before touching timeouts.
+- `prepare_python` runs `just py build` in the workspace, so concurrent runs
+ rewrite the same `.venv` and maturin output (Codex on #4228). Build into the
+ run directory, as Go now does, or serialize the build.
+- `just test harness` runs `harness.browser.ts` without installing workspace
+ dependencies or Playwright Chromium, so it only passes where CI's earlier
+ step prepared them. Provision them in the recipe, or reuse the path
+ `interop.sh` already takes.
+- Prove it by running two `--all` matrices at once, several times, from one
+ checkout.
+
+Public API: none. Wire: none.
diff --git a/quest/m1/quic/README.md b/quest/m1/quic/README.md
index 7280d2ff8f5..81e79f3342d 100644
--- a/quest/m1/quic/README.md
+++ b/quest/m1/quic/README.md
@@ -53,7 +53,7 @@ This is a transport API change, not a MoQ wire change.
- [Preserve QUIC packet identity in BBR](/quest/m1/quic/bbr-packet-identity.md) - ACKs and losses identify the right packet across QUIC spaces
- [Finish each BBR ACK sample before using it](/quest/m1/quic/bbr-ack-sampling.md) - current delivery samples reach the model once with consistent metadata
-- [Mark application starvation before the next BBR send](/quest/m1/quic/bbr-app-limited.md) - resumed bursts retain correct sample labels
+- [BBR idle burst](/quest/m1/quic/bbr-app-limited.md) - a fork regression proves a burst after a long idle is paced at the learned bandwidth, closing #4219
- [Finish BBR bandwidth-probe feedback once](/quest/m1/quic/bbr-probe-feedback.md) - cruise rounds neither age probe history repeatedly nor retain probe-loss classification
- [Recalibrate BBR startup pacing from measured RTT](/quest/m1/quic/bbr-startup-pacing.md) - measured RTT replaces the nominal startup rate for media senders
- [Protect bandwidth samples during BBR ProbeRTT](/quest/m1/quic/bbr-probe-rtt.md) - intentionally reduced sending cannot masquerade as reduced capacity
diff --git a/quest/m1/quic/bbr-app-limited.md b/quest/m1/quic/bbr-app-limited.md
index dca67a99a8a..ea26b55a4a9 100644
--- a/quest/m1/quic/bbr-app-limited.md
+++ b/quest/m1/quic/bbr-app-limited.md
@@ -1,38 +1,40 @@
-# [M] Mark application starvation before the next BBR send
+# [S] Prove a BBR burst after a long idle is paced at the learned bandwidth
## Goal
-Packets sent after application starvation carry the correct historical
-application-limited label, even when no ACK arrives during the idle gap.
-The bandwidth model cannot mistake a source-limited sample for capacity.
+After minutes of keep-alive-only idle, a BBRv3 (`delay`) sender paces its
+next burst near the bandwidth it learned before, not at a trickle, and a
+regression test in the fork proves it.
## Plan
-In noq `1a26a8b064d21e316fe6769f068617975bd8a27b`, an empty unblocked
-[transmit poll](https://github.com/n0-computer/noq/blob/1a26a8b064d21e316fe6769f068617975bd8a27b/noq-proto/src/connection/mod.rs#L1337) records starvation, but BBR receives the marker only in
-[on_end_acks](https://github.com/n0-computer/noq/blob/1a26a8b064d21e316fe6769f068617975bd8a27b/noq-proto/src/congestion/bbr3/mod.rs#L1732).
-A resumed send can be stamped before that notification. Google's
-[QUICHE BBR3](https://github.com/google/quiche/blob/535a2730e77d47e0dc03746555cc9c34b17bc9e9/quiche/quic/core/congestion_control/bbr3_sender.cc#L505) notifies its sampler immediately when application limited.
-
-Reproduce through the transport boundary: send and ACK one 1200-byte packet
-with a 10-ms RTT, run an empty unblocked transmit poll, wait until 30 ms to
-send another packet, then ACK it 10 ms later. There is no intervening ACK
-to notify the controller of starvation. The existing public-callback
-reproduction yields a non-limited sample; preserve a failing regression
-without privately seeding the sampler marker. This establishes a label bug,
-not a measured throughput regression.
-
-Communicate starvation before subsequent sends, preserving the delivery
-boundary that ends the sampler's limited phase. Distinguish producer
-starvation from cwnd, pacing, anti-amplification, receiver credit, and local
-buffer limits; do not silently change receiver-limited policy. Cover streams,
-datagrams, resumed backlog, repeated empty polls, and ACK batching. Coordinate
-any controller event changes with the packet identity and ACK sampling fixes.
-Keep state private where possible; document any public Controller change and
-its consumers. No wire change is intended. Wire regressions into fork CI.
+moq-dev/noq#5 (in moq-noq 1.3.1; main pins 1.3.2) fixed the label bug this
+quest was opened for. The transport calls `Controller::on_app_limited` on
+every empty poll that nothing held back, and BBR marks starvation before the
+next send. Its tests cover streams, datagrams, batched ACKs, and backlogs
+held by the window or the pacer. What is left is
+[#4219](https://github.com/moq-dev/moq/issues/4219), reported on 1.3.0 and
+not yet reproduced on either version: the first 250 KB after five idle
+minutes took 5.2 s at 50 ms RTT, against 0.5 s with CUBIC.
+
+The fix plausibly covers it. The fork's max-bw filter ages only on
+non-app-limited samples, and before #5 every other keep-alive was stamped
+non-app-limited. Nothing measures it, though. Add a virtual-time transport
+test in the fork: learn the bandwidth, idle on keep-alives for about five
+minutes, send 250 KB, and assert the pacing rate stays at or above about
+0.9x the earlier max bandwidth. Check that it fails on 1.3.0.
+
+If it still stalls, find the remaining cause, such as ProbeRTT entered during
+the idle or a stale `bw_shortterm`, and fix it in the fork. Dropping the
+estimate after a long idle is a policy change for the m2 study, not this
+quest. The `iroh` feature uses upstream noq, which lacks #5; offering it
+there belongs to the upstream quest.
+
+## Closes
+
+- [#4219](https://github.com/moq-dev/moq/issues/4219) - the first send after an idle period is paced at a trickle
## Related
-- [Finish each BBR ACK sample](/quest/m1/quic/bbr-ack-sampling.md) - a separate ordering defect in the same callback lifecycle
-- [Release BBR fixes](/quest/m1/quic/bbr-release.md) - deliver correct labels before policy experiments
-- [Upstream the fork](/quest/m1/quic/upstream.md) - offer the general fix upstream
+- [Release BBR fixes](/quest/m1/quic/bbr-release.md) - ships any remaining fix
+- [Upstream the fork](/quest/m1/quic/upstream.md) - offer the starvation fix upstream
diff --git a/quest/m1/quic/bbr-release.md b/quest/m1/quic/bbr-release.md
index 8966e3ae3d2..41365f1707a 100644
--- a/quest/m1/quic/bbr-release.md
+++ b/quest/m1/quic/bbr-release.md
@@ -24,7 +24,7 @@ and Google comparison do not gate these bug fixes.
- [Preserve QUIC packet identity in BBR](/quest/m1/quic/bbr-packet-identity.md)
- [Finish each BBR ACK sample before using it](/quest/m1/quic/bbr-ack-sampling.md)
-- [Mark application starvation before the next BBR send](/quest/m1/quic/bbr-app-limited.md)
+- [BBR idle burst](/quest/m1/quic/bbr-app-limited.md) - the starvation fix shipped in moq-noq 1.3.1; any remaining idle cause ships here
- [Finish BBR bandwidth-probe feedback once](/quest/m1/quic/bbr-probe-feedback.md)
- [Recalibrate BBR startup pacing from measured RTT](/quest/m1/quic/bbr-startup-pacing.md)
- [Protect bandwidth samples during BBR ProbeRTT](/quest/m1/quic/bbr-probe-rtt.md)
diff --git a/quest/m1/raw-stream-codes.md b/quest/m1/raw-stream-codes.md
index a4c1b517da3..7338196d3e4 100644
--- a/quest/m1/raw-stream-codes.md
+++ b/quest/m1/raw-stream-codes.md
@@ -23,12 +23,16 @@ on stream errors. WebTransport sessions keep the mapping they need.
crates depend on crates.io releases, never a patch. A moq-tokio test over
`moqt://` asserts a reset code arrives verbatim, beside `close_code.rs`.
- Mixed versions: two moq peers on raw QUIC agree today because both map, and
- wire changes must stay compatible with published versions. A fixed peer can
- read both forms, since a mapped code lands in the HTTP/3 WebTransport range
- that no application code reaches. An older peer misreads a fixed peer's raw
- codes. Check which codes moq-net acts on (group stream resets, subscribe
- STOP_SENDING): if any drives behaviour beyond reporting, this is a wire
- break and retargets to `dev`.
+ wire changes must stay compatible with published versions. An older peer
+ still sends `error_to_http3(code)`, so a fixed peer that only skips the
+ mapping reports the large HTTP/3 value, not the code. The legacy form is
+ detectable, since it lands in the HTTP/3 WebTransport range that no moq
+ code reaches (`error_from_http3` returns `None` outside it), so the raw
+ receive path unmaps a code in that range and passes the rest through, with
+ a legacy-sender test per adapter. The other direction has no fix at the
+ receiver: an older peer misreads a fixed peer's raw codes. Check which codes
+ moq-net acts on (group stream resets, subscribe STOP_SENDING): if any drives
+ behaviour beyond reporting, this is a wire break and retargets to `dev`.
Public API: none expected. Wire: raw QUIC stream error codes become the
application's own values; compatible only if older peers merely report them.
diff --git a/quest/m1/redirect-resolve.md b/quest/m1/redirect-resolve.md
index 5c3f7e56d99..7ee9ef70141 100644
--- a/quest/m1/redirect-resolve.md
+++ b/quest/m1/redirect-resolve.md
@@ -19,8 +19,9 @@ the connection it documents.
Recommendation: make it private. Nothing outside `moq-tokio` calls it (only
its own unit tests), and the repo keeps things private until a consumer
needs them. If a consumer turns up, the alternative is returning the same
-`Result