docs(quest): finish the hard fork epic

quest/README.md

@@ -8,7 +8,7 @@ grouped into milestones ordered by priority.
 ## Plan
 
 m0 holds urgent fixes and release-line maintenance. m1 is the finite next
-breaking release: clustering stability first, the QUIC library switch, and
+breaking release: clustering stability first, the in-tree QUIC stack, and
 planned public API and format breaks with their correctness and validation.
 m2 holds independently shippable capabilities and optimizations, plus the
 publication and adoption steps that follow m1. m3 holds external conditions

quest/m1/README.md

@@ -14,9 +14,8 @@ Decided with the maintainer on 2026-10-13:
   through a stale route; a working backup recovers; matching-epoch handover
   preserves eligible content; a new epoch produces an explicit Restart.
   Catalogs, long-lived readers, and late joiners must obey the same contract.
-- Prioritize the QUIC library switch beside routing. Its clock prerequisite
-  lands first. Keep its correctness, interoperability, memory, and performance
-  evidence; a passing simulator alone does not validate a real transport.
+- Prioritize the in-tree QUIC stack (`moq-quic`) beside routing. Keep its
+  correctness, interoperability, memory, and performance evidence; a passing simulator alone does not validate a real transport.
 - Finish planned breaking APIs in this release, including public clocks,
   signed priority, binding shape, watch worker, and the QoS lag API. Keep
   prerequisites of those changes here even when a prerequisite is additive.
@@ -65,8 +64,7 @@ above them.
 - [Cluster routing](/quest/m1/cluster-routing/README.md) - prove shared routing contracts, implement per-origin routes, and connect outbound local clusters
 - [P2P](/quest/m1/p2p/README.md) - application-selected peer sessions use shared priorities, routing, and same-epoch handover
 - [Routing guide](/quest/m1/routing-guide.md) - concepts and practical outbound federation/P2P setup
-- [Controlled time](/quest/m1/time/README.md) - every crate and package reads time through moq-clock or @moq/clock, with regression tests for the changed contracts; ranks above the fork, whose switch adopts its instant
-- [Hard fork](/quest/m1/quic/fork/README.md) - quinn hard-forked in-tree as `moq-quic`, ranked ahead of perf; the rest of the QUIC line follows it
+- [Controlled time](/quest/m1/time/README.md) - every crate and package reads time through moq-clock or @moq/clock, with regression tests for the changed contracts
 - [Own the QUIC stack](/quest/m1/quic/README.md) - quinn hard-forked in-tree as `moq-quic`, carrying BBR, reliable reset, hierarchical scheduling, peer limits, and endpoint sharding
 - [Finalize moq-lite-07](/quest/m1/lite07-finalize.md) - when the maintainer cuts it, lite-07 negotiates as `moq-lite-07` and the next release ships it
 - [moq-transport passthrough](/quest/m1/ietf-extension/README.md) - object IDs, properties, end status, datagram objects, and unknown track properties survive moq-transport -> moq-relay (and a relay cluster) -> moq-transport; moxygen's moq-test sections 1-7 pass nightly, except cases that use a subgroup other than 0

quest/m1/close-tail-drain.md

@@ -20,7 +20,7 @@ Found while reworking the in-memory transport (#5530). Facts at 813a92b48:
   `:931-942`) does the same, and `ietf::session::start` aborts again after
   the race in each of its two arms, drafts 14-16 (`:371-374`) and drafts 17+
   (`:588-591`).
-- Real QUIC keeps that data readable: noq's `poll_accept` hands out
+- Real QUIC keeps that data readable: moq-tokio's `quic::driver` `poll_accept` hands out
   already-received streams before the connection error, and reads return
   buffered chunks and the FIN, reporting `ConnectionLost` only when blocked.
   moq-uring's raw QUIC follows the same order, but its WebTransport layer
@@ -71,8 +71,8 @@ Decided (maintainer, 2026-10-14):
 The receiver drain also needs moq-uring WebTransport to classify and hand
 out its pending uni streams before reporting the connection error, with a
 regression for a tail stream and CONNECTION_CLOSE arriving in the same poll.
