@moqtap/codec 0.1.1 → 0.2.1

package/dist/drafts/draft11/codec.js

@@ -0,0 +1,775 @@
+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_ANNOUNCE, MSG_ANNOUNCE_CANCEL, MSG_ANNOUNCE_ERROR, MSG_ANNOUNCE_OK, MSG_CLIENT_SETUP, MSG_FETCH, MSG_FETCH_CANCEL, MSG_FETCH_ERROR, MSG_FETCH_OK, MSG_GOAWAY, MSG_MAX_REQUEST_ID, MSG_REQUESTS_BLOCKED, MSG_SERVER_SETUP, MSG_SUBSCRIBE, MSG_SUBSCRIBE_ANNOUNCES, MSG_SUBSCRIBE_ANNOUNCES_ERROR, MSG_SUBSCRIBE_ANNOUNCES_OK, MSG_SUBSCRIBE_DONE, MSG_SUBSCRIBE_ERROR, MSG_SUBSCRIBE_OK, MSG_SUBSCRIBE_UPDATE, MSG_TRACK_STATUS, MSG_TRACK_STATUS_REQUEST, MSG_UNANNOUNCE, MSG_UNSUBSCRIBE, MSG_UNSUBSCRIBE_ANNOUNCES, PARAM_AUTHORIZATION_TOKEN, PARAM_DELIVERY_TIMEOUT, SETUP_PARAM_MAX_REQUEST_ID, SETUP_PARAM_PATH, } from "./messages.js";
+// ─── Setup Parameter Encoding/Decoding (even/odd convention) ────────────────────
+function encodeSetupParams(params, w) {
+    let count = 0;
+    if (params.path !== undefined)
+        count++;
+    if (params.max_request_id !== undefined)
+        count++;
+    if (params.unknown)
+        count += params.unknown.length;
+    w.writeVarInt(count);
+    if (params.path !== undefined) {
+        w.writeVarInt(SETUP_PARAM_PATH);
+        const encoded = new TextEncoder().encode(params.path);
+        w.writeVarInt(encoded.byteLength);
+        w.writeBytes(encoded);
+    }
+    if (params.max_request_id !== undefined) {
+        w.writeVarInt(SETUP_PARAM_MAX_REQUEST_ID);
+        w.writeVarInt(params.max_request_id);
+    }
+    if (params.unknown) {
+        for (const u of params.unknown) {
+            const id = BigInt(u.id);
+            w.writeVarInt(id);
+            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(raw.byteLength);
+                w.writeBytes(raw);
+            }
+        }
+    }
+}
+function decodeSetupParams(r) {
+    const count = Number(r.readVarInt());
+    const result = {};
+    const unknown = [];
+    for (let i = 0; i < count; i++) {
+        const paramType = r.readVarInt();
+        if (paramType % 2n === 0n) {
+            const value = r.readVarInt();
+            if (paramType === SETUP_PARAM_MAX_REQUEST_ID) {
+                result.max_request_id = value;
+            }
+            else {
+                const tmpW = new BufferWriter(16);
+                tmpW.writeVarInt(value);
+                const raw = tmpW.finish();
+                unknown.push({
+                    id: `0x${paramType.toString(16)}`,
+                    length: raw.byteLength,
+                    raw_hex: bytesToHex(raw),
+                });
+            }
+        }
+        else {
+            const length = Number(r.readVarInt());
+            const bytes = r.readBytes(length);
+            if (paramType === SETUP_PARAM_PATH) {
+                result.path = new TextDecoder().decode(bytes);
+            }
+            else {
+                unknown.push({ id: `0x${paramType.toString(16)}`, length, raw_hex: bytesToHex(bytes) });
+            }
+        }
+    }
+    if (unknown.length > 0)
+        result.unknown = unknown;
+    return result;
+}
+// ─── Version-Specific Parameter Encoding/Decoding ───────────────────────────────
+// Uses even/odd convention: even type → bare varint value, odd type → length-prefixed blob
+function encodeParams(params, w) {
+    let count = params.unknown ? params.unknown.length : 0;
+    if (params.authorization_token !== undefined)
+        count++;
+    if (params.delivery_timeout !== undefined)
+        count++;
+    w.writeVarInt(count);
+    if (params.authorization_token !== undefined) {
+        // AUTHORIZATION_TOKEN = 0x01 (odd → length-prefixed)
+        w.writeVarInt(PARAM_AUTHORIZATION_TOKEN);
+        const at = params.authorization_token;
+        const tmpW = new BufferWriter(64);
+        tmpW.writeVarInt(at.alias_type);
+        tmpW.writeVarInt(at.token_type);
+        const tokenBytes = new TextEncoder().encode(at.token_value);
+        tmpW.writeBytes(tokenBytes);
+        const raw = tmpW.finish();
+        w.writeVarInt(raw.byteLength);
+        w.writeBytes(raw);
+    }
+    if (params.delivery_timeout !== undefined) {
+        // DELIVERY_TIMEOUT = 0x02 (even → bare varint)
+        w.writeVarInt(PARAM_DELIVERY_TIMEOUT);
+        w.writeVarInt(params.delivery_timeout);
+    }
+    if (params.unknown) {
+        for (const u of params.unknown) {
+            const id = BigInt(u.id);
+            w.writeVarInt(id);
+            if (id % 2n === 0n) {
+                // Even → bare varint
+                const raw = hexToBytes(u.raw_hex);
+                const tmpReader = new BufferReader(raw);
+                w.writeVarInt(tmpReader.readVarInt());
+            }
+            else {
+                // Odd → length-prefixed
+                const raw = hexToBytes(u.raw_hex);
+                w.writeVarInt(raw.byteLength);
+                w.writeBytes(raw);
+            }
+        }
+    }
+}
+function decodeParams(r) {
+    const count = Number(r.readVarInt());
+    const result = {};
+    const unknown = [];
+    for (let i = 0; i < count; i++) {
+        const paramType = r.readVarInt();
+        if (paramType % 2n === 0n) {
+            // Even type → bare varint value
+            const value = r.readVarInt();
+            if (paramType === PARAM_DELIVERY_TIMEOUT) {
+                result.delivery_timeout = value;
+            }
+            else {
+                const tmpW = new BufferWriter(16);
+                tmpW.writeVarInt(value);
+                const raw = tmpW.finish();
+                unknown.push({
+                    id: `0x${paramType.toString(16)}`,
+                    length: raw.byteLength,
+                    raw_hex: bytesToHex(raw),
+                });
+            }
+        }
+        else {
+            // Odd type → length-prefixed blob
+            const length = Number(r.readVarInt());
+            const startOff = r.offset;
+            if (paramType === PARAM_AUTHORIZATION_TOKEN) {
+                const alias_type = r.readVarInt();
+                const token_type = r.readVarInt();
+                const tokenBytesLen = length - (r.offset - startOff);
+                const tokenBytes = r.readBytes(tokenBytesLen);
+                result.authorization_token = {
+                    alias_type,
+                    token_type,
+                    token_value: new TextDecoder().decode(tokenBytes),
+                };
+            }
+            else {
+                const bytes = r.readBytes(length);
+                unknown.push({ id: `0x${paramType.toString(16)}`, length, raw_hex: bytesToHex(bytes) });
+            }
+        }
+    }
+    if (unknown.length > 0)
+        result.unknown = unknown;
+    return result;
+}
+// ─── Payload Encoders ──────────────────────────────────────────────────────────
+function encodeClientSetupPayload(msg, w) {
+    w.writeVarInt(msg.supported_versions.length);
+    for (const v of msg.supported_versions)
+        w.writeVarInt(v);
+    encodeSetupParams(msg.parameters, w);
+}
+function encodeServerSetupPayload(msg, w) {
+    w.writeVarInt(msg.selected_version);
+    encodeSetupParams(msg.parameters, w);
+}
+function encodeSubscribePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.track_alias);
+    w.writeTuple(msg.track_namespace);
+    w.writeString(msg.track_name);
+    w.writeUint8(msg.subscriber_priority);
+    w.writeVarInt(msg.group_order);
+    w.writeVarInt(msg.forward);
+    w.writeVarInt(msg.filter_type);
+    const ft = Number(msg.filter_type);
+    if (ft === 3 || ft === 4) {
+        w.writeVarInt(msg.start_group);
+        w.writeVarInt(msg.start_object);
+    }
+    if (ft === 4) {
+        w.writeVarInt(msg.end_group);
+    }
+    encodeParams(msg.parameters, w);
+}
+function encodeSubscribeOkPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.expires);
+    w.writeVarInt(msg.group_order);
+    w.writeVarInt(msg.content_exists);
+    if (msg.content_exists === 1n && msg.largest_location) {
+        w.writeVarInt(msg.largest_location.group);
+        w.writeVarInt(msg.largest_location.object);
+    }
+    encodeParams(msg.parameters, w);
+}
+function encodeSubscribeErrorPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.error_code);
+    w.writeString(msg.reason_phrase);
+    w.writeVarInt(msg.track_alias);
+}
+function encodeSubscribeUpdatePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.start_group);
+    w.writeVarInt(msg.start_object);
+    w.writeVarInt(msg.end_group);
+    w.writeUint8(msg.subscriber_priority);
+    w.writeVarInt(msg.forward);
+    encodeParams(msg.parameters, w);
+}
+function encodeSubscribeDonePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.status_code);
+    w.writeVarInt(msg.stream_count);
+    w.writeString(msg.reason_phrase);
+}
+function encodeUnsubscribePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+}
+function encodeAnnouncePayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeTuple(msg.track_namespace);
+    encodeParams(msg.parameters, w);
+}
+function encodeAnnounceOkPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+}
+function encodeAnnounceErrorPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.error_code);
+    w.writeString(msg.reason_phrase);
+}
+function encodeUnannouncePayload(msg, w) {
+    w.writeTuple(msg.track_namespace);
+}
+function encodeAnnounceCancelPayload(msg, w) {
+    w.writeTuple(msg.track_namespace);
+    w.writeVarInt(msg.error_code);
+    w.writeString(msg.reason_phrase);
+}
+function encodeSubscribeAnnouncesPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeTuple(msg.track_namespace_prefix);
+    encodeParams(msg.parameters, w);
+}
+function encodeSubscribeAnnouncesOkPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+}
+function encodeSubscribeAnnouncesErrorPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.error_code);
+    w.writeString(msg.reason_phrase);
+}
+function encodeUnsubscribeAnnouncesPayload(msg, w) {
+    w.writeTuple(msg.track_namespace_prefix);
+}
+function encodeFetchPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeUint8(msg.subscriber_priority);
+    w.writeVarInt(msg.group_order);
+    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_subscribe_id);
+        w.writeVarInt(msg.joining.joining_start);
+    }
+    encodeParams(msg.parameters, w);
+}
+function encodeFetchOkPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.group_order);
+    w.writeVarInt(msg.end_of_track);
+    w.writeVarInt(msg.end_location.group);
+    w.writeVarInt(msg.end_location.object);
+    encodeParams(msg.parameters, w);
+}
+function encodeFetchErrorPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.error_code);
+    w.writeString(msg.reason_phrase);
+}
+function encodeFetchCancelPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+}
+function encodeTrackStatusRequestPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeTuple(msg.track_namespace);
+    w.writeString(msg.track_name);
+    encodeParams(msg.parameters, w);
+}
+function encodeTrackStatusPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+    w.writeVarInt(msg.status_code);
+    w.writeVarInt(msg.largest_location.group);
+    w.writeVarInt(msg.largest_location.object);
+    encodeParams(msg.parameters, w);
+}
+function encodeGoAwayPayload(msg, w) {
+    w.writeString(msg.new_session_uri);
+}
+function encodeMaxRequestIdPayload(msg, w) {
+    w.writeVarInt(msg.request_id);
+}
+function encodeRequestsBlockedPayload(msg, w) {
+    w.writeVarInt(msg.maximum_request_id);
+}
+// ─── Payload Decoders ──────────────────────────────────────────────────────────
+function decodeClientSetupPayload(r) {
+    const numVersions = Number(r.readVarInt());
+    if (numVersions === 0) {
+        throw new DecodeError("CONSTRAINT_VIOLATION", "supported_versions must not be empty", r.offset);
+    }
+    const supported_versions = [];
+    for (let i = 0; i < numVersions; i++)
+        supported_versions.push(r.readVarInt());
+    const parameters = decodeSetupParams(r);
+    return { type: "client_setup", supported_versions, parameters };
+}
+function decodeServerSetupPayload(r) {
+    const selected_version = r.readVarInt();
+    const parameters = decodeSetupParams(r);
+    return { type: "server_setup", selected_version, parameters };
+}
+function decodeSubscribePayload(r) {
+    const request_id = r.readVarInt();
+    const track_alias = r.readVarInt();
+    const track_namespace = r.readTuple();
+    const track_name = r.readString();
+    const subscriber_priority = r.readUint8();
+    const group_order = r.readVarInt();
+    const forward = r.readVarInt();
+    const filter_type = r.readVarInt();
+    const ft = Number(filter_type);
+    if (ft < 1 || ft > 4) {
+        throw new DecodeError("CONSTRAINT_VIOLATION", `Invalid filter_type: ${ft}`, r.offset);
+    }
+    let start_group;
+    let start_object;
+    let end_group;
+    if (ft === 3 || ft === 4) {
+        start_group = r.readVarInt();
+        start_object = r.readVarInt();
+    }
+    if (ft === 4) {
+        end_group = r.readVarInt();
+    }
+    const parameters = decodeParams(r);
+    const msg = {
+        type: "subscribe",
+        request_id,
+        track_alias,
+        track_namespace,
+        track_name,
+        subscriber_priority,
+        group_order,
+        forward,
+        filter_type,
+        parameters,
+    };
+    if (start_group !== undefined)
+        msg.start_group = start_group;
+    if (start_object !== undefined)
+        msg.start_object = start_object;
+    if (end_group !== undefined)
+        msg.end_group = end_group;
+    return msg;
+}
+function decodeSubscribeOkPayload(r) {
+    const request_id = r.readVarInt();
+    const expires = r.readVarInt();
+    const group_order = r.readVarInt();
+    const content_exists = r.readVarInt();
+    let largest_location;
+    if (content_exists === 1n) {
+        const group = r.readVarInt();
+        const object = r.readVarInt();
+        largest_location = { group, object };
+    }
+    const parameters = decodeParams(r);
+    const msg = {
+        type: "subscribe_ok",
+        request_id,
+        expires,
+        group_order,
+        content_exists,
+        parameters,
+    };
+    if (largest_location)
+        msg.largest_location = largest_location;
+    return msg;
+}
+function decodeSubscribeErrorPayload(r) {
+    const request_id = r.readVarInt();
+    const error_code = r.readVarInt();
+    const reason_phrase = r.readString();
+    const track_alias = r.readVarInt();
+    return { type: "subscribe_error", request_id, error_code, reason_phrase, track_alias };
+}
+function decodeSubscribeUpdatePayload(r) {
+    const request_id = r.readVarInt();
+    const start_group = r.readVarInt();
+    const start_object = r.readVarInt();
+    const end_group = r.readVarInt();
+    const subscriber_priority = r.readUint8();
+    const forward = r.readVarInt();
+    const parameters = decodeParams(r);
+    return {
+        type: "subscribe_update",
+        request_id,
+        start_group,
+        start_object,
+        end_group,
+        subscriber_priority,
+        forward,
+        parameters,
+    };
+}
+function decodeSubscribeDonePayload(r) {
+    const request_id = r.readVarInt();
+    const status_code = r.readVarInt();
+    const stream_count = r.readVarInt();
+    const reason_phrase = r.readString();
+    return { type: "subscribe_done", request_id, status_code, stream_count, reason_phrase };
+}
+function decodeUnsubscribePayload(r) {
+    const request_id = r.readVarInt();
+    return { type: "unsubscribe", request_id };
+}
+function decodeAnnouncePayload(r) {
+    const request_id = r.readVarInt();
+    const track_namespace = r.readTuple();
+    const parameters = decodeParams(r);
+    return { type: "announce", request_id, track_namespace, parameters };
+}
+function decodeAnnounceOkPayload(r) {
+    const request_id = r.readVarInt();
+    return { type: "announce_ok", request_id };
+}
+function decodeAnnounceErrorPayload(r) {
+    const request_id = r.readVarInt();
+    const error_code = r.readVarInt();
+    const reason_phrase = r.readString();
+    return { type: "announce_error", request_id, error_code, reason_phrase };
+}
+function decodeUnannouncePayload(r) {
+    const track_namespace = r.readTuple();
+    return { type: "unannounce", track_namespace };
+}
+function decodeAnnounceCancelPayload(r) {
+    const track_namespace = r.readTuple();
+    const error_code = r.readVarInt();
+    const reason_phrase = r.readString();
+    return { type: "announce_cancel", track_namespace, error_code, reason_phrase };
+}
+function decodeSubscribeAnnouncesPayload(r) {
+    const request_id = r.readVarInt();
+    const track_namespace_prefix = r.readTuple();
+    const parameters = decodeParams(r);
+    return { type: "subscribe_announces", request_id, track_namespace_prefix, parameters };
+}
+function decodeSubscribeAnnouncesOkPayload(r) {
+    const request_id = r.readVarInt();
+    return { type: "subscribe_announces_ok", request_id };
+}
+function decodeSubscribeAnnouncesErrorPayload(r) {
+    const request_id = r.readVarInt();
+    const error_code = r.readVarInt();
+    const reason_phrase = r.readString();
+    return { type: "subscribe_announces_error", request_id, error_code, reason_phrase };
+}
+function decodeUnsubscribeAnnouncesPayload(r) {
+    const track_namespace_prefix = r.readTuple();
+    return { type: "unsubscribe_announces", track_namespace_prefix };
+}
+function decodeFetchPayload(r) {
+    const request_id = r.readVarInt();
+    const subscriber_priority = r.readUint8();
+    const group_order = 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_subscribe_id = r.readVarInt();
+        const joining_start = r.readVarInt();
+        joining = { joining_subscribe_id, joining_start };
+    }
+    const parameters = decodeParams(r);
+    return {
+        type: "fetch",
+        request_id,
+        subscriber_priority,
+        group_order,
+        fetch_type,
+        standalone,
+        joining,
+        parameters,
+    };
+}
+function decodeFetchOkPayload(r) {
+    const request_id = r.readVarInt();
+    const group_order = r.readVarInt();
+    const end_of_track = r.readVarInt();
+    const group = r.readVarInt();
+    const object = r.readVarInt();
+    const parameters = decodeParams(r);
+    return {
+        type: "fetch_ok",
+        request_id,
+        group_order,
+        end_of_track,
+        end_location: { group, object },
+        parameters,
+    };
+}
+function decodeFetchErrorPayload(r) {
+    const request_id = r.readVarInt();
+    const error_code = r.readVarInt();
+    const reason_phrase = r.readString();
+    return { type: "fetch_error", request_id, error_code, reason_phrase };
+}
+function decodeFetchCancelPayload(r) {
+    const request_id = r.readVarInt();
+    return { type: "fetch_cancel", request_id };
+}
+function decodeTrackStatusRequestPayload(r) {
+    const request_id = r.readVarInt();
+    const track_namespace = r.readTuple();
+    const track_name = r.readString();
+    const parameters = decodeParams(r);
+    return { type: "track_status_request", request_id, track_namespace, track_name, parameters };
+}
+function decodeTrackStatusPayload(r) {
+    const request_id = r.readVarInt();
+    const status_code = r.readVarInt();
+    const group = r.readVarInt();
+    const object = r.readVarInt();
+    const parameters = decodeParams(r);
+    return {
+        type: "track_status",
+        request_id,
+        status_code,
+        largest_location: { group, object },
+        parameters,
+    };
+}
+function decodeGoAwayPayload(r) {
+    const new_session_uri = r.readString();
+    return { type: "goaway", new_session_uri };
+}
+function decodeMaxRequestIdPayload(r) {
+    const request_id = r.readVarInt();
+    return { type: "max_request_id", request_id };
+}
+function decodeRequestsBlockedPayload(r) {
+    const maximum_request_id = r.readVarInt();
+    return { type: "requests_blocked", maximum_request_id };
+}
+// ─── Payload dispatch tables ───────────────────────────────────────────────────
+const payloadDecoders = new Map([
+    [MSG_CLIENT_SETUP, decodeClientSetupPayload],
+    [MSG_SERVER_SETUP, decodeServerSetupPayload],
+    [MSG_SUBSCRIBE, decodeSubscribePayload],
+    [MSG_SUBSCRIBE_OK, decodeSubscribeOkPayload],
+    [MSG_SUBSCRIBE_ERROR, decodeSubscribeErrorPayload],
+    [MSG_SUBSCRIBE_UPDATE, decodeSubscribeUpdatePayload],
+    [MSG_SUBSCRIBE_DONE, decodeSubscribeDonePayload],
+    [MSG_UNSUBSCRIBE, decodeUnsubscribePayload],
+    [MSG_ANNOUNCE, decodeAnnouncePayload],
+    [MSG_ANNOUNCE_OK, decodeAnnounceOkPayload],
+    [MSG_ANNOUNCE_ERROR, decodeAnnounceErrorPayload],
+    [MSG_UNANNOUNCE, decodeUnannouncePayload],
+    [MSG_ANNOUNCE_CANCEL, decodeAnnounceCancelPayload],
+    [MSG_SUBSCRIBE_ANNOUNCES, decodeSubscribeAnnouncesPayload],
+    [MSG_SUBSCRIBE_ANNOUNCES_OK, decodeSubscribeAnnouncesOkPayload],
+    [MSG_SUBSCRIBE_ANNOUNCES_ERROR, decodeSubscribeAnnouncesErrorPayload],
+    [MSG_UNSUBSCRIBE_ANNOUNCES, decodeUnsubscribeAnnouncesPayload],
+    [MSG_FETCH, decodeFetchPayload],
+    [MSG_FETCH_OK, decodeFetchOkPayload],
+    [MSG_FETCH_ERROR, decodeFetchErrorPayload],
+    [MSG_FETCH_CANCEL, decodeFetchCancelPayload],
+    [MSG_TRACK_STATUS_REQUEST, decodeTrackStatusRequestPayload],
+    [MSG_TRACK_STATUS, decodeTrackStatusPayload],
+    [MSG_GOAWAY, decodeGoAwayPayload],
+    [MSG_MAX_REQUEST_ID, decodeMaxRequestIdPayload],
+    [MSG_REQUESTS_BLOCKED, decodeRequestsBlockedPayload],
+]);
+// ─── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Encode a draft-11 control message with type(varint) + length(varint) + 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();
+    // Draft-11 uses varint framing (not uint16 BE like draft-14/15)
+    const writer = new BufferWriter();
+    writer.writeVarInt(typeId);
+    writer.writeVarInt(payload.byteLength);
+    writer.writeBytes(payload);
+    return writer.finish();
+}
+function encodePayload(msg, w) {
+    switch (msg.type) {
+        case "client_setup":
+            return encodeClientSetupPayload(msg, w);
+        case "server_setup":
+            return encodeServerSetupPayload(msg, w);
+        case "subscribe":
+            return encodeSubscribePayload(msg, w);
+        case "subscribe_ok":
+            return encodeSubscribeOkPayload(msg, w);
+        case "subscribe_error":
+            return encodeSubscribeErrorPayload(msg, w);
+        case "subscribe_update":
+            return encodeSubscribeUpdatePayload(msg, w);
+        case "subscribe_done":
+            return encodeSubscribeDonePayload(msg, w);
+        case "unsubscribe":
+            return encodeUnsubscribePayload(msg, w);
+        case "announce":
+            return encodeAnnouncePayload(msg, w);
+        case "announce_ok":
+            return encodeAnnounceOkPayload(msg, w);
+        case "announce_error":
+            return encodeAnnounceErrorPayload(msg, w);
+        case "unannounce":
+            return encodeUnannouncePayload(msg, w);
+        case "announce_cancel":
+            return encodeAnnounceCancelPayload(msg, w);
+        case "subscribe_announces":
+            return encodeSubscribeAnnouncesPayload(msg, w);
+        case "subscribe_announces_ok":
+            return encodeSubscribeAnnouncesOkPayload(msg, w);
+        case "subscribe_announces_error":
+            return encodeSubscribeAnnouncesErrorPayload(msg, w);
+        case "unsubscribe_announces":
+            return encodeUnsubscribeAnnouncesPayload(msg, w);
+        case "fetch":
+            return encodeFetchPayload(msg, w);
+        case "fetch_ok":
+            return encodeFetchOkPayload(msg, w);
+        case "fetch_error":
+            return encodeFetchErrorPayload(msg, w);
+        case "fetch_cancel":
+            return encodeFetchCancelPayload(msg, w);
+        case "track_status_request":
+            return encodeTrackStatusRequestPayload(msg, w);
+        case "track_status":
+            return encodeTrackStatusPayload(msg, w);
+        case "goaway":
+            return encodeGoAwayPayload(msg, w);
+        case "max_request_id":
+            return encodeMaxRequestIdPayload(msg, w);
+        case "requests_blocked":
+            return encodeRequestsBlockedPayload(msg, w);
+        default: {
+            const _exhaustive = msg;
+            throw new Error(`Unhandled message type: ${_exhaustive.type}`);
+        }
+    }
+}
+/**
+ * Decode a draft-11 control message from bytes (type + varint length + payload).
+ */
+export function decodeMessage(bytes) {
+    try {
+        const reader = new BufferReader(bytes);
+        const typeId = reader.readVarInt();
+        const payloadLength = Number(reader.readVarInt());
+        const payloadBytes = reader.readBytes(payloadLength);
+        const payloadReader = new BufferReader(payloadBytes);
+        const decoder = payloadDecoders.get(typeId);
+        if (!decoder) {
+            return {
+                ok: false,
+                error: new DecodeError("UNKNOWN_MESSAGE_TYPE", `Unknown message type ID: 0x${typeId.toString(16)}`, 0),
+            };
+        }
+        const message = decoder(payloadReader);
+        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 ─────────────────────────────────────────────
+export { encodeSubgroupStream, encodeDatagram, encodeFetchStream, decodeSubgroupStream, decodeDatagram, decodeFetchStream, decodeDataStream } from "./data-streams.js";
+import { encodeSubgroupStream, encodeDatagram, encodeFetchStream, decodeSubgroupStream, decodeDatagram, decodeFetchStream, decodeDataStream } from "./data-streams.js";
+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 data", 0));
+        },
+    });
+}
+export function createDraft11Codec() {
+    return {
+        draft: "draft-ietf-moq-transport-11",
+        encodeMessage,
+        decodeMessage,
+        encodeSubgroupStream,
+        encodeDatagram,
+        encodeFetchStream,
+        decodeSubgroupStream,
+        decodeDatagram,
+        decodeFetchStream,
+        decodeDataStream,
+        createStreamDecoder,
+    };
+}
+//# sourceMappingURL=codec.js.map