@moqtap/codec 0.8.0 → 0.9.0

package/dist/draft20-session.d.ts

@@ -0,0 +1,195 @@
+import { g as SessionPhase, j as SubscriptionState, b as AnnounceState, f as PublishState, c as FetchState, V as ValidationResult, T as TransitionResult, h as SideEffect } from './session-types-Dn7b3RZM.js';
+export { P as ProtocolViolation } from './session-types-Dn7b3RZM.js';
+import { a as Draft20MessageType, D as Draft20Message } from './types-CWCQwuvy.js';
+import './types-DG5_iKuv.js';
+
+/**
+ * What kind of request a bidirectional request stream carries.
+ *
+ * draft-20 keeps the draft-17 shape where a response is tied to its request by
+ * the stream it arrives on rather than by a Request ID field. Several draft-20
+ * rules are stated per request *kind* — most sharply
+ * "PUBLISH_STATE_NOTIFY applies only to subscriptions ... An endpoint that
+ * receives a PUBLISH_STATE_NOTIFY for any other request type ... MUST close
+ * the session with a PROTOCOL_VIOLATION" (Section 10.10) — so the FSM has to
+ * know which stream a message arrived on to enforce them. That is what
+ * {@link Draft20SessionFSM.receiveOn} and {@link Draft20SessionFSM.sendOn} are
+ * for.
+ */
+type RequestKind = 'subscription' | 'fetch' | 'track_status' | 'publish_namespace' | 'subscribe_namespace' | 'subscribe_tracks';
+/** Whether the local endpoint or the peer is the publisher on a request stream. */
+type PublisherSide = 'local' | 'remote';
+type FillFetchStreamPhase = 'open' | 'complete' | 'reset' | 'cancelled';
+/**
+ * One fill fetch stream — draft-20 Section 5.1.3, new in draft-20.
+ *
+ * A unidirectional stream that begins with FETCH_HEADER and is delivered
+ * exactly as a FETCH response, opened because a SUBSCRIBE or REQUEST_UPDATE
+ * carried FILL_PARAMETERS. It is NOT a FETCH: there is no FETCH request, no
+ * FETCH_OK and no REQUEST_ERROR for it, so it never appears in
+ * {@link Draft20SessionFSM.fetches}.
+ */
+interface FillFetchStreamState {
+    /**
+     * The Request ID of the message that opened it — the SUBSCRIBE's for the
+     * initial fill, the REQUEST_UPDATE's for a later one (Section 5.1.3). This
+     * is what the stream's FETCH_HEADER carries, and it is how a subscription's
+     * concurrent fills are told apart.
+     */
+    readonly requestId: bigint;
+    /** The Request ID of the subscription the fill belongs to. */
+    readonly subscribeId: bigint;
+    readonly phase: FillFetchStreamPhase;
+}
+declare class Draft20SessionFSM {
+    private _phase;
+    private _role;
+    private _setupDirection;
+    private _subscriptions;
+    private _subscriptionMeta;
+    private _publishes;
+    private _fetches;
+    private _requests;
+    private _requestIds;
+    private _pendingSubscribes;
+    private _pendingPublishes;
+    private _pendingFetches;
+    /**
+     * The peer's MAX_REQUEST_UPDATES (Setup Option 0x08), learned from its SETUP.
+     * 0 means the peer does not limit REQUEST_UPDATE concurrency, and 0 is also
+     * the default when the option is absent.
+     */
+    private _peerMaxRequestUpdates;
+    /** The local endpoint's own advertised MAX_REQUEST_UPDATES. */
+    private _localMaxRequestUpdates;
+    constructor(role: 'client' | 'server');
+    get phase(): SessionPhase;
+    get role(): 'client' | 'server';
+    get subscriptions(): ReadonlyMap<bigint, SubscriptionState>;
+    get announces(): ReadonlyMap<string, AnnounceState>;
+    get publishes(): ReadonlyMap<bigint, PublishState>;
+    get fetches(): ReadonlyMap<bigint, FetchState>;
+    get legalOutgoing(): ReadonlySet<Draft20MessageType>;
+    get legalIncoming(): ReadonlySet<Draft20MessageType>;
+    /**
+     * Every fill fetch stream currently tracked, across all subscriptions, keyed
+     * by the Request ID that opened it.
+     *
+     * Fill fetch streams are unidirectional and carry no control messages, so
+     * nothing here is inferred from a message alone; the transport events that
+     * end one are reported with {@link closeFillFetchStream}.
+     */
+    get fillFetchStreams(): ReadonlyMap<bigint, FillFetchStreamState>;
+    /** The fill fetch streams belonging to one subscription. */
+    fillFetchStreamsFor(subscribeId: bigint): ReadonlyMap<bigint, FillFetchStreamState>;
+    /** A subscription's current Forward State, or undefined if it is unknown here. */
+    forwardStateOf(subscribeId: bigint): 0 | 1 | undefined;
+    /** What kind of request a Request ID names, or undefined if it names none. */
+    requestKindOf(requestId: bigint): RequestKind | undefined;
+    private checkDuplicateRequestId;
+    validateOutgoing(message: Draft20Message): ValidationResult<Draft20MessageType>;
+    receive(message: Draft20Message): TransitionResult<Draft20MessageType>;
+    send(message: Draft20Message): TransitionResult<Draft20MessageType>;
+    /**
+     * Receive a message that arrived on a known request stream.
+     *
+     * Prefer this over {@link receive} for anything that carries no Request ID of
+     * its own — SUBSCRIBE_OK, REQUEST_OK, REQUEST_ERROR, PUBLISH_DONE, FETCH_OK
+     * and PUBLISH_STATE_NOTIFY. Without the stream, the request-kind and
+     * direction rules of Section 10.10 cannot be checked at all, and the
+     * response-matching below falls back to FIFO guessing.
+     */
+    receiveOn(requestId: bigint, message: Draft20Message): TransitionResult<Draft20MessageType>;
+    /** Send a message on a known request stream. See {@link receiveOn}. */
+    sendOn(requestId: bigint, message: Draft20Message): TransitionResult<Draft20MessageType>;
+    private applyTransition;
+    private handleSetup;
+    private handleGoAway;
+    private requireReady;
+    private handleSubscribe;
+    /**
+     * Open a fill fetch stream if this message asked for one — draft-20 Sections
+     * 5.1.3 and 5.1.3.1, both new in draft-20.
+     *
+     * Three rules, all of which the draft states as bullets and all of which are
+     * easy to get wrong by analogy with draft-19's Joining FETCH:
+     *
+     *  1. Presence of FILL_PARAMETERS is the request. There is no separate
+     *     message and no Fetch Type; an empty FILL_PARAMETERS still opens a
+     *     stream, with every setting inherited from the subscription.
+     *  2. It only opens one "while Forward State is 1". FILL_PARAMETERS carried
+     *     while Forward State is 0 opens nothing, and later transitioning to
+     *     Forward State 1 without re-sending FILL_PARAMETERS opens nothing
+     *     either — so this is checked at the moment the message is processed and
+     *     never retried.
+     *  3. Streams accumulate. The new one is keyed by the opening message's
+     *     Request ID and does not disturb any stream already open on the same
+     *     subscription.
+     *
+     * The opened stream has no FETCH_OK: per DECISIONS.md D7 (SPEC-DELTA Section
+     * 11 Q9) there is no End Location and no End Of Track for a fill, and stream
+     * FIN is the only completion signal. Nothing here synthesizes one, and the
+     * stream is deliberately absent from {@link fetches}.
+     */
+    private applyFillParameters;
+    /**
+     * Report the transport event that ended a fill fetch stream.
+     *
+     * A fill fetch stream carries no control message of its own, so its end is
+     * never inferable from the message sequence:
+     *
+     *  - `'complete'` — the publisher FINed the stream. Section 5.1.3.1 makes
+     *    that the ONLY completion signal; there is no FETCH_OK to read an End
+     *    Location or an End Of Track flag from (DECISIONS.md D7 / Q9).
+     *  - `'reset'` — the publisher reset it, which is how a fill failure is
+     *    signalled, "because there is no REQUEST_ERROR associated with a fill
+     *    fetch stream".
+     *  - `'cancelled'` — the subscriber sent STOP_SENDING.
+     *
+     * Either way "Resetting or cancelling a fill fetch stream, by either
+     * endpoint, does not affect the subscription, which continues to deliver
+     * objects using subscribe subgroups and datagrams", so the subscription's
+     * own state is untouched here.
+     */
+    closeFillFetchStream(requestId: bigint, phase: Exclude<FillFetchStreamPhase, 'open'>): SideEffect[];
+    private handleSubscribeOk;
+    private handleRequestUpdate;
+    /**
+     * PUBLISH_STATE_NOTIFY — draft-20 Section 10.10, new in draft-20.
+     *
+     * Three properties set it apart from every other control message, and all
+     * three are enforced here:
+     *
+     *  - **Unilateral.** "The receiver does not respond with REQUEST_OK or
+     *    REQUEST_ERROR", so nothing is queued as pending and nothing is
+     *    dequeued. A REQUEST_OK arriving later belongs to some other request.
+     *  - **Not rate-limited.** "The message is not subject to the
+     *    MAX_REQUEST_UPDATES limit", so `outstandingUpdates` is deliberately not
+     *    touched — that counter exists only for REQUEST_UPDATE.
+     *  - **Publisher to subscriber, subscriptions only.** "An endpoint that
+     *    receives a PUBLISH_STATE_NOTIFY for any other request type, or from the
+     *    subscriber, MUST close the session with a PROTOCOL_VIOLATION."
+     *
+     * The last one needs the request stream, because the message has no Request
+     * ID field. Called through {@link receive}/{@link send} without one, the
+     * kind and direction rules cannot be evaluated and the message is allowed
+     * through unchecked rather than guessed at.
+     */
+    private handlePublishStateNotify;
+    private handlePublish;
+    private handlePublishDone;
+    private handleFetch;
+    private handleFetchOk;
+    private handleRequestError;
+    private handleRequestOk;
+    private handleGenericRequest;
+    private restoreUpdateCredit;
+    private dropPending;
+    private dequeuePending;
+    private handleReadyPhaseMessage;
+    reset(): void;
+}
+
+declare function createDraft20SessionState(role: 'client' | 'server'): Draft20SessionFSM;
+
+export { Draft20SessionFSM, type FillFetchStreamPhase, type FillFetchStreamState, type PublisherSide, type RequestKind, SessionPhase, SideEffect, TransitionResult, ValidationResult, createDraft20SessionState };