-Check the other `poll_accept_uni` adapters (such as `rs/moq-ffi` and the
-noq WebTransport path) for the same ordering.
+Check the other `poll_accept_uni` adapters (such as `rs/moq-ffi` and
+moq-tokio's `quic::web` path) for the same ordering.
 
 Public API: none. Wire: none.
 

quest/m1/quic/README.md

@@ -3,8 +3,8 @@
 ## Goal
 
 MoQ owns the QUIC features it needs in an in-tree stack, `moq-quic`, hard
-forked from quinn (see [the fork](/quest/m1/quic/fork/README.md) for why
-quinn and not noq). One core serves the tokio backend, the thread-per-core
+forked from quinn rather than noq, whose multipath, NAT traversal, and QAD
+MoQ never negotiates. One core serves the tokio backend, the thread-per-core
 `moq-uring` backend, and qmux; iroh stays on upstream noq. The features are
 BBR correctness, reliable stream resets, hierarchical stream scheduling with
 per-broadcast fairness, bounded incomplete-message memory, wider limits for
@@ -19,13 +19,9 @@ careful resume, and a receive-timestamps spike toward GCC live in
 ## Plan
 
 Decided in the 2026-09-30 plan: the moq-dev/noq soft fork is replaced by a
-hard fork of quinn in `rs/`, so every QUIC change here waits for
-[the fork](/quest/m1/quic/fork/README.md). moq-dev/noq is frozen to
-security patches for `release`.
-
-Older quests say "the fork" or "noq"; read that as `moq-quic`. Their steps to
-publish a fork release, pin it, or offer a change upstream are superseded:
-a change lands in-tree with its consumer, and upstreaming is optional.
+hard fork of quinn in `rs/`, where every QUIC change here lands.
+moq-dev/noq is frozen to security patches for `release` and archived once
+no released MoQ crate depends on it.
 
 The seven BBR correctness fixes shipped in moq-noq 1.3.1 (#4206) are in
 `moq-quic`'s BBR3. The remaining BBR quests here all edit
@@ -55,7 +51,6 @@ Decided in the 2026-09-30 audit: deadlines, qmux, BBR loss parity, ECN
 measurement, ACK progress, and the ACK hook moved to m2, since no m1 quest
 consumes them. Decided 2026-10-08: L4S and careful resume moved on to m3,
 and GCC shrank to a receive-timestamps spike, since none has a consumer.
-The BBR app-limited fixes land in `moq-quic` without waiting for the switch.
 
 Decided in the 2026-10-10 receive-memory plan: native message assembly holds
 connection credit until complete-unit handoff, while stream credit advances
@@ -67,7 +62,6 @@ cache limits remain separate; bitrate pacing composes with this memory cap.
 
 ## Required
 
-- [Hard fork](/quest/m1/quic/fork/README.md) - quinn in-tree as `moq-quic`, with BBR3 and lazy stream slots, and MoQ switched onto it
 - [Retain connection credit](/quest/m1/quic/receive-credit.md) - native receivers own connection credit independently of stream reads
 - [Bound message assembly](/quest/m1/quic/receive-memory.md) - complete headers and frames return credit, and receiver priority cancellation restores progress
 - [Reliable stream reset](/quest/m1/quic/reliable-reset.md) - `RESET_STREAM_AT`,
@@ -88,7 +82,7 @@ cache limits remain separate; bitrate pacing composes with this memory cap.
 - [Scope track priority](/quest/m1/track-priority-scope.md) - the
   per-broadcast fairness policy on cluster sessions
 - [Discover media headroom](/quest/m2/quic-probe.md) - test useful-media pacing before adding redundant probe traffic
-- [L4S on the backbone](/quest/m3/quic-ecn.md) - an ECT(1) option in the fork, an `ecn` config knob, and a dualpi2 measurement
+- [L4S on the backbone](/quest/m3/quic-ecn.md) - an ECT(1) option in `moq-quic`, an `ecn` config knob, and a dualpi2 measurement
 - [Careful resume on reconnect](/quest/m3/quic-careful-resume.md) - a redial starts at the previous connection's rate
 - [Keep-alive from the idle timeout](/quest/m2/quic-keep-alive.md) - the keep-alive interval defaults to a fraction of the negotiated idle timeout; an explicit `quic.keep_alive` overrides
 - [QUIC receive-timestamps spike](/quest/m3/quic-gcc.md) - measures whether receive timestamps give a cheaper, more accurate forward delay than half the RTT

quest/m1/quic/datagram-priority.md

@@ -95,7 +95,7 @@ synchronous `send_datagram` taking a send-group handle and a group
 sequence.
 Every implementation follows: moq-tokio (`transport.rs`,
 `transport/owned.rs`), moq-uring (`transport/adapter.rs`,
-`quic/noq/connection.rs`, `quic/web.rs`), moq-ffi and moq-wasm
+`quic/driver/connection.rs`, `quic/web.rs`), moq-ffi and moq-wasm
 (`transport/adapter.rs`), moq-net's `ietf/adapter.rs`, and the test mocks.
 moq-uring's `quic/web.rs` serves WebTransport over the worker's own QUIC
 connection, so it honors the handle and order like raw QUIC. moq-wasm sits

quest/m1/quic/peer-limits.md

@@ -14,9 +14,8 @@ The in-tree `moq-quic` `Connection` (`rs/moq-quic/src/connection/mod.rs`)
 already exposes runtime `set_max_concurrent_streams`, `set_receive_window`,
 and `set_send_window`; a raise queues `MAX_STREAMS` and `MAX_DATA` on the next
 packet, and a shrink is a debt paid as the peer consumes credit. The existing
-setters provide this seam; the transport integration waits for
-[the fork switch](/quest/m1/quic/fork/README.md), so moq-tokio and moq-uring
-run on `moq-quic` instead of `moq-noq`.
+setters provide this seam in `moq-quic`, which moq-tokio and moq-uring both
+run on.
 
 Decided 2026-10-08: the relay's peer config surface already exists. A
 session is a cluster peer when its admitted grant is marked `peer`, and the
@@ -26,7 +25,7 @@ its own.
 
 - moq-net's transport trait gains `set_limits(Limits)` on the session,
   `Limits` carrying the three values, implemented by the moq-tokio and
-  moq-uring adapters over `moq-quic` after the fork switch; every other
+  moq-uring adapters over `moq-quic`; every other
   backend, the browser included, reports it unsupported.
 - The peer table gains the same three values (the stream limit and the two
   windows),
@@ -45,8 +44,3 @@ unbounded assembly pool.
 Tests: a cluster session sees the raised `MAX_STREAMS` after SETUP and a
 viewer session does not; the io_uring path applies the same values; a
 `peer` table below the defaults is refused at resolve time.
-
-## Required
-
-- [Hard fork](/quest/m1/quic/fork/README.md) - moq-tokio and moq-uring run on `moq-quic`, whose setters this calls
-

quest/m1/quic/receive-credit.md

@@ -10,8 +10,8 @@ an entire application message to fit before more bytes arrive.
 
 ## Plan
 
-Decided in the 2026-10-10 receive-memory interview: use `moq-quic` after the
-fork switch, not a new feature in the frozen moq-dev/noq fork. This quest
+Decided in the 2026-10-10 receive-memory interview: use `moq-quic`, not a
+new feature in the frozen moq-dev/noq fork. This quest
 provides the transport primitive; [message assembly](/quest/m1/quic/receive-memory.md)
 activates it with the recovery policy needed for progress.
 

quest/m1/quic/reliable-reset.md

@@ -2,7 +2,7 @@
 
 ## Goal
 
-noq-proto and its WebTransport adapter implement
+`moq-quic` and moq-tokio's WebTransport adapter (`quic::web`) implement
 [QUIC Stream Resets with Partial Delivery](https://datatracker.ietf.org/doc/draft-ietf-quic-reliable-stream-reset/).
 A reset WebTransport data stream reliably delivers enough prefix bytes for the
 receiver to associate it with its session before surfacing the application
@@ -16,7 +16,7 @@ the receiver may discard that header and cannot attribute the reset.
 
 ## Plan
 
-Implement the current reliable-reset draft in noq-proto:
+Implement the current reliable-reset draft in `moq-quic`:
 
 - advertise and validate the empty `reset_stream_at` transport parameter,
   including remembered negotiation state for 0-RTT;
@@ -63,10 +63,6 @@ Track the unversioned draft during implementation. The planning baseline is
 draft 10, with transport parameter `0x1d` and frame type `0x24`; do not freeze
 provisional codepoints if the document changes before release.
 
-## Required
-
-- [Hard fork](/quest/m1/quic/fork/README.md) - lands in `moq-quic`, not the frozen fork
-
 ## Related
 
 - moq-net (`rs/moq-net/src/tail.rs`) and `@moq/net` (`js/net/src/tail.ts`) wait

quest/m1/quic/scheduler.md

@@ -15,7 +15,7 @@ group backlog.
 
 ## Plan
 
-Add a generic send-group primitive to noq-proto. A group owns its
+Add a generic send-group primitive to `moq-quic`. A group owns its
 strict priority and fair-share scheduler state; each stream owns only its
 order within that group. Prefer an owned group handle whose drop removes its
 scheduler state and whose priority can be updated without walking every open
@@ -58,7 +58,7 @@ the tier and the weighting.
 
 The delivered API is hierarchical send groups. Do not require a separately
 published scalar-widening API or drop fairness as an intermediate release.
-Prototype the byte-accounted scheduler in the fork. An existing Quinn prototype can
+Prototype the byte-accounted scheduler in `moq-quic`. An existing Quinn prototype can
 supply a workload baseline, but a recency field alone does not prove byte
 fairness: differently sized writes must spend the group's byte credit, and
 requeueing or adding streams must not reset that credit.
@@ -101,10 +101,6 @@ scheduler completion must not wait for that dependent integration. Preserve
 working behavior on backends not yet migrated, and remove queue code only
 where the new implementation makes it redundant.
 
-## Required
-
-- [Hard fork](/quest/m1/quic/fork/README.md) - lands in `moq-quic`, not the frozen fork
-
 ## Closes
 
 - [#699](https://github.com/moq-dev/moq/issues/699) - close this issue when the

quest/m1/quic/send-errors.md

@@ -20,10 +20,6 @@ Only fatal, destination-specific errors end the attempt; transient ones
 against an unroutable family, and check that moq-uring maps the same errors
 through its ring.
 
-## Required
-
-- [Hard fork](/quest/m1/quic/fork/README.md) - the change lands in `moq_sock::udp` and moq-tokio's imported quinn layer
-
 ## Related
 
 - [quinn#2766](https://github.com/quinn-rs/quinn/issues/2766) - the upstream issue

quest/m1/quic/shard.md

@@ -37,10 +37,6 @@ own threading model.
 
 Update `doc/bin/relay/` for the flag change.
 
-## Required
-
-- [Hard fork](/quest/m1/quic/fork/README.md) - the stack has to be in-tree before the library can own sharding
-
 ## Related
 
 - [UDP demux](/quest/m1/p2p/udp-demux.md) - demuxes each shard's socket; keep the demux over whatever the library hands out

quest/m1/rs-request-credit.md

@@ -19,15 +19,15 @@ leaves, or the session closes, and a relay shouldn't kill a subscribe on a
 slow upstream hop.
 
 A single `Pending` poll of `open_bi` is not "no credit": on WebTransport,
-`web-transport-moq` opens the QUIC stream and then writes the session header,
+moq-tokio's `quic::web` opens the QUIC stream and then writes the session header,
 which can be pending under send-window pressure. Check credit at the QUIC
 level instead, likely a non-waiting open on moq-net's `transport::poll`
 session trait. Also note that
 `moq-tokio`'s `poll_open_bi` parks an abandoned open in the session's slot
 rather than dropping it, so the next request inherits it; the non-waiting open
-should avoid that. The async backends `moq-tokio` wraps (qmux, iroh, noq) have
-no credit query in `web-transport-trait`, which `moq-tokio` needs to
-implement that method for them; prefer adding one upstream in
+should avoid that. `quic::web` is in-tree and can ask `moq-quic` directly,
+but the backends `moq-tokio` wraps through `web-transport-trait` (qmux,
+iroh) have no credit query there; prefer adding one upstream in
 moq-dev/web-transport over leaving them waiting, and say in the PR which
 backends fail fast.
 

quest/m1/test-flakes-2/README.md

@@ -36,8 +36,7 @@ Public API: none. Wire: none.
 ## Required
 
 - [TS decoded content](/quest/m1/test-flakes-2/ts-video-content.md) - CI's TS compliance decoded-content checks fail only on real loss, and the exporter names every frame it drops
-- [WebTransport close release](/quest/m1/test-flakes-2/interop-close-release.md) - a compatible published adapter contains the acknowledged-close fix
-- [Interop close code](/quest/m1/test-flakes-2/interop-close-code.md) - adopt that release so the browser reliably sees `unauthorized` for a refused session
+- [Interop close code](/quest/m1/test-flakes-2/interop-close-code.md) - the browser reliably sees `unauthorized` for a refused session
 - [Auth refresh mocks time](/quest/m1/test-flakes-2/auth-refresh-mock-time.md) - moq-relay's auth refresh and fixed-lease tests measure a grant's life on one mocked clock
 - [uring teardown close](/quest/m1/test-flakes-2/uring-teardown-close.md) - moq-uring's published-close teardown test holds under load, fixed at its cause
 - [js -> go rewind](/quest/m1/test-flakes-2/js-go-rewind.md) - the `js -> go` interop cell never reads a frame below the previous group's start, fixed on the side that produced it