Skip to main content

WAI Extension: MoQ Streaming Format

Mirrored from the canonical text at commit 498e6b88 ().

Status: Draft, and deliberately tracking rather than pinning — MOQT is pre-Working-Group-Last-Call and its text still moves. Declares WAI as a packaging of the MOQT Streaming Format (MSF) over Media over QUIC Transport, so a WAI envelope is a first-class MOQT object rather than an opaque payload inside someone else’s container. No new transport: WAI defines none by charter, and this extension does not change that. Field semantics and rules over them only — never MOQT’s byte encoding. Keywords MUST, MUST NOT, SHOULD, MAY are RFC 2119/8174.

Drafts read for this revision: draft-ietf-moq-transport-22 (MOQT), draft-ietf-moq-msf-01 (MSF) and draft-ietf-moq-cmsf-01 (CMSF), all Internet-Drafts of the IETF MoQ working group, none past Working Group Last Call. A section number of MOQT, MSF or CMSF in this text is one of those revisions; §6 says what happens when they move. For §4.4 and §4.5, each the latest revision in the IETF archive on 10 November 2026, read whole unless a part is named: draft-nandakumar-moq-tempo-00; draft-ramadan-moq-fec-catalog-00, with draft-ramadan-moq-fec-core-00 §2 to §7, §9.2, §10, §13 and §15 and draft-ramadan-moq-fec-block-codes-00 §6 to §9 and Appendix B; draft-ramadan-moq-multicast-02 §1 to §6; draft-yuyou-moq-v3c-00 §1 to §7 and §9 to §11; and RFC 10034 §4.3. ISO/IEC 23090-5 was not read. For §4.8, read whole at the same date: draft-jennings-moq-metrics-03, draft-jennings-moq-log-04 and draft-pardue-moq-qlog-moq-events-08, with draft-ietf-quic-qlog-main-schema-14 §3 to §11.

1. Why a packaging of MSF

MoQ separates two things that other stacks fuse:

WAI’s confidentiality extension seals MoQ objects end to end (secure objects keyed by MLS; see confidentiality), and leaves what the objects mean to this one. This one treats MoQ as what it is — a two-layer design with an open slot at the upper layer, which is precisely where a container that carries capability-dispatched objects belongs.

The alignment is structural, not aspirational. MSF fragments a stream into objects in groups; WAI envelopes are already objects, and jwp-receipts already commits per object and signs per group. The two layers agree on the unit without either being changed.

2. Precedent: the slot is open, and cheaply

MSF’s catalog names a format in its packaging field, over a value set MSF’s own text fixes (MSF §5.2.4: loc, mediatimeline, eventtimeline, moqlog, moqmetrics; the catalog itself is the track named catalog, MSF §5). There is no central streaming-format registry. Read alone, that is closed.

draft-ietf-moq-cmsf shows it is not. CMSF is a sibling Internet-Draft that declares packaging value cmaf, stating that it extends the allowed packaging values defined in MSF; inherits MSF wholesale — all of the specifications, requirements and terminology defined in MSF apply to implementations of this extension; adds two track-level catalog fields; and registers nothing: this document has no IANA actions. LOCMAF is a second instance of the same move.

So the path is a sibling draft with no registry action and no permission sought. This extension is the WAI-side statement of what such a draft would say.

3. The packaging value

A track carrying WAI envelopes MUST declare packaging value "wai".

WAI defines two more packaging values, for tracks whose objects are not envelopes: "wai-receipts", a media track’s receipts (§4.1), and "wai-link", the records of a contribution link (live-contribution §5.4). A catalog that carries WAI tracks is otherwise MSF’s: its version is the string MSF §5.1.1 gives the revision it follows ("draft-01" for draft-ietf-moq-msf-01), and every track carries isLive (MSF §5.2.7).

4. Catalog declaration

A WAI track’s catalog entry MUST declare, in addition to MSF’s required fields, the capabilities a sink needs to dispatch what the track carries:

fieldtypemeaning
wai_capabilitiesarray of stringCapability strings (WAI SPEC.md §4) that objects on this track may dispatch to.
wai_determinismstringThe weakest tier any object on the track claims — see determinism-tiers. Absent means no tier is claimed.
wai_receiptsbooleanWhether objects carry receipts per §5.
wai_receipt_aliasintegerThe track_alias the publisher signs in this track’s receipts (jwp-receipts §2.4.1), from 0 to 2^53 − 1.
wai_receipts_trackstringThe name, in this track’s namespace, of the track that carries this track’s receipts (§4.1).
wai_ai_usageobjectThe usage statement of the track’s objects (ai-usage §3), or of the room record in effect for a room’s track. Absent means the catalog states none.
wai_priorsarray of objectOPTIONAL. The parameter sets the track’s objects pin (SPEC §3.1), by digest, each with the tier it is offered at (§4.2). Absent means the catalog states none.
wai_frame_streamobjectRequired on a track whose objects are the frames of a frame capability (frame-stream), and absent on any other: the frame stream the track carries (§4.3).
wai_nmsfarray of objectOPTIONAL, on a track that declares a frame stream: the catalog entries of the NMSF track or tracks (packaging nvc) its frames map to and from (frame-stream §9.2).
wai_tempoobjectOPTIONAL. The bound and the defaults of the playout timing the track’s objects carry (§4.4). Absent means the catalog states none.
wai_v3cobjectOPTIONAL, on a track whose objects are wai.pc.vpcc: the V3C tracks (packaging v3c) its objects map to and from, with their initialization data (§4.5).
wai_creative_signingobjectNot a wai track’s: on an event timeline of ad creative signalling alone, its scope and the keys its records are signed with (§4.7).

These are custom catalog fields under MSF’s extension rule (MSF §5: custom field names “MUST NOT collide” with MSF’s, and a parser ignores a field it does not understand); they are namespaced by their wai_ prefix and MUST NOT collide with MSF-defined names.

4.1 Staged tracks

A stage set (staged-delivery) is carried as one track per layer: a base track, which carries the set’s bases, and a layer track for each layer index, which carries the layers of that index. Every track keeps §3: each object is one whole WAI1 envelope. A subscriber chooses its stage by the tracks it subscribes to; a relay forwards tracks and never reads an envelope.

The catalog. Each track of a set MUST carry, in its catalog entry,

"wai_staged": { "set": "cam1", "layer": 1, "lead_ms": 40 }
membertypemeaning
setnon-empty stringThe set’s name: the same on every track of the set.
layerinteger, 0–2550 on a base track; k on a track that carries layer k.
lead_msinteger from 0 to 2^53 − 1, or nullOn a layer track of a live set, the lead of its layer (staged-delivery §8): the time before a unit’s presentation by which the layer must arrive to be applied to it. null on a base track. A sink reads it only while the set is live: when isLive is false it ignores it, as MSF §5.2.8 has a sink ignore targetLatency.

A set’s extent is the tracks present: its layers are 0 to the highest layer a track of the set states, each with at least one track. The catalog states no count of layers, so an MSF delta update (MSF §5.1.6, §5.3), which adds and removes tracks and changes none it declared before, changes a set’s extent by adding or removing a layer track alone. More than one track MAY carry one layer, as renditions of it. Each rendition is a track of its own, with a receipt chain of its own: a clone (MSF §5.1.6) inherits every member of its parent but its name, so a clone of a track that declares receipts MUST override wai_receipt_alias and wai_receipts_track (Receipts, below).

A layer track’s wai_capabilities lists the refinement capabilities its envelopes carry; a sink that does not implement staged delivery finds them unsupported (SPEC §4) and has no reason to subscribe. A member of wai_staged this revision does not define is ignored, an earlier revision’s layers among them. A publisher puts on a track of layer k only envelopes whose refines.layer is k, and on a base track only envelopes with no refines; a sink applies an envelope by its own refines (staged-delivery §4.1, §13), whichever track it came on.

Names and types. A track is named by its namespace and its name (MSF §5.2.2, §5.2.3); one that declares no namespace inherits the catalog track’s (MSF §5.2.2). Two tracks of a catalog MUST NOT share one namespace|name pair, and the tracks of a set MUST share one namespace. The check below needs the catalog track’s namespace, which a sink knows, since it subscribed to the catalog track: a checker that does not know it compares a track that inherits only with tracks that inherit, and refuses a set that mixes declared and inherited namespaces (staged-malformed). On a track of a set, renderGroup, where present, MUST be an integer that fits 64 unsigned bits, written as one (SPEC §2), and is compared as such: true, 1.0 and "1" are not 1. depends, where present, MUST be an array of strings.

MSF fields. The tracks of a set MUST have the same isLive (MSF §5.2.7) and MUST share one renderGroup (MSF §5.2.11), which is present on each. On a live set, MSF already requires one targetLatency across a render group (MSF §5.2.8); it is the target latency staged-delivery §8 adds to a unit’s timing, unless the sink applies its own. Every entry of a track’s depends (MSF §5.2.14) MUST name a track of the catalog in the track’s own namespace, where MSF resolves it. The depends of a track of layer k MUST name at least one track of the set at each layer below k, and MUST NOT name a track of the set at k or above; a base track’s MUST NOT name a track of the set. An altGroup (MSF §5.2.12) MAY group the base tracks of alternative sets, and MUST NOT be set on a layer track: a subscriber picks one track of an alternate group, and a layer is never an alternative to its base or to another layer. A layer track MUST NOT carry temporalId or spatialId (MSF §5.2.16, §5.2.17), which number a codec’s own layers; a layer’s index is wai_staged.layer here, and refines.layer in the envelope.

Receipts. Every track of a set that declares wai_receipts true MUST carry wai_receipt_alias (§4) and wai_receipts_track: the name, in its namespace, of its receipts track, of packaging "wai-receipts". Each media track has a receipts track of its own, so each layer has a receipt chain of its own and a subscriber verifies the tracks it subscribes to without the receipts of those it does not (jwp-receipts §6.1); and a subscriber subscribes to the receipts tracks of the media tracks it subscribes to and no others, so the tracks it chooses cap the receipts it receives as they cap its stage. A track MUST NOT carry an alias another track of the catalog carries, or name a receipts track another track names: a rendition of a layer carries an alias and names a receipts track of its own.

Verifying, recovering and joining. A subscriber verifies each group receipt as jwp-receipts §3 does, on the chain of the publisher key and the track’s wai_receipt_alias, and admits a group only after its parent (§3 step 3). Each object of a receipts track travels on a stream of its own (MSF §6), so receipts can arrive out of order, and a relay can drop one at its discretion (MOQT §5.2). It holds no receipt of the track’s object until it verifies it, and until then applies no layer it carries (staged-delivery §10.1).

A MOQT relay forwards a receipts track as it forwards any track, its objects opaque payload (MOQT §7.8): it neither reads nor verifies the receipts in it. It is therefore not a relay that conforms to jwp-receipts §4, which verifies a group’s signature before fanning its objects out; the subscriber verifies every receipt itself (jwp-receipts §4.1, Receipts carried as payload).

Checking a catalog. A sink checks each set’s entries in this order, and stops at the first that fails:

  1. wai_staged is an object with the three members above, of their types and in their ranges; the track’s packaging is "wai" and its isLive a boolean; its name is a string, its namespace absent or a string, and the pair is no other track’s; its renderGroup, if present, an integer that fits 64 unsigned bits; its depends, if present, an array of strings; and, where the checker does not know the catalog track’s namespace, either every track of the set declares a namespace or none does (staged-malformed). An entry whose set cannot be read belongs to no set, and is reported for the empty name.
  2. The set has a track at each layer from 0 to the highest a track of it states (staged-set-incomplete).
  3. Every entry of every track’s depends names a track of the catalog in the track’s namespace; a track of layer k names a track of the set at each layer below k, and none at k or above (staged-depends).
  4. The tracks have one namespace, one isLive and one renderGroup, present on each, and no layer track carries altGroup, temporalId or spatialId (staged-grouping).
  5. On a live set, lead_ms is an integer on every layer track and null on every base track (staged-lead). A set that is not live is not checked here.
  6. Every wai_receipt_alias of the catalog, on any track, is an integer from 0 to 2^53 − 1; every track of the set that declares wai_receipts true carries an alias and names, in its namespace, a receipts track of packaging "wai-receipts"; no other track of the catalog carries its alias; and no other track names its receipts track (staged-receipts).

A sink treats the layer tracks of a set that fails as absent. Its base tracks are tracks of packaging wai like any other, and the sink MAY subscribe to them.

Groups and objects.

Priority. MOQT schedules first by subscriber priority, the priority a subscriber gives its request (MOQT §5.1.2, §9.20.7), and only between objects of equal subscriber priority by publisher priority, the lower number first, 0 the highest (MOQT §5.1.1, §5.1.2). The base track’s publisher priority MUST be a number strictly below every layer track’s; the priority of a track of layer k MUST be no greater than that of any track of a layer above k; and a receipts track’s is its media track’s. These hold for each track’s DEFAULT_PUBLISHER_PRIORITY (MOQT §10.4) and for every subgroup that sets its own (MOQT §5.1.1). A subscriber’s own priorities can still put a layer before its base: one that wants the publisher’s order SHOULD give its requests for a set’s tracks one subscriber priority.

Delivery timeouts.

Capping. A subscriber caps its stage by subscribing to the base tracks and to the tracks of layers 1 to n, and to their receipts tracks, and to no others. A relay MUST NOT read an envelope to cap layers: it treats every payload as opaque (MOQT §7.8), and forwards the tracks it is asked for. On a track of packaging wai the prototype header fields of staged-delivery §13 are not read.

Example. The entry of the first layer track of a live set, with its base track cam1/base, and the entry of its receipts track:

{ "namespace": "example/cam1", "name": "cam1/L1", "packaging": "wai",
  "isLive": true, "targetLatency": 300, "role": "video", "renderGroup": 1,
  "depends": ["cam1/base"],
  "wai_capabilities": ["wai.video.int_refine"], "wai_determinism": "decode-equivalence",
  "wai_receipts": true, "wai_receipt_alias": 8, "wai_receipts_track": "cam1/L1/receipts",
  "wai_staged": { "set": "cam1", "layer": 1, "lead_ms": 20 } }
{ "namespace": "example/cam1", "name": "cam1/L1/receipts", "packaging": "wai-receipts",
  "isLive": true }

4.2 Pinned parameter sets

A capability that decodes against a parameter set names that set in each envelope, by a pin: the SHA-256 of the whole set, in a declared form, with the tier the sender claims (SPEC §3.1). A track MAY also state, in its catalog entry, the pins its objects carry. A sink can then tell before it subscribes whether it holds the parameter sets the track needs, and which tier each is offered at:

"wai_priors": [
  { "capability": "wai.neural.int_hyper",
    "sha256": "<64 lowercase hexadecimal digits>",
    "form": "wai.prior.set", "tier": "decode-equivalence" }
]
memberpresencemeaning
capabilityREQUIRED, stringA capability the track’s wai_capabilities lists.
sha256REQUIRED, stringA pin’s sha256: 64 lowercase hexadecimal digits.
formOPTIONAL, stringThe pin’s form. Absent, or null, where the pin declares none.
tierOPTIONAL, stringThe tier the publisher offers the set at, from SPEC §3.1’s vocabulary. Advisory (below).
locationsOPTIONAL, array of stringsSet roots to fetch the set from, in order: a location hint of http-delivery §8.7: where to ask, never evidence.

An entry lists a pin for a capability when its capability is that capability, its sha256 is the pin’s, and its form is the pin’s: both absent, or the same string. A member of an entry that this revision does not define is ignored.

Reference implementation: staged::moq::CatalogPriors reads the member (CatalogPriors::read) and checks an object against it (CatalogPriors::check, CatalogPriors::check_manifest). staged-conformance/moq/priors.json holds a case for each reason and for each way an object can break the catalog. wai_staged_vectors checks the cases, and so does staged_verify.py, which shares no code with wai-rs. The browser sink of joule-moq-web dispatches no capability that decodes against a parameter set, and does not read the member.

4.3 Frame streams

A track MAY carry the frames of a frame capability (frame-stream §1): one frame an object, a group of the stream a MOQT group. Its catalog entry declares it:

"wai_frame_stream": { "capability": "wai.video.int_motion.frame" }
memberpresencemeaning
capabilityREQUIRED, stringThe frame capability whose frames the track’s objects are.

A member this revision does not define is ignored.

A relay reads neither the catalog member nor frame: it forwards the track’s groups and objects as it forwards any track’s.

A frame stream of wai.neural.dcvc_rt.frame or wai.neural.dcvc_fm.frame maps to and from a track of packaging nvc, the neural video packaging of draft-herz-moq-nmsf-01, one frame for one frame, its MOQT groups and Object IDs unchanged; its catalog entry keeps the NMSF entries in wai_nmsf (frame-stream §9).

Reference implementation: frame_stream::catalog::read reads the member and TrackFrameStream::check checks an object against it. int-payload-conformance/frame-stream/catalog.json holds a case for each way an entry is refused and each way an object breaks the declaration; wai_int_payload_vectors verify checks them, and so does int_payload_verify.py, which shares no code with wai-rs.

Example. The entry of a live track of integer inter-frame video, a group a second:

{ "namespace": "example/cam1", "name": "cam1/frames", "packaging": "wai",
  "isLive": true, "role": "video",
  "wai_capabilities": ["wai.video.int_motion.frame"], "wai_determinism": "decode-equivalence",
  "wai_frame_stream": { "capability": "wai.video.int_motion.frame" } }

4.4 Playout timing, forward error correction and multicast endpoints

Three more things a catalog of WAI tracks may state, each defined by another text. This section says what the catalog carries; the texts it names say what it means.

Playout timing: wai_tempo. A track whose objects carry the CaptureTimestamp and PlayoutDelay of draft-nandakumar-moq-tempo-00 (co-watch §15) states the bound on what they may say, and the defaults for an object that says less. The draft leaves both of its catalog extensions to be defined (its §4.3 and §4.4); until it defines them, they are these members, under WAI’s prefix:

"wai_tempo": { "max_delay_ms": 2000, "playout_delay_ms": 200,
               "objects_per_720s": 21600, "start_ms": 1793577600000 }
membertypemeaning
max_delay_msinteger, 0 to 2^32 − 1REQUIRED. The greatest PlayoutDelay an object of the track states. A sink refuses an object that states more (tempo_delay_out_of_bound), whatever instant it gives: a delay is how long a sink holds an object, and a track says how long that may be before a sink subscribes.
playout_delay_msinteger, 0 to max_delay_msOPTIONAL. The PlayoutDelay of an object that states none and follows none that did (the draft’s §4.4).
objects_per_720s, start_msintegers, the first at least 1, each at most 2^53 − 1OPTIONAL, together or not at all: time-aligned groups (the draft’s §4.3). An object without a CaptureTimestamp, of group g and Object ID o, was captured at start_ms + ⌊(g + o) × 720 000 / objects_per_720s⌋. start_ms is in milliseconds since 1970-01-01T00:00:00Z, as a CaptureTimestamp is (the draft’s §2.1; its §4.3 says the NTP epoch for the same quantity). The draft’s formula steps a group by one object’s time, so it fits a track of one object a group.

Each member is an integer written as one. wai_tempo that is not an object of these members alone, each of its type and range, is catalog_tempo_malformed, and the track then states no timing a sink acts on.

Forward error correction: fec. A WAI track is a source track of draft-ramadan-moq-fec-catalog-00 under the block profile moq-object-v1, which admits any packaging whose objects are whole MoQ objects (draft-ramadan-moq-fec-core-00 §15.3): its entry carries that draft’s fec array (its §3.1), and the catalog carries the repair tracks and symbol tracks that serve it, of packaging fec-repair and fec-source, with that draft’s source, instanceId, repairLayer, repairSymbols and priority (its §3.2). WAI adds no member to any of them. carousel §8.3 says which instances a schedule’s entries bind to, what a block’s symbols are cut from, and what a receiver does with one. An object rebuilt from symbols is delivered with its Immutable Properties alone (fec-core §9.2), so a WAI track under FEC carries its WAI_RECEIPT property (§5) inside Immutable Properties, where §5 already places it. A sink that does not implement the draft ignores the repair and symbol tracks, whose packaging it does not know (§3), and reads the source track as before.

Multicast endpoints: multicast. draft-ramadan-moq-multicast-02 §4.1 adds a root member multicast that lists the endpoints a catalog’s tracks are sent to. bearer-receipts §9.7 says how WAI reads it, and what that revision of the draft does and does not let a WAI track ride.

wai/ietf/catalog_check.py holds these members, the two packaging values and the tracks that carry them to the rules their drafts state for a catalog, in every catalog this repository’s implementations write.

4.6 Rendition sets, track switching and probe tracks

A rendition set is the tracks of a catalog that share one altGroup (MSF’s alternate group): encodings of one source a subscriber takes one of at a time. Three drafts say how a subscriber moves among them; each was read at the latest revision in the IETF archive on 10 November 2026, and the reference for all three is joule-moq’s switching and probe modules.

Switching: draft-ugur-moq-fast-switching-00, draft-gurel-moq-track-switching-01. A track of a rendition set that states keyframeSpacing (the objects in each of its Groups; a member the first draft takes from MSF’s editor’s copy, draft-ietf-moq-msf-01 not having it) is a member of a Switch Set: every spacing is a multiple of the least one, each Group begins with the one object a receiver can start at, and Group IDs are numbered so that a Location on any track names one position of the source, its Frame Number. From the object in hand a subscriber computes each candidate’s Switch Point (the first Group of the candidate at or after that position), picks by the draft’s policy, and computes the Group the track it leaves ends with. The switch itself is stated with what draft-ietf-moq-transport-23 has: a SUBSCRIBE of the target whose Location Filter starts at the Switch Point’s Group, object 0, and a REQUEST_UPDATE that ends the current subscription at the End Group; the subscriber ends the old subscription once that Group has arrived. Neither the SWITCH_FROM parameter the first draft builds on (two pull requests against MOQT, unmerged) nor the second draft’s altTrackGroup and Switch Track Alias fields is in -23, and none is sent. A subscriber releases what it receives of both tracks in Frame Number order, each frame once.

Refused, each with its code (switch_*, listed in moqt-conformance/switching/README.md): a set whose spacings do not align; a start that is not object 0 (switch_start_mid_group) or not a Group the target publishes (switch_start_not_switch_point); and a switch whose End Group, computed as the draft writes it, would end the current track before the Switch Point and so leave frames unsent (switch_end_group_short), which arises where neither spacing divides the other.

Probe tracks: draft-gurel-moq-probing-00. A probe track is a track of padding objects, shaped by its name, that measures one hop: the name’s grammar and its resolution to a rate, an object size, a schedule and a total, the draft’s limits and their defaults, the refusal each outcome has in each direction, the probe catalog (which states presets and never limits) and the receiver’s measurement are implemented and held to the draft’s own examples. joule-moq-relay serves them where its operator enables them: the catalog, a downlink probe generated for the one subscription that asked, and an uplink probe measured and discarded and ended if it leaves its declared shape, none of it cached, forwarded or shared with another session. A relay that does not serve probes answers a subscriber that asks for one DOES_NOT_EXIST, as the draft has it.

The corpora are moqt-conformance/switching/ and moqt-conformance/probe/, each read by a second implementation that shares no code with the reference (switching_verify.py, probe_verify.py). joule-moq-relay’s test switches a subscriber between two renditions through the relay: the track left is forwarded through its End Group and no further, the track joined from its Switch Point, and every frame is presented once, in order; a switch planted mid-group is refused by the plan and, sent all the same, is forwarded a Group without its first object, as the request’s range has it, of which the subscriber’s buffer holds what arrives and presents nothing.

4.5 V3C tracks

draft-yuyou-moq-v3c-00 carries a V3C bitstream (ISO/IEC 23090-5) over MOQT as one track for each V3C component, of packaging v3c: the V3C parameter set is the catalog’s initialization data, a V3C composition unit, or a run of them that starts at a random access point on every component, is a MOQT Group, and each V3C unit’s payload is an object, without its unit header, whose fields are the track’s v3c object in the catalog (its §4, §5.5, §7.2). The payload of a wai.pc.vpcc object is a V3C bitstream (SPEC §5), so a track of such objects maps to and from those tracks: a publisher of WAI objects unwraps each object’s payload into a Group of the V3C tracks, for a receiver of the draft, and a publisher that receives the V3C tracks rewraps each Group into the payload of a WAI object.

What maps. One payload is one Group, of the Group ID its WAI object has. The payload is read as a V3C sample stream: one octet whose top three bits are the size precision less one and whose other bits are 0, then each V3C unit behind its size in that many octets; a unit is its four-octet unit header, as RFC 10034 §4.3.1 copies it with the packed-video layout the draft’s §7.2 states (an 8-bit vuh_packed_map_index and 9 reserved bits), and its payload. ISO/IEC 23090-5, which defines both, was not read for this revision: the framing is that standard’s Annex C as the reference understands it, and the corpus holds no bitstream an encoder wrote (its unit payloads are opaque test bytes), so what is shown is the mapping, byte for byte, and not that an encoder’s bitstream meets it.

A payload unwraps only in the form a rewrap writes, so that the tracks join to the same bytes:

The parameter set’s payload becomes the entry of initDataList the tracks’ initRef names, inline, in base64 (the draft’s §5.3). Each other unit’s payload is one object of the track of its component, whose catalog entry is the draft’s (§7): packaging "v3c"; role v3c-atlas, v3c-occupancy, v3c-geometry, v3c-attribute, v3c-packed or v3c-common-atlas; renderGroup; initRef; depends, on its atlas’s track for a video-coded component and on the common atlas track for an atlas where there is one; codec on a video-coded component where the publisher states one; and the v3c object, with component, atlasId (but for the common atlas), attributeIndex and attributePartitionIndex for attribute video, packedMapIndex for packed video, auxiliaryVideo where it is 1, and parameterSetId. The reference does not parse a parameter set, so what a publisher reads from its own it states: whether each map is a stream of its own (vps_multiple_map_streams_present_flag; then each geometry and attribute track states its mapIndex, and otherwise the tracks omit it and a unit whose map index is not 0 is refused), and the video codec. Track names are the draft’s recommended ones (its Figure 2), with /map/<n> after an attribute track’s where maps are streams of their own, for which the draft gives no pattern. The draft’s requirement that a Group start at a random access point on every component (§5.4) is the publisher’s to meet: nothing here reads a video or an atlas sub-bitstream.

The catalog member wai_v3c. The WAI track keeps what the mapping needs:

"wai_v3c": { "initData": { "id": "v3c-init-0", "type": "inline", "data": "<base64>" },
             "tracks": [ { "name": "v3c/atlas/0", "packaging": "v3c", "isLive": false,
                           "role": "v3c-atlas", "renderGroup": 1, "initRef": "v3c-init-0",
                           "v3c": { "component": "atlas", "atlasId": 0, "parameterSetId": 3 } } ] }

initData is the initialization data entry and tracks the V3C tracks’ entries, as the unwrap publishes them and the rewrap read them, member for member. A catalog that offers both the WAI track and its V3C tracks carries the entries twice, here and as tracks of their own with initData in initDataList; a sink of WAI reads the WAI track and one of the draft its tracks.

Joining. A rewrap takes a Group’s objects on the V3C tracks, in whatever order they arrived, builds each unit header from its track’s v3c object, and writes the payload in the form above. A track whose component it does not know it leaves out, as the draft’s §7.2 has a receiver ignore one. The tracks do not state how many objects a Group has, so a Group whose last object on a track is missing joins, to another payload: the payload is known to be the one a WAI object carried only by that object’s content hash, which a sink holds from the WAI track’s receipts (§4.1), and a rewrap that holds none publishes what it joined under its own receipts, as any publisher does.

A payload is not unwrapped, and a Group not joined, with one of:

codewhen
v3c_stream_malformedThe payload is empty, a reserved bit of its first octet is set, it holds no unit, or a unit’s size is below 4 or runs past the payload’s end.
v3c_header_reservedA reserved bit of a unit header is set.
v3c_component_unmappedA unit’s type is 7 or above.
v3c_parameter_setThe first unit is not the parameter set, another unit is one, there is no other unit, or the other units name more than one parameter set.
v3c_not_canonicalThe size precision is not the least, or the units after the parameter set are not in ascending order of their headers.
v3c_map_index_unexpectedA unit’s map index is not 0 and the publisher states one map stream.
v3c_catalog_malformedOn joining: the initialization data is not an inline entry with an id and base64 data; a track’s entry lacks a name, is not of packaging v3c, names other initialization data, repeats a name or a component’s identity, or names another parameter set; or its v3c object lacks component or parameterSetId, lacks or has a member its component requires or forbids, has a member out of its field’s range, or has tileId (a tile track holds part of an atlas unit, which does not join to the unit).
v3c_objects_incompleteOn joining: a track has no object of the Group, a track’s objects are not numbered from 0 with none missing between, or an object is of a track the catalog does not list.

The reference implementation is the v3c module of joule-moq (joule-code/joule-code-rs/crates/joule-moq); the corpus is moqt-conformance/v3c/vectors.json: payloads with the tracks, the catalog member and the objects they unwrap to, payloads refused and Groups that do not join, and its second implementation is moqt-conformance/v3c_verify.py, written from this section. What this revision does not do: nothing publishes or subscribes these tracks on a session yet (the module is the mapping, which a publisher calls), and no bitstream an encoder wrote is in the corpus.

4.7 Ad creative signalling

A track of draft-riedl-moq-ad-creative-signaling-01 (read whole, at the latest revision in the IETF archive on 10 November 2026) is an MSF event timeline: packaging "eventtimeline", mimeType "application/json", depends, and eventType "urn:svta:advertising-wg:ad-creative-signaling". live-ads §13 says what its records are and what each is held to. The draft leaves open how a subscriber learns which keys sign a track’s records and which audience a track is for (its §8 and §10); until it settles them, they are this member, under WAI’s prefix:

"wai_creative_signing": { "scope": "session",
                          "keys": [ { "crv": "Ed25519", "kid": "dd8d…2575", "kty": "OKP", "x": "3Y2z…JXU" } ] }
membertypemeaning
scopestringREQUIRED. "shared", "cohort" or "session": whether the track’s records are for every viewer of the programme, for the sessions given one set of fills, or for one session (the draft’s §8).
keysarray of 1 to 16 objectsREQUIRED. The keys of a JWK Set (RFC 7517), each exactly kty "OKP", crv "Ed25519", a string kid and x, the base64url of 32 bytes with no padding; no two with one kid.

wai_creative_signing that is not an object of these two members, each of its form, or that stands on a track that is not an event timeline of that eventType, is catalog_ads_malformed, and a subscriber then takes no key from it. A reader takes the member under the name it had before this revision too, wai_ads, until the release after this one; a track that carries both is catalog_ads_malformed. A writer writes wai_creative_signing. A catalog is unsigned: a subscriber takes a key from it as far as it trusts where the catalog came from, and a verifier of a room takes the decider’s key from the room’s own records, whatever a catalog says (live-ads §13.6). The composed tracks of live-ads §14 are ordinary tracks of this packaging and carry no member of their own.

4.8 Monitoring: metrics, logs and qlog

Three drafts carry what an operator watches a deployment by, each the latest revision in the IETF archive on 10 November 2026 and read whole: draft-jennings-moq-metrics-03 and draft-jennings-moq-log-04 (both written against draft-ietf-moq-transport-22), which publish a resource’s metrics and its logs as MOQT tracks, and draft-pardue-moq-qlog-moq-events-08, which gives MOQT its qlog events on draft-ietf-quic-qlog-main-schema-14. None of them carries media, an envelope, a receipt or a claim, and nothing here is evidence of delivery: a figure a relay states of itself is its operator’s to read, and what a session did is attested by receipts (jwp-receipts).

The resource. A resource publishes under ("metrics.moq.arpa", "v1", <ResourceID>) and ("logs.moq.arpa", "v1", <ResourceID>). The drafts’ first choice of ResourceID is a hash of a network interface’s address, which reveals that address; their second, any stable 64-bit identifier, is taken: a WAI resource’s ResourceID is the first eight bytes of SHA-256 over the ASCII bytes wai moq resource id, a zero byte and a public key the resource already publishes. A resource adds no identifier of the machine it runs on.

Metrics. A data track at a granularity level (its Track Name the digit 0 to 7, its default publisher priority 128 + 16 × level) holds one group a capture: the Group ID is the capture time in milliseconds, Object 0 the Capture Info, Object N the value of the metric whose description is Object N of the catalog version the group names, and an End of Group object one past the last value. A service that already answers GET /metrics in the text exposition format publishes the same numbers:

Logs. A track at a severity (the same eight names and priorities) holds one group a second in which the resource logged: each message is one object, a Log Record with its offset in the second, its RFC 5424 fields and its attributes, and the group ends with an End of Group object when a later second’s message is produced or its second has passed. A message of a second that has ended is refused. An attribute whose value is a network address (an IPv4 or IPv6 address, alone or with a port) is refused by a publisher and by a reader: a log track is read by whoever may subscribe to it, and a peer’s address is not theirs to have.

qlog. A log is JSON Text Sequences: a header record that names the event schema urn:ietf:params:qlog:events:moqt-08 and a monotonic clock with no epoch, then one record an event, {time, name, data}, with name moqt:<type> and data as the draft defines the event. A log states lengths and never bytes: an object’s payload, a property’s value, a token’s value and a GOAWAY’s URI are a RawInfo with a length and no data, and a PATH is cut at its ?. The events draft is written against MOQT -21: a message of -22 that it does not define is logged through its type socket under the transport’s name, and FETCH, whose range -22 carries in parameters, with fetch_type standalone. The draft states no order; a log is held to ascending times, to a header before the objects of its stream, to one header a stream and direction, and to one type a stream.

The reference is joule-moq: its metrics_track and log_track modules compute the objects a publisher sends and read them back, and its qlog module, behind a feature, writes the events from the crate’s own messages and headers and checks a log. They open no stream. The reference relay (joule-moq-relay) uses them where its operator turns each on, all off by default. Its ResourceID is from the public half of the key it signs its summaries with. It serves its metrics track, one group a capture of the text its GET /metrics answers at that instant, and its log tracks, one a severity, to a session whose grants cover a subscription there, from the group that begins after the subscription; it keeps none of either, so neither is fetched. Built with its qlog feature it writes one log a session, in which stream_id is the order it took the session’s streams up in and not a QUIC stream ID, and it logs neither fetch streams nor datagrams. Its test reads a metrics group off the relay and holds it to the exposition, and plants a counter one above its exposition’s, a peer’s address in a log attribute and an event out of order. The corpora are moqt-conformance/metrics-track/, moqt-conformance/log-track/ and moqt-conformance/qlog/, each with its README’s reasons and each read by a second implementation that shares no code with the reference (metrics_track_verify.py, log_track_verify.py, qlog_verify.py); the metrics corpus holds the draft’s worked example and a resource’s captures with the catalog versions they make, and a counter one above its exposition’s is refused there.

4.9 Protected CMAF tracks

A room’s CMAF track (packaging cmaf) may be protected with Common Encryption, as draft-ietf-moq-cmsf-01 §4 has it: the media samples inside each object’s CMAF chunk are encrypted, and the catalog states the protection. Nothing is added to an object: it carries no key identifier and no property of this section, a relay forwards it as any object, and its receipts are over its bytes as published, the protected ones. This is not the sealing of confidentiality, which is between the members of a room and which a relay sees as a Key ID on each object; a protected track is content protection, whose keys a viewer’s device is released by key-release.

What is written. The scheme is cbcs or cenc, and the header and the chunks are protected as a package’s floor files are (packaging §7, its item on the protected floor): the sample entry becomes encv, or enca for an audio track, with its sinf, schm and tenc, a pssh of the W3C common system ID names the track’s KID, and each chunk gains its senc with its saiz and saio. An AV1 sample is protected by its subsample map. An Opus sample is encrypted whole, with no subsample map: under cenc every byte of it, and under cbcs its whole blocks with no pattern, where the senc has no entry to carry and stands without saiz and saio. A protected object is a function of its clear chunk, or chunks, the key and the track’s name. Each track of an owner has a header, an entry and a key of its own, so a video track’s key opens no audio object; one catalog may state several such tracks, each with its wai_key_period. The catalog states, as CMSF §4.1 has it, a root contentProtections entry (refID, defaultKID, scheme, and a drmSystem whose systemID is a system ID, never a product’s name) and the track’s contentProtectionRefIDs; the header its initRef names is the protected one (CMSF §4.2).

Key periods. CMSF states one header for a track and no way to change a track’s key. A live track’s key changes with its key period (key-release §7.4), and this section states that with a catalog for each period, published before the period’s first group, in which:

A group is of the last period stated whose from_group is at most its Group ID. A subscriber that joins holds the current catalog, and so the current period’s header and KID; one that fetches earlier groups needs the catalog that stated their period, which a publisher that serves the past keeps published as it keeps the groups. wai_key_period is on a track that carries contentProtectionRefIDs and on no other, and a protected track whose key never changes carries none. wai/ietf/catalog_check.py holds the CMSF fields and this one.

The keys. A packager asks a key provider for the periods’ keys (key-release §15), naming each KID with its period, and encrypts under what it is answered. The list the provider signs is the one a signing proxy loads, so a key’s period in the list is the period the catalog states, and key-release §7.2’s check 9 releases a period’s key only to an entitlement that holds during it. A sink asks for a period’s key when it holds that period’s catalog; under an entitlement with a stream limit (key-release §14), each such request is also what keeps the session’s place.

Verification. A verifier given the catalogs in the order they were published, the objects, the SHA-256 of the clear header and of each clear chunk, and the CPIX document refuses the track at the first of these. Each catalog is read in turn, and of one catalog what needs no key is found before its key is looked for:

reasonwhen
protected_cmsf_catalogno catalog; a catalog whose track states no wai_key_period, names no header that is the clear header protected as this section writes it (under the document’s key, once that key is found), or names an entry whose scheme or defaultKID is not the header’s; or a catalog whose period, first group or scheme does not follow the one before
protected_cmsf_key_unknowna header’s KID is not in the CPIX document
protected_cmsf_key_periodthe document holds that KID for another key period than the catalog states, for none, or under another scheme
protected_cmsf_no_periodan object’s group is before the first period’s from_group
protected_cmsf_objectan object does not decrypt, under the key of its group’s period, to the chunk whose SHA-256 is stated, or is not the protected object this section writes from that chunk under that key

Over HTTP. A live-http-egress gateway serves a room’s CMAF objects as LL-HLS and DASH, and serves a protected track with no key: live-http-egress §4.5 says what it writes from the catalog alone. In DASH, a ContentProtection descriptor of urn:mpeg:dash:mp4protection:2011 with the scheme and the cenc:default_KID, and one for each entry’s system ID with its pssh and licence URI, in a Period for each key period; in HLS, EXT-X-KEY lines (SAMPLE-AES for cbcs, SAMPLE-AES-CTR for cenc) and an EXT-X-MAP naming that period’s header at each key period’s first segment, with a discontinuity where the header changes. A track whose header is protected and whose catalog does not state it is not served there.

Conformance, and what is not done. The reference is wai-pack’s cmsf module, over the writers of its protected floor; the corpus is live-conformance/protected-cmsf/, an AV1 track under both schemes with three key periods and a planted fault for each reason, an Opus track the same way under keys of its own, and catalogs that state both tracks, and live-conformance/protected_cmsf_verify.py is its second implementation. joule-moq-ingest’s tests/protected_cmsf.rs publishes the corpus’s video and audio tracks through a relay with their receipts, and the catalogs that state both on the owner’s catalog track, each key period’s before its first group, and reads all of it back byte for byte. A protected room plays in a browser over HTTP, from the live HTTP egress, with the browser’s Clear Key, its key changing with the key period (joule-moq-http’s web/protected.sh, run by hand). Not done: a packager inside the ingest gateway, which publishes envelopes and no CMAF; playback in a browser from MoQ itself; and any content protection system’s licence, which is that system’s and is not tested here.

4.10 Tracks for testing

Two drafts name tracks by what a test asks of them, each carrying its parameters in the Track Namespace. Neither is a WAI track: their objects are synthetic bytes, they carry no envelope and no receipt, and no catalog of this extension lists them. They are implemented because a relay that carries WAI is first a relay that carries MOQT, and these are what the working group’s implementations test one against another. Both are implemented under decisions D8, and their readings are that file’s decision on MoQ test tracks.

Test tracks: draft-afrind-moq-test-01 (7 July 2025, the latest revision, expired). Sixteen tuple fields state a track of objects whose payload is the byte t repeated: how objects are forwarded (a subgroup a group, a subgroup an object, two subgroups a group, or datagrams), the groups and objects with their increments, the two object sizes, the interval between objects, End of Group markers, two test extensions and a delivery timeout. The draft’s blank field, standing for a default, cannot be sent: no MOQT draft spoken here carries an empty namespace field, so every field is written out. The whole draft is implemented: the namespace’s reading and its refusals, a publisher’s limits, the schedule every publisher of a namespace sends, and a subscriber’s check of each object it receives, which refuses an object off the schedule, on the wrong subgroup, out of its stream’s order, of the wrong length, with a byte that is not t, with a marker missing or misplaced, or without a test extension, each with a reason of its own. The interop client’s test moq-test runs a publisher and a subscriber of it through a relay, by namespace and by PUBLISH, with FETCH, at -23, -22, -18 and -16 and across them, and a publisher made to send a track wrongly is refused by the subscriber with the fault’s reason.

Media test tracks: draft-marzot-moq-test-tracks-00 (2 November 2026). Fourteen tuple fields state a set of media tracks: content, packaging, codecs, height, frame rate, catalog, where initialization data goes, group duration, audio delivery, duration and the number of video tracks. What follows from the namespace alone is implemented: its grammar and the refusal of each invalid field by number, the one shortest namespace of a set, the tracks’ names, ladders, labels and altGroups, the target bitrates, and each track’s timescale, multipliers and the Group ID a capture time falls in. No publisher of these tracks is implemented: the draft’s media is encoded video and audio of content this repository does not compute, and no encoder for it is here. A request for such a set is answered as the draft has a publisher answer a set it does not support, DOES_NOT_EXIST.

The reference is joule-moq’s moq_test and test_tracks modules and the moq-test test of joule-moq-interop. The corpora are moqt-conformance/moq-test/ and moqt-conformance/test-tracks/, each with its README’s readings and reasons and each read by a second implementation that shares no code with the reference (moq_test_verify.py, test_tracks_verify.py).

4.11 MPEG-2 transport streams

draft-gregoire-moq-msfts-02 (14 October 2026) gives MSF the packaging mpeg2ts: a track whose objects are whole packets of an MPEG-2 transport stream, 188 octets each, or 192 with a four-octet prefix. It is implemented as that draft states it, with the transport stream’s own syntax read from Rec. ITU-T H.222.0 (08/2023), which is the text of ISO/IEC 13818-1: the packet and its adaptation field (2.4.3.2 to 2.4.3.5), the program association and program map sections (2.4.4.1 to 2.4.4.10), the PCR (2.4.2.2, 2.7.2) and the CRC (Annex A). No elementary stream is parsed. The readings are decisions’s decision on transport stream packaging.

Not a WAI track. An mpeg2ts track carries no envelope and declares no wai_capabilities: a transport stream is a multiplex with a clock of its own, and no capability of SPEC §4 names one. It is neither of the two things a package’s other tracks are:

It is a track beside a package’s: a feed that already is a transport stream, relayed for equipment that takes one.

Receipts. Its objects are receipted exactly as another track’s are. The content hash of an object is jwp-receipts §2.1’s over the object’s payload, the packets as sent; a group’s receipts travel on a receipts track (§4.1) and may ride each object as WAI_RECEIPT (§5). The catalog entry declares them with wai_receipts, wai_receipt_alias and wai_receipts_track (§4), the only fields of WAI’s an mpeg2ts track carries. A receipt says that these packets are the ones the publisher signed. It does not say that the stream conforms to H.222.0, nor that mpeg2tsMode is true of it: a subscriber cannot check that the packets are the ones a publisher received (the draft’s §10).

The catalog entry. MSF’s fields, packaging "mpeg2ts", and the draft’s (its §6):

fieldtyperule
mpeg2tsModestringrequired: unmodified-program, unmodified-multiplex, per-program or es-packets
mpeg2tsPacketSizenumberrequired: 188 or 192
mpeg2tsEsPidnumberpresent exactly in es-packets: a PID, 0 to 8190
mpeg2tsProgramNumbernumber1 to 65535
mpeg2tsPcrPidnumbera PID, 0 to 8191
mpeg2tsMuxRatenumber1 to 2^53 − 1, bits a second; absent in the unmodified modes
mpeg2tsSiPidsarrayPIDs, each once; absent beside mpeg2tsEsPid and in unmodified-multiplex
mpeg2tsRandomAccessbooleanin unmodified-multiplex, only beside mpeg2tsProgramNumber
mpeg2tsTimestampModestringnot empty; absent with 188-octet packets
mpeg2tsScte35Pidnumbera PID; absent beside mpeg2tsEsPid and in unmodified-multiplex

A track’s initRef names an inline initDataList entry whose data is whole source packets of the track’s size, in which a publisher places the current PAT and PMT (the draft’s §6.12). An unmodified-multiplex track is in no altGroup (its §8). ietf/catalog_check.py --strict holds every catalog to this table, refuses a field named mpeg2ts… that the draft does not define, and refuses an mpeg2ts track in a wai track’s altGroup.

A publisher sends whole packets in every object and never cuts one (the draft’s §5.1). The reference starts a group at each packet whose random_access_indicator is set, moved back over the PAT and PMT packets directly before it, so a group opens with its tables; a stream that sets no such indicator is one group. It forwards a stream unchanged in the unmodified modes; for per-program it keeps the CAT, the program’s PMT and every PID that PMT lists, drops null packets and rewrites the PAT to list the program alone, with a version_number of its own that changes only when the rewritten table does; for es-packets it keeps one PID’s packets. It introduces no discontinuity.

A subscriber reads the entry, then the initialization data, then each object in ascending Group ID and Object ID, and refuses at the first of these that holds. Where it knows objects are missing it starts again after the gap: continuity counters, partial sections and the last PCR of each PID are forgotten there (the draft’s §5.1).

coderefused
mpeg2ts_modempeg2tsMode is absent or not one of the four
mpeg2ts_packet_sizempeg2tsPacketSize is absent or neither 188 nor 192
mpeg2ts_es_pidmpeg2tsEsPid is present outside es-packets, or absent in it
mpeg2ts_field_rangea field’s value is not of its type or outside its range
mpeg2ts_field_forbiddena field is present where the table above has it absent, or an unmodified-multiplex track is in an altGroup
mpeg2ts_init_datathe initialization data is empty, not whole source packets, or lacks a sync byte
mpeg2ts_object_orderan object is not after the last one read
mpeg2ts_object_splitan object’s length is not a whole number of source packets, and its packets are in step up to a partial last one: it was cut inside a packet
mpeg2ts_packet_lengthan object’s length is not a whole number of source packets, and a packet in it is out of step: a packet is not of the declared size, or the object begins inside one
mpeg2ts_synca packet does not begin with 0x47
mpeg2ts_packet_formadaptation_field_control is 00; an adaptation field’s length is past its packet (183 with no payload, at most 182 before one); or it flags a PCR it has no room for
mpeg2ts_pidan es-packets track holds a packet of another PID
mpeg2ts_null_packetan es-packets track holds a null packet
mpeg2ts_continuitya PID’s continuity_counter is not continuous, with no discontinuity_indicator: it does not go up by one on a packet with a payload, moves on a packet without one, or repeats on a packet that is not the one permitted duplicate
mpeg2ts_psi_forma PAT or PMT section does not read: its pointer, its syntax bits, its lengths, a table_id other than 0 on PID 0, a program listed twice
mpeg2ts_psi_crca PAT or PMT section’s CRC is not 0 over the whole section
mpeg2ts_program_countan unmodified-program track’s PAT does not list exactly one program, or an unmodified-multiplex track’s lists fewer than two
mpeg2ts_program_mismatchthe PAT does not list mpeg2tsProgramNumber, or a PMT track’s PMT is another program’s
mpeg2ts_pcr_pid_mismatchthe PMT of the program the catalog describes names another PCR_PID than mpeg2tsPcrPid
mpeg2ts_pcr_unsignalleda PID’s PCR repeats or goes back with no discontinuity_indicator since the one before

The catalog is held to the program’s definition it was written beside: the PMT in the initialization data, or with none the first the track carries, and any other of the same version_number. A PMT of a later version takes precedence over mpeg2tsPcrPid, as the draft’s §6 has it, and is not refused. The program number has no such allowance: the draft has a publisher start a new track when it changes.

What the draft leaves to the receiver a subscriber reports and does not refuse: each signalled discontinuity, with whether a PCR of its PID came earlier in the group (a publisher must introduce none there, the draft’s §5.4, and a subscriber cannot tell whose it is); each group whose first object holds no random_access_indicator; duplicates; and the longest interval between two PCRs of a PID. A reader of this text refuses a continuity counter that breaks unsignalled even in an unmodified mode, where the draft lets a loss before the publisher pass: a subscriber that must hand on a damaged source does so without this reader’s verdict.

The reference is joule-moq’s mpeg2ts module. The corpus is moqt-conformance/mpeg2ts/: two streams built by the module’s own test multiplexer from the CMAF segments of a wai-pack floor, carried as private data that no receiver would decode, the tracks of all four modes, one track’s receipts, and deliveries accepted and refused, every code above given. mpeg2ts_verify.py is its second implementation, sharing no code with the reference.

5. The per-object property

MOQT carries metadata a relay can see as Properties of a track or of an object (MOQT §8.4), registered in a table MOQT creates, with ranges set aside for an application’s own use. MSF §12 defines its properties this way; the one it defines, MSF_COMPRESSION, is at both scopes. CMSF adds track-level catalog fields and defines no per-object property. None of them carries a receipt.

A WAI receipt is already per-object. This extension therefore defines one object-scope property, WAI_RECEIPT, whose value is the object’s receipt commitment:

fieldtypemeaning
content_hash32 Bjwp-receipts §2.1 BLAKE3 over the envelope bytes.
joules_microu64Microjoules producing this object; 0 is the unmetered marker, never 0 J (energy-measurement §2).
acquisitionstringAcquisition class per energy-measurement §2; empty when joules_micro is 0.
acquisition_evidencebytesFor OnChipCounter and CalibratedInstrument, the evidence that follows the tag byte in energy-measurement.md §2.7 (declared uncertainty, then filtering state or calibration reference). Empty for every other class.
group_receipt32 BThe link hash of the group receipt covering this object (jwp-receipts §3 step 3).

On the wire the property is one Key-Value-Pair (MOQT §8.3) of an odd type. Its value is the five fields in the order of the table, with nothing after them: content_hash (32 bytes); joules_micro (a MOQT variable-length integer, MOQT §8.1); acquisition (a variable-length integer giving its length, then its UTF-8 bytes); acquisition_evidence (a variable-length integer giving its length, then the bytes); and group_receipt (32 bytes). A sink refuses a value that ends early, has bytes left after group_receipt, or whose acquisition is not UTF-8 (property_invalid). The publisher sets the property inside the object’s Immutable Properties (MOQT §10.7), which no relay may change or remove. No property type is registered for it. The Internet-Draft source in wai/ietf/ requests one from the Specification Required range of MOQT’s property registry (MOQT §16.8). Until one is assigned, a track of packaging wai carries the property as type 0x3A41, from the range MOQT §8.4 sets aside for an application’s own use. Another application may give that type another meaning, so a sink reads it only on a track of packaging wai.

6. What this extension does not do

Stated so it is not re-argued:

7. Framing

The delivery industry is converging on MoQ, and the layer above it is where formats declare themselves. A container that carries instructions, dispatches by capability, and commits per object has a natural home there — not because it competes with the transport, but because the transport deliberately left the question of meaning to someone else.