@moqtap/codec 0.8.0 → 0.8.1

package/src/drafts/draft15/data-streams.ts

@@ -75,19 +75,23 @@ export function encodeDatagram(dg: DatagramObject): Uint8Array {
   w.writeVarInt(dg.trackAlias)
   w.writeVarInt(dg.groupId)
 
-  // Datagram type flags:
+  // Datagram type flags, Table 5:
   // bit 0 (0x01): extensions present
   // bit 1 (0x02): end-of-group
   // bit 2 (0x04): object_id ABSENT when set
+  // bit 3 (0x08): publisher priority ABSENT when set
   // bit 5 (0x20): status (replaces payload)
   const extensionsPresent = (dgType & 0x01) !== 0
   const objectIdAbsent = (dgType & 0x04) !== 0
+  const defaultPriority = (dgType & 0x08) !== 0
   const isStatus = (dgType & 0x20) !== 0
 
   if (!objectIdAbsent) {
     w.writeVarInt(dg.objectId)
   }
-  w.writeUint8(dg.publisherPriority)
+  if (!defaultPriority) {
+    w.writeUint8(dg.publisherPriority)
+  }
 
   if (extensionsPresent) {
     const extData = dg.extensionData ?? new Uint8Array(0)
@@ -141,29 +145,34 @@ export function decodeSubgroupStream(bytes: Uint8Array): DecodeResult<SubgroupSt
     const r = new BufferReader(bytes)
     const streamType = Number(r.readVarInt())
 
-    // Draft-15 valid subgroup types: 0x10-0x17, 0x30-0x37
-    // bit 0: extensions, bit 1: end-of-group, bit 2: explicit subgroup_id
+    // Draft-15 Table 6 assigns 0x10-0x15, 0x18-0x1D, 0x30-0x35 and 0x38-0x3D:
+    // the end-of-group marker at 0x08 doubles the range the previous drafts
+    // used. What the table leaves out is every Type whose two Subgroup ID mode
+    // bits are 0b11. Draft-16 names those reserved in prose; draft-15 only
+    // omits them, which comes to the same refusal by a different route.
     if (
-      !((streamType >= 0x10 && streamType <= 0x17) || (streamType >= 0x30 && streamType <= 0x37))
+      !((streamType >= 0x10 && streamType <= 0x1f) || (streamType >= 0x30 && streamType <= 0x3f)) ||
+      (streamType & 0x06) === 0x06
     ) {
       return {
         ok: false,
         error: new DecodeError(
           'CONSTRAINT_VIOLATION',
-          `Expected subgroup stream type 0x10-0x17/0x30-0x37, got 0x${streamType.toString(16)}`,
+          `Expected subgroup stream type 0x10-0x1F/0x30-0x3F, got 0x${streamType.toString(16)}`,
           0,
         ),
       }
     }
 
     // Decode type flags
-    // Draft-15 bit layout:
-    // bit 0: extensions present
-    // bit 1: end-of-group
-    // bit 2: explicit subgroup_id field present
+    // Draft-15 Table 6, over the 0x10 base:
+    // bit 0 (0x01): extensions present
+    // bit 1 (0x02): subgroup id is the first Object ID, not transmitted
+    // bit 2 (0x04): explicit subgroup_id field present
+    // bit 3 (0x08): contains end of group
     // bit 5 (0x20): no priority (>= 0x30)
     const extensionsPresent = (streamType & 0x01) !== 0
-    const endOfGroup = (streamType & 0x02) !== 0
+    const endOfGroup = (streamType & 0x08) !== 0
     const hasSubgroupField = (streamType & 0x04) !== 0
     const hasPriority = streamType < 0x30
 
@@ -260,10 +269,12 @@ export function decodeDatagram(bytes: Uint8Array): DecodeResult<DatagramObject>
     // bit 0 (0x01): extensions present
     // bit 1 (0x02): end-of-group
     // bit 2 (0x04): object_id ABSENT when set
+    // bit 3 (0x08): publisher priority ABSENT when set
     // bit 5 (0x20): status (replaces payload with status varint)
     const extensionsPresent = (dgType & 0x01) !== 0
     const objectIdAbsent = (dgType & 0x04) !== 0
     const endOfGroup = (dgType & 0x02) !== 0
+    const defaultPriority = (dgType & 0x08) !== 0
     const isStatus = (dgType & 0x20) !== 0
 
     const trackAlias = r.readVarInt()
@@ -272,7 +283,10 @@ export function decodeDatagram(bytes: Uint8Array): DecodeResult<DatagramObject>
     if (!objectIdAbsent) {
       objectId = r.readVarInt()
     }
-    const publisherPriority = r.readUint8()
+    let publisherPriority = 128 // default
+    if (!defaultPriority) {
+      publisherPriority = r.readUint8()
+    }
 
     let extensionData: Uint8Array | undefined
     if (extensionsPresent) {
@@ -531,8 +545,8 @@ export function createSubgroupStreamDecoder(): TransformStream<
 
           if (
             !(
-              (streamType >= 0x10 && streamType <= 0x17) ||
-              (streamType >= 0x30 && streamType <= 0x37)
+              (streamType >= 0x10 && streamType <= 0x1f) ||
+              (streamType >= 0x30 && streamType <= 0x3f)
             )
           ) {
             controller.error(
@@ -760,7 +774,7 @@ export function createDataStreamDecoder(): TransformStream<Uint8Array, DataStrea
         if (offset >= buffer.length) return
         const firstByte = buffer[offset]!
 
-        if ((firstByte >= 0x10 && firstByte <= 0x17) || (firstByte >= 0x30 && firstByte <= 0x37)) {
+        if ((firstByte >= 0x10 && firstByte <= 0x1f) || (firstByte >= 0x30 && firstByte <= 0x3f)) {
           // Subgroup — delegate to subgroup decoder
           // We need to feed the full buffer including the type byte
           const decoder = createSubgroupStreamDecoder()
@@ -796,7 +810,7 @@ export function createDataStreamDecoder(): TransformStream<Uint8Array, DataStrea
       const firstByte = view[0]!
       let result: DecodeResult<Draft15DataStream>
 
-      if ((firstByte >= 0x10 && firstByte <= 0x17) || (firstByte >= 0x30 && firstByte <= 0x37)) {
+      if ((firstByte >= 0x10 && firstByte <= 0x1f) || (firstByte >= 0x30 && firstByte <= 0x3f)) {
         result = decodeSubgroupStream(view)
       } else if (firstByte === 0x05) {
         result = decodeFetchStream(view)

package/src/drafts/draft16/codec.ts

@@ -311,116 +311,146 @@ function decodeTrackExtensions(reader: BufferReader): Draft16TrackExtensions {
 }
 
 function encodeParams(params: Draft16Params, writer: BufferWriter): void {
-  let count = params.unknown ? params.unknown.length : 0
-  if (params.delivery_timeout !== undefined) count++
-  if (params.authorization_token !== undefined) count++
-  if (params.max_cache_duration !== undefined) count++
-  if (params.expires !== undefined) count++
-  if (params.largest_object !== undefined) count++
-  if (params.publisher_priority !== undefined) count++
-  if (params.forward !== undefined) count++
-  if (params.subscriber_priority !== undefined) count++
-  if (params.subscription_filter !== undefined) count++
-  if (params.group_order !== undefined) count++
-  if (params.dynamic_groups !== undefined) count++
-  if (params.new_group_request !== undefined) count++
-  writer.writeVarInt(count)
+  // Draft-16 Section 1.4.2: "Key-Value-Pairs encode a Type value as a delta
+  // from the previous Type value, or from 0 if there is no previous Type
+  // value." That only defines a wire format if the order is fixed, which the
+  // same section fixes: "Parameters MUST be serialized in ascending order by
+  // Type." So the entries are collected, sorted, and written as differences.
+  const entries: Array<{ type: bigint; encode: (w: BufferWriter) => void }> = []
 
   if (params.delivery_timeout !== undefined) {
-    writer.writeVarInt(PARAM_DELIVERY_TIMEOUT)
-    writer.writeVarInt(params.delivery_timeout)
+    entries.push({
+      type: PARAM_DELIVERY_TIMEOUT,
+      encode: (w) => w.writeVarInt(params.delivery_timeout!),
+    })
   }
   if (params.authorization_token !== undefined) {
-    writer.writeVarInt(PARAM_AUTHORIZATION_TOKEN)
-    const tmpW = new BufferWriter(64)
-    encodeAuthorizationToken(params.authorization_token, tmpW)
-    const raw = tmpW.finish()
-    writer.writeVarInt(raw.byteLength)
-    writer.writeBytes(raw)
+    entries.push({
+      type: PARAM_AUTHORIZATION_TOKEN,
+      encode: (w) => {
+        const tmpW = new BufferWriter(64)
+        encodeAuthorizationToken(params.authorization_token!, tmpW)
+        const raw = tmpW.finish()
+        w.writeVarInt(raw.byteLength)
+        w.writeBytes(raw)
+      },
+    })
   }
   if (params.max_cache_duration !== undefined) {
-    writer.writeVarInt(PARAM_MAX_CACHE_DURATION)
-    writer.writeVarInt(params.max_cache_duration)
+    entries.push({
+      type: PARAM_MAX_CACHE_DURATION,
+      encode: (w) => w.writeVarInt(params.max_cache_duration!),
+    })
   }
   if (params.expires !== undefined) {
-    writer.writeVarInt(PARAM_EXPIRES)
-    writer.writeVarInt(params.expires)
+    entries.push({ type: PARAM_EXPIRES, encode: (w) => w.writeVarInt(params.expires!) })
   }
   if (params.largest_object !== undefined) {
-    writer.writeVarInt(PARAM_LARGEST_OBJECT)
-    const tmpW = new BufferWriter(16)
-    tmpW.writeVarInt(params.largest_object.group)
-    tmpW.writeVarInt(params.largest_object.object)
-    const raw = tmpW.finish()
-    writer.writeVarInt(raw.byteLength)
-    writer.writeBytes(raw)
+    entries.push({
+      type: PARAM_LARGEST_OBJECT,
+      // Draft-16 has no per-parameter value encoding: a Key-Value-Pair whose
+      // Type is odd carries a Length, and 0x09 is odd. Drafts 17 and later
+      // replaced that with "the encoding is specified by each parameter
+      // definition", which is where the same field loses its length.
+      encode: (w) => {
+        const tmpW = new BufferWriter(16)
+        tmpW.writeVarInt(params.largest_object!.group)
+        tmpW.writeVarInt(params.largest_object!.object)
+        const raw = tmpW.finish()
+        w.writeVarInt(raw.byteLength)
+        w.writeBytes(raw)
+      },
+    })
   }
   if (params.publisher_priority !== undefined) {
-    writer.writeVarInt(PARAM_PUBLISHER_PRIORITY)
-    writer.writeVarInt(params.publisher_priority)
+    entries.push({
+      type: PARAM_PUBLISHER_PRIORITY,
+      encode: (w) => w.writeVarInt(params.publisher_priority!),
+    })
   }
   if (params.forward !== undefined) {
-    writer.writeVarInt(PARAM_FORWARD)
-    writer.writeVarInt(params.forward)
+    entries.push({ type: PARAM_FORWARD, encode: (w) => w.writeVarInt(params.forward!) })
   }
   if (params.subscriber_priority !== undefined) {
-    writer.writeVarInt(PARAM_SUBSCRIBER_PRIORITY)
-    writer.writeVarInt(params.subscriber_priority)
+    entries.push({
+      type: PARAM_SUBSCRIBER_PRIORITY,
+      encode: (w) => w.writeVarInt(params.subscriber_priority!),
+    })
   }
   if (params.subscription_filter !== undefined) {
-    writer.writeVarInt(PARAM_SUBSCRIPTION_FILTER)
-    const tmpW = new BufferWriter(32)
-    const f = params.subscription_filter
-    tmpW.writeVarInt(f.filter_type)
-    if (f.filter_type === 3n || f.filter_type === 4n) {
-      tmpW.writeVarInt(f.start_group!)
-      tmpW.writeVarInt(f.start_object!)
-    }
-    if (f.filter_type === 4n) {
-      tmpW.writeVarInt(f.end_group!)
-    }
-    const raw = tmpW.finish()
-    writer.writeVarInt(raw.byteLength)
-    writer.writeBytes(raw)
+    entries.push({
+      type: PARAM_SUBSCRIPTION_FILTER,
+      encode: (w) => {
+        const tmpW = new BufferWriter(32)
+        const f = params.subscription_filter!
+        tmpW.writeVarInt(f.filter_type)
+        if (f.filter_type === 3n || f.filter_type === 4n) {
+          tmpW.writeVarInt(f.start_group!)
+          tmpW.writeVarInt(f.start_object!)
+        }
+        if (f.filter_type === 4n) {
+          tmpW.writeVarInt(f.end_group!)
+        }
+        const raw = tmpW.finish()
+        w.writeVarInt(raw.byteLength)
+        w.writeBytes(raw)
+      },
+    })
   }
   if (params.group_order !== undefined) {
-    writer.writeVarInt(PARAM_GROUP_ORDER)
-    writer.writeVarInt(params.group_order)
+    entries.push({ type: PARAM_GROUP_ORDER, encode: (w) => w.writeVarInt(params.group_order!) })
   }
   if (params.dynamic_groups !== undefined) {
-    writer.writeVarInt(PARAM_DYNAMIC_GROUPS)
-    writer.writeVarInt(params.dynamic_groups)
+    entries.push({
+      type: PARAM_DYNAMIC_GROUPS,
+      encode: (w) => w.writeVarInt(params.dynamic_groups!),
+    })
   }
   if (params.new_group_request !== undefined) {
-    writer.writeVarInt(PARAM_NEW_GROUP_REQUEST)
-    writer.writeVarInt(params.new_group_request)
+    entries.push({
+      type: PARAM_NEW_GROUP_REQUEST,
+      encode: (w) => w.writeVarInt(params.new_group_request!),
+    })
   }
 
   if (params.unknown) {
     for (const u of params.unknown) {
       const id = BigInt(u.id)
-      writer.writeVarInt(id)
-      if (id % 2n === 0n) {
-        const raw = hexToBytes(u.raw_hex)
-        const tmpReader = new BufferReader(raw)
-        const value = tmpReader.readVarInt()
-        writer.writeVarInt(value)
-      } else {
-        const raw = hexToBytes(u.raw_hex)
-        writer.writeVarInt(raw.byteLength)
-        writer.writeBytes(raw)
-      }
+      entries.push({
+        type: id,
+        encode: (w) => {
+          const raw = hexToBytes(u.raw_hex)
+          if (id % 2n === 0n) {
+            w.writeVarInt(new BufferReader(raw).readVarInt())
+          } else {
+            w.writeVarInt(raw.byteLength)
+            w.writeBytes(raw)
+          }
+        },
+      })
     }
   }
+
+  entries.sort((a, b) => (a.type < b.type ? -1 : a.type > b.type ? 1 : 0))
+
+  writer.writeVarInt(entries.length)
+  let prevType = 0n
+  for (const entry of entries) {
+    writer.writeVarInt(entry.type - prevType)
+    entry.encode(writer)
+    prevType = entry.type
+  }
 }
 
 function decodeParams(reader: BufferReader): Draft16Params {
   const count = Number(reader.readVarInt())
   const result: Draft16Params = {}
-  const unknown: UnknownParam[] = []
+  let prevType = 0n
 
   for (let i = 0; i < count; i++) {
-    const paramType = reader.readVarInt()
+    const delta = reader.readVarInt()
+    const paramType = prevType + delta
+    prevType = paramType
 
     if (paramType === PARAM_DELIVERY_TIMEOUT) {
       result.delivery_timeout = reader.readVarInt()
@@ -472,31 +502,24 @@ function decodeParams(reader: BufferReader): Draft16Params {
       const consumed = reader.offset - startOff
       if (consumed < length) reader.readBytes(length - consumed)
       result.subscription_filter = filter
-    } else if (paramType % 2n === 0n) {
-      const value = reader.readVarInt()
-      const tmpWriter = new BufferWriter(16)
-      tmpWriter.writeVarInt(value)
-      const raw = tmpWriter.finish()
-      unknown.push({
-        id: `0x${paramType.toString(16)}`,
-        length: raw.byteLength,
-        raw_hex: bytesToHex(raw),
-      })
     } else {
-      const length = Number(reader.readVarInt())
-      const bytes = reader.readBytes(length)
-      unknown.push({
-        id: `0x${paramType.toString(16)}`,
-        length,
-        raw_hex: bytesToHex(bytes),
-      })
+      // Drafts 16 and later: "All Message Parameters MUST be defined in the
+      // negotiated version of MOQT or negotiated via Setup Parameters. An
+      // endpoint that receives an unknown Message Parameter MUST close the
+      // session with PROTOCOL_VIOLATION." (Section 9.2)
+      //
+      // There is no skipping an unknown one and carrying on: the value's
+      // encoding comes from its definition, so a receiver that does not know
+      // the Type does not know how many bytes it spans either. Drafts 11
+      // through 15 say the opposite and keep collecting them.
+      throw new DecodeError(
+        'INVALID_PARAMETER',
+        `Unknown Message Parameter type 0x${paramType.toString(16)}`,
+        reader.offset,
+      )
     }
   }
 
-  if (unknown.length > 0) {
-    result.unknown = unknown
-  }
-
   return result
 }
 

package/src/drafts/draft17/codec.ts

@@ -236,6 +236,43 @@ const PARAM_SUBSCRIPTION_FILTER = 0x21n
 const PARAM_GROUP_ORDER = 0x22n
 const PARAM_NEW_GROUP_REQUEST = 0x32n
 
+/**
+ * Which messages each Message Parameter's own definition names.
+ *
+ * Section 9.3.1: "Each Message Parameter definition indicates the message types in
+ * which it can appear. If it appears in some other type of message, the
+ * receiving endpoint MUST close the connection with a PROTOCOL_VIOLATION."
+ * Drafts up to and including 16 end that sentence "it MUST be ignored", so this
+ * table has no counterpart there.
+ *
+ * A parameter type absent from this table is one no definition restricts. A
+ * type this draft does not define at all never reaches here: it is refused as
+ * unknown while its scope is still undecidable.
+ */
+const PARAMETER_SCOPE = new Map<bigint, Set<string>>([
+  [0x02n, new Set(['publish_ok', 'subscribe', 'request_update'])],
+  [
+    0x03n,
+    new Set([
+      'publish',
+      'subscribe',
+      'request_update',
+      'subscribe_namespace',
+      'publish_namespace',
+      'track_status',
+      'fetch',
+    ]),
+  ],
+  [0x04n, new Set(['subscribe'])],
+  [0x08n, new Set(['subscribe_ok', 'publish', 'publish_ok', 'request_ok'])],
+  [0x09n, new Set(['subscribe_ok', 'publish', 'request_ok'])],
+  [0x10n, new Set(['subscribe', 'request_update', 'publish', 'publish_ok', 'subscribe_namespace'])],
+  [0x20n, new Set(['subscribe', 'fetch', 'request_update', 'publish_ok'])],
+  [0x21n, new Set(['subscribe', 'publish_ok', 'request_update'])],
+  [0x22n, new Set(['subscribe', 'publish_ok', 'fetch'])],
+  [0x32n, new Set(['publish_ok', 'subscribe', 'request_update'])],
+])
+
 function encodeParams(params: Draft17Params, writer: BufferWriter): void {
   // Collect and sort params by type
   const entries: Array<{ type: bigint; encode: (w: BufferWriter) => void }> = []
@@ -350,10 +387,9 @@ function encodeParams(params: Draft17Params, writer: BufferWriter): void {
   }
 }
 
-function decodeParams(reader: BufferReader): Draft17Params {
+function decodeParams(reader: BufferReader, messageType: string): Draft17Params {
   const count = Number(reader.readVarInt())
   const result: Draft17Params = {}
-  const unknown: UnknownParam[] = []
   let prevType = 0n
 
   for (let i = 0; i < count; i++) {
@@ -361,6 +397,15 @@ function decodeParams(reader: BufferReader): Draft17Params {
     const paramType = prevType + delta
     prevType = paramType
 
+    const scope = PARAMETER_SCOPE.get(paramType)
+    if (scope !== undefined && !scope.has(messageType)) {
+      throw new DecodeError(
+        'CONSTRAINT_VIOLATION',
+        `Message Parameter 0x${paramType.toString(16)} may not appear in ${messageType}`,
+        reader.offset,
+      )
+    }
+
     if (paramType === PARAM_DELIVERY_TIMEOUT) {
       result.delivery_timeout = reader.readVarInt()
     } else if (paramType === PARAM_AUTHORIZATION_TOKEN) {
@@ -408,31 +453,23 @@ function decodeParams(reader: BufferReader): Draft17Params {
     } else if (paramType === PARAM_NEW_GROUP_REQUEST) {
       result.new_group_request = reader.readVarInt()
     } else {
-      // Unknown parameter — we don't know the encoding, protocol violation per spec
-      // But for robustness, attempt even/odd heuristic
-      if (paramType % 2n === 0n) {
-        const value = reader.readVarInt()
-        const tmpWriter = new BufferWriter(16)
-        tmpWriter.writeVarInt(value)
-        const raw = tmpWriter.finish()
-        unknown.push({
-          id: `0x${paramType.toString(16)}`,
-          length: raw.byteLength,
-          raw_hex: bytesToHex(raw),
-        })
-      } else {
-        const length = Number(reader.readVarInt())
-        const bytes = reader.readBytes(length)
-        unknown.push({
-          id: `0x${paramType.toString(16)}`,
-          length,
-          raw_hex: bytesToHex(bytes),
-        })
-      }
+      // Drafts 16 and later: "All Message Parameters MUST be defined in the
+      // negotiated version of MOQT or negotiated via Setup Options. An
+      // endpoint that receives an unknown Message Parameter MUST close the
+      // session with PROTOCOL_VIOLATION." (Section 9.3)
+      //
+      // There is no skipping an unknown one and carrying on: the value's
+      // encoding comes from its definition, so a receiver that does not know
+      // the Type does not know how many bytes it spans either. Drafts 11
+      // through 15 say the opposite and keep collecting them.
+      throw new DecodeError(
+        'INVALID_PARAMETER',
+        `Unknown Message Parameter type 0x${paramType.toString(16)}`,
+        reader.offset,
+      )
     }
   }
 
-  if (unknown.length > 0) result.unknown = unknown
   return result
 }
 
@@ -747,7 +784,7 @@ function decodeSubscribePayload(r: BufferReader): Draft17Message {
   const required_request_id_delta = r.readVarInt()
   const track_namespace = r.readTuple()
   const track_name = r.readString()
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'subscribe')
   return {
     type: 'subscribe',
     request_id,
@@ -760,7 +797,7 @@ function decodeSubscribePayload(r: BufferReader): Draft17Message {
 
 function decodeSubscribeOkPayload(r: BufferReader, payloadEnd: number): Draft17Message {
   const track_alias = r.readVarInt()
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'subscribe_ok')
   const track_properties = decodeTrackProperties(r, payloadEnd)
   return { type: 'subscribe_ok', track_alias, parameters, track_properties }
 }
@@ -768,7 +805,7 @@ function decodeSubscribeOkPayload(r: BufferReader, payloadEnd: number): Draft17M
 function decodeRequestUpdatePayload(r: BufferReader): Draft17Message {
   const request_id = r.readVarInt()
   const required_request_id_delta = r.readVarInt()
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'request_update')
   return {
     type: 'request_update',
     request_id,
@@ -783,7 +820,7 @@ function decodePublishPayload(r: BufferReader, payloadEnd: number): Draft17Messa
   const track_namespace = r.readTuple()
   const track_name = r.readString()
   const track_alias = r.readVarInt()
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'publish')
   const track_properties = decodeTrackProperties(r, payloadEnd)
   return {
     type: 'publish',
@@ -798,7 +835,7 @@ function decodePublishPayload(r: BufferReader, payloadEnd: number): Draft17Messa
 }
 
 function decodePublishOkPayload(r: BufferReader): Draft17Message {
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'publish_ok')
   return { type: 'publish_ok', parameters }
 }
 
@@ -813,7 +850,7 @@ function decodePublishNamespacePayload(r: BufferReader): Draft17Message {
   const request_id = r.readVarInt()
   const required_request_id_delta = r.readVarInt()
   const track_namespace = r.readTuple()
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'publish_namespace')
   return {
     type: 'publish_namespace',
     request_id,
@@ -838,7 +875,7 @@ function decodeSubscribeNamespacePayload(r: BufferReader): Draft17Message {
   const required_request_id_delta = r.readVarInt()
   const namespace_prefix = r.readTuple()
   const subscribe_options = r.readVarInt()
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'subscribe_namespace')
   return {
     type: 'subscribe_namespace',
     request_id,
@@ -889,7 +926,7 @@ function decodeFetchPayload(r: BufferReader): Draft17Message {
     joining = { joining_request_id, joining_start }
   }
 
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'fetch')
 
   return {
     type: 'fetch',
@@ -906,7 +943,7 @@ function decodeFetchOkPayload(r: BufferReader, payloadEnd: number): Draft17Messa
   const end_of_track = r.readUint8()
   const end_group = r.readVarInt()
   const end_object = r.readVarInt()
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'fetch_ok')
   const track_properties = decodeTrackProperties(r, payloadEnd)
   return {
     type: 'fetch_ok',
@@ -923,7 +960,7 @@ function decodeTrackStatusPayload(r: BufferReader): Draft17Message {
   const required_request_id_delta = r.readVarInt()
   const track_namespace = r.readTuple()
   const track_name = r.readString()
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'track_status')
   return {
     type: 'track_status',
     request_id,
@@ -935,7 +972,7 @@ function decodeTrackStatusPayload(r: BufferReader): Draft17Message {
 }
 
 function decodeRequestOkPayload(r: BufferReader): Draft17Message {
-  const parameters = decodeParams(r)
+  const parameters = decodeParams(r, 'request_ok')
   return { type: 'request_ok', parameters }
 }