feat!: generate async wrappers behind default-off async features

doc/lib/rs/hang.md

@@ -20,6 +20,9 @@ carries a timestamp with each payload.
 cargo add hang
 ```
 
+The `poll_*` methods work by default. Enable the `async` Cargo feature to await
+`Catalog::subscribe` and the catalog consumer's `next()` instead.
+
 hang is the format, not the pipeline. [`moq-mux`](/lib/rs/moq-mux) produces the
 catalog for you and decodes any container in group order
 (`moq_mux::container::Consumer`). Its `Delay { min, max }` says how far behind

doc/lib/rs/moq-json.md

@@ -13,6 +13,9 @@ stream are the catalog modes on the [hang](/concept/hang#data-tracks) page.
 Window is a third framing for a raw track: both ends opt into it, and a
 generic catalog reader will not pick it up.
 
+The `poll_*` methods work by default. Enable the `async` Cargo feature to await
+`next()`, `latest()`, or `refresh()` instead.
+
 - **snapshot**: lossy latest value, with RFC 7396 merge-patch deltas. An unchanged update publishes nothing. Several owners can edit their own keys in place instead of clobbering one document. Deltas ride one group until a joiner wants a fresh one: set the track's `refresh` ratio (8 is typical) and drive `Producer::refresh`, which restates the value in a new group. Without a ratio a group rolls only at its caps.
 - **stream**: lossless append-log in a single group. A reader that falls behind fails the read rather than resuming mid-log.
 - **window**: a bounded run of records a reader can join at any point. A new group restates what it keeps explicitly, so a reader that was keeping up is not handed a record twice. Its ops roll on the track's `refresh` ratio the same way.

doc/lib/rs/moq-mux.md

@@ -61,5 +61,9 @@ only when they share that clock.
 cargo add moq-mux
 ```
 