package/dist/draft20-session.js

@@ -0,0 +1,8 @@
+import {
+  Draft20SessionFSM,
+  createDraft20SessionState
+} from "./chunk-WX5PU7HF.js";
+export {
+  Draft20SessionFSM,
+  createDraft20SessionState
+};

package/dist/draft20.cjs

@@ -0,0 +1,217 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkMAXEHYVBcjs = require('./chunk-MAXEHYVB.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkBMJMY6FXcjs = require('./chunk-BMJMY6FX.cjs');
+require('./chunk-4XLYCT5Q.cjs');
+
+// src/drafts/draft20/error-codes.ts
+var SessionTerminationCode = {
+  NoError: 0x0n,
+  InternalError: 0x1n,
+  Unauthorized: 0x2n,
+  ProtocolViolation: 0x3n,
+  InvalidRequestId: 0x4n,
+  DuplicateTrackAlias: 0x5n,
+  KeyValueFormattingError: 0x6n,
+  InvalidPath: 0x8n,
+  MalformedPath: 0x9n,
+  GoawayTimeout: 0x10n,
+  ControlMessageTimeout: 0x11n,
+  DataStreamTimeout: 0x12n,
+  AuthTokenCacheOverflow: 0x13n,
+  DuplicateAuthTokenAlias: 0x14n,
+  // 0x15 VERSION_NEGOTIATION_FAILED — REMOVED in draft-20. Version negotiation
+  // moved to ALPN / WT-Available-Protocols in draft-15, so there is no longer a
+  // SETUP-time negotiation that can fail. See RETIRED_SESSION_TERMINATION_CODES.
+  MalformedAuthToken: 0x16n,
+  UnknownAuthTokenAlias: 0x17n,
+  ExpiredAuthToken: 0x18n,
+  InvalidAuthority: 0x19n,
+  MalformedAuthority: 0x1an,
+  TooManyRequestUpdates: 0x1bn
+};
+var RequestErrorCode = {
+  InternalError: 0x0n,
+  Unauthorized: 0x1n,
+  Timeout: 0x2n,
+  NotSupported: 0x3n,
+  MalformedAuthToken: 0x4n,
+  ExpiredAuthToken: 0x5n,
+  GoingAway: 0x6n,
+  ExcessiveLoad: 0x9n,
+  DoesNotExist: 0x10n,
+  InvalidRange: 0x11n,
+  MalformedTrack: 0x12n,
+  Uninterested: 0x20n,
+  PrefixOverlap: 0x30n,
+  NamespaceTooLarge: 0x31n,
+  // 0x32 INVALID_JOINING_REQUEST_ID — REMOVED in draft-20 along with the whole
+  // joining-fetch mechanism (draft-19 Section 10.12.2). A draft-20 FETCH names
+  // its own track inline and never references another request, so there is no
+  // joining Request ID left to be invalid. See RETIRED_REQUEST_ERROR_CODES.
+  UnsupportedExtension: 0x33n,
+  Redirect: 0x34n,
+  ConflictingFilters: 0x35n,
+  InvalidFilter: 0x36n
+};
+var PublishDoneCode = {
+  InternalError: 0x0n,
+  Unauthorized: 0x1n,
+  TrackEnded: 0x2n,
+  // 0x3 SUBSCRIPTION_ENDED — REMOVED in draft-20. The behaviour went with it:
+  // Section 5.1.2 now says "A publisher does not end a subscription solely
+  // because the Largest Object advances past the end of the current Location
+  // Filter", which is the only thing this code used to report.
+  // See RETIRED_PUBLISH_DONE_CODES.
+  GoingAway: 0x4n,
+  TooFarBehind: 0x5n,
+  Expired: 0x6n,
+  UpdateFailed: 0x8n,
+  ExcessiveLoad: 0x9n,
+  MalformedTrack: 0x12n
+};
+var DataStreamResetCode = {
+  InternalError: 0x0n,
+  Cancelled: 0x1n,
+  DeliveryTimeout: 0x2n,
+  SessionClosed: 0x3n,
+  GoingAway: 0x4n,
+  TooFarBehind: 0x5n,
+  UnknownObjectStatus: 0x6n,
+  ExpiredAuthToken: 0x7n,
+  ExcessiveLoad: 0x9n,
+  MalformedTrack: 0x12n
+};
+var RETIRED_SESSION_TERMINATION_CODES = /* @__PURE__ */ new Set([
+  0x15n
+  // VERSION_NEGOTIATION_FAILED (draft-19 Section 3.5)
+]);
+var RETIRED_REQUEST_ERROR_CODES = /* @__PURE__ */ new Set([
+  0x32n
+  // INVALID_JOINING_REQUEST_ID (draft-19 Section 10.6.2)
+]);
+var RETIRED_PUBLISH_DONE_CODES = /* @__PURE__ */ new Set([
+  0x3n
+  // SUBSCRIPTION_ENDED (draft-19 Section 10.11)
+]);
+
+// src/drafts/draft20/index.ts
+var PROTOCOL_STRING = "moqt-20";
+var DRAFT_VERSION = 0xff000014n;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BIDIRECTIONAL_MESSAGES = _chunkBMJMY6FXcjs.BIDIRECTIONAL_MESSAGES; exports.CLIENT_ONLY_MESSAGES = _chunkBMJMY6FXcjs.CLIENT_ONLY_MESSAGES; exports.CONTROL_MESSAGES = _chunkBMJMY6FXcjs.CONTROL_MESSAGES; exports.DRAFT_VERSION = DRAFT_VERSION; exports.DataStreamResetCode = DataStreamResetCode; exports.Draft20SessionFSM = _chunkBMJMY6FXcjs.Draft20SessionFSM; exports.MESSAGE_ID_MAP = _chunkMAXEHYVBcjs.MESSAGE_ID_MAP; exports.MESSAGE_TYPE_MAP = _chunkMAXEHYVBcjs.MESSAGE_TYPE_MAP; exports.MSG_FETCH = _chunkMAXEHYVBcjs.MSG_FETCH; exports.MSG_FETCH_OK = _chunkMAXEHYVBcjs.MSG_FETCH_OK; exports.MSG_GOAWAY = _chunkMAXEHYVBcjs.MSG_GOAWAY; exports.MSG_NAMESPACE = _chunkMAXEHYVBcjs.MSG_NAMESPACE; exports.MSG_NAMESPACE_DONE = _chunkMAXEHYVBcjs.MSG_NAMESPACE_DONE; exports.MSG_PUBLISH = _chunkMAXEHYVBcjs.MSG_PUBLISH; exports.MSG_PUBLISH_DONE = _chunkMAXEHYVBcjs.MSG_PUBLISH_DONE; exports.MSG_PUBLISH_NAMESPACE = _chunkMAXEHYVBcjs.MSG_PUBLISH_NAMESPACE; exports.MSG_PUBLISH_OK = _chunkMAXEHYVBcjs.MSG_PUBLISH_OK; exports.MSG_PUBLISH_SKIPPED = _chunkMAXEHYVBcjs.MSG_PUBLISH_SKIPPED; exports.MSG_PUBLISH_STATE_NOTIFY = _chunkMAXEHYVBcjs.MSG_PUBLISH_STATE_NOTIFY; exports.MSG_REQUEST_ERROR = _chunkMAXEHYVBcjs.MSG_REQUEST_ERROR; exports.MSG_REQUEST_OK = _chunkMAXEHYVBcjs.MSG_REQUEST_OK; exports.MSG_REQUEST_UPDATE = _chunkMAXEHYVBcjs.MSG_REQUEST_UPDATE; exports.MSG_SETUP = _chunkMAXEHYVBcjs.MSG_SETUP; exports.MSG_SUBSCRIBE = _chunkMAXEHYVBcjs.MSG_SUBSCRIBE; exports.MSG_SUBSCRIBE_NAMESPACE = _chunkMAXEHYVBcjs.MSG_SUBSCRIBE_NAMESPACE; exports.MSG_SUBSCRIBE_OK = _chunkMAXEHYVBcjs.MSG_SUBSCRIBE_OK; exports.MSG_SUBSCRIBE_TRACKS = _chunkMAXEHYVBcjs.MSG_SUBSCRIBE_TRACKS; exports.MSG_TRACK_STATUS = _chunkMAXEHYVBcjs.MSG_TRACK_STATUS; exports.PROTOCOL_STRING = PROTOCOL_STRING; exports.PublishDoneCode = PublishDoneCode; exports.REQUEST_STREAM_OPENERS = _chunkBMJMY6FXcjs.REQUEST_STREAM_OPENERS; exports.RETIRED_PUBLISH_DONE_CODES = RETIRED_PUBLISH_DONE_CODES; exports.RETIRED_REQUEST_ERROR_CODES = RETIRED_REQUEST_ERROR_CODES; exports.RETIRED_SESSION_TERMINATION_CODES = RETIRED_SESSION_TERMINATION_CODES; exports.RequestErrorCode = RequestErrorCode; exports.SERVER_ONLY_MESSAGES = _chunkBMJMY6FXcjs.SERVER_ONLY_MESSAGES; exports.SETUP_OPT_AUTHORITY = _chunkMAXEHYVBcjs.SETUP_OPT_AUTHORITY; exports.SETUP_OPT_AUTHORIZATION_TOKEN = _chunkMAXEHYVBcjs.SETUP_OPT_AUTHORIZATION_TOKEN; exports.SETUP_OPT_MAX_AUTH_TOKEN_CACHE_SIZE = _chunkMAXEHYVBcjs.SETUP_OPT_MAX_AUTH_TOKEN_CACHE_SIZE; exports.SETUP_OPT_MAX_FILTER_RANGES = _chunkMAXEHYVBcjs.SETUP_OPT_MAX_FILTER_RANGES; exports.SETUP_OPT_MAX_REQUEST_UPDATES = _chunkMAXEHYVBcjs.SETUP_OPT_MAX_REQUEST_UPDATES; exports.SETUP_OPT_MOQT_IMPLEMENTATION = _chunkMAXEHYVBcjs.SETUP_OPT_MOQT_IMPLEMENTATION; exports.SETUP_OPT_PATH = _chunkMAXEHYVBcjs.SETUP_OPT_PATH; exports.SessionTerminationCode = SessionTerminationCode; exports.UNKNOWN_STREAM_COUNT = _chunkMAXEHYVBcjs.UNKNOWN_STREAM_COUNT; exports.createDataStreamDecoder = _chunkMAXEHYVBcjs.createDataStreamDecoder; exports.createDraft20Codec = _chunkMAXEHYVBcjs.createDraft20Codec; exports.createDraft20SessionState = _chunkBMJMY6FXcjs.createDraft20SessionState; exports.createFetchStreamDecoder = _chunkMAXEHYVBcjs.createFetchStreamDecoder; exports.createStreamDecoder = _chunkMAXEHYVBcjs.createStreamDecoder; exports.createSubgroupStreamDecoder = _chunkMAXEHYVBcjs.createSubgroupStreamDecoder; exports.decodeDataStream = _chunkMAXEHYVBcjs.decodeDataStream; exports.decodeDatagram = _chunkMAXEHYVBcjs.decodeDatagram; exports.decodeFetchStream = _chunkMAXEHYVBcjs.decodeFetchStream; exports.decodeMessage = _chunkMAXEHYVBcjs.decodeMessage; exports.decodeSubgroupStream = _chunkMAXEHYVBcjs.decodeSubgroupStream; exports.encodeDatagram = _chunkMAXEHYVBcjs.encodeDatagram; exports.encodeFetchStream = _chunkMAXEHYVBcjs.encodeFetchStream; exports.encodeMessage = _chunkMAXEHYVBcjs.encodeMessage; exports.encodeSubgroupStream = _chunkMAXEHYVBcjs.encodeSubgroupStream; exports.getLegalIncoming = _chunkBMJMY6FXcjs.getLegalIncoming; exports.getLegalOutgoing = _chunkBMJMY6FXcjs.getLegalOutgoing;

package/dist/draft20.d.cts

@@ -0,0 +1,175 @@
+export { D as Draft20Codec, U as UNKNOWN_STREAM_COUNT, c as createDraft20Codec, a as createStreamDecoder, d as decodeMessage, e as encodeMessage } from './codec-Bym-K2q2.cjs';
+import { b as DataStreamEvent, F as FetchStreamHeader, O as ObjectPayload, S as SubgroupStreamHeader, c as Draft20DataStream, d as DatagramObject, e as FetchStream, f as SubgroupStream, a as Draft20MessageType } from './types-CWCQwuvy.cjs';
+export { g as DataStreamHeader, h as Draft20BaseMessage, i as Draft20Fetch, j as Draft20FetchOk, k as Draft20FillParameters, l as Draft20GoAway, D as Draft20Message, m as Draft20Namespace, n as Draft20NamespaceDone, o as Draft20Params, p as Draft20Publish, q as Draft20PublishDone, r as Draft20PublishNamespace, s as Draft20PublishSkipped, t as Draft20PublishStateNotify, u as Draft20RequestError, v as Draft20RequestOk, w as Draft20RequestUpdate, x as Draft20Setup, y as Draft20SetupOptions, z as Draft20Subscribe, A as Draft20SubscribeNamespace, B as Draft20SubscribeOk, C as Draft20SubscribeTracks, E as Draft20TrackProperties, G as Draft20TrackStatus, H as FetchObjectPayload, L as LargestObject, I as LocationFilter, R as RangeFilter, J as RangeFilterRange, K as Redirect, U as UnknownParam } from './types-CWCQwuvy.cjs';
+export { Draft20SessionFSM, FillFetchStreamPhase, FillFetchStreamState, PublisherSide, RequestKind, createDraft20SessionState } from './draft20-session.cjs';
+export { P as ProtocolViolation, g as SessionPhase, h as SideEffect, T as TransitionResult, V as ValidationResult } from './session-types-B9idsih-.cjs';
+import { b as DecodeResult } from './types-DG5_iKuv.cjs';
+
+declare function encodeSubgroupStream(stream: SubgroupStream): Uint8Array;
+declare function encodeDatagram(dg: DatagramObject): Uint8Array;
+declare function encodeFetchStream(stream: FetchStream): Uint8Array;
+declare function decodeSubgroupStream(bytes: Uint8Array): DecodeResult<SubgroupStream>;
+declare function decodeDatagram(bytes: Uint8Array): DecodeResult<DatagramObject>;
+declare function decodeFetchStream(bytes: Uint8Array): DecodeResult<FetchStream>;
+declare function decodeDataStream(streamType: 'subgroup' | 'datagram' | 'fetch', bytes: Uint8Array): DecodeResult<Draft20DataStream>;
+declare function createSubgroupStreamDecoder(): TransformStream<Uint8Array, SubgroupStreamHeader | ObjectPayload>;
+declare function createFetchStreamDecoder(): TransformStream<Uint8Array, FetchStreamHeader | ObjectPayload>;
+declare function createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
+
+/** draft-20 Section 15.11.1, Table 18 (prose Section 3.5). */
+declare const SessionTerminationCode: {
+    readonly NoError: 0n;
+    readonly InternalError: 1n;
+    readonly Unauthorized: 2n;
+    readonly ProtocolViolation: 3n;
+    readonly InvalidRequestId: 4n;
+    readonly DuplicateTrackAlias: 5n;
+    readonly KeyValueFormattingError: 6n;
+    readonly InvalidPath: 8n;
+    readonly MalformedPath: 9n;
+    readonly GoawayTimeout: 16n;
+    readonly ControlMessageTimeout: 17n;
+    readonly DataStreamTimeout: 18n;
+    readonly AuthTokenCacheOverflow: 19n;
+    readonly DuplicateAuthTokenAlias: 20n;
+    readonly MalformedAuthToken: 22n;
+    readonly UnknownAuthTokenAlias: 23n;
+    readonly ExpiredAuthToken: 24n;
+    readonly InvalidAuthority: 25n;
+    readonly MalformedAuthority: 26n;
+    readonly TooManyRequestUpdates: 27n;
+};
+type SessionTerminationCodeValue = (typeof SessionTerminationCode)[keyof typeof SessionTerminationCode];
+/** draft-20 Section 15.11.2, Table 19 (prose Section 10.6.2). */
+declare const RequestErrorCode: {
+    readonly InternalError: 0n;
+    readonly Unauthorized: 1n;
+    readonly Timeout: 2n;
+    readonly NotSupported: 3n;
+    readonly MalformedAuthToken: 4n;
+    readonly ExpiredAuthToken: 5n;
+    readonly GoingAway: 6n;
+    readonly ExcessiveLoad: 9n;
+    readonly DoesNotExist: 16n;
+    readonly InvalidRange: 17n;
+    readonly MalformedTrack: 18n;
+    readonly Uninterested: 32n;
+    readonly PrefixOverlap: 48n;
+    readonly NamespaceTooLarge: 49n;
+    readonly UnsupportedExtension: 51n;
+    readonly Redirect: 52n;
+    readonly ConflictingFilters: 53n;
+    readonly InvalidFilter: 54n;
+};
+type RequestErrorCodeValue = (typeof RequestErrorCode)[keyof typeof RequestErrorCode];
+/** draft-20 Section 15.11.3, Table 20 (prose Section 10.12). */
+declare const PublishDoneCode: {
+    readonly InternalError: 0n;
+    readonly Unauthorized: 1n;
+    readonly TrackEnded: 2n;
+    readonly GoingAway: 4n;
+    readonly TooFarBehind: 5n;
+    readonly Expired: 6n;
+    readonly UpdateFailed: 8n;
+    readonly ExcessiveLoad: 9n;
+    readonly MalformedTrack: 18n;
+};
+type PublishDoneCodeValue = (typeof PublishDoneCode)[keyof typeof PublishDoneCode];
+/** draft-20 Section 15.11.4, Table 21 (prose Section 3.3.4) — unchanged from draft-19. */
+declare const DataStreamResetCode: {
+    readonly InternalError: 0n;
+    readonly Cancelled: 1n;
+    readonly DeliveryTimeout: 2n;
+    readonly SessionClosed: 3n;
+    readonly GoingAway: 4n;
+    readonly TooFarBehind: 5n;
+    readonly UnknownObjectStatus: 6n;
+    readonly ExpiredAuthToken: 7n;
+    readonly ExcessiveLoad: 9n;
+    readonly MalformedTrack: 18n;
+};
+type DataStreamResetCodeValue = (typeof DataStreamResetCode)[keyof typeof DataStreamResetCode];
+declare const RETIRED_SESSION_TERMINATION_CODES: ReadonlySet<bigint>;
+declare const RETIRED_REQUEST_ERROR_CODES: ReadonlySet<bigint>;
+declare const RETIRED_PUBLISH_DONE_CODES: ReadonlySet<bigint>;
+
+declare const MSG_REQUEST_UPDATE = 2n;
+declare const MSG_SUBSCRIBE = 3n;
+declare const MSG_SUBSCRIBE_OK = 4n;
+declare const MSG_REQUEST_ERROR = 5n;
+declare const MSG_PUBLISH_NAMESPACE = 6n;
+declare const MSG_REQUEST_OK = 7n;
+declare const MSG_NAMESPACE = 8n;
+declare const MSG_PUBLISH_DONE = 11n;
+declare const MSG_TRACK_STATUS = 13n;
+declare const MSG_NAMESPACE_DONE = 14n;
+declare const MSG_PUBLISH_SKIPPED = 15n;
+declare const MSG_GOAWAY = 16n;
+declare const MSG_FETCH = 22n;
+declare const MSG_FETCH_OK = 24n;
+declare const MSG_PUBLISH = 29n;
+/** NEW in draft-20 — Section 10.10. Unilateral publisher→subscriber notification. */
+declare const MSG_PUBLISH_STATE_NOTIFY = 34n;
+declare const MSG_PUBLISH_OK = 7n;
+declare const MSG_SUBSCRIBE_NAMESPACE = 80n;
+declare const MSG_SUBSCRIBE_TRACKS = 81n;
+declare const MSG_SETUP = 12032n;
+declare const SETUP_OPT_PATH = 1n;
+declare const SETUP_OPT_AUTHORIZATION_TOKEN = 3n;
+declare const SETUP_OPT_MAX_AUTH_TOKEN_CACHE_SIZE = 4n;
+declare const SETUP_OPT_AUTHORITY = 5n;
+declare const SETUP_OPT_MAX_FILTER_RANGES = 6n;
+declare const SETUP_OPT_MOQT_IMPLEMENTATION = 7n;
+declare const SETUP_OPT_MAX_REQUEST_UPDATES = 8n;
+declare const MESSAGE_TYPE_MAP: ReadonlyMap<bigint, string>;
+declare const MESSAGE_ID_MAP: ReadonlyMap<string, bigint>;
+
+declare const CONTROL_MESSAGES: ReadonlySet<Draft20MessageType>;
+declare const CLIENT_ONLY_MESSAGES: ReadonlySet<Draft20MessageType>;
+declare const SERVER_ONLY_MESSAGES: ReadonlySet<Draft20MessageType>;
+declare const BIDIRECTIONAL_MESSAGES: ReadonlySet<Draft20MessageType>;
+/**
+ * The seven message types that may be the FIRST message on a new bidirectional
+ * (request) stream — draft-20 Section 3.3, and the rows marked "First" in the
+ * Section 10 registry. Unchanged from draft-19.
+ *
+ * "Bidirectional streams MUST NOT begin with any other message type unless
+ * negotiated. If they do, the peer MUST close the Session with a
+ * PROTOCOL_VIOLATION." Note GOAWAY (0x10) is marked "Control, Request" but not
+ * "First": it may travel on either kind of stream but may never open one.
+ */
+declare const REQUEST_STREAM_OPENERS: ReadonlySet<Draft20MessageType>;
+declare function getLegalOutgoing(phase: string, _role: 'client' | 'server'): Set<Draft20MessageType>;
+declare function getLegalIncoming(phase: string, role: 'client' | 'server'): Set<Draft20MessageType>;
+
+/**
+ * Draft-20's real identifier is the protocol string `moqt-20`.
+ *
+ * draft-20 Section 3.1: "MOQT uses ALPN in QUIC and 'WT-Available-Protocols' in
+ * WebTransport to perform version negotiation. […] ALPNs used to identify IETF
+ * drafts are created by appending the draft number to 'moqt-'. […] Note: Draft
+ * versions prior to -15 all used moq-00 ALPN, followed by version negotiation
+ * in the SETUP messages."
+ *
+ * So this is what a draft-20 peer actually negotiates with, and it is the only
+ * identifier that appears anywhere in a draft-20 session.
+ */
+declare const PROTOCOL_STRING = "moqt-20";
+/**
+ * The `0xff000000 + N` identifier for draft 20.
+ *
+ * **This is a derived identifier, not an observed wire value.** No draft-20
+ * peer ever sends it. The `0xff0000NN` scheme belonged to the SETUP-time
+ * version negotiation that drafts before -15 used; from draft-15 on the version
+ * is negotiated by ALPN / `WT-Available-Protocols` and no version number
+ * appears on the wire at all. It is kept only so that code indexing drafts by a
+ * numeric key — {@link DRAFT_VERSIONS} in the package root, trace formats,
+ * anything that predates the change — has a stable key for draft-20.
+ *
+ * Anything that reports a version to a user should report
+ * {@link PROTOCOL_STRING} instead, and should not claim to have observed this
+ * number.
+ */
+declare const DRAFT_VERSION = 4278190100n;
+
+export { BIDIRECTIONAL_MESSAGES, CLIENT_ONLY_MESSAGES, CONTROL_MESSAGES, DRAFT_VERSION, DataStreamEvent, DataStreamResetCode, type DataStreamResetCodeValue, DatagramObject, Draft20DataStream, Draft20MessageType, FetchStream, FetchStreamHeader, MESSAGE_ID_MAP, MESSAGE_TYPE_MAP, MSG_FETCH, MSG_FETCH_OK, MSG_GOAWAY, MSG_NAMESPACE, MSG_NAMESPACE_DONE, MSG_PUBLISH, MSG_PUBLISH_DONE, MSG_PUBLISH_NAMESPACE, MSG_PUBLISH_OK, MSG_PUBLISH_SKIPPED, MSG_PUBLISH_STATE_NOTIFY, MSG_REQUEST_ERROR, MSG_REQUEST_OK, MSG_REQUEST_UPDATE, MSG_SETUP, MSG_SUBSCRIBE, MSG_SUBSCRIBE_NAMESPACE, MSG_SUBSCRIBE_OK, MSG_SUBSCRIBE_TRACKS, MSG_TRACK_STATUS, ObjectPayload, PROTOCOL_STRING, PublishDoneCode, type PublishDoneCodeValue, REQUEST_STREAM_OPENERS, RETIRED_PUBLISH_DONE_CODES, RETIRED_REQUEST_ERROR_CODES, RETIRED_SESSION_TERMINATION_CODES, RequestErrorCode, type RequestErrorCodeValue, SERVER_ONLY_MESSAGES, SETUP_OPT_AUTHORITY, SETUP_OPT_AUTHORIZATION_TOKEN, SETUP_OPT_MAX_AUTH_TOKEN_CACHE_SIZE, SETUP_OPT_MAX_FILTER_RANGES, SETUP_OPT_MAX_REQUEST_UPDATES, SETUP_OPT_MOQT_IMPLEMENTATION, SETUP_OPT_PATH, SessionTerminationCode, type SessionTerminationCodeValue, SubgroupStream, SubgroupStreamHeader, createDataStreamDecoder, createFetchStreamDecoder, createSubgroupStreamDecoder, decodeDataStream, decodeDatagram, decodeFetchStream, decodeSubgroupStream, encodeDatagram, encodeFetchStream, encodeSubgroupStream, getLegalIncoming, getLegalOutgoing };