@moqtap/codec 0.2.0 → 0.2.1

package/dist/drafts/draft17/codec.js

@@ -0,0 +1,799 @@
+import { bytesToHex, hexToBytes } from "../../core/hex.js";
+import { BufferReader } from "../../core/buffer-reader.js";
+import { BufferWriter } from "../../core/buffer-writer.js";
+import { DecodeError } from "../../core/types.js";
+import { MESSAGE_ID_MAP, MSG_FETCH, MSG_FETCH_OK, MSG_GOAWAY, MSG_NAMESPACE, MSG_NAMESPACE_DONE, MSG_PUBLISH, MSG_PUBLISH_BLOCKED, MSG_PUBLISH_DONE, MSG_PUBLISH_NAMESPACE, MSG_PUBLISH_OK, MSG_REQUEST_ERROR, MSG_REQUEST_OK, MSG_REQUEST_UPDATE, MSG_SETUP, MSG_SUBSCRIBE, MSG_SUBSCRIBE_NAMESPACE, MSG_SUBSCRIBE_OK, MSG_TRACK_STATUS, SETUP_OPT_AUTHORITY, SETUP_OPT_MAX_AUTH_TOKEN_CACHE_SIZE, SETUP_OPT_MOQT_IMPLEMENTATION, SETUP_OPT_PATH, } from "./messages.js";
+// ─── Setup Options Encoding/Decoding (KVP, no count prefix) ─────────────────
+function encodeSetupOptions(opts, writer) {
+    // Collect all options sorted by type ID
+    const entries = [];
+    if (opts.path !== undefined) {
+        entries.push({
+            type: SETUP_OPT_PATH,
+            encode: (w) => {
+                const encoded = new TextEncoder().encode(opts.path);
+                w.writeVarInt(BigInt(encoded.byteLength));
+                w.writeBytes(encoded);
+            },
+        });
+    }
+    if (opts.max_auth_token_cache_size !== undefined) {
+        entries.push({
+            type: SETUP_OPT_MAX_AUTH_TOKEN_CACHE_SIZE,
+            encode: (w) => w.writeVarInt(opts.max_auth_token_cache_size),
+        });
+    }
+    if (opts.authority !== undefined) {
+        entries.push({
+            type: SETUP_OPT_AUTHORITY,
+            encode: (w) => {
+                const encoded = new TextEncoder().encode(opts.authority);
+                w.writeVarInt(BigInt(encoded.byteLength));
+                w.writeBytes(encoded);
+            },
+        });
+    }
+    if (opts.moqt_implementation !== undefined) {
+        entries.push({
+            type: SETUP_OPT_MOQT_IMPLEMENTATION,
+            encode: (w) => {
+                const encoded = new TextEncoder().encode(opts.moqt_implementation);
+                w.writeVarInt(BigInt(encoded.byteLength));
+                w.writeBytes(encoded);
+            },
+        });
+    }
+    if (opts.unknown) {
+        for (const u of opts.unknown) {
+            const id = BigInt(u.id);
+            entries.push({
+                type: id,
+                encode: (w) => {
+                    if (id % 2n === 0n) {
+                        const raw = hexToBytes(u.raw_hex);
+                        const tmpReader = new BufferReader(raw);
+                        w.writeVarInt(tmpReader.readVarInt());
+                    }
+                    else {
+                        const raw = hexToBytes(u.raw_hex);
+                        w.writeVarInt(BigInt(raw.byteLength));
+                        w.writeBytes(raw);
+                    }
+                },
+            });
+        }
+    }
+    // Sort by type (ascending) and write with delta encoding
+    entries.sort((a, b) => (a.type < b.type ? -1 : a.type > b.type ? 1 : 0));
+    let prevType = 0n;
+    for (const entry of entries) {
+        writer.writeVarInt(entry.type - prevType);
+        entry.encode(writer);
+        prevType = entry.type;
+    }
+}
+function decodeSetupOptions(reader, payloadEnd) {
+    const result = {};
+    const unknown = [];
+    let prevType = 0n;
+    while (reader.offset < payloadEnd) {
+        const delta = reader.readVarInt();
+        const optType = prevType + delta;
+        prevType = optType;
+        if (optType % 2n === 0n) {
+            // Even: single varint value
+            const value = reader.readVarInt();
+            if (optType === SETUP_OPT_MAX_AUTH_TOKEN_CACHE_SIZE) {
+                result.max_auth_token_cache_size = value;
+            }
+            else {
+                const tmpWriter = new BufferWriter(16);
+                tmpWriter.writeVarInt(value);
+                const raw = tmpWriter.finish();
+                unknown.push({
+                    id: `0x${optType.toString(16)}`,
+                    length: raw.byteLength,
+                    raw_hex: bytesToHex(raw),
+                });
+            }
+        }
+        else {
+            // Odd: length-prefixed bytes
+            const length = Number(reader.readVarInt());
+            const bytes = reader.readBytes(length);
+            if (optType === SETUP_OPT_PATH) {
+                result.path = new TextDecoder().decode(bytes);
+            }
+            else if (optType === SETUP_OPT_AUTHORITY) {
+                result.authority = new TextDecoder().decode(bytes);
+            }
+            else if (optType === SETUP_OPT_MOQT_IMPLEMENTATION) {
+                result.moqt_implementation = new TextDecoder().decode(bytes);
+            }
+            else {
+                unknown.push({ id: `0x${optType.toString(16)}`, length, raw_hex: bytesToHex(bytes) });
+            }
+        }
+    }
+    if (unknown.length > 0)
+        result.unknown = unknown;
+    return result;
+}
+// ─── Message Parameter Encoding/Decoding (delta types, count prefix) ─────────
+const PARAM_EXPIRES = 0x08n;
+const PARAM_LARGEST_OBJECT = 0x09n;
+const PARAM_SUBSCRIBER_PRIORITY = 0x20n;
+const PARAM_SUBSCRIPTION_FILTER = 0x21n;
+const PARAM_GROUP_ORDER = 0x22n;
+function encodeParams(params, writer) {
+    // Collect and sort params by type
+    const entries = [];
+    if (params.expires !== undefined) {
+        entries.push({ type: PARAM_EXPIRES, encode: (w) => w.writeVarInt(params.expires) });
+    }
+    if (params.largest_object !== undefined) {
+        entries.push({
+            type: PARAM_LARGEST_OBJECT,
+            encode: (w) => {
+                w.writeVarInt(params.largest_object.group);
+                w.writeVarInt(params.largest_object.object);
+            },
+        });
+    }
+    if (params.subscriber_priority !== undefined) {
+        entries.push({
+            type: PARAM_SUBSCRIBER_PRIORITY,
+            encode: (w) => w.writeUint8(Number(params.subscriber_priority)),
+        });
+    }
+    if (params.subscription_filter !== undefined) {
+        entries.push({
+            type: PARAM_SUBSCRIPTION_FILTER,
+            encode: (w) => {
+                const f = params.subscription_filter;
+                const tmpW = new BufferWriter(32);
+                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(BigInt(raw.byteLength));
+                w.writeBytes(raw);
+            },
+        });
+    }
+    if (params.group_order !== undefined) {
+        entries.push({
+            type: PARAM_GROUP_ORDER,
+            encode: (w) => w.writeUint8(Number(params.group_order)),
+        });
+    }
+    // Unknown params
+    if (params.unknown) {
+        for (const u of params.unknown) {
+            const id = BigInt(u.id);
+            entries.push({
+                type: id,
+                encode: (w) => {
+                    const raw = hexToBytes(u.raw_hex);
+                    // For unknown params, we store raw bytes and re-emit them
+                    w.writeBytes(raw);
+                },
+            });
+        }
+    }
+    entries.sort((a, b) => (a.type < b.type ? -1 : a.type > b.type ? 1 : 0));
+    writer.writeVarInt(BigInt(entries.length));
+    let prevType = 0n;
+    for (const entry of entries) {
+        writer.writeVarInt(entry.type - prevType);
+        entry.encode(writer);
+        prevType = entry.type;
+    }
+}
+function decodeParams(reader) {
+    const count = Number(reader.readVarInt());
+    const result = {};
+    const unknown = [];
+    let prevType = 0n;
+    for (let i = 0; i < count; i++) {
+        const delta = reader.readVarInt();
+        const paramType = prevType + delta;
+        prevType = paramType;
+        if (paramType === PARAM_EXPIRES) {
+            result.expires = reader.readVarInt();
+        }
+        else if (paramType === PARAM_LARGEST_OBJECT) {
+            // Location: 2 bare varints (not length-prefixed)
+            const group = reader.readVarInt();
+            const object = reader.readVarInt();
+            result.largest_object = { group, object };
+        }
+        else if (paramType === PARAM_SUBSCRIBER_PRIORITY) {
+            // uint8: single raw byte
+            result.subscriber_priority = BigInt(reader.readUint8());
+        }
+        else if (paramType === PARAM_SUBSCRIPTION_FILTER) {
+            // Length-prefixed
+            const length = Number(reader.readVarInt());
+            const startOff = reader.offset;
+            const filter_type = reader.readVarInt();
+            const filter = { filter_type };
+            if (filter_type === 3n || filter_type === 4n) {
+                filter.start_group = reader.readVarInt();
+                filter.start_object = reader.readVarInt();
+            }
+            if (filter_type === 4n) {
+                filter.end_group = reader.readVarInt();
+            }
+            const consumed = reader.offset - startOff;
+            if (consumed < length)
+                reader.readBytes(length - consumed);
+            result.subscription_filter = filter;
+        }
+        else if (paramType === PARAM_GROUP_ORDER) {
+            // uint8: single raw byte
+            result.group_order = BigInt(reader.readUint8());
+        }
+        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) });
+            }
+        }
+    }
+    if (unknown.length > 0)
+        result.unknown = unknown;
+    return result;
+}
+// ─── Track Properties Encoding/Decoding (KVP, no count prefix) ──────────────
+function encodeTrackProperties(props, writer) {
+    if (!props.unknown || props.unknown.length === 0)
+        return;
+    const entries = props.unknown.map((u) => ({ type: BigInt(u.id), raw: u }));
+    entries.sort((a, b) => (a.type < b.type ? -1 : a.type > b.type ? 1 : 0));
+    let prevType = 0n;
+    for (const entry of entries) {
+        writer.writeVarInt(entry.type - prevType);
+        if (entry.type % 2n === 0n) {
+            const raw = hexToBytes(entry.raw.raw_hex);
+            const tmpReader = new BufferReader(raw);
+            writer.writeVarInt(tmpReader.readVarInt());
+        }
+        else {
+            const raw = hexToBytes(entry.raw.raw_hex);
+            writer.writeVarInt(BigInt(raw.byteLength));
+            writer.writeBytes(raw);
+        }
+        prevType = entry.type;
+    }
+}
+function decodeTrackProperties(reader, payloadEnd) {
+    const result = {};
+    const unknown = [];
+    let prevType = 0n;
+    while (reader.offset < payloadEnd) {
+        const delta = reader.readVarInt();
+        const propType = prevType + delta;
+        prevType = propType;
+        if (propType % 2n === 0n) {
+            const value = reader.readVarInt();
+            const tmpWriter = new BufferWriter(16);
+            tmpWriter.writeVarInt(value);
+            const raw = tmpWriter.finish();
+            unknown.push({
+                id: `0x${propType.toString(16)}`,
+                length: raw.byteLength,
+                raw_hex: bytesToHex(raw),
+            });
+        }
+        else {
+            const length = Number(reader.readVarInt());
+            const bytes = reader.readBytes(length);
+            unknown.push({ id: `0x${propType.toString(16)}`, length, raw_hex: bytesToHex(bytes) });
+        }
+    }
+    if (unknown.length > 0)
+        result.unknown = unknown;
+    return result;
+}
+// ─── Payload Encoders ──────────────────────────────────────────────────────────
+function encodeSetupPayload(msg, w) {
+    encodeSetupOptions(msg.options, w);
+}
+function encodeSubscribePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.required_request_id_delta);
+    w.writeTuple(msg.track_namespace);
+    w.writeString(msg.track_name);
+    encodeParams(msg.parameters, w);
+}
+function encodeSubscribeOkPayload(msg, w) {
+    w.writeVarInt(msg.track_alias);
+    encodeParams(msg.parameters, w);
+    encodeTrackProperties(msg.track_properties, w);
+}
+function encodeRequestUpdatePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.required_request_id_delta);
+    encodeParams(msg.parameters, w);
+}
+function encodePublishPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.required_request_id_delta);
+    w.writeTuple(msg.track_namespace);
+    w.writeString(msg.track_name);
+    w.writeVarInt(msg.track_alias);
+    encodeParams(msg.parameters, w);
+    encodeTrackProperties(msg.track_properties, w);
+}
+function encodePublishOkPayload(msg, w) {
+    encodeParams(msg.parameters, w);
+}
+function encodePublishDonePayload(msg, w) {
+    w.writeVarInt(msg.status_code);
+    w.writeVarInt(msg.stream_count);
+    w.writeString(msg.reason_phrase);
+}
+function encodePublishNamespacePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.required_request_id_delta);
+    w.writeTuple(msg.track_namespace);
+    encodeParams(msg.parameters, w);
+}
+function encodeNamespacePayload(msg, w) {
+    w.writeTuple(msg.namespace_suffix);
+}
+function encodeNamespaceDonePayload(msg, w) {
+    w.writeTuple(msg.namespace_suffix);
+}
+function encodeSubscribeNamespacePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.required_request_id_delta);
+    w.writeTuple(msg.namespace_prefix);
+    w.writeVarInt(msg.subscribe_options);
+    encodeParams(msg.parameters, w);
+}
+function encodePublishBlockedPayload(msg, w) {
+    w.writeTuple(msg.namespace_suffix);
+    w.writeString(msg.track_name);
+}
+function encodeFetchPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.required_request_id_delta);
+    w.writeVarInt(msg.fetch_type);
+    const ft = Number(msg.fetch_type);
+    if (ft === 1 && msg.standalone) {
+        w.writeTuple(msg.standalone.track_namespace);
+        w.writeString(msg.standalone.track_name);
+        w.writeVarInt(msg.standalone.start_group);
+        w.writeVarInt(msg.standalone.start_object);
+        w.writeVarInt(msg.standalone.end_group);
+        w.writeVarInt(msg.standalone.end_object);
+    }
+    else if ((ft === 2 || ft === 3) && msg.joining) {
+        w.writeVarInt(msg.joining.joining_request_id);
+        w.writeVarInt(msg.joining.joining_start);
+    }
+    encodeParams(msg.parameters, w);
+}
+function encodeFetchOkPayload(msg, w) {
+    w.writeUint8(msg.end_of_track);
+    w.writeVarInt(msg.end_group);
+    w.writeVarInt(msg.end_object);
+    encodeParams(msg.parameters, w);
+    encodeTrackProperties(msg.track_properties, w);
+}
+function encodeTrackStatusPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.required_request_id_delta);
+    w.writeTuple(msg.track_namespace);
+    w.writeString(msg.track_name);
+    encodeParams(msg.parameters, w);
+}
+function encodeRequestOkPayload(msg, w) {
+    encodeParams(msg.parameters, w);
+}
+function encodeRequestErrorPayload(msg, w) {
+    w.writeVarInt(msg.error_code);
+    w.writeVarInt(msg.retry_interval);
+    w.writeString(msg.reason_phrase);
+}
+function encodeGoAwayPayload(msg, w) {
+    w.writeString(msg.new_session_uri);
+    w.writeVarInt(msg.timeout);
+}
+// ─── Payload Decoders ──────────────────────────────────────────────────────────
+function decodeSetupPayload(r, payloadEnd) {
+    const options = decodeSetupOptions(r, payloadEnd);
+    return { type: "setup", options };
+}
+function decodeSubscribePayload(r) {
+    const request_id = r.readVarInt();
+    const required_request_id_delta = r.readVarInt();
+    const track_namespace = r.readTuple();
+    const track_name = r.readString();
+    const parameters = decodeParams(r);
+    return {
+        type: "subscribe",
+        request_id,
+        required_request_id_delta,
+        track_namespace,
+        track_name,
+        parameters,
+    };
+}
+function decodeSubscribeOkPayload(r, payloadEnd) {
+    const track_alias = r.readVarInt();
+    const parameters = decodeParams(r);
+    const track_properties = decodeTrackProperties(r, payloadEnd);
+    return { type: "subscribe_ok", track_alias, parameters, track_properties };
+}
+function decodeRequestUpdatePayload(r) {
+    const request_id = r.readVarInt();
+    const required_request_id_delta = r.readVarInt();
+    const parameters = decodeParams(r);
+    return { type: "request_update", request_id, required_request_id_delta, parameters };
+}
+function decodePublishPayload(r, payloadEnd) {
+    const request_id = r.readVarInt();
+    const required_request_id_delta = r.readVarInt();
+    const track_namespace = r.readTuple();
+    const track_name = r.readString();
+    const track_alias = r.readVarInt();
+    const parameters = decodeParams(r);
+    const track_properties = decodeTrackProperties(r, payloadEnd);
+    return {
+        type: "publish",
+        request_id,
+        required_request_id_delta,
+        track_namespace,
+        track_name,
+        track_alias,
+        parameters,
+        track_properties,
+    };
+}
+function decodePublishOkPayload(r) {
+    const parameters = decodeParams(r);
+    return { type: "publish_ok", parameters };
+}
+function decodePublishDonePayload(r) {
+    const status_code = r.readVarInt();
+    const stream_count = r.readVarInt();
+    const reason_phrase = r.readString();
+    return { type: "publish_done", status_code, stream_count, reason_phrase };
+}
+function decodePublishNamespacePayload(r) {
+    const request_id = r.readVarInt();
+    const required_request_id_delta = r.readVarInt();
+    const track_namespace = r.readTuple();
+    const parameters = decodeParams(r);
+    return {
+        type: "publish_namespace",
+        request_id,
+        required_request_id_delta,
+        track_namespace,
+        parameters,
+    };
+}
+function decodeNamespacePayload(r) {
+    const namespace_suffix = r.readTuple();
+    return { type: "namespace", namespace_suffix };
+}
+function decodeNamespaceDonePayload(r) {
+    const namespace_suffix = r.readTuple();
+    return { type: "namespace_done", namespace_suffix };
+}
+function decodeSubscribeNamespacePayload(r) {
+    const request_id = r.readVarInt();
+    const required_request_id_delta = r.readVarInt();
+    const namespace_prefix = r.readTuple();
+    const subscribe_options = r.readVarInt();
+    const parameters = decodeParams(r);
+    return {
+        type: "subscribe_namespace",
+        request_id,
+        required_request_id_delta,
+        namespace_prefix,
+        subscribe_options,
+        parameters,
+    };
+}
+function decodePublishBlockedPayload(r) {
+    const namespace_suffix = r.readTuple();
+    const track_name = r.readString();
+    return { type: "publish_blocked", namespace_suffix, track_name };
+}
+function decodeFetchPayload(r) {
+    const request_id = r.readVarInt();
+    const required_request_id_delta = r.readVarInt();
+    const fetch_type = r.readVarInt();
+    const ft = Number(fetch_type);
+    if (ft < 1 || ft > 3) {
+        throw new DecodeError("CONSTRAINT_VIOLATION", `Invalid fetch_type: ${ft}`, r.offset);
+    }
+    let standalone;
+    let joining;
+    if (ft === 1) {
+        const track_namespace = r.readTuple();
+        const track_name = r.readString();
+        const start_group = r.readVarInt();
+        const start_object = r.readVarInt();
+        const end_group = r.readVarInt();
+        const end_object = r.readVarInt();
+        standalone = { track_namespace, track_name, start_group, start_object, end_group, end_object };
+    }
+    else {
+        const joining_request_id = r.readVarInt();
+        const joining_start = r.readVarInt();
+        joining = { joining_request_id, joining_start };
+    }
+    const parameters = decodeParams(r);
+    return {
+        type: "fetch",
+        request_id,
+        required_request_id_delta,
+        fetch_type,
+        standalone,
+        joining,
+        parameters,
+    };
+}
+function decodeFetchOkPayload(r, payloadEnd) {
+    const end_of_track = r.readUint8();
+    const end_group = r.readVarInt();
+    const end_object = r.readVarInt();
+    const parameters = decodeParams(r);
+    const track_properties = decodeTrackProperties(r, payloadEnd);
+    return { type: "fetch_ok", end_of_track, end_group, end_object, parameters, track_properties };
+}
+function decodeTrackStatusPayload(r) {
+    const request_id = r.readVarInt();
+    const required_request_id_delta = r.readVarInt();
+    const track_namespace = r.readTuple();
+    const track_name = r.readString();
+    const parameters = decodeParams(r);
+    return {
+        type: "track_status",
+        request_id,
+        required_request_id_delta,
+        track_namespace,
+        track_name,
+        parameters,
+    };
+}
+function decodeRequestOkPayload(r) {
+    const parameters = decodeParams(r);
+    return { type: "request_ok", parameters };
+}
+function decodeRequestErrorPayload(r) {
+    const error_code = r.readVarInt();
+    const retry_interval = r.readVarInt();
+    const reason_phrase = r.readString();
+    return { type: "request_error", error_code, retry_interval, reason_phrase };
+}
+function decodeGoAwayPayload(r) {
+    const new_session_uri = r.readString();
+    const timeout = r.readVarInt();
+    return { type: "goaway", new_session_uri, timeout };
+}
+// ─── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Encode a draft-17 control message with type(varint) + length(uint16 BE) + payload.
+ */
+export function encodeMessage(message) {
+    const typeId = MESSAGE_ID_MAP.get(message.type);
+    if (typeId === undefined) {
+        throw new Error(`Unknown message type: ${message.type}`);
+    }
+    const payloadWriter = new BufferWriter();
+    encodePayload(message, payloadWriter);
+    const payload = payloadWriter.finish();
+    if (payload.byteLength > 0xffff) {
+        throw new Error(`Payload too large for 16-bit length: ${payload.byteLength}`);
+    }
+    const writer = new BufferWriter();
+    writer.writeVarInt(typeId);
+    writer.writeUint8((payload.byteLength >> 8) & 0xff);
+    writer.writeUint8(payload.byteLength & 0xff);
+    writer.writeBytes(payload);
+    return writer.finish();
+}
+function encodePayload(msg, w) {
+    switch (msg.type) {
+        case "setup":
+            return encodeSetupPayload(msg, w);
+        case "subscribe":
+            return encodeSubscribePayload(msg, w);
+        case "subscribe_ok":
+            return encodeSubscribeOkPayload(msg, w);
+        case "request_update":
+            return encodeRequestUpdatePayload(msg, w);
+        case "publish":
+            return encodePublishPayload(msg, w);
+        case "publish_ok":
+            return encodePublishOkPayload(msg, w);
+        case "publish_done":
+            return encodePublishDonePayload(msg, w);
+        case "publish_namespace":
+            return encodePublishNamespacePayload(msg, w);
+        case "namespace":
+            return encodeNamespacePayload(msg, w);
+        case "namespace_done":
+            return encodeNamespaceDonePayload(msg, w);
+        case "subscribe_namespace":
+            return encodeSubscribeNamespacePayload(msg, w);
+        case "publish_blocked":
+            return encodePublishBlockedPayload(msg, w);
+        case "fetch":
+            return encodeFetchPayload(msg, w);
+        case "fetch_ok":
+            return encodeFetchOkPayload(msg, w);
+        case "track_status":
+            return encodeTrackStatusPayload(msg, w);
+        case "request_ok":
+            return encodeRequestOkPayload(msg, w);
+        case "request_error":
+            return encodeRequestErrorPayload(msg, w);
+        case "goaway":
+            return encodeGoAwayPayload(msg, w);
+        default: {
+            const _exhaustive = msg;
+            throw new Error(`Unhandled message type: ${_exhaustive.type}`);
+        }
+    }
+}
+/**
+ * Decode a draft-17 control message from bytes (type + uint16 length + payload).
+ */
+export function decodeMessage(bytes) {
+    try {
+        const reader = new BufferReader(bytes);
+        const typeId = reader.readVarInt();
+        const lenHi = reader.readUint8();
+        const lenLo = reader.readUint8();
+        const payloadLength = (lenHi << 8) | lenLo;
+        const payloadStart = reader.offset;
+        const _payloadEnd = payloadStart + payloadLength;
+        const payloadBytes = reader.readBytes(payloadLength);
+        const payloadReader = new BufferReader(payloadBytes);
+        let message;
+        if (typeId === MSG_SETUP) {
+            message = decodeSetupPayload(payloadReader, payloadLength);
+        }
+        else if (typeId === MSG_SUBSCRIBE) {
+            message = decodeSubscribePayload(payloadReader);
+        }
+        else if (typeId === MSG_SUBSCRIBE_OK) {
+            message = decodeSubscribeOkPayload(payloadReader, payloadLength);
+        }
+        else if (typeId === MSG_REQUEST_UPDATE) {
+            message = decodeRequestUpdatePayload(payloadReader);
+        }
+        else if (typeId === MSG_PUBLISH) {
+            message = decodePublishPayload(payloadReader, payloadLength);
+        }
+        else if (typeId === MSG_PUBLISH_OK) {
+            message = decodePublishOkPayload(payloadReader);
+        }
+        else if (typeId === MSG_PUBLISH_DONE) {
+            message = decodePublishDonePayload(payloadReader);
+        }
+        else if (typeId === MSG_PUBLISH_NAMESPACE) {
+            message = decodePublishNamespacePayload(payloadReader);
+        }
+        else if (typeId === MSG_NAMESPACE) {
+            message = decodeNamespacePayload(payloadReader);
+        }
+        else if (typeId === MSG_NAMESPACE_DONE) {
+            message = decodeNamespaceDonePayload(payloadReader);
+        }
+        else if (typeId === MSG_SUBSCRIBE_NAMESPACE) {
+            message = decodeSubscribeNamespacePayload(payloadReader);
+        }
+        else if (typeId === MSG_PUBLISH_BLOCKED) {
+            message = decodePublishBlockedPayload(payloadReader);
+        }
+        else if (typeId === MSG_FETCH) {
+            message = decodeFetchPayload(payloadReader);
+        }
+        else if (typeId === MSG_FETCH_OK) {
+            message = decodeFetchOkPayload(payloadReader, payloadLength);
+        }
+        else if (typeId === MSG_TRACK_STATUS) {
+            message = decodeTrackStatusPayload(payloadReader);
+        }
+        else if (typeId === MSG_REQUEST_OK) {
+            message = decodeRequestOkPayload(payloadReader);
+        }
+        else if (typeId === MSG_REQUEST_ERROR) {
+            message = decodeRequestErrorPayload(payloadReader);
+        }
+        else if (typeId === MSG_GOAWAY) {
+            message = decodeGoAwayPayload(payloadReader);
+        }
+        else {
+            return {
+                ok: false,
+                error: new DecodeError("UNKNOWN_MESSAGE_TYPE", `Unknown message type ID: 0x${typeId.toString(16)}`, 0),
+            };
+        }
+        return { ok: true, value: message, bytesRead: reader.offset };
+    }
+    catch (e) {
+        if (e instanceof DecodeError) {
+            return { ok: false, error: e };
+        }
+        throw e;
+    }
+}
+// ─── Data Stream Encoding/Decoding (re-exported from data-streams.ts) ───────
+import { encodeSubgroupStream, decodeSubgroupStream, encodeDatagram, decodeDatagram, encodeFetchStream, decodeFetchStream, decodeDataStream, createSubgroupStreamDecoder, createFetchStreamDecoder, createDataStreamDecoder } from "./data-streams.js";
+export { encodeSubgroupStream, decodeSubgroupStream, encodeDatagram, decodeDatagram, encodeFetchStream, decodeFetchStream, decodeDataStream, createSubgroupStreamDecoder, createFetchStreamDecoder, createDataStreamDecoder };
+// ─── Stream Decoders ───────────────────────────────────────────────────────────
+export function createStreamDecoder() {
+    let buffer = new Uint8Array(0);
+    return new TransformStream({
+        transform(chunk, controller) {
+            const newBuffer = new Uint8Array(buffer.length + chunk.length);
+            newBuffer.set(buffer, 0);
+            newBuffer.set(chunk, buffer.length);
+            buffer = newBuffer;
+            while (buffer.length > 0) {
+                const result = decodeMessage(buffer);
+                if (!result.ok) {
+                    if (result.error.code === "UNEXPECTED_END") {
+                        break;
+                    }
+                    controller.error(result.error);
+                    return;
+                }
+                controller.enqueue(result.value);
+                buffer = buffer.slice(result.bytesRead);
+            }
+        },
+        flush(controller) {
+            if (buffer.length > 0) {
+                controller.error(new DecodeError("UNEXPECTED_END", "Stream ended with incomplete message data", 0));
+            }
+        },
+    });
+}
+export function createDraft17Codec() {
+    return {
+        draft: "draft-ietf-moq-transport-17",
+        encodeMessage,
+        decodeMessage,
+        encodeSubgroupStream,
+        encodeDatagram,
+        encodeFetchStream,
+        decodeSubgroupStream,
+        decodeDatagram,
+        decodeFetchStream,
+        decodeDataStream,
+        createStreamDecoder,
+        createSubgroupStreamDecoder,
+        createFetchStreamDecoder,
+        createDataStreamDecoder,
+    };
+}
+//# sourceMappingURL=codec.js.map