+The `poll_*` methods work by default. Enable the `async` Cargo feature to await
+the exporters' `next()`, a container's `read()`, and the async constructors such
+as `catalog::Consumer::new` and `Source::catalog` instead.
+
 API: [docs.rs/moq-mux](https://docs.rs/moq-mux). The commands that exercise it
 are [`moq-cli`](/bin/cli).

doc/lib/rs/moq-net.md

@@ -25,14 +25,15 @@ What you use it for, beyond what the concept page already describes:
 - **Authored tracks default to a zero `max_age`.** `track::Info::default()` sets `max_age` to `Some(Duration::ZERO)`, the live edge only; a publisher that wants readers to reach history sets a longer bound, or `with_max_age(None)` for no publisher limit. Media tracks from `hang::container::track_info` declare `hang::container::MAX_AGE` (30 seconds). `max_age` is how long a superseded group stays fresh, never the newest group; it frees no bytes, which the cache pool's expiry reclaims. Received metadata keeps absence as no limit, and an origin's `cache_duration` can only cap it lower.
 - **End content by finishing tracks.** A broadcast has no finished state. When the input ends, finish each track; the broadcast stays announced and keeps serving them until you close it or drop its last producer. How long to keep it up for late readers is yours to decide: `moq_mux::Linger` holds a hang broadcast for a fixed window.
 - **Demand says whether anyone is watching.** `demand()` on a track, group, or broadcast says whether a subscriber is attached. First-party capture does not wait for it: video encodes while enabled and audio keeps raw PCM to encode when someone listens, so a late subscription's `delay.max` or a FETCH finds the recent past. Demand gates bandwidth reservations, transcode rungs, and on-demand video where a publisher opts in, which saves the encode but leaves nothing from before the first subscriber. Holding a broadcast or track consumer is not demand: a track consumer requests nothing until it queries, subscribes, or fetches, and those count until dropped. A shared fetch stays up until its last reader leaves. Demand rolls up: a frame being read keeps its group wanted, a group a subscription or fetch handed out keeps its track wanted until read to its end, and any wanted track keeps its broadcast wanted.
-- **Use the model without a runtime.** Disable default features on `moq-net` to use its `poll_*` APIs and origin driver with caller-supplied time. The default `async` feature adds async helpers, `time::run`, and both wire sessions.
+- **Use the model without a runtime.** By default `moq-net` is its `poll_*` APIs and origin driver with caller-supplied time. The `async` feature adds their async wrappers, `time::run`, and both wire sessions.
 - **You drive the session, or `moq-tokio` does.** `connect` and `accept` return a session plus a driver that never reads the clock itself. `moq_net::time::run` polls it on tokio. `moq-tokio` hides that. A custom transport implements `moq_net::transport::poll`, and `moq_net::transport::memory::pair` links two sessions in one process with no sockets, for tests or in-process links.
 - **A session bounds what its peer can hold.** Each request holds a stream, so the transport's stream credit bounds subscriptions and FETCHes. `session::Limits` (via `Client::with_limits` and `Server::with_limits`) bounds the announcements per session. The default suits a relay mesh, so lower it for untrusted peers. Past it, the session closes with `TOO_MANY_REQUESTS`. Peer-declared lengths are capped before they are buffered.
 - **Authorization is in band.** On moq-lite 07 (`moq-lite-07-wip`, opt-in) and on moq-transport draft-18+ with the [MoQ Auth extension](/draft/moq-auth), `session.auth()` presents tokens without reconnecting and watches the grant the peer sent back. `add(token)` resolves with the token and how the peer took it: `Answer::Granted` on its AUTH stream, or `Answer::Requests` on moq-transport without AUTH, where only a request that names it carries it. A handle passed to `Client::with_auth` outlives each session, so its tokens, and the routes naming them, carry across your own reconnects. A server verifies tokens itself by taking `handshake.requests()` before `ok()`. `authorize(&grant)` narrows or widens a live session on any version: what falls outside resets with `Unauthorized` and the session stays up. A client that publishes outside its grant closes the session, naming the path.
 - **A graceful close waits.** `session.close().await` withdraws announcements and drains for up to one second. `moq-lite-05` and newer wait for the subscriber to receive finished tails; older Lite versions and IETF wait only for transport ACKs. `abort` ends immediately.
 
 ```bash
-cargo add moq-net moq-tokio
+cargo add moq-net --features async
+cargo add moq-tokio
 ```
 
 See the [Rust quick start](/lib/rs/#quick-start) and

quest/m1/README.md

@@ -176,7 +176,6 @@ their end report, so an embedder's drain alert pages on real cuts.
 - [Catalog contributions become includes on the root's timeline](/quest/m1/catalog-include.md) - rename the unreleased `contributions` map before the cut and state that included broadcasts share the root's timeline
 - [Unbounded groups](/quest/m1/unbounded-groups/README.md) - groups and frames lose their size caps; a group keeps a 32 MB tail, and readers behind it replay through paced flights or refresh
 - [Session policy lives in moq-net](/quest/m1/session-policy/README.md) - accept and connect deadlines, admission, window widening and reconnect live once in moq-net; moq-tokio and moq-relay's io_uring path call them
-- [Poll-first async](/quest/m1/poll-first/README.md) - library crates compile no coroutines by default: async wrappers are generated from `poll_*` and gated behind an `async` feature
 - [moq auth serve scopes each client certificate by its chain](/quest/m1/auth-cert-rules.md) - per-certificate and per-intermediate rules in a reloaded TOML config, keyed by the chain hashes the relay sends
 - [A replacement that fails before delivering never ends a live track](/quest/m1/route-swap-keeps-incumbent.md) - a route change whose replacement aborts before its first group leaves readers on the source that was serving
 - [A Rust relay never replays from group 0 to a lite-03/04 subscriber](/quest/m1/relay-inflight-replay.md) - A Rust relay or publisher serving a lite-03 or lite-04 SUBSCRIBE from a track copy that is still resolving starts at the newest group once the copy resolves

quest/m1/session-policy/accept.md

@@ -38,7 +38,3 @@ see it for the decisions and research.
 
 Public API: breaking in moq-net (`Server`, `Handshake`, the transport session
 trait), with MIGRATE notes. Wire: none.
-
-## Required
-
-- [Generated async wrappers](/quest/m1/poll-first/async-feature.md) - gives the handshake a poll form these machines wait on

rs/hang/Cargo.toml

@@ -12,6 +12,14 @@ rust-version.workspace = true
 keywords = ["quic", "http3", "webtransport", "media", "live"]
 categories = ["multimedia", "network-programming", "web-programming"]
 
+[package.metadata.docs.rs]
+features = ["async"]
+
+[features]
+default = []
+# Generated async wrappers for the poll methods, and `Catalog::subscribe`. Enable where you `.await` them.
+async = ["kio/async"]
+
 [dependencies]
 bytes = { workspace = true }
 hex = { workspace = true }
@@ -30,7 +38,9 @@ features = ["from", "display", "debug"]
 
 [dev-dependencies]
 anyhow = { workspace = true }
-moq-mux = { path = "../moq-mux" }
+# Compile the async API used by the tests.
+hang = { path = ".", features = ["async"] }
+moq-mux = { path = "../moq-mux", features = ["async"] }
 moq-tokio = { path = "../moq-tokio", default-features = false, features = ["quic", "websocket"] }
 tokio = { workspace = true, features = ["macros", "fs"] }
 tracing = { workspace = true }

rs/hang/MIGRATE.md

@@ -4,6 +4,14 @@ How to update your code for each breaking change, newest first.
 
 ## Unreleased
 
+### The async API is opt-in
+
+Enable the `async` Cargo feature to keep awaiting `catalog::Consumer::next` and `Catalog::subscribe`:
+`hang = { version = "...", features = ["async"] }`. This also applies with `default-features = false`.
+The feature is off by default; `catalog::Consumer::poll_next` stays available without it.
+The generated `next` no longer requires `Catalog<E>: Unpin`.
+The catalog format and JS and binding APIs are unchanged.
+
 ### The catalog track advertises a zero max age ([#7729](https://github.com/moq-dev/moq/pull/7729))
 
 `Catalog::default_track_info` takes moq-net's new zero default, so the catalog track advertises the live edge only where it advertised no limit. A late joiner still reads the newest snapshot, which never goes stale.