diff --git a/cpp/moq/MIGRATE.md b/cpp/moq/MIGRATE.md
index 986d21b524..ed2216eaf5 100644
--- a/cpp/moq/MIGRATE.md
+++ b/cpp/moq/MIGRATE.md
@@ -9,6 +9,13 @@ How to update your code for each breaking change, newest first.
 `Anchor` gains a `Time` case holding `timestamp_us`, the group containing that presentation time, so exhaustive visits need a case for it.
 `TrackConsumer::update` now returns a result, failing with `TimestampMismatch` on a time anchor an untimed track can't serve.
 
+### Rebuild the matching raw bindings
+
+The documentation update changes UniFFI's audio-producer method metadata checksums.
+Regenerate the C++ binding headers and sources from the rebuilt native library,
+then rebuild the application; older generated guards reject the rebuilt library.
+Application calls are unchanged.
+
 ### JSON consumers return `JsonValue` (#5677)
 
 `JsonSnapshotConsumer::next()` and `JsonStreamConsumer::next()` return `JsonValue` (`value`, `timestamp_us`) instead of a string; `timestamp_us` is empty when untimed.
diff --git a/dart/moq/MIGRATE.md b/dart/moq/MIGRATE.md
index b280596e61..3f57b3d0ba 100644
--- a/dart/moq/MIGRATE.md
+++ b/dart/moq/MIGRATE.md
@@ -9,6 +9,13 @@ How to update your code for each breaking change, newest first.
 `Anchor` gains a time variant, so exhaustive switches need a case for it.
 `TrackConsumer.update` now throws on a time anchor an untimed track can't serve.
 
+### Rebuild the matching raw bindings
+
+The documentation update changes UniFFI's audio-producer method metadata checksums.
+Update `moq_ffi` and its native library together; older generated guards reject the rebuilt library.
+For a custom native library, regenerate its matching Dart bindings with `just dart generate`.
+Application calls are unchanged.
+
 ### JSON consumers return `Value` (#5677)
 
 `SnapshotConsumer.next()` and `StreamConsumer.next()` return `Value` (`value`, `timestampUs`) instead of a string; `timestampUs` is null when untimed.
diff --git a/dart/moq_ffi/MIGRATE.md b/dart/moq_ffi/MIGRATE.md
new file mode 100644
index 0000000000..fcfb6c6b00
--- /dev/null
+++ b/dart/moq_ffi/MIGRATE.md
@@ -0,0 +1,12 @@
+# Migrating the Dart moq\_ffi package
+
+How to update your code for each breaking change, newest first.
+
+## Unreleased
+
+### Regenerate the matching bindings
+
+Documentation on `MoqAudioProducer::write` and `finish` changes their UniFFI metadata checksums.
+Keep the generated Dart code and native library together.
+For a custom native build, regenerate the matching bindings with `just dart generate`.
+The method signatures and behavior are unchanged.
diff --git a/dart/moq_ffi/lib/src/moq.dart b/dart/moq_ffi/lib/src/moq.dart
index f47baef063..da3f0f3eeb 100644
--- a/dart/moq_ffi/lib/src/moq.dart
+++ b/dart/moq_ffi/lib/src/moq.dart
@@ -8,9 +8,7 @@ import "dart:ffi";
 import "dart:io" show Platform, File, Directory;
 import "dart:isolate";
 import "dart:typed_data";
-
 import "package:ffi/ffi.dart";
-
 import "uniffi_runtime.dart";
 export "uniffi_runtime.dart";
 
@@ -18570,7 +18568,7 @@ void _checkApiChecksums() {
   if (uniffi_moq_ffi_checksum_method_moqaudioproducer_demand() != 42822) {
     throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
   }
-  if (uniffi_moq_ffi_checksum_method_moqaudioproducer_finish() != 6287) {
+  if (uniffi_moq_ffi_checksum_method_moqaudioproducer_finish() != 52976) {
     throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
   }
   if (uniffi_moq_ffi_checksum_method_moqaudioproducer_reanchor() != 34412) {
@@ -18579,7 +18577,7 @@ void _checkApiChecksums() {
   if (uniffi_moq_ffi_checksum_method_moqaudioproducer_reservation() != 43848) {
     throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
   }
-  if (uniffi_moq_ffi_checksum_method_moqaudioproducer_write() != 22094) {
+  if (uniffi_moq_ffi_checksum_method_moqaudioproducer_write() != 48796) {
     throw UniffiInternalError.panicked("UniFFI API checksum mismatch");
   }
   if (uniffi_moq_ffi_checksum_method_moqbandwidth_reserve() != 27807) {
diff --git a/go/ffi/MIGRATE.md b/go/ffi/MIGRATE.md
new file mode 100644
index 0000000000..943e86f1f1
--- /dev/null
+++ b/go/ffi/MIGRATE.md
@@ -0,0 +1,11 @@
+# Migrating the Go moq-ffi module
+
+How to update your code for each breaking change, newest first.
+
+## Unreleased
+
+### Regenerate the matching bindings
+
+Documentation on `MoqAudioProducer::write` and `finish` changes their UniFFI metadata checksums.
+Regenerate the Go sources and bundle the matching static libraries, then rebuild callers.
+The method signatures and behavior are unchanged.
diff --git a/go/wrapper/MIGRATE.md b/go/wrapper/MIGRATE.md
index 0331ac824c..083ccb38da 100644
--- a/go/wrapper/MIGRATE.md
+++ b/go/wrapper/MIGRATE.md
@@ -13,6 +13,13 @@ A positional `TrackInfo{...}` literal adds a trailing `false`; keyed literals ne
 `AnchorTime` names the group containing a presentation time, and type switches over `Anchor` need a case for it.
 `TrackConsumer.Update` also fails on a time anchor an untimed track can't serve.
 
+### Rebuild the matching raw bindings
+
+The documentation update changes UniFFI's audio-producer method metadata checksums.
+Update generated `moq.dev/moq-ffi` sources and its bundled static libraries together,
+then rebuild the application; older generated guards reject the rebuilt library.
+Application calls are unchanged.
+
 ### JSON consumers return `*json.Timed` (#5677)
 
 `SnapshotConsumer.Next`, `StreamConsumer.Next`, and `All` return `*Timed{Value, Timestamp}` instead of the raw message; `Timestamp` is a `*time.Duration`, nil when untimed.
diff --git a/go/wrapper/errors.go b/go/wrapper/errors.go
index fb6df76c5c..2dfb8be0d6 100644
--- a/go/wrapper/errors.go
+++ b/go/wrapper/errors.go
@@ -41,7 +41,7 @@ var (
 	ErrVideo = ffi.ErrMoqErrorVideo
 	// ErrURL matches a malformed URL passed when connecting or publishing.
 	ErrURL = ffi.ErrMoqErrorUrl
-	// ErrTimeOverflow matches a timestamp that overflowed its timescale.
+	// ErrTimeOverflow matches a timestamp outside the supported range.
 	ErrTimeOverflow = ffi.ErrMoqErrorTimeOverflow
 	// ErrLogLevel matches an unparseable log level string passed to LogLevel.
 	ErrLogLevel = ffi.ErrMoqErrorLogLevel
diff --git a/kt/moq-ffi/MIGRATE.md b/kt/moq-ffi/MIGRATE.md
new file mode 100644
index 0000000000..2eecf89713
--- /dev/null
+++ b/kt/moq-ffi/MIGRATE.md
@@ -0,0 +1,11 @@
+# Migrating the Kotlin moq-ffi package
+
+How to update your code for each breaking change, newest first.
+
+## Unreleased
+
+### Regenerate the matching bindings
+
+Documentation on `MoqAudioProducer::write` and `finish` changes their UniFFI metadata checksums.
+Regenerate the Kotlin sources and package matching native libraries, then rebuild callers.
+The method signatures and behavior are unchanged.
diff --git a/kt/moq/MIGRATE.md b/kt/moq/MIGRATE.md
index 9a3ad22f29..05a0620475 100644
--- a/kt/moq/MIGRATE.md
+++ b/kt/moq/MIGRATE.md
@@ -9,6 +9,13 @@ How to update your code for each breaking change, newest first.
 `Anchor` gains `AnchorTime`, so exhaustive `when` expressions need a branch for it.
 `TrackConsumer.update` now throws `MoqException` on a time anchor an untimed track can't serve.
 
+### Rebuild the matching raw bindings
+
+The documentation update changes UniFFI's audio-producer method metadata checksums.
+Regenerate the Kotlin sources and update the native libraries in `moq-ffi` together,
+then rebuild the application; older generated guards reject the rebuilt library.
+Application calls are unchanged.
+
 ### JSON consumers emit timestamps (#5677)
 
 `values()` emits `json.Value` (`value`, plus `timestamp` as a `Duration?`) instead of a string, and `valuesAs<T>()` emits `Timed<T>(value, timestamp)`.
diff --git a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/audio/Audio.kt b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/audio/Audio.kt
index ac9e6d37e1..bbead7c43f 100644
--- a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/audio/Audio.kt
+++ b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/audio/Audio.kt
@@ -12,7 +12,7 @@ typealias EncoderInput = uniffi.moq.MoqAudioEncoderInput
 typealias EncoderOutput = uniffi.moq.MoqAudioEncoderOutput
 /** The PCM layout a [Consumer] delivers, how stale a group may get, and its playout delay. */
 typealias DecoderOutput = uniffi.moq.MoqAudioDecoderOutput
-/** Interleaved PCM with its presentation timestamp. */
+/** PCM samples in the configured layout with their presentation timestamp. */
 typealias Frame = uniffi.moq.MoqAudioFrame
 /** One encoded payload from an [Encoder]. */
 typealias Packet = uniffi.moq.MoqAudioPacket
diff --git a/py/moq-ffi/MIGRATE.md b/py/moq-ffi/MIGRATE.md
new file mode 100644
index 0000000000..e88a41ac96
--- /dev/null
+++ b/py/moq-ffi/MIGRATE.md
@@ -0,0 +1,11 @@
+# Migrating the Python moq-ffi package
+
+How to update your code for each breaking change, newest first.
+
+## Unreleased
+
+### Regenerate the matching bindings
+
+Documentation on `MoqAudioProducer::write` and `finish` changes their UniFFI metadata checksums.
+Rebuild or reinstall the complete wheel so its generated Python code and native library match.
+The method signatures and behavior are unchanged.
diff --git a/py/moq-rs/MIGRATE.md b/py/moq-rs/MIGRATE.md
index 59f06c9963..afc40f5f1d 100644
--- a/py/moq-rs/MIGRATE.md
+++ b/py/moq-rs/MIGRATE.md
@@ -9,6 +9,12 @@ How to update your code for each breaking change, newest first.
 `Anchor` gains a `TIME` variant, the group containing a presentation time.
 `TrackConsumer.update` now raises on a time anchor an untimed track can't serve.
 
+### Rebuild the matching raw bindings
+
+The documentation update changes UniFFI's audio-producer method metadata checksums.
+Rebuild or reinstall the complete `moq-ffi` wheel, keeping its generated Python code
+and native library together; application calls are unchanged.
+
 ### JSON consumers yield `json.Timed` (#5677)
 
 `json.SnapshotConsumer` and `json.StreamConsumer` yield `Timed(value, timestamp)` instead of the bare value; `timestamp` is a `timedelta`, or `None` when untimed.
diff --git a/quest/m1/README.md b/quest/m1/README.md
index 7b42ed8e64..e561aa0cce 100644
--- a/quest/m1/README.md
+++ b/quest/m1/README.md
@@ -108,7 +108,6 @@ lands before the cut.
 - [Exporters follow a rendition to a new track](/quest/m1/export-rendition-rebind.md) - the fMP4, TS, MKV and FLV exporters rebuild a rendition whose resolved `track` or `broadcast` changes under the same ID
 - [lite-06 max sequence](/quest/m1/lite06-max-sequence.md) - group sequence 2^62-1 reaches a lite-06 subscriber or is refused loudly, instead of vanishing
 - [Track live signal](/quest/m1/track-live.md) - a reader can wait for its track's feed to be live, so a player skips old cached groups while a fresh upstream subscription starts
-- [Binding docs](/quest/m1/docs-bindings.md) - every public moq-ffi and moq-c item has rustdoc, carried into the generated bindings and `moq.h`
 
 - [C++ and OBS package proof](/quest/m1/cpp-package-check.md) - the installed artifacts pass before their first release
 
diff --git a/quest/m1/docs-bindings.md b/quest/m1/docs-bindings.md
deleted file mode 100644
index c89a595def..0000000000
--- a/quest/m1/docs-bindings.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# [M] Document the moq-ffi and moq-c APIs
-
-## Goal
-
-Every public item in `moq-ffi` and `moq-c` has a one-line rustdoc, so the
-generated bindings and `moq.h` carry it, and both crates set
-`#![warn(missing_docs)]`.
-
-## Plan
-
-The m0 documentation audit (2026-10-19) found 116 undocumented public items
-in `moq-ffi` (42 in `error.rs`, the rest across `media`, `audio`, `origin`,
-`video`, and the producer and consumer types) and 133 in `moq-c` (39 in
-`error.rs`, 63 in `api.rs`, plus `audio` and `video`). Error codes and
-variants make up most of it.
-
-Count them with `cargo rustdoc -p <crate> --lib --all-features -- -W
-missing_docs`. Check that the docs reach the outputs a binding user reads:
-UniFFI copies rustdoc into the generated Python, Swift, Kotlin, and Go code,
-and cbindgen copies it into `moq.h`. The hand-written wrappers listed in the
-Cross-Package Sync table keep their own docs; align them where they restate
-the same item.
diff --git a/rs/moq-c/src/api.rs b/rs/moq-c/src/api.rs
index c000402518..cb0921214e 100644
--- a/rs/moq-c/src/api.rs
+++ b/rs/moq-c/src/api.rs
@@ -44,6 +44,7 @@ pub struct moq_container {
 	/// The CMAF init segment (ftyp+moov), or NULL.
 	/// Read only when `kind` is `MOQ_CONTAINER_KIND_CMAF`, where it is required.
 	pub init: *const u8,
+	/// The length in bytes of `init`.
 	pub init_len: usize,
 }
 
@@ -321,10 +322,12 @@ fn container_format_from_u32(value: u32) -> Result<moq_mux::import::ContainerFor
 pub struct moq_video_config {
 	/// The name of the track, NOT NULL terminated.
 	pub name: *const c_char,
+	/// The length in bytes of `name`.
 	pub name_len: usize,
 
 	/// The codec of the track, NOT NULL terminated
 	pub codec: *const c_char,
+	/// The length in bytes of `codec`.
 	pub codec_len: usize,
 
 	/// The description of the track, or NULL if not used.
@@ -332,12 +335,14 @@ pub struct moq_video_config {
 	///   - NULL: annex.b encoded
 	///   - Non-NULL: AVCC encoded
 	pub description: *const u8,
+	/// The length in bytes of `description`.
 	pub description_len: usize,
 
 	/// The encoded width/height of the media, a hint so a decoder can size its
 	/// buffers up front. Zero means absent, which no valid dimension is, so the
 	/// two are independent: a catalog carrying only one round-trips unchanged.
 	pub coded_width: u32,
+	/// The encoded height in pixels, or zero when absent.
 	pub coded_height: u32,
 
 	/// How the track's frames are wrapped.
@@ -384,14 +389,17 @@ pub struct moq_video_properties {
 pub struct moq_audio_config {
 	/// The name of the track, NOT NULL terminated
 	pub name: *const c_char,
+	/// The length in bytes of `name`.
 	pub name_len: usize,
 
 	/// The codec of the track, NOT NULL terminated
 	pub codec: *const c_char,
+	/// The length in bytes of `codec`.
 	pub codec_len: usize,
 
 	/// The description of the track, or NULL if not used.
 	pub description: *const u8,
+	/// The length in bytes of `description`.
 	pub description_len: usize,
 
 	/// The sample rate of the track in Hz
@@ -455,6 +463,7 @@ pub struct moq_binary_config {
 pub struct moq_json_value {
 	/// The JSON document as UTF-8, NOT NULL terminated.
 	pub json: *const c_char,
+	/// The length in bytes of `json`.
 	pub json_len: usize,
 
 	/// The timestamp of the frame that carried the value in microseconds, or 0 when
@@ -472,6 +481,7 @@ pub struct moq_json_value {
 pub struct moq_frame {
 	/// The payload of the frame, or NULL/0 if the stream has ended
 	pub payload: *const u8,
+	/// The length in bytes of `payload`.
 	pub payload_size: usize,
 
 	/// The presentation timestamp of the frame in microseconds, or 0 when
@@ -492,6 +502,7 @@ pub struct moq_frame {
 pub struct moq_datagram {
 	/// The payload of the datagram, or NULL/0 if the track has ended.
 	pub payload: *const u8,
+	/// The length in bytes of `payload`.
 	pub payload_size: usize,
 
 	/// The presentation timestamp of the datagram in microseconds, or 0 when
@@ -597,6 +608,7 @@ pub struct moq_subscription {
 	/// A request to the publisher, aggregated across every subscriber. Reads start at the
 	/// lowest group a range starts at, and stop past the last absolute end.
 	pub ranges: *const moq_range,
+	/// The number of entries in `ranges`.
 	pub ranges_len: usize,
 
 	/// `moq_order` discriminant: which pending group the publisher sends first.
@@ -718,6 +730,7 @@ pub(crate) unsafe fn parse_subscription(
 pub struct moq_string {
 	/// Pointer to `len` bytes of UTF-8, NOT NULL terminated.
 	pub data: *const c_char,
+	/// The string length in bytes.
 	pub len: usize,
 }
 
@@ -732,10 +745,12 @@ pub struct moq_string {
 pub struct moq_section {
 	/// The section name, NOT NULL terminated.
 	pub name: *const c_char,
+	/// The length in bytes of `name`.
 	pub name_len: usize,
 
 	/// The section value as a JSON document, NOT NULL terminated.
 	pub json: *const c_char,
+	/// The length in bytes of `json`.
 	pub json_len: usize,
 }
 
@@ -753,6 +768,7 @@ pub struct moq_route {
 	/// Hop ids, oldest first. NULL when `hops_len` is 0. 0 is the anonymous
 	/// mark and is legal on a received chain.
 	pub hops: *const u64,
+	/// The number of entries in `hops`.
 	pub hops_len: usize,
 	/// Preference among routes covering the same prefix: lower wins.
 	pub cost: u64,
@@ -807,11 +823,13 @@ unsafe fn parse_route(route: *const moq_route) -> Result<moq_net::origin::Route,
 pub struct moq_announce_config {
 	/// A literal path root, NOT NULL terminated. NULL when `prefix_len` is 0.
 	pub prefix: *const c_char,
+	/// The length in bytes of `prefix`.
 	pub prefix_len: usize,
 
 	/// A pattern relative to `prefix`, NOT NULL terminated, or NULL for every
 	/// path beneath it. Empty is a valid exact filter.
 	pub filter: *const c_char,
+	/// The length in bytes of `filter`.
 	pub filter_len: usize,
 
 	/// Also list hidden paths: those with a segment starting with `.` below the prefix.
@@ -840,13 +858,16 @@ pub enum moq_announce_kind {
 pub struct moq_announce_event {
 	/// The covered prefix, relative to the origin, NOT NULL terminated
 	pub prefix: *const c_char,
+	/// The length in bytes of `prefix`.
 	pub prefix_len: usize,
 
 	/// What each requested filter wildcard matched. Each string is NOT NULL terminated.
 	/// Meaningful only when `has_captures` is true; false means the route overlaps
 	/// the filter without pinning every wildcard.
 	pub captures: *const moq_string,
+	/// The number of entries in `captures`.
 	pub captures_len: usize,
+	/// Whether `captures` is present.
 	pub has_captures: bool,
 
 	/// Which event this is.
@@ -874,34 +895,42 @@ pub struct moq_connection_snapshot {
 pub struct moq_connection_stats {
 	/// Smoothed round-trip time, in microseconds.
 	pub rtt_us: u64,
+	/// Whether `rtt_us` is available in this sample.
 	pub rtt_valid: bool,
 
 	/// Estimated send bandwidth from the congestion controller, in bits per second.
 	pub estimated_send_rate_bps: u64,
+	/// Whether `estimated_send_rate_bps` is available in this sample.
 	pub estimated_send_rate_valid: bool,
 
 	/// Total bytes sent, including retransmissions and overhead.
 	pub bytes_sent: u64,
+	/// Whether `bytes_sent` is available in this sample.
 	pub bytes_sent_valid: bool,
 
 	/// Total bytes received, including duplicates and overhead.
 	pub bytes_received: u64,
+	/// Whether `bytes_received` is available in this sample.
 	pub bytes_received_valid: bool,
 
 	/// Total bytes lost (detected via retransmission or acknowledgement).
 	pub bytes_lost: u64,
+	/// Whether `bytes_lost` is available in this sample.
 	pub bytes_lost_valid: bool,
 
 	/// Total datagrams sent.
 	pub packets_sent: u64,
+	/// Whether `packets_sent` is available in this sample.
 	pub packets_sent_valid: bool,
 
 	/// Total datagrams received.
 	pub packets_received: u64,
+	/// Whether `packets_received` is available in this sample.
 	pub packets_received_valid: bool,
 
 	/// Total datagrams detected as lost.
 	pub packets_lost: u64,
+	/// Whether `packets_lost` is available in this sample.
 	pub packets_lost_valid: bool,
 }
 
@@ -1080,31 +1109,38 @@ pub struct moq_client_config {
 	/// the CLI spells them (`moq-lite-05`, `moq-transport-22`); [moq_versions]
 	/// lists what is on offer.
 	pub versions: *const moq_string,
+	/// The number of entries in `versions`.
 	pub versions_len: usize,
 
 	/// Local socket address to bind, or NULL for the wildcard address.
 	pub bind: *const c_char,
+	/// The length in bytes of `bind`.
 	pub bind_len: usize,
 
 	/// How long a dial may take before it gives up.
 	pub connect_timeout_us: u64,
+	/// Whether `connect_timeout_us` is present.
 	pub has_connect_timeout: bool,
 
 	/// Happy Eyeballs: how long before the next address is also dialed.
 	pub failover_delay_us: u64,
+	/// Whether `failover_delay_us` is present.
 	pub has_failover_delay: bool,
 
 	/// Happy Eyeballs: how long the first family waits for the AAAA answer.
 	pub resolution_delay_us: u64,
+	/// Whether `resolution_delay_us` is present.
 	pub has_resolution_delay: bool,
 
 	/// Whether the WebSocket fallback may be raced, for a UDP-blocked network.
 	/// Enabled unless you turn it off, hence the flag.
 	pub websocket_enabled: bool,
+	/// Whether `websocket_enabled` is present.
 	pub has_websocket_enabled: bool,
 
 	/// How long QUIC gets before the WebSocket fallback is also dialed.
 	pub websocket_delay_us: u64,
+	/// Whether `websocket_delay_us` is present.
 	pub has_websocket_delay: bool,
 
 	/// Accept any certificate. Development only: prefer `tls_fingerprints`,
@@ -1114,60 +1150,83 @@ pub struct moq_client_config {
 	/// Whether to trust the platform root store. Its default depends on the
 	/// backend, so it needs the flag to distinguish "off" from "unset".
 	pub tls_system_roots: bool,
+	/// Whether `tls_system_roots` is present.
 	pub has_tls_system_roots: bool,
 
 	/// Extra root certificate paths to trust.
 	pub tls_roots: *const moq_string,
+	/// The number of entries in `tls_roots`.
 	pub tls_roots_len: usize,
 
 	/// SHA-256 certificate fingerprints to pin, hex encoded. The native
 	/// equivalent of the browser's `serverCertificateHashes`.
 	pub tls_fingerprints: *const moq_string,
+	/// The number of entries in `tls_fingerprints`.
 	pub tls_fingerprints_len: usize,
 
 	/// SNI override, or NULL to use the host from the URL.
 	pub tls_host_name: *const c_char,
+	/// The length in bytes of `tls_host_name`.
 	pub tls_host_name_len: usize,
 
 	/// Client certificate and key paths for mTLS, or NULL for none.
 	pub tls_cert: *const c_char,
+	/// The length in bytes of `tls_cert`.
 	pub tls_cert_len: usize,
+	/// The client private key path for mTLS, or NULL for none.
 	pub tls_key: *const c_char,
+	/// The length in bytes of `tls_key`.
 	pub tls_key_len: usize,
 
 	/// Reconnect pacing. Each must leave a non-zero delay or retrying would
 	/// spin, which is rejected at dial.
 	pub backoff_initial_us: u64,
+	/// Whether `backoff_initial_us` is present.
 	pub has_backoff_initial: bool,
+	/// The factor by which the reconnect delay increases.
 	pub backoff_multiplier: u32,
+	/// Whether `backoff_multiplier` is present.
 	pub has_backoff_multiplier: bool,
+	/// The maximum reconnect delay in microseconds.
 	pub backoff_max_us: u64,
+	/// Whether `backoff_max_us` is present.
 	pub has_backoff_max: bool,
 	/// How long reconnection keeps trying before giving up for good.
 	pub backoff_timeout_us: u64,
+	/// Whether `backoff_timeout_us` is present.
 	pub has_backoff_timeout: bool,
 
 	/// QUIC transport tuning, all ignored by the WebSocket fallback.
 	pub quic_max_streams: u64,
+	/// Whether `quic_max_streams` is present.
 	pub has_quic_max_streams: bool,
+	/// The QUIC idle timeout in microseconds.
 	pub quic_idle_timeout_us: u64,
+	/// Whether `quic_idle_timeout_us` is present.
 	pub has_quic_idle_timeout: bool,
+	/// The QUIC keep-alive interval in microseconds.
 	pub quic_keep_alive_us: u64,
+	/// Whether `quic_keep_alive_us` is present.
 	pub has_quic_keep_alive: bool,
 	/// Generic segmentation offload and path MTU discovery. Both default to the
 	/// backend's choice, so both need their flag.
 	pub quic_gso: bool,
+	/// Whether `quic_gso` is present.
 	pub has_quic_gso: bool,
+	/// Whether QUIC may discover the path MTU.
 	pub quic_mtu_discovery: bool,
+	/// Whether `quic_mtu_discovery` is present.
 	pub has_quic_mtu_discovery: bool,
 
 	/// Congestion control family name (`loss`, `delay`, or `none`), or NULL for the backend's choice.
 	pub quic_congestion_control: *const c_char,
+	/// The length in bytes of `quic_congestion_control`.
 	pub quic_congestion_control_len: usize,
 
 	/// Directory to write qlog traces into, or NULL for none. Capture is
 	/// compile-time optional; see [moq_qlog_supported].
 	pub quic_qlog: *const c_char,
+	/// The length in bytes of `quic_qlog`.
 	pub quic_qlog_len: usize,
 
 	/// Danger: write TLS session secrets to the file `SSLKEYLOGFILE` names, for
@@ -1448,19 +1507,23 @@ pub struct moq_server_config {
 	/// Address to bind, e.g. `[::]:443`, `127.0.0.1:0`, or `localhost:4443`; NULL
 	/// for `[::]:443`. A port of 0 picks one; read it back with [moq_server_addr].
 	pub bind: *const c_char,
+	/// The length in bytes of `bind`.
 	pub bind_len: usize,
 
 	/// Certificate chain paths (PEM), paired with `tls_key`.
 	pub tls_cert: *const moq_string,
+	/// The number of entries in `tls_cert`.
 	pub tls_cert_len: usize,
 
 	/// Private key paths (PEM), paired with `tls_cert`.
 	pub tls_key: *const moq_string,
+	/// The number of entries in `tls_key`.
 	pub tls_key_len: usize,
 
 	/// Hostnames to generate a self-signed certificate for. Clients must pin its
 	/// fingerprint ([moq_server_fingerprints]) or disable verification.
 	pub tls_generate: *const moq_string,
+	/// The number of entries in `tls_generate`.
 	pub tls_generate_len: usize,
 
 	/// Danger: write TLS session secrets to the file `SSLKEYLOGFILE` names, for
diff --git a/rs/moq-c/src/audio.rs b/rs/moq-c/src/audio.rs
index 89b004f34e..6bd963c318 100644
--- a/rs/moq-c/src/audio.rs
+++ b/rs/moq-c/src/audio.rs
@@ -36,13 +36,21 @@ use crate::{Error, Id, NonZeroSlab, Shared, State, ffi};
 #[allow(non_camel_case_types)]
 #[derive(Clone, Copy, Debug)]
 pub enum moq_audio_sample_format {
+	/// Unsigned 8-bit PCM samples, interleaved by channel.
 	MOQ_AUDIO_SAMPLE_FORMAT_U8 = 0,
+	/// Signed 16-bit PCM samples, interleaved by channel.
 	MOQ_AUDIO_SAMPLE_FORMAT_S16 = 1,
+	/// Signed 32-bit PCM samples, interleaved by channel.
 	MOQ_AUDIO_SAMPLE_FORMAT_S32 = 2,
+	/// 32-bit floating-point PCM samples, interleaved by channel.
 	MOQ_AUDIO_SAMPLE_FORMAT_F32 = 3,
+	/// Unsigned 8-bit PCM samples, one plane per channel.
 	MOQ_AUDIO_SAMPLE_FORMAT_U8_PLANAR = 4,
+	/// Signed 16-bit PCM samples, one plane per channel.
 	MOQ_AUDIO_SAMPLE_FORMAT_S16_PLANAR = 5,
+	/// Signed 32-bit PCM samples, one plane per channel.
 	MOQ_AUDIO_SAMPLE_FORMAT_S32_PLANAR = 6,
+	/// 32-bit floating-point PCM samples, one plane per channel.
 	MOQ_AUDIO_SAMPLE_FORMAT_F32_PLANAR = 7,
 }
 
@@ -67,8 +75,9 @@ fn audio_format_from_u32(value: u32) -> Result<moq_audio::Format, Error> {
 pub struct moq_audio_encoder_input {
 	/// `moq_audio_sample_format` discriminant.
 	pub format: u32,
+	/// The number of PCM samples per second.
 	pub sample_rate: u32,
-	/// Interleaved channel count, which also names the speaker layout by the
+	/// The channel count, which also names the speaker layout by the
 	/// WAVE convention: 1 mono, 2 stereo, 3 2.1, 4 quad, 5 5.0, 6 5.1, 7 6.1,
 	/// 8 7.1, in front left, front right, center, LFE, back, side order.
 	pub channels: u32,
@@ -83,6 +92,7 @@ pub struct moq_audio_encoder_output {
 	/// Codec id, UTF-8: "opus", "pcm", or "aac". AAC encodes through the
 	/// platform's encoder, so a host without one refuses it.
 	pub codec: *const c_char,
+	/// The length in bytes of `codec`.
 	pub codec_len: usize,
 	/// 0 = derive from input.
 	pub sample_rate: u32,
@@ -100,6 +110,7 @@ pub struct moq_audio_encoder_output {
 #[repr(C)]
 #[allow(non_camel_case_types)]
 pub struct moq_audio_decoder_output {
+	/// The moq_audio_sample_format discriminant.
 	pub format: u32,
 	/// 0 = deliver at the codec's native sample rate.
 	pub sample_rate: u32,
@@ -111,9 +122,8 @@ pub struct moq_audio_decoder_output {
 	/// microseconds. Same congestion-control knob as
 	/// `moq_consume_audio`'s `max_delay_us`. 0 = skip
 	/// aggressively (the moq-mux default); set to your playout
-	/// buffer (tens to a few hundred ms) for a softer skip. Named
-	/// `_max` to leave room for a future `min_buffer_us`, a
-	/// jitter-buffer floor rather than a staleness bound.
+	/// buffer (tens to a few hundred ms) for a softer skip. This bounds
+	/// group staleness rather than setting a minimum playout delay.
 	pub max_delay_us: u64,
 }
 
@@ -125,8 +135,11 @@ pub struct moq_audio_decoder_output {
 #[repr(C)]
 #[allow(non_camel_case_types)]
 pub struct moq_audio_frame {
+	/// The presentation timestamp in microseconds.
 	pub timestamp_us: u64,
+	/// The raw frame bytes in the configured layout.
 	pub data: *const u8,
+	/// The length in bytes of `data`.
 	pub data_size: usize,
 }
 
@@ -142,6 +155,7 @@ pub(crate) struct AudioEncoder {
 type AudioProducer = Shared<AudioEncoder>;
 
 #[derive(Default)]
+/// The audio encoder, decoder, and decoded frame handle tables.
 pub struct Audio {
 	producers: NonZeroSlab<AudioProducer>,
 	consumer_tasks: NonZeroSlab<Task>,
@@ -149,6 +163,7 @@ pub struct Audio {
 }
 
 impl Audio {
+	/// Encode PCM frames into an audio track and return its handle.
 	pub fn publish(
 		&mut self,
 		broadcast: &mut moq_net::broadcast::Producer,
@@ -199,6 +214,7 @@ impl Audio {
 		self.producers.remove(id).ok_or(Error::MediaNotFound)
 	}
 
+	/// Decode a rendition and deliver frame handles to the callback.
 	pub fn consume(
 		&mut self,
 		rendition: crate::consume::Rendition<hang::catalog::AudioConfig>,
@@ -259,10 +275,12 @@ impl Audio {
 		}
 	}
 
+	/// Stop decoding and release the consumer handle.
 	pub fn consume_close(&mut self, id: Id) -> Result<(), Error> {
 		self.consumer_tasks.close(id, Error::TrackNotFound)
 	}
 
+	/// Borrow a decoded frame and its metadata until its handle is freed.
 	pub fn frame_info(&self, id: Id, dst: &mut moq_audio_frame) -> Result<(), Error> {
 		let frame = self.frames.get(id).ok_or(Error::FrameNotFound)?;
 		*dst = moq_audio_frame {
@@ -277,6 +295,7 @@ impl Audio {
 		Ok(())
 	}
 
+	/// Release a decoded frame handle.
 	pub fn frame_free(&mut self, id: Id) -> Result<(), Error> {
 		self.frames.remove(id).ok_or(Error::FrameNotFound)?;
 		Ok(())
diff --git a/rs/moq-c/src/error.rs b/rs/moq-c/src/error.rs
index 4b6c8d4c4f..75d7eb3d58 100644
--- a/rs/moq-c/src/error.rs
+++ b/rs/moq-c/src/error.rs
@@ -4,44 +4,83 @@ use crate::ffi;
 
 // Keep these public constants as the single source for both Rust's return mapping and the
 // generated C header. -1, -11, -12, and -39 are retired and remain reserved.
+/// The MoQ protocol operation failed.
 pub const MOQ_ERROR_MOQ: i32 = -2;
+/// The URL could not be parsed.
 pub const MOQ_ERROR_URL: i32 = -3;
+/// The input is not valid UTF-8.
 pub const MOQ_ERROR_UTF8: i32 = -4;
+/// The connection could not be established.
 pub const MOQ_ERROR_CONNECT: i32 = -5;
+/// A required pointer is null or invalid.
 pub const MOQ_ERROR_INVALID_POINTER: i32 = -6;
+/// The resource handle is invalid.
 pub const MOQ_ERROR_INVALID_ID: i32 = -7;
+/// The requested resource was not found.
 pub const MOQ_ERROR_NOT_FOUND: i32 = -8;
+/// The media format is not recognized.
 pub const MOQ_ERROR_UNKNOWN_FORMAT: i32 = -9;
+/// Initialization failed.
 pub const MOQ_ERROR_INIT_FAILED: i32 = -10;
+/// The timestamp is outside the supported range.
 pub const MOQ_ERROR_TIMESTAMP_OVERFLOW: i32 = -13;
+/// The requested log level is invalid.
 pub const MOQ_ERROR_LEVEL: i32 = -14;
+/// The enum value or error code is invalid.
 pub const MOQ_ERROR_INVALID_CODE: i32 = -15;
+/// A Rust task panicked.
 pub const MOQ_ERROR_PANIC: i32 = -16;
+/// The origin is offline.
 pub const MOQ_ERROR_OFFLINE: i32 = -17;
+/// The media catalog or container could not be processed.
 pub const MOQ_ERROR_HANG: i32 = -18;
+/// The requested rendition index is out of range.
 pub const MOQ_ERROR_NO_INDEX: i32 = -19;
+/// A string contains an unexpected NUL byte.
 pub const MOQ_ERROR_NUL: i32 = -20;
+/// The session handle was not found.
 pub const MOQ_ERROR_SESSION_NOT_FOUND: i32 = -21;
+/// The origin handle was not found.
 pub const MOQ_ERROR_ORIGIN_NOT_FOUND: i32 = -22;
+/// The announcement handle was not found.
 pub const MOQ_ERROR_ANNOUNCEMENT_NOT_FOUND: i32 = -23;
+/// The broadcast handle was not found.
 pub const MOQ_ERROR_BROADCAST_NOT_FOUND: i32 = -24;
+/// The catalog handle was not found.
 pub const MOQ_ERROR_CATALOG_NOT_FOUND: i32 = -25;
+/// The media handle was not found.
 pub const MOQ_ERROR_MEDIA_NOT_FOUND: i32 = -26;
+/// The track handle was not found.
 pub const MOQ_ERROR_TRACK_NOT_FOUND: i32 = -27;
+/// The frame handle was not found.
 pub const MOQ_ERROR_FRAME_NOT_FOUND: i32 = -28;
+/// Media could not be imported or exported.
 pub const MOQ_ERROR_MUX: i32 = -29;
+/// An audio codec operation failed.
 pub const MOQ_ERROR_AUDIO: i32 = -30;
+/// The importer did not consume the complete input buffer.
 pub const MOQ_ERROR_BUFFER_NOT_CONSUMED: i32 = -31;
+/// The group handle was not found.
 pub const MOQ_ERROR_GROUP_NOT_FOUND: i32 = -32;
+/// The native transport helper failed.
 pub const MOQ_ERROR_NATIVE: i32 = -33;
+/// Authorization is required or invalid.
 pub const MOQ_ERROR_UNAUTHORIZED: i32 = -34;
+/// Authorization does not permit the requested operation.
 pub const MOQ_ERROR_FORBIDDEN: i32 = -35;
+/// A video codec operation failed.
 pub const MOQ_ERROR_VIDEO: i32 = -36;
+/// JSON could not be parsed or encoded.
 pub const MOQ_ERROR_JSON: i32 = -37;
+/// A JSON track could not be processed.
 pub const MOQ_ERROR_JSON_TRACK: i32 = -38;
+/// The configuration contains an invalid value.
 pub const MOQ_ERROR_INVALID_CONFIG: i32 = -40;
+/// A standalone consumer cannot resolve a rendition in another broadcast.
 pub const MOQ_ERROR_UNRESOLVABLE_BROADCAST: i32 = -41;
+/// The authorization token expired.
 pub const MOQ_ERROR_EXPIRED: i32 = -42;
+/// The catalog requires a newer moq-hang version than this build supports.
 pub const MOQ_ERROR_UNSUPPORTED_CATALOG: i32 = -43;
 
 /// Whether a protocol code is from the session or stream registry.
diff --git a/rs/moq-c/src/lib.rs b/rs/moq-c/src/lib.rs
index 453b298ad9..c249cc994e 100644
--- a/rs/moq-c/src/lib.rs
+++ b/rs/moq-c/src/lib.rs
@@ -1,3 +1,5 @@
+#![warn(missing_docs)]
+
 //! C bindings for [`moq_net`].
 //!
 //! Provides a C-compatible API for real-time pub/sub over QUIC.
diff --git a/rs/moq-c/src/video.rs b/rs/moq-c/src/video.rs
index 7d09c68079..b433bfac27 100644
--- a/rs/moq-c/src/video.rs
+++ b/rs/moq-c/src/video.rs
@@ -106,6 +106,7 @@ pub struct moq_video_encoder_output {
 	/// Backend name, UTF-8, e.g. `"videotoolbox"`, `"nvenc"`, `"mediafoundation"`,
 	/// `"openh264"`. Read only when `kind` is `MOQ_VIDEO_ENCODER_KIND_NAMED`.
 	pub encoder: *const c_char,
+	/// The length in bytes of `encoder`.
 	pub encoder_len: usize,
 }
 
@@ -121,7 +122,9 @@ pub struct moq_video_encoder_output {
 pub struct moq_video_encoder_frame {
 	/// Presentation timestamp, in microseconds.
 	pub timestamp_us: u64,
+	/// The raw frame bytes in the configured layout.
 	pub data: *const u8,
+	/// The length in bytes of `data`.
 	pub data_size: usize,
 }
 
@@ -169,10 +172,15 @@ pub struct moq_video_decoder_output {
 #[repr(C)]
 #[allow(non_camel_case_types)]
 pub struct moq_video_frame {
+	/// The presentation timestamp in microseconds.
 	pub timestamp_us: u64,
+	/// The decoded width in pixels.
 	pub width: u32,
+	/// The decoded height in pixels.
 	pub height: u32,
+	/// The raw frame bytes in the configured layout.
 	pub data: *const u8,
+	/// The length in bytes of `data`.
 	pub data_size: usize,
 }
 
@@ -521,6 +529,7 @@ impl Video {
 		self.producers.remove(id).ok_or(Error::MediaNotFound)
 	}
 
+	/// Decode a rendition and deliver frame handles to the callback.
 	pub fn consume(
 		&mut self,
 		rendition: crate::consume::Rendition<hang::catalog::VideoConfig>,
@@ -578,6 +587,7 @@ impl Video {
 		}
 	}
 
+	/// Stop decoding and release the consumer handle.
 	pub fn consume_close(&mut self, id: Id) -> Result<(), Error> {
 		self.consumer_tasks.close(id, Error::TrackNotFound)
 	}
@@ -588,6 +598,7 @@ impl Video {
 		self.frames.get(id).cloned().ok_or(Error::FrameNotFound)
 	}
 
+	/// Release a decoded frame handle.
 	pub fn frame_free(&mut self, id: Id) -> Result<(), Error> {
 		self.frames.remove(id).ok_or(Error::FrameNotFound)?;
 		Ok(())
diff --git a/rs/moq-ffi/MIGRATE.md b/rs/moq-ffi/MIGRATE.md
index d12b0488b5..151435de8c 100644
--- a/rs/moq-ffi/MIGRATE.md
+++ b/rs/moq-ffi/MIGRATE.md
@@ -14,6 +14,13 @@ It defaults to `false` in every generated binding; a Rust struct literal adds `c
 `MoqAnchor` gains `Time { timestamp_us }`, the group containing that presentation time, so exhaustive matches need an arm for it.
 `MoqTrackConsumer::update` now returns `Result<(), MoqError>`, failing with `TimestampMismatch` on a time anchor an untimed track can't serve.
 
+### Regenerate bindings after the API documentation update
+
+The new documentation on `MoqAudioProducer::write` and `finish` changes their
+UniFFI metadata checksums, even though their signatures and behavior are unchanged.
+Regenerate each language's bindings from the rebuilt library and update them together.
+Older generated bindings with active checksum guards reject this library during initialization.
+
 ### JSON consumers return `MoqJsonValue` (#5677)
 
 `MoqJsonSnapshotConsumer::next` and `MoqJsonStreamConsumer::next` return `MoqJsonValue { value, timestamp_us }` instead of a string; `timestamp_us` is null when untimed.
diff --git a/rs/moq-ffi/src/audio.rs b/rs/moq-ffi/src/audio.rs
index d91929fba5..ae9a0dc896 100644
--- a/rs/moq-ffi/src/audio.rs
+++ b/rs/moq-ffi/src/audio.rs
@@ -20,13 +20,21 @@ use crate::ffi::Task;
 /// <https://developer.mozilla.org/en-US/docs/Web/API/AudioData/format>
 #[derive(Clone, Copy, uniffi::Enum)]
 pub enum MoqAudioSampleFormat {
+	/// Unsigned 8-bit PCM samples, interleaved by channel.
 	U8,
+	/// Signed 16-bit PCM samples, interleaved by channel.
 	S16,
+	/// Signed 32-bit PCM samples, interleaved by channel.
 	S32,
+	/// 32-bit floating-point PCM samples, interleaved by channel.
 	F32,
+	/// Unsigned 8-bit PCM samples, one plane per channel.
 	U8Planar,
+	/// Signed 16-bit PCM samples, one plane per channel.
 	S16Planar,
+	/// Signed 32-bit PCM samples, one plane per channel.
 	S32Planar,
+	/// 32-bit floating-point PCM samples, one plane per channel.
 	F32Planar,
 }
 
@@ -106,27 +114,34 @@ impl From<MoqAudioPreset> for moq_audio::encode::Preset {
 /// PCM layout the caller will pass to [`MoqAudioProducer::write`].
 #[derive(uniffi::Record)]
 pub struct MoqAudioEncoderInput {
+	/// The raw PCM sample layout.
 	pub format: MoqAudioSampleFormat,
+	/// The number of samples per second.
 	pub sample_rate: u32,
-	/// Interleaved channel count, which also names the speaker layout by the
+	/// The channel count, which also names the speaker layout by the
 	/// WAVE convention: 1 mono, 2 stereo, 3 2.1, 4 quad, 5 5.0, 6 5.1, 7 6.1,
 	/// 8 7.1, in front left, front right, center, LFE, back, side order.
 	pub channels: u32,
 }
 
-/// Codec-side configuration. `sample_rate` / `channels` `None` means
-/// "match the input (snapping the rate up to a libopus-supported
-/// value if necessary)".
+/// Codec-side configuration for a [`MoqAudioProducer`] or a standalone [`MoqAudioEncoder`].
+/// Opus snaps the encoded rate up to one libopus supports.
 #[derive(uniffi::Record)]
 pub struct MoqAudioEncoderOutput {
+	/// The codec used to encode this rendition.
 	pub codec: Arc<MoqAudioCodec>,
 	/// Track name for a broadcast-bound producer. `None` derives one from the codec.
 	#[uniffi(default = None)]
 	pub track: Option<String>,
+	/// The encoded samples per second. Absent matches a producer's input rate,
+	/// or 48000 for a standalone encoder, which has no input to match.
 	#[uniffi(default = None)]
 	pub sample_rate: Option<u32>,
+	/// The encoded channel count. Absent matches a producer's input, or 2 for a
+	/// standalone encoder, which has no input to match.
 	#[uniffi(default = None)]
 	pub channels: Option<u32>,
+	/// The target bitrate in bits per second, or absent for the codec default.
 	#[uniffi(default = None)]
 	pub bitrate: Option<u32>,
 	/// Encoded frame duration in microseconds. Opus accepts exactly
@@ -161,6 +176,7 @@ impl MoqAudioEncoderOutput {
 /// PCM layout the caller wants out of [`MoqAudioConsumer::next`].
 #[derive(uniffi::Record)]
 pub struct MoqAudioDecoderOutput {
+	/// The raw PCM sample layout.
 	pub format: MoqAudioSampleFormat,
 	/// `None` delivers samples at the codec's native rate.
 	#[uniffi(default = None)]
@@ -379,6 +395,7 @@ impl MoqAudioProducer {
 		Ok(())
 	}
 
+	/// Encode and publish one PCM frame.
 	pub fn write(&self, frame: MoqAudioFrame) -> Result<(), MoqError> {
 		let _guard = crate::ffi::runtime().enter();
 		let frame = moq_audio::Frame::try_from(frame)?;
@@ -395,6 +412,7 @@ impl MoqAudioProducer {
 		self.reservation.lock().unwrap().clone()
 	}
 
+	/// Drain the encoder and finish the audio track.
 	pub fn finish(&self) -> Result<(), MoqError> {
 		let _guard = crate::ffi::runtime().enter();
 		let mut producer = self.inner.lock().unwrap().take().ok_or(MoqError::Closed)?;
diff --git a/rs/moq-ffi/src/consumer.rs b/rs/moq-ffi/src/consumer.rs
index 40be2cadba..52b361d22f 100644
--- a/rs/moq-ffi/src/consumer.rs
+++ b/rs/moq-ffi/src/consumer.rs
@@ -1,3 +1,5 @@
+//! Read broadcasts, tracks, and groups.
+
 use std::future::Future;
 use std::sync::{Arc, Mutex};
 use std::task::{Poll, ready};
@@ -64,12 +66,22 @@ pub struct MoqRange {
 #[derive(Clone, Copy, uniffi::Enum)]
 pub enum MoqAnchor {
 	/// This exact group and frame.
-	Absolute { group: u64, frame: u64 },
+	Absolute {
+		/// The absolute group sequence number.
+		group: u64,
+		/// The zero-based frame index within the group.
+		frame: u64,
+	},
 	/// The group this many before the latest, clamped to group 0: `0` is the latest group.
-	Relative { groups: u64 },
-	/// The group containing this presentation time, in microseconds. An untimed track
-	/// refuses it.
-	Time { timestamp_us: u64 },
+	Relative {
+		/// The number of groups back from the live edge.
+		groups: u64,
+	},
+	/// The group containing this presentation time. An untimed track refuses it.
+	Time {
+		/// The presentation time in microseconds.
+		timestamp_us: u64,
+	},
 }
 
 /// Which of a subscription's pending groups the publisher sends first, mirroring
@@ -159,6 +171,7 @@ impl TryFrom<MoqSubscription> for moq_net::track::Subscription {
 	}
 }
 
+/// A broadcast from which tracks and groups can be read.
 #[derive(Clone, uniffi::Object)]
 pub struct MoqBroadcastConsumer {
 	pub(crate) inner: moq_net::broadcast::Consumer,
@@ -518,6 +531,7 @@ async fn with_lane<R>(_lane: Guard<ReadLane>, fut: impl Future<Output = Result<R
 	fut.await
 }
 
+/// A subscribed track whose groups, frames, or datagrams can be read.
 #[derive(uniffi::Object)]
 pub struct MoqTrackConsumer {
 	shared: Arc<TrackShared>,
@@ -708,6 +722,7 @@ impl GroupInner {
 	}
 }
 
+/// A group whose frames can be read in order.
 #[derive(uniffi::Object)]
 pub struct MoqGroupConsumer {
 	sequence: u64,
diff --git a/rs/moq-ffi/src/error.rs b/rs/moq-ffi/src/error.rs
index 85f098f1d7..5fc89ceff1 100644
--- a/rs/moq-ffi/src/error.rs
+++ b/rs/moq-ffi/src/error.rs
@@ -167,54 +167,101 @@ fn stream_kind(err: &moq_net::StreamError) -> MoqProtocolKind {
 pub enum MoqError {
 	/// A protocol failure carrying the peer's session or stream code.
 	#[error("{details}")]
-	Protocol { details: MoqProtocolError },
+	Protocol {
+		/// The protocol registry, wire code, and diagnostic message.
+		details: MoqProtocolError,
+	},
 
 	/// The underlying QUIC/WebTransport connection failed.
 	#[error("transport: {reason}")]
-	Transport { reason: String },
+	Transport {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
 	/// A local failure without a session or stream code.
 	#[error("internal: {reason}")]
-	Internal { reason: String },
+	Internal {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// The media catalog or container could not be processed.
 	#[error("{reason}")]
-	Media { reason: String },
+	Media {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// Media could not be imported or exported.
 	#[error("{reason}")]
-	Mux { reason: String },
+	Mux {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// A JSON track could not be processed.
 	#[error("{reason}")]
-	JsonTrack { reason: String },
+	JsonTrack {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
 	// Native codec errors, behind the optional `audio`/`video` features.
+	/// An audio codec operation failed.
 	#[cfg(all(feature = "audio", not(target_arch = "wasm32")))]
 	#[error("{reason}")]
-	Audio { reason: String },
+	Audio {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// A video codec operation failed.
 	#[cfg(all(feature = "video", not(target_arch = "wasm32")))]
 	#[error("{reason}")]
-	Video { reason: String },
+	Video {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// The connection URL could not be parsed.
 	#[error("url: {reason}")]
-	Url { reason: String },
+	Url {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// A timestamp is outside the supported range.
 	#[error("timestamp overflow")]
 	TimeOverflow,
 
+	/// The requested log level is invalid.
 	#[error("log level: {reason}")]
-	LogLevel { reason: String },
+	LogLevel {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
 	/// An owned native task panicked; cancellation is reported separately.
 	#[cfg(not(target_arch = "wasm32"))]
 	#[error("task: {reason}")]
-	Task { reason: String },
+	Task {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// JSON could not be parsed or encoded.
 	#[error("json: {reason}")]
-	Json { reason: String },
+	Json {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// The operation was cancelled.
 	#[error("cancelled")]
 	Cancelled,
 
+	/// The handle or connection is closed.
 	#[error("closed")]
 	Closed,
 
@@ -225,24 +272,43 @@ pub enum MoqError {
 	#[error("busy")]
 	Busy,
 
+	/// A connection could not be established.
 	#[error("connect: {reason}")]
-	Connect { reason: String },
+	Connect {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// The local server socket could not be bound.
 	#[error("bind: {reason}")]
-	Bind { reason: String },
+	Bind {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// A connection was refused during the handshake.
 	#[error("reject: {reason}")]
-	Reject { reason: String },
+	Reject {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// The request has already been accepted or rejected.
 	#[error("already responded")]
 	AlreadyResponded,
 
+	/// Codec configuration or bitstream parsing failed.
 	#[error("codec: {reason}")]
-	Codec { reason: String },
+	Codec {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// Authorization is required or invalid.
 	#[error("unauthorized")]
 	Unauthorized,
 
+	/// Authorization does not permit the requested operation.
 	#[error("forbidden")]
 	Forbidden,
 
@@ -275,31 +341,53 @@ pub enum MoqError {
 
 	/// A route carried an invalid hop id or too many hops.
 	#[error("invalid route: {reason}")]
-	InvalidRoute { reason: String },
+	InvalidRoute {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
 	/// A path pattern was empty, had a doubled slash, or used a reserved segment form.
 	#[error("invalid pattern: {reason}")]
-	InvalidPattern { reason: String },
+	InvalidPattern {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
 	/// An epoch was not a lowercase hyphenated UUIDv7.
 	#[error("{reason}")]
-	InvalidEpoch { reason: String },
+	InvalidEpoch {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
 	/// A catalog rendition named another broadcast, but this consumer came from a standalone
 	/// broadcast rather than an origin, so there is nothing to resolve the reference against.
 	#[error("unresolvable broadcast reference: {reason}")]
-	UnresolvableBroadcast { reason: String },
+	UnresolvableBroadcast {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
+	/// The logger could not be initialized.
 	#[error("log: {reason}")]
-	Log { reason: String },
+	Log {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
 	/// A configuration record held a value the constructor cannot use.
 	#[error("config: {reason}")]
-	Config { reason: String },
+	Config {
+		/// A diagnostic message describing the failure.
+		reason: String,
+	},
 
 	/// A catalog needs a newer moq-hang draft than this build reads; upgrade to read it.
 	#[error("unsupported catalog version {version}")]
-	UnsupportedCatalog { version: u64 },
+	UnsupportedCatalog {
+		/// The catalog version this build cannot read.
+		version: u64,
+	},
 }
 
 impl From<moq_net::Error> for MoqError {
diff --git a/rs/moq-ffi/src/lib.rs b/rs/moq-ffi/src/lib.rs
index 5b741a8efc..0cc72dd72b 100644
--- a/rs/moq-ffi/src/lib.rs
+++ b/rs/moq-ffi/src/lib.rs
@@ -1,3 +1,4 @@
+#![warn(missing_docs)]
 #![cfg_attr(test, allow(clippy::disallowed_methods))]
 
 //! UniFFI bindings for [`moq_net`].
diff --git a/rs/moq-ffi/src/media.rs b/rs/moq-ffi/src/media.rs
index c9262b2a45..55f03e543d 100644
--- a/rs/moq-ffi/src/media.rs
+++ b/rs/moq-ffi/src/media.rs
@@ -1,3 +1,5 @@
+//! Publish and consume media catalogs and encoded frames.
+
 use std::collections::HashMap;
 use std::sync::{Arc, Weak};
 
@@ -15,7 +17,9 @@ use crate::producer::{MoqBroadcastProducer, MoqTrackRequest};
 /// A width and height in pixels.
 #[derive(Clone, uniffi::Record)]
 pub struct MoqDimensions {
+	/// The width in pixels.
 	pub width: u32,
+	/// The height in pixels.
 	pub height: u32,
 }
 
@@ -43,7 +47,10 @@ pub enum MoqContainer {
 	/// The legacy hang container.
 	Legacy,
 	/// CMAF (fMP4), carrying the initialization segment.
-	Cmaf { init: Vec<u8> },
+	Cmaf {
+		/// The CMAF initialization segment.
+		init: Vec<u8>,
+	},
 	/// LOC, the low-overhead container.
 	Loc,
 }
@@ -76,12 +83,18 @@ impl From<MoqContainer> for hang::catalog::Container {
 	}
 }
 
+/// A catalog snapshot describing the available media renditions.
 #[derive(uniffi::Record)]
 pub struct MoqCatalog {
+	/// Video renditions keyed by their catalog IDs.
 	pub video: HashMap<String, MoqVideo>,
+	/// Audio renditions keyed by their catalog IDs.
 	pub audio: HashMap<String, MoqAudio>,
+	/// The final rendered size after rotation, when specified.
 	pub display: Option<MoqDimensions>,
+	/// The clockwise rotation in degrees, when specified.
 	pub rotation: Option<f64>,
+	/// Whether to flip horizontally after rotation, when specified.
 	pub flip: Option<bool>,
 	/// Untyped application catalog sections, keyed by section name, each value a JSON string.
 	/// These are the top-level catalog keys beyond `video`/`audio`, carried through verbatim
@@ -90,6 +103,7 @@ pub struct MoqCatalog {
 	pub sections: HashMap<String, String>,
 }
 
+/// A video rendition and the configuration needed to decode it.
 #[derive(Clone, uniffi::Record)]
 pub struct MoqVideo {
 	/// Human-readable rendition name for track pickers.
@@ -103,20 +117,26 @@ pub struct MoqVideo {
 	/// the ID is the track name.
 	#[uniffi(default = None)]
 	pub track: Option<String>,
+	/// The codec string identifying this rendition's encoded format.
 	pub codec: String,
+	/// The codec initialization bytes, when required.
 	pub description: Option<Vec<u8>>,
 	/// The encoded pixel dimensions.
 	pub coded: Option<MoqDimensions>,
 	/// The aspect ratio the whole picture is displayed at; absent means the decoded shape.
 	pub display_aspect: Option<MoqDimensions>,
+	/// The maximum encoded bitrate in bits per second.
 	pub bitrate: Option<u64>,
 	/// Whether this rendition may be selected; when false, no frames are coming.
 	#[uniffi(default = true)]
 	pub enabled: bool,
+	/// The frame rate in frames per second, when specified.
 	pub framerate: Option<f64>,
+	/// The framing used to carry this rendition.
 	pub container: MoqContainer,
 }
 
+/// An audio rendition and the configuration needed to decode it.
 #[derive(Clone, uniffi::Record)]
 pub struct MoqAudio {
 	/// Human-readable rendition name for track pickers.
@@ -130,14 +150,20 @@ pub struct MoqAudio {
 	/// the ID is the track name.
 	#[uniffi(default = None)]
 	pub track: Option<String>,
+	/// The codec string identifying this rendition's encoded format.
 	pub codec: String,
+	/// The codec initialization bytes, when required.
 	pub description: Option<Vec<u8>>,
+	/// The number of samples per second.
 	pub sample_rate: u32,
+	/// The number of audio channels.
 	pub channel_count: u32,
+	/// The maximum encoded bitrate in bits per second.
 	pub bitrate: Option<u64>,
 	/// Whether this rendition may be selected; when false, no frames are coming.
 	#[uniffi(default = true)]
 	pub enabled: bool,
+	/// The framing used to carry this rendition.
 	pub container: MoqContainer,
 	/// The publisher's worst-case delay between a frame being ready and its flush, in
 	/// microseconds, which floors an estimated playout delay. Absent means frames flush at once.
@@ -603,9 +629,15 @@ mod test {
 #[derive(Clone, uniffi::Enum)]
 pub enum MoqMediaTarget {
 	/// A new track with an explicit name, or a unique name derived from its format.
-	Named { name: Option<String> },
+	Named {
+		/// The explicit track name, or absent to allocate a unique name from its format.
+		name: Option<String>,
+	},
 	/// A requested track whose name and ownership are already fixed.
-	Requested { request: Arc<MoqTrackRequest> },
+	Requested {
+		/// The pending track request to accept.
+		request: Arc<MoqTrackRequest>,
+	},
 }
 
 impl MoqMediaTarget {
@@ -1097,9 +1129,19 @@ fn reserve_track(
 #[derive(Clone, uniffi::Enum)]
 pub enum MoqRendition {
 	/// A video rendition.
-	Video { id: String, config: MoqVideo },
+	Video {
+		/// The rendition ID in the catalog.
+		id: String,
+		/// The rendition configuration.
+		config: MoqVideo,
+	},
 	/// An audio rendition.
-	Audio { id: String, config: MoqAudio },
+	Audio {
+		/// The rendition ID in the catalog.
+		id: String,
+		/// The rendition configuration.
+		config: MoqAudio,
+	},
 }
 
 impl MoqRendition {
diff --git a/rs/moq-ffi/src/origin.rs b/rs/moq-ffi/src/origin.rs
index 161d46be42..e0d36f0a28 100644
--- a/rs/moq-ffi/src/origin.rs
+++ b/rs/moq-ffi/src/origin.rs
@@ -1,3 +1,5 @@
+//! Publish, discover, and route broadcasts.
+
 use std::sync::Arc;
 
 use crate::consumer::MoqBroadcastConsumer;
@@ -112,6 +114,7 @@ pub fn moq_epoch_time_ms(epoch: String) -> Result<u64, MoqError> {
 	Ok(since.as_millis() as u64)
 }
 
+/// An origin in which broadcasts can be published.
 #[derive(uniffi::Object)]
 pub struct MoqOriginProducer {
 	inner: Origin,
@@ -130,12 +133,14 @@ impl std::ops::Deref for Origin {
 	}
 }
 
+/// An origin from which broadcasts can be discovered and requested.
 #[derive(uniffi::Object)]
 pub struct MoqOriginConsumer {
 	inner: moq_net::origin::Consumer,
 	pub(crate) driver: Background,
 }
 
+/// A stream of broadcast announcement changes.
 #[derive(uniffi::Object)]
 pub struct MoqAnnounceConsumer {
 	task: Task<Announced>,
@@ -251,14 +256,26 @@ impl From<moq_net::announce::Announce> for MoqAnnounce {
 #[derive(Clone, Debug, PartialEq, Eq, uniffi::Enum)]
 pub enum MoqAnnounceEvent {
 	/// A route now covers the prefix; the stream had none there.
-	Start { announce: MoqAnnounce },
+	Start {
+		/// The broadcast announcement affected by this event.
+		announce: MoqAnnounce,
+	},
 	/// The route covering the prefix changed hops or cost.
-	Update { announce: MoqAnnounce },
+	Update {
+		/// The broadcast announcement affected by this event.
+		announce: MoqAnnounce,
+	},
 	/// No route covers the prefix any more. Carries its last advertised route.
-	End { announce: MoqAnnounce },
+	End {
+		/// The broadcast announcement affected by this event.
+		announce: MoqAnnounce,
+	},
 	/// Another publisher instance now serves the prefix: drop what was resolved under
 	/// it and request afresh.
-	Restart { announce: MoqAnnounce },
+	Restart {
+		/// The broadcast announcement affected by this event.
+		announce: MoqAnnounce,
+	},
 }
 
 impl From<moq_net::announce::Event> for MoqAnnounceEvent {
diff --git a/rs/moq-ffi/src/producer.rs b/rs/moq-ffi/src/producer.rs
index 97b2c3ec24..5d2bc8c4d8 100644
--- a/rs/moq-ffi/src/producer.rs
+++ b/rs/moq-ffi/src/producer.rs
@@ -1,3 +1,5 @@
+//! Publish broadcasts, tracks, and groups.
+
 use std::sync::Arc;
 
 use moq_mux::catalog::hang::Extra;
@@ -96,11 +98,13 @@ pub(crate) struct BroadcastProducer {
 	pub(crate) driver: Background,
 }
 
+/// A broadcast in which tracks can be published.
 #[derive(uniffi::Object)]
 pub struct MoqBroadcastProducer {
 	pub(crate) state: std::sync::Mutex<Option<BroadcastProducer>>,
 }
 
+/// A handler for requests for tracks in a broadcast.
 #[derive(uniffi::Object)]
 pub struct MoqBroadcastDynamic {
 	task: Task<DynamicProducer>,
@@ -478,6 +482,7 @@ impl MoqTrackRequest {
 
 // ---- Track Producer ----
 
+/// A track to which groups, frames, or datagrams can be published.
 #[derive(uniffi::Object)]
 pub struct MoqTrackProducer {
 	inner: std::sync::Mutex<Option<moq_net::track::Producer>>,
@@ -628,6 +633,7 @@ impl MoqTrackProducer {
 	}
 }
 
+/// A group to which frames can be published.
 #[derive(uniffi::Object)]
 pub struct MoqGroupProducer {
 	sequence: u64,
diff --git a/rs/moq-ffi/src/server.rs b/rs/moq-ffi/src/server.rs
index 47504eb97f..ffc8b1f21d 100644
--- a/rs/moq-ffi/src/server.rs
+++ b/rs/moq-ffi/src/server.rs
@@ -1,3 +1,5 @@
+//! Accept incoming MoQ sessions.
+
 use std::path::PathBuf;
 use std::sync::Arc;
 
diff --git a/rs/moq-ffi/src/session.rs b/rs/moq-ffi/src/session.rs
index 4e7175c147..b5167c2216 100644
--- a/rs/moq-ffi/src/session.rs
+++ b/rs/moq-ffi/src/session.rs
@@ -1,3 +1,5 @@
+//! Connect to peers and manage MoQ sessions.
+
 use std::sync::Arc;
 
 use url::Url;
@@ -927,6 +929,7 @@ impl Accepted {
 	}
 }
 
+/// A connection that exchanges broadcasts with a peer.
 #[derive(uniffi::Object)]
 pub struct MoqSession {
 	inner: Inner,
diff --git a/rs/moq-ffi/src/video.rs b/rs/moq-ffi/src/video.rs
index 2b06f339e0..064698febc 100644
--- a/rs/moq-ffi/src/video.rs
+++ b/rs/moq-ffi/src/video.rs
@@ -70,7 +70,10 @@ pub enum MoqVideoEncoderKind {
 	/// `"openh264"` (software, everywhere).
 	/// Naming one this build lacks fails with a no-encoder error, so reach for
 	/// this only when [`Auto`](Self::Auto) picks the wrong one.
-	Named { name: String },
+	Named {
+		/// The encoder backend name to open.
+		name: String,
+	},
 }
 
 impl From<MoqVideoEncoderKind> for moq_video::encode::Kind {
@@ -89,6 +92,7 @@ impl From<MoqVideoEncoderKind> for moq_video::encode::Kind {
 /// match `width` x `height`; scale before writing if your source moves.
 #[derive(uniffi::Record)]
 pub struct MoqVideoEncoderInput {
+	/// The raw pixel layout.
 	pub format: MoqVideoPixelFormat,
 	/// Encoded width in pixels. Must be even (I420 chroma is subsampled 2x2).
 	pub width: u32,
@@ -102,6 +106,7 @@ pub struct MoqVideoEncoderInput {
 /// Codec-side configuration.
 #[derive(uniffi::Record)]
 pub struct MoqVideoEncoderOutput {
+	/// The codec used to encode this rendition.
 	pub codec: MoqVideoCodec,
 	/// Track name for a broadcast-bound producer. `None` derives one from the codec.
 	#[uniffi(default = None)]
@@ -122,7 +127,10 @@ pub struct MoqVideoEncoderOutput {
 #[derive(Clone, Copy, uniffi::Enum)]
 pub enum MoqVideoGop {
 	/// Start a group with a keyframe every `interval` frames.
-	Keyframe { interval: u32 },
+	Keyframe {
+		/// The number of frames between keyframes.
+		interval: u32,
+	},
 }
 
 impl From<MoqVideoGop> for moq_video::encode::Gop {
@@ -761,7 +769,10 @@ pub struct MoqVideoDecoderOutput {
 #[derive(Clone, Copy, uniffi::Enum)]
 pub enum MoqVideoSurface {
 	/// An Apple `CVPixelBufferRef` from VideoToolbox, IOSurface-backed NV12.
-	PixelBuffer { pointer: u64 },
+	PixelBuffer {
+		/// The borrowed CVPixelBuffer address, valid while the frame is held.
+		pointer: u64,
+	},
 }
 
 /// One decoded video frame, owning the surface it was decoded into.
diff --git a/swift/MIGRATE.md b/swift/MIGRATE.md
index 2f6ffc91e7..af94c21437 100644
--- a/swift/MIGRATE.md
+++ b/swift/MIGRATE.md
@@ -9,6 +9,13 @@ How to update your code for each breaking change, newest first.
 `Subscription.Anchor` gains `.time(timestampUs:)`, so exhaustive switches need a case for it.
 `TrackConsumer.update(subscription:)` now `throws`, on a time anchor an untimed track can't serve; call it with `try`.
 
+### Rebuild the matching raw bindings
+
+The documentation update changes UniFFI's audio-producer method metadata checksums.
+Regenerate the Swift sources and rebuild the `MoqFFI` XCFramework together,
+then rebuild the application; older generated guards reject the rebuilt library.
+Application calls are unchanged.
+
 ### JSON consumers yield `Json.Timed` (#5677)
 
 `Json.SnapshotConsumer` and `Json.StreamConsumer` yield `Json.Timed<Value>` (`value`, `timestampUs`) instead of the bare value; `timestampUs` is `nil` when untimed.
diff --git a/swift/Sources/Moq/Aliases.swift b/swift/Sources/Moq/Aliases.swift
index 9b9fd71b54..03a5fc8c37 100644
--- a/swift/Sources/Moq/Aliases.swift
+++ b/swift/Sources/Moq/Aliases.swift
@@ -24,7 +24,7 @@ public typealias VideoDecoderOutput = MoqVideoDecoderOutput
 /// One decoded video frame, owning the decoder's surface until released;
 /// `pixels(format:)` converts it to packed CPU pixels.
 public typealias VideoDecodedFrame = MoqVideoDecodedFrame
-/// The PCM layout an `AudioConsumer` decodes to, plus its max delay.
+/// The decoded PCM layout, maximum group staleness, and playout delay.
 public typealias AudioDecoderOutput = MoqFFI.MoqAudioDecoderOutput
 /// A raw PCM sample format, mirroring WebCodecs `AudioData.format`.
 public typealias AudioSampleFormat = MoqFFI.MoqAudioSampleFormat
diff --git a/swift/ffi/MIGRATE.md b/swift/ffi/MIGRATE.md
new file mode 100644
index 0000000000..d85c40bac2
--- /dev/null
+++ b/swift/ffi/MIGRATE.md
@@ -0,0 +1,11 @@
+# Migrating the Swift MoqFFI package
+
+How to update your code for each breaking change, newest first.
+
+## Unreleased
+
+### Regenerate the matching bindings
+
+Documentation on `MoqAudioProducer::write` and `finish` changes their UniFFI metadata checksums.
+Regenerate the Swift sources and rebuild the matching XCFramework, then rebuild callers.
+The method signatures and behavior are unchanged.