@moqtap/codec 0.8.1 → 0.9.0

package/dist/draft20-session.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkBMJMY6FXcjs = require('./chunk-BMJMY6FX.cjs');
+
+
+
+exports.Draft20SessionFSM = _chunkBMJMY6FXcjs.Draft20SessionFSM; exports.createDraft20SessionState = _chunkBMJMY6FXcjs.createDraft20SessionState;

package/dist/draft20-session.d.cts

@@ -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-B9idsih-.cjs';
+export { P as ProtocolViolation } from './session-types-B9idsih-.cjs';
+import { a as Draft20MessageType, D as Draft20Message } from './types-CWCQwuvy.cjs';
+import './types-DG5_iKuv.cjs';
+
+/**
+ * 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.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;