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) anddraft-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, withdraft-ramadan-moq-fec-core-00§2 to §7, §9.2, §10, §13 and §15 anddraft-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-04anddraft-pardue-moq-qlog-moq-events-08, withdraft-ietf-quic-qlog-main-schema-14§3 to §11.
1. Why a packaging of MSF
MoQ separates two things that other stacks fuse:
- MOQT (
draft-ietf-moq-transport) moves objects, in groups, on tracks, and orders them by priority. It does not know what an object means. - MSF (
draft-ietf-moq-msf) says what objects mean: it fragments a stream into objects, maps each object to a stream of its own, and declares what a publisher emits in a catalog.
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".
- Every object on such a track MUST be exactly one WAI envelope (
WAI1magic + manifest + payload), whole. An object carrying a fragment of an envelope, or more than one, is not this packaging. - The object boundary MUST be the envelope boundary. This is what makes the
receipt’s per-object commitment (
jwp-receipts§2.1) and MOQT’s object identity the same unit; if they diverge, every guarantee that composes them is void. - A sink that does not recognise
"wai"MUST NOT attempt to interpret the objects. MSF’s tolerant-parser rule covers unknown fields; it does not license guessing at unknown packaging.
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:
| field | type | meaning |
|---|---|---|
wai_capabilities | array of string | Capability strings (WAI SPEC.md §4) that objects on this track may dispatch to. |
wai_determinism | string | The weakest tier any object on the track claims — see determinism-tiers. Absent means no tier is claimed. |
wai_receipts | boolean | Whether objects carry receipts per §5. |
wai_receipt_alias | integer | The track_alias the publisher signs in this track’s receipts (jwp-receipts §2.4.1), from 0 to 2^53 − 1. |
wai_receipts_track | string | The name, in this track’s namespace, of the track that carries this track’s receipts (§4.1). |
wai_ai_usage | object | The 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_priors | array of object | OPTIONAL. 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_stream | object | Required 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_nmsf | array of object | OPTIONAL, 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_tempo | object | OPTIONAL. The bound and the defaults of the playout timing the track’s objects carry (§4.4). Absent means the catalog states none. |
wai_v3c | object | OPTIONAL, 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_signing | object | Not 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). |
wai_receipt_aliasnames the track’s receipt chain, which a verifier keeps per publisher key andtrack_alias(jwp-receipts §3 step 3). MOQT’s own Track Alias is chosen for each session by the publisher of that session, a relay included (MOQT §3.1.3), so past the first hop it is not the number the receipts sign; a sink finds a track’s chain by this member. It is an integer written as one (SPEC §2: not8.0, not"8"), compared as a number; a catalog that carries any other value for it, on any track, carries no stage set with receipts (§4.1, check 6). Two tracks of one catalog MUST NOT carry the same value: each track that declares receipts has a chain of its own (§4.1). §4.1 requires it, andwai_receipts_track, on the tracks of a stage set that declare receipts; on another track both are OPTIONAL.wai_capabilitiesMUST be exhaustive for the track. A publisher that dispatches to a capability it did not declare has broken the catalog’s purpose, which is letting a sink decide before subscribing whether it can play what it is about to receive.- A sink MUST NOT subscribe on the assumption that an undeclared capability will not appear, and MUST treat an undeclared capability at dispatch as a protocol error rather than falling back silently.
wai_determinismis the weakest tier on the track, not the strongest. Declaring the strongest would let a track advertise a guarantee most of its objects do not meet.wai_ai_usagelets an agent know a track’s AI usage preference before it subscribes. The catalog is unsigned and the objects’ own statements are signed with them: a catalog whose statement differs from an object’s is refused (catalog_conflicts), and the object’s governs (ai-usage §4.5, §5.3).
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 }
| member | type | meaning |
|---|---|---|
set | non-empty string | The set’s name: the same on every track of the set. |
layer | integer, 0–255 | 0 on a base track; k on a track that carries layer k. |
lead_ms | integer from 0 to 2^53 − 1, or null | On 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.
- Group g of a receipts track carries one object: the group’s receipts in the binary
form of jwp-receipts §2.7.3 (
WJR1), the group receipt and the object receipts of group g of its media track. A publisher publishes it no later than that group’s first object; one that cannot, since it signs a group when it ends, MAY state each object as it sends it in a running receipt (live-http-egress §3.5). A subscriber reads it by jwp-receipts §2.7.4, and refuses an object that does not read (malformed) as it refuses one whose receipts do not verify. - A receipt is about one MOQT object, and MUST say which: the group receipt in
group g of a receipts track has
group_idg, the MOQT Group ID of the media track’s group, and each object receipt in it has thatgroup_idand, asobject_id, the MOQT Object ID of its object. Itssigner_pubkeyis the publisher’s key and itstrack_aliasthe media track’swai_receipt_alias. A subscriber refuses a receipt that breaks this (moqt_mismatch, jwp-receipts §3.3) before it verifies the receipt’s signature, and holds nothing of it. - A receipts track has no delivery timeout of either kind, and its publisher priority is its media track’s. A subscriber sets no delivery timeout on its subscription to a receipts track (MOQT §9.20.3, §9.20.4); a receipt it loses anyway it recovers as below.
- Its objects are receipts, not envelopes, and §3 does not apply to them. The
WAI_RECEIPTproperty (§5) names an object’s group receipt but does not carry it.
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 subscriber that subscribed to a receipts track from its first group, and that has received every object of it, holds the receipt of every object of its media track, delivered or not, and checks one it did not receive by inclusion (jwp-receipts §3, Verified by inclusion). Where a receipts-track object is missing, the receipts after it on that track wait for it, within the bound below.
- A receipt whose parent the subscriber lacks is held (
parent_not_held). The subscriber recovers the parent by a FETCH (MOQT §3.2) of the receipts track’s groups from its chain’s head to the held group: group g of the receipts track holds the receipts of group g of its media track. - A subscriber MUST state a bound on what it holds for missing parents
(jwp-receipts §3 step 3, Holding), each count a finite number: a count of receipts
held live for each chain, and a time from each one’s arrival only beside it, never
alone; a count of receipts held as history for each chain; and a count across all its
chains. Past the live bound it refuses the layers whose receipts it holds, their
receipts refused (
parent_not_recovered) and the layers refused for want of them (staged-delivery §10.1), and re-anchors the chain at the next validly signed group of it that it receives (Re-anchoring). The layers of the groups the anchor skips are refused for want of their receipts, unless history later fills them. - After a re-anchor, a FETCH of the gap (MOQT §3.2) can deliver its groups in any order, ascending among them: the verifier admits as history each group that links forward from the last group admitted before the gap or back from the anchor (jwp-receipts §3 step 3, History), never as a fork, and holds as history, under the history count, one that links to neither yet.
- A subscriber that joins a live track after its first group (MOQT §3.5) declares a
join: its verifier anchors the chain at the first validly signed group of it that it
receives, and holds the history before it as unverified (jwp-receipts §3 step 3,
Joining). Joining at an earlier group (MOQT §3.5: a SUBSCRIBE whose
FILL_PARAMETERSselect it, its objects delivered on a fill fetch stream, §3.4; earlier revisions of MOQT called this a Joining FETCH) retrieves earlier receipts. The fill fetch stream delivers them in ascending order, so each waits for the one after it: the verifier holds them as history, under the history count and outside the live one, and admits them, back from the anchor, where their signed links lead to it.
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:
wai_stagedis an object with the three members above, of their types and in their ranges; the track’spackagingis"wai"and itsisLivea boolean; its name is a string, its namespace absent or a string, and the pair is no other track’s; itsrenderGroup, if present, an integer that fits 64 unsigned bits; itsdepends, 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 whosesetcannot be read belongs to no set, and is reported for the empty name.- The set has a track at each layer from 0 to the highest a track of it states
(
staged-set-incomplete). - Every entry of every track’s
dependsnames 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). - The tracks have one namespace, one
isLiveand onerenderGroup, present on each, and no layer track carriesaltGroup,temporalIdorspatialId(staged-grouping). - On a live set,
lead_msis an integer on every layer track andnullon every base track (staged-lead). A set that is not live is not checked here. - Every
wai_receipt_aliasof the catalog, on any track, is an integer from 0 to 2^53 − 1; every track of the set that declareswai_receiptstrue carries an alias and names, in its namespace, a receipts track ofpackaging"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.
- Group and object ids of different tracks need not align.
refinesnames what a layer refines, and a sink checks it (staged-delivery §4.1); nothing is read from where a group falls on another track. - On a live track each group MUST carry exactly one object, which travels in a subgroup of its own (MOQT §2.2): MSF maps every object to a new stream (MSF §6), so none travels as a datagram. A group of one object is complete when its object is, so its group receipt is signed before the object is sent, and the latency the receipt adds to a layer’s arrival (staged-delivery §8) is one signature and its carriage, not a group’s duration.
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.
- A publisher SHOULD set a live layer object’s
OBJECT_DELIVERY_TIMEOUT(MOQT §5.2, §10.2) to no more than its slack at publication: the time from publication to the presentation of the last unit the object covers, less the layer’slead_ms, less the publisher’s estimate of the path. MOQT reads a timeout set as an object property on the first object of a subgroup (MOQT §5.2, §10.2); here that object is its subgroup’s only one, so the publisher MAY set each object’s timeout on the object, from its own slack. A slack of zero or less cannot be set, since a timeout of 0 is no timeout (MOQT §5.2): such an object cannot arrive in time for any unit it covers, and a publisher MAY withhold it. - For an object that is not a layer and whose timeliness stands, the slack is to its end, and on a base track the floor below stands: timeliness §8.1.
- A publisher MUST NOT set on a base track a delivery timeout of either kind shorter than the time from a base’s publication to the presentation of its last unit.
OBJECT_DELIVERY_TIMEOUTruns at each hop, from the time the object’s last header byte reaches that hop, and is checked when the hop passes the object to its transport (MOQT §5.2).SUBGROUP_DELIVERY_TIMEOUTstarts instead when the subgroup’s FIN arrives, and runs until all its data is acknowledged (MOQT §5.2): on a subgroup of one object, it bounds that object’s delivery after it was sent. Where both the publisher and the subscriber set a value, MOQT uses the smaller (MOQT §5.2, §9.20.3, §9.20.4), so a sink whose own target latency is longer than the one a publisher assumed cannot extend the publisher’s timeout. Either timeout releases, hop by hop, bandwidth that a late layer would waste; neither is an end-to-end deadline: an object can pass every hop within its timeouts and still arrive late. The rule of staged-delivery §8 is the only rule that decides whether a layer is late.
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" }
]
| member | presence | meaning |
|---|---|---|
capability | REQUIRED, string | A capability the track’s wai_capabilities lists. |
sha256 | REQUIRED, string | A pin’s sha256: 64 lowercase hexadecimal digits. |
form | OPTIONAL, string | The pin’s form. Absent, or null, where the pin declares none. |
tier | OPTIONAL, string | The tier the publisher offers the set at, from SPEC §3.1’s vocabulary. Advisory (below). |
locations | OPTIONAL, array of strings | Set 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.
-
Reading.
wai_priors, where present and notnull, is an array of objects, each with the members above of their types and no two with the samecapability,sha256andform, and eachcapabilityone the track’swai_capabilitieslists. A sink that reads anything else refuses the track (catalog_priors_malformed): it does not subscribe to it. Atierthis revision does not register is read asnone(SPEC §3.1).locationsis read as http-delivery §8.7 reads a hint: a value that does not read as one is passed over there, and never refuses the track or the entry. -
Exhaustive. Where a track carries
wai_priors, the publisher MUST list in it every pin its objects carry. An object breaks the catalog when:- it carries a pin that no entry lists, either for its
capabilityor for itsfallback; or - an entry names its
capability, or itsfallback(notnull), and the object carries no pin, or carries a pin that no entry lists for that capability.
A publisher whose objects’ pin can decode through the fallback (SPEC §4 step 5) SHOULD list the set for the fallback as well, so that a sink that holds only the fallback can make the same decision before it subscribes.
- it carries a pin that no entry lists, either for its
-
Mismatch. A sink checks each object of such a track against the track’s
wai_priorsbefore it dispatches the object (SPEC §4). An object that breaks the catalog is refused (catalog_prior_mismatch). The track is refused with it: the sink dispatches no further object of the track, and MAY unsubscribe from it. The catalog never stands in for the envelope. A sink verifies an object’s pin under SPEC §3.1 whether or not the catalog lists it. An entry never satisfies a pin, never supplies a pin the envelope lacks, and never changes which set a decode reads. -
Tier. A listed
tieris advisory. A publisher MUST NOT list a tier above the one the capability’s registry class gives (SPEC §3.1). A sink MUST NOT claim a tier on the strength of a listed tier: the tier it claims for an object is the one its own decode earns, under SPEC §3.1 and §7 and determinism-tiers §3, whatever the catalog says. A listed tier that differs from the tier an object’s pin states is not a mismatch. -
wai_determinism(§4) still states the weakest tier any object on the track claims.
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" }
| member | presence | meaning |
|---|---|---|
capability | REQUIRED, string | The frame capability whose frames the track’s objects are. |
A member this revision does not define is ignored.
- Reading. A track whose entry has
wai_frame_stream, notnull, declares a frame stream: the member is an object, itscapabilityis a frame capability, and the track’swai_capabilitieslists that capability and no other. A track whose entry has nowai_frame_stream, ornull, declares none, and itswai_capabilitieslists no frame capability. A sink that reads anything else refuses the track (catalog_frame_stream_malformed): it does not subscribe to it. - Groups and objects. Each MOQT group of the track is one group of the frame stream: its
first object is the group’s intra frame, and the object of Object ID k is the frame whose
frame.indexis k (frame-stream §2). Each object keeps §3: one wholeWAI1envelope. A subscriber joins at a group’s first object (MOQT §3.5), and decodes the track’s objects in object order with one decoder state, which each group’s intra frame resets (frame-stream §5). - Mismatch. A sink checks each object of the track against the declaration before it
dispatches it: an object whose capability is not the declared one, whose manifest carries
no
frameobject, or whoseframe.indexis not its Object ID breaks the catalog (catalog_frame_mismatch). It is refused, and the track with it, as §4.2 refuses an object that breakswai_priors. The catalog never stands in for the envelope: the sink makes frame-stream §5’s checks on every object it dispatches, whatever the catalog says. - Receipts and loss. Each object’s receipt is an object receipt like any other (§4.1, §5). A frame a relay does not forward is accounted for by its receipt and refused as a gap at the frame after it (frame-stream §5): no frame is decoded against a reference that is not its predecessor’s.
wai_priors(§4.2) lists the pins of a frame capability that decodes against a parameter set as for any capability: every object of a group carries its intra frame’s pin (frame-stream §2).
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 }
| member | type | meaning |
|---|---|---|
max_delay_ms | integer, 0 to 2^32 − 1 | REQUIRED. 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_ms | integer, 0 to max_delay_ms | OPTIONAL. The PlayoutDelay of an object that states none and follows none that did (the draft’s §4.4). |
objects_per_720s, start_ms | integers, the first at least 1, each at most 2^53 − 1 | OPTIONAL, 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 size precision is the least that holds the largest unit’s size;
- the first unit is the V3C parameter set (unit type 0), and no other unit is one; every
other unit names one parameter set (
vuh_v3c_parameter_set_id); - the other units are in ascending order of their unit headers, read as 32-bit integers, so an atlas’s units come before its occupancy, geometry, attribute and packed video and the common atlas last; units of one header keep their order and are that track’s objects 0, 1 and on;
- every reserved bit of every unit header is 0, and every unit’s type is 0 to 6. The header layouts of basemesh and displacement units (the draft’s Table 4) are in ISO/IEC 23090-5’s current edition alone, so a unit of type 7 or above has no form here.
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:
| code | when |
|---|---|
v3c_stream_malformed | The 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_reserved | A reserved bit of a unit header is set. |
v3c_component_unmapped | A unit’s type is 7 or above. |
v3c_parameter_set | The 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_canonical | The size precision is not the least, or the units after the parameter set are not in ascending order of their headers. |
v3c_map_index_unexpected | A unit’s map index is not 0 and the publisher states one map stream. |
v3c_catalog_malformed | On 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_incomplete | On 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" } ] }
| member | type | meaning |
|---|---|---|
scope | string | REQUIRED. "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). |
keys | array of 1 to 16 objects | REQUIRED. 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:
- a series is one metric: the draft’s metric has a name and no labels, so a sample with
labels is named
<family>:<label>:<value>…, its labels in the exposition’s order. A family name that holds a:, and a label value with a character outside letters, digits and_, are refused; no name is escaped or cut to fit; - the draft has counters and gauges: a family of another kind is refused;
- a non-negative integer is sent as an unsigned integer, a negative one as a signed integer, anything else as a binary64. A metric’s representation only widens, and each widening, like each new series, is a new catalog version. A series keeps its Metric Index across versions, and a series the exposition no longer has is left out of its group behind the Prior Object ID Gap the draft requires;
- a group and the exposition it was captured from are equal when they have the same
series, each of the same kind and the same number (an integer by value, a binary64 by its
bits). A reader that holds both refuses the first difference:
value_disagrees,kind_disagrees, orseries_disagreefor a series only one of them has.
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:
- the track’s
initRefnames that period’s header: the clear header protected under the period’s key, so itstencnames the period’s KID; contentProtectionsholds that period’s entries, whosedefaultKIDholds that KID;- the track carries
wai_key_period, an object of exactlyindex, the key period’s index (CPIX’sContentKeyPeriod@index), andfrom_group, the Group ID of the first group the period holds for. Both are integers from 0, and each later catalog’s are higher.
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:
| reason | when |
|---|---|
protected_cmsf_catalog | no 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_unknown | a header’s KID is not in the CPIX document |
protected_cmsf_key_period | the document holds that KID for another key period than the catalog states, for none, or under another scheme |
protected_cmsf_no_period | an object’s group is before the first period’s from_group |
protected_cmsf_object | an 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:
- Not a floor. A floor is a rendition in a capability of SPEC §5’s mandatory floor or
recommended set, held object by object to its profile and to the piece it stands for
(packaging §7, its items on the floor rendition and on floor objects). A
transport stream’s elementary streams are not read here and are held to nothing, and no
sink is required to demultiplex one. An
mpeg2tstrack therefore MUST NOT share analtGroupwith awaitrack, and a package’s floor is never one. - Not a carriage of envelopes. Packaging
waimakes the object boundary the envelope boundary (§3). Anmpeg2tsobject’s boundary is a packet boundary, and this text defines no way to place an envelope in a transport stream.
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):
| field | type | rule |
|---|---|---|
mpeg2tsMode | string | required: unmodified-program, unmodified-multiplex, per-program or es-packets |
mpeg2tsPacketSize | number | required: 188 or 192 |
mpeg2tsEsPid | number | present exactly in es-packets: a PID, 0 to 8190 |
mpeg2tsProgramNumber | number | 1 to 65535 |
mpeg2tsPcrPid | number | a PID, 0 to 8191 |
mpeg2tsMuxRate | number | 1 to 2^53 − 1, bits a second; absent in the unmodified modes |
mpeg2tsSiPids | array | PIDs, each once; absent beside mpeg2tsEsPid and in unmodified-multiplex |
mpeg2tsRandomAccess | boolean | in unmodified-multiplex, only beside mpeg2tsProgramNumber |
mpeg2tsTimestampMode | string | not empty; absent with 188-octet packets |
mpeg2tsScte35Pid | number | a 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).
| code | refused |
|---|---|
mpeg2ts_mode | mpeg2tsMode is absent or not one of the four |
mpeg2ts_packet_size | mpeg2tsPacketSize is absent or neither 188 nor 192 |
mpeg2ts_es_pid | mpeg2tsEsPid is present outside es-packets, or absent in it |
mpeg2ts_field_range | a field’s value is not of its type or outside its range |
mpeg2ts_field_forbidden | a field is present where the table above has it absent, or an unmodified-multiplex track is in an altGroup |
mpeg2ts_init_data | the initialization data is empty, not whole source packets, or lacks a sync byte |
mpeg2ts_object_order | an object is not after the last one read |
mpeg2ts_object_split | an 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_length | an 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_sync | a packet does not begin with 0x47 |
mpeg2ts_packet_form | adaptation_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_pid | an es-packets track holds a packet of another PID |
mpeg2ts_null_packet | an es-packets track holds a null packet |
mpeg2ts_continuity | a 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_form | a 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_crc | a PAT or PMT section’s CRC is not 0 over the whole section |
mpeg2ts_program_count | an unmodified-program track’s PAT does not list exactly one program, or an unmodified-multiplex track’s lists fewer than two |
mpeg2ts_program_mismatch | the PAT does not list mpeg2tsProgramNumber, or a PMT track’s PMT is another program’s |
mpeg2ts_pcr_pid_mismatch | the PMT of the program the catalog describes names another PCR_PID than mpeg2tsPcrPid |
mpeg2ts_pcr_unsignalled | a 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:
| field | type | meaning |
|---|---|---|
content_hash | 32 B | jwp-receipts §2.1 BLAKE3 over the envelope bytes. |
joules_micro | u64 | Microjoules producing this object; 0 is the unmetered marker, never 0 J (energy-measurement §2). |
acquisition | string | Acquisition class per energy-measurement §2; empty when joules_micro is 0. |
acquisition_evidence | bytes | For 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_receipt | 32 B | The 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.
-
A non-zero
joules_microMUST be accompanied byacquisition. A joule figure without its acquisition class is exactly whatenergy-measurement.md§2 forbids, and putting it on the wire does not make it acceptable. -
A zero
joules_microis the unmetered marker:acquisitionMUST be empty andacquisition_evidenceempty, since a class beside a zero figure claims a measurement that did not occur (energy-measurement.md§2). A sink MUST NOT present the marker as a figure of zero joules, and MUST discard a property that breaks this bullet or the one above (property_invalid). -
acquisition_evidenceMUST be present and non-empty for a refined hardware class (OnChipCounter,CalibratedInstrument), and empty otherwise — including for legacyHwShunt, which carries no evidence. A refined class without its declared uncertainty is refused byenergy-measurement.md§2 on the same terms as a figure without a class. A property written before this field existed has noacquisition_evidence; a reader treats its absence as empty, which is valid only for the classes that carry none. -
No signature covers this property. A sink MUST NOT report
acquisitionoracquisition_evidenceas signed unless they andjoules_microequal a signed statement it holds of the same object, which is one of:- the label in the object’s Merkle leaf, once the object receipt has been
accepted under
jwp-receipts§3 against the group receiptgroup_receiptnames —group_receiptmust then name that group; or - an
energyclaim about the object that it has accepted underjwp-receipts§3.1. A claim names no group, sogroup_receiptis outside what it states.
Where such a statement gives another figure, class, evidence or group, the sink MUST discard the property (
property_disagrees). Where it holds none, the class is outside every signature, and the sink reads the figure as unlabelled. - the label in the object’s Merkle leaf, once the object receipt has been
accepted under
-
A class read as signed is the statement of the key that signed it: the group receipt’s
signer_pubkeyfor a leaf, the claim’ssigner_pubkeyfor anenergyclaim. A sink MUST report that key with the class, and MUST NOT report a class a claim signs as the publisher’s unless the claim’s signer is a key it holds as the publisher’s. Anyone can sign anenergyclaim, a relay that rewrites this property included. -
A relay MUST preserve this property unchanged, per
jwp-receipts§4.1. A relay that recomputes it is asserting something it did not measure. -
A relay that does not forward an object, whether because a delivery timeout passed or at its discretion (MOQT §5.2), MUST still forward that object’s receipts to every subscriber that requested receipts for its track (jwp-receipts §4.1). This property rides on the object and is lost with it; the receipts ride the track’s receipts track (§4.1), which the relay forwards as it forwards any track, so a subscriber of that receipts track that receives the receipt accounts for the object as
inclusion-verified(jwp-receipts §4.4). A receipts-track object the relay drops in turn is recovered as §4.1 says. A relay that signs adelivery-gapclaim (jwp-receipts §2.4.11) does not add it to the publisher’s receipts track, whose objects it forwards unaltered (MOQT §7.8); this extension defines no carriage for such a claim. -
Telemetry about objects on a WAI track is delivery-telemetry’s. It is unsigned and advisory, and it MUST NOT restate this property’s figure, class or evidence.
-
Absence of the property is not evidence of absence of a receipt; receipts MAY ride elsewhere (§1 of
jwp-receiptslists sidecar and trailer carriage). A sink MUST NOT infer that an object without the property is unattested.
6. What this extension does not do
Stated so it is not re-argued:
- It does not define, profile, or restate MOQT’s wire encoding — not the object header, not the byte layout of properties, not the control messages. Those are MOQT’s, and the property that makes this binding cheap is that WAI rides a transport instead of defining one. §4.1 paraphrases MOQT’s scheduling order, its delivery timeouts and its joining (MOQT §5.1, §5.2, §3.5) only to say how a stage set uses them and which values it sets; it defines none of them, and where a paraphrase and MOQT differ, MOQT holds.
- It does not replace CMSF or LOC. A publisher with CMAF-packaged media
should use CMSF; this packaging is for tracks whose objects are WAI envelopes.
An envelope whose payload is one chunk of a WebCodecs codec may instead travel on
a track of packaging
loc, its manifest and receipt in properties of the object (loc-carriage). - It does not make MoQ WAI’s transport. WAI remains carrier-agnostic; this
is one binding among the several
jwp-receipts§1 anticipates. - It is not the only binding. http-delivery binds the same
objects to HTTP, admits
WAI2envelopes with verified component ranges, carriesWAI_RECEIPTin a sidecar index, and maps this extension in its Appendix C. - It does not pin a MOQT draft revision. MOQT is pre-Last-Call; an extension that pinned a moving target would be wrong within a meeting cycle. Where MOQT and this text disagree, MOQT wins and this text is the thing that must change. The revisions named in the status note are the ones this text was last read against: where a later revision renumbers or renames what it cites, the citation is what changes.
- Nothing in it depends on which MOQT draft carries the objects: an envelope, its
WAI_RECEIPTproperty inside Immutable Properties, a receipts track and its catalog fields are the same on every draft that has Immutable Properties. The reference implementation (joule-moqandjoule-moq-relay, injoule-code/joule-code-rs/crates/) speaksdraft-ietf-moq-transport-23,-22,-18and-16, the draft chosen per session by ALPN orWT-Available-Protocols, and carries this extension’s objects and receipts unchanged on each: -23 keeps -22’s Immutable Properties, its Key-Value-Pairs and the range §8.4 sets aside for applications, whereWAI_RECEIPTis. Its README records the relays and drafts it has carried them through, and when.
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.