@openmoq/playback 0.0.0-stage → 0.6.0

package/dist/buffer-based-controller.d.ts

@@ -0,0 +1,87 @@
+/**
+ * BufferBasedController — hybrid ABR using buffer depth as the primary
+ * signal and bandwidth estimation as a secondary corroboration signal.
+ *
+ * Buffer depth directly measures stall risk (the thing we care about).
+ * Bandwidth estimation measures throughput (a proxy for stall risk that
+ * can be noisy on bursty networks). Combining them:
+ *
+ *   buffer < LOW  → downshift immediately (emergency, bandwidth irrelevant)
+ *   buffer in [LOW, HIGH] → hold steady (buffer is fine, don't react to noise)
+ *   buffer > HIGH AND bandwidth > 2.25× next-higher → upshift (both agree)
+ *   buffer > HIGH AND bandwidth insufficient → hold (don't burn buffer)
+ *
+ * This avoids the EWMA over-reaction problem (bursty delivery tanks the
+ * estimate but buffer is healthy) while still enabling proactive upshift
+ * when conditions genuinely support it.
+ *
+ * @module
+ */
+import type { ClockSource } from './types.js';
+/** One entry in the ABR quality ladder. */
+export interface AbrTrack {
+    readonly name: string;
+    readonly bitrateKbps: number;
+}
+/** Configuration for the buffer-based controller. */
+export interface BufferBasedConfig {
+    readonly clock: ClockSource;
+    /** Quality ladder sorted highest-bitrate-first (index 0 = best). */
+    readonly ladder: readonly AbrTrack[];
+    /** Starting index into the ladder. */
+    readonly initialIndex: number;
+    /** Buffer depth below this → emergency downshift (µs). */
+    readonly lowThresholdUs: number;
+    /** Buffer depth above this → consider upshift (µs). */
+    readonly highThresholdUs: number;
+    /** Bandwidth must exceed this multiple of the target track's bitrate
+     *  for an upshift to be approved. Default 2.25. */
+    readonly upshiftBandwidthMultiple?: number;
+}
+/** Input signals for an ABR evaluation. */
+export interface AbrSignals {
+    /** Current buffer depth in microseconds. */
+    readonly bufferDepthUs: number;
+    /** EWMA bandwidth estimate in kbps (0 = unknown). */
+    readonly bandwidthEstimateKbps: number;
+}
+/** ABR decision. */
+export interface AbrDecision {
+    readonly action: 'downshift' | 'upshift' | 'hold';
+    /** Target ladder index (only set for downshift/upshift). */
+    readonly targetIndex?: number;
+}
+export declare class BufferBasedController {
+    private readonly ladder;
+    readonly lowThresholdUs: number;
+    /** Kept for future temporal-buffer mode (playout buffer, not jitter buffer). */
+    readonly highThresholdUs: number;
+    private readonly upshiftMultiple;
+    private currentIndex;
+    constructor(config: BufferBasedConfig);
+    /** Current ladder index. */
+    get index(): number;
+    /** Current track. */
+    get currentTrack(): AbrTrack | undefined;
+    /**
+     * Evaluate buffer depth + bandwidth and return an ABR decision.
+     *
+     * Called periodically (e.g., every tick or every group arrival).
+     */
+    /**
+     * Evaluate buffer depth + bandwidth and return an ABR recommendation.
+     *
+     * Does NOT mutate internal state — the caller must call
+     * {@link commitDownshift} or {@link commitUpshift} after a
+     * confirmed switch. This prevents index drift when async switches
+     * fail or are aborted.
+     */
+    evaluate(signals: AbrSignals): AbrDecision;
+    /** Confirm a downshift — advances index to the lower track. */
+    commitDownshift(): void;
+    /** Confirm an upshift — moves index to the higher track. */
+    commitUpshift(): void;
+    /** Reset to a specific ladder index (e.g., after manual selection). */
+    setIndex(index: number): void;
+}
+//# sourceMappingURL=buffer-based-controller.d.ts.map

package/dist/buffer-based-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-based-controller.d.ts","sourceRoot":"","sources":["../src/buffer-based-controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,2CAA2C;AAC3C,MAAM,WAAW,QAAQ;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAChC;AAED,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;IACrC,sCAAsC;IACtC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,0DAA0D;IAC1D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,uDAAuD;IACvD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;uDACmD;IACnD,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAC;CAC9C;AAED,2CAA2C;AAC3C,MAAM,WAAW,UAAU;IACvB,4CAA4C;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,qDAAqD;IACrD,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;CAC1C;AAED,oBAAoB;AACpB,MAAM,WAAW,WAAW;IACxB,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC;IAClD,4DAA4D;IAC5D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,gFAAgF;IAChF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,YAAY,CAAS;gBAEjB,MAAM,EAAE,iBAAiB;IAQrC,4BAA4B;IAC5B,IAAI,KAAK,IAAI,MAAM,CAA8B;IAEjD,qBAAqB;IACrB,IAAI,YAAY,IAAI,QAAQ,GAAG,SAAS,CAA2C;IAEnF;;;;OAIG;IACH;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,WAAW;IAsB1C,+DAA+D;IAC/D,eAAe,IAAI,IAAI;IAIvB,4DAA4D;IAC5D,aAAa,IAAI,IAAI;IAIrB,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAGhC"}

package/dist/buffer-based-controller.js

@@ -0,0 +1,85 @@
+/**
+ * BufferBasedController — hybrid ABR using buffer depth as the primary
+ * signal and bandwidth estimation as a secondary corroboration signal.
+ *
+ * Buffer depth directly measures stall risk (the thing we care about).
+ * Bandwidth estimation measures throughput (a proxy for stall risk that
+ * can be noisy on bursty networks). Combining them:
+ *
+ *   buffer < LOW  → downshift immediately (emergency, bandwidth irrelevant)
+ *   buffer in [LOW, HIGH] → hold steady (buffer is fine, don't react to noise)
+ *   buffer > HIGH AND bandwidth > 2.25× next-higher → upshift (both agree)
+ *   buffer > HIGH AND bandwidth insufficient → hold (don't burn buffer)
+ *
+ * This avoids the EWMA over-reaction problem (bursty delivery tanks the
+ * estimate but buffer is healthy) while still enabling proactive upshift
+ * when conditions genuinely support it.
+ *
+ * @module
+ */
+export class BufferBasedController {
+    ladder;
+    lowThresholdUs;
+    /** Kept for future temporal-buffer mode (playout buffer, not jitter buffer). */
+    highThresholdUs;
+    upshiftMultiple;
+    currentIndex;
+    constructor(config) {
+        this.ladder = config.ladder;
+        this.lowThresholdUs = config.lowThresholdUs;
+        this.highThresholdUs = config.highThresholdUs;
+        this.upshiftMultiple = config.upshiftBandwidthMultiple ?? 2.25;
+        this.currentIndex = config.initialIndex;
+    }
+    /** Current ladder index. */
+    get index() { return this.currentIndex; }
+    /** Current track. */
+    get currentTrack() { return this.ladder[this.currentIndex]; }
+    /**
+     * Evaluate buffer depth + bandwidth and return an ABR decision.
+     *
+     * Called periodically (e.g., every tick or every group arrival).
+     */
+    /**
+     * Evaluate buffer depth + bandwidth and return an ABR recommendation.
+     *
+     * Does NOT mutate internal state — the caller must call
+     * {@link commitDownshift} or {@link commitUpshift} after a
+     * confirmed switch. This prevents index drift when async switches
+     * fail or are aborted.
+     */
+    evaluate(signals) {
+        // Emergency: buffer critically low → recommend downshift
+        if (signals.bufferDepthUs < this.lowThresholdUs) {
+            if (this.currentIndex < this.ladder.length - 1) {
+                return { action: 'downshift', targetIndex: this.currentIndex + 1 };
+            }
+            return { action: 'hold' }; // already at lowest
+        }
+        // Upshift: buffer must be above the high threshold — asymmetric
+        // hysteresis so upshift is much harder to trigger than downshift.
+        // AND bandwidth must corroborate.
+        if (this.currentIndex > 0 && signals.bufferDepthUs >= this.highThresholdUs) {
+            const higherTrack = this.ladder[this.currentIndex - 1];
+            if (signals.bandwidthEstimateKbps > higherTrack.bitrateKbps * this.upshiftMultiple) {
+                return { action: 'upshift', targetIndex: this.currentIndex - 1 };
+            }
+        }
+        return { action: 'hold' };
+    }
+    /** Confirm a downshift — advances index to the lower track. */
+    commitDownshift() {
+        if (this.currentIndex < this.ladder.length - 1)
+            this.currentIndex++;
+    }
+    /** Confirm an upshift — moves index to the higher track. */
+    commitUpshift() {
+        if (this.currentIndex > 0)
+            this.currentIndex--;
+    }
+    /** Reset to a specific ladder index (e.g., after manual selection). */
+    setIndex(index) {
+        this.currentIndex = Math.max(0, Math.min(index, this.ladder.length - 1));
+    }
+}
+//# sourceMappingURL=buffer-based-controller.js.map

package/dist/buffer-based-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-based-controller.js","sourceRoot":"","sources":["../src/buffer-based-controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAyCH,MAAM,OAAO,qBAAqB;IACb,MAAM,CAAsB;IACpC,cAAc,CAAS;IAChC,gFAAgF;IACvE,eAAe,CAAS;IAChB,eAAe,CAAS;IACjC,YAAY,CAAS;IAE7B,YAAY,MAAyB;QACjC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;QAC5C,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC9C,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,wBAAwB,IAAI,IAAI,CAAC;QAC/D,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;IAC5C,CAAC;IAED,4BAA4B;IAC5B,IAAI,KAAK,KAAa,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;IAEjD,qBAAqB;IACrB,IAAI,YAAY,KAA2B,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAEnF;;;;OAIG;IACH;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAmB;QACxB,yDAAyD;QACzD,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YAC9C,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC7C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;YACvE,CAAC;YACD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,oBAAoB;QACnD,CAAC;QAED,gEAAgE;QAChE,kEAAkE;QAClE,kCAAkC;QAClC,IAAI,IAAI,CAAC,YAAY,GAAG,CAAC,IAAI,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzE,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAE,CAAC;YACxD,IAAI,OAAO,CAAC,qBAAqB,GAAG,WAAW,CAAC,WAAW,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;gBACjF,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,IAAI,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;YACrE,CAAC;QACL,CAAC;QAED,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAC9B,CAAC;IAED,+DAA+D;IAC/D,eAAe;QACX,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,YAAY,EAAE,CAAC;IACxE,CAAC;IAED,4DAA4D;IAC5D,aAAa;QACT,IAAI,IAAI,CAAC,YAAY,GAAG,CAAC;YAAE,IAAI,CAAC,YAAY,EAAE,CAAC;IACnD,CAAC;IAED,uEAAuE;IACvE,QAAQ,CAAC,KAAa;QAClB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IAC7E,CAAC;CACJ"}

package/dist/decoder-state.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Decoder lifecycle FSM.
+ *
+ * Models the decoder's state without touching actual WebCodecs APIs.
+ * Tracks whether a keyframe is needed before delta frames can be decoded
+ * (after startup or after a gap).
+ *
+ * Audio is treated as independently decodable (Opus/AAC-LC frames are
+ * self-contained) — no keyframe wait needed.
+ *
+ * ```
+ * IDLE ──configure──► NEEDS_KEYFRAME ──keyframe──► DECODING ──gap──► NEEDS_KEYFRAME
+ *                                                      │
+ *                                                 END_OF_TRACK
+ *                                                      │
+ *                                                      ▼
+ *                                                    ENDED
+ * ```
+ *
+ * @see draft-ietf-moq-loc-01 §2.3.2.2 (VideoFrameMarking.independent)
+ * @module
+ */
+import type { VideoChunkInit, AudioChunkInit, VideoFrameMarking } from '@openmoq/loc';
+/**
+ * Decoder states.
+ */
+export declare const DecoderState: {
+    /** Not yet configured. */
+    readonly IDLE: "idle";
+    /** Configured but waiting for a keyframe. */
+    readonly NEEDS_KEYFRAME: "needs_keyframe";
+    /** Actively decoding. */
+    readonly DECODING: "decoding";
+    /** Track ended. */
+    readonly ENDED: "ended";
+};
+export type DecoderStateValue = (typeof DecoderState)[keyof typeof DecoderState];
+/**
+ * Decision for each incoming chunk.
+ */
+export type FrameDecision = {
+    readonly action: 'decode';
+    readonly chunk: VideoChunkInit | AudioChunkInit;
+} | {
+    readonly action: 'skip';
+    readonly reason: string;
+} | {
+    readonly action: 'configure';
+    readonly config: Uint8Array;
+} | {
+    readonly action: 'flush';
+} | {
+    readonly action: 'reset';
+    readonly reason: string;
+};
+/**
+ * Decoder lifecycle FSM.
+ *
+ * @see draft-ietf-moq-loc-01 §4.2 (decode order)
+ */
+export declare class DecoderStateMachine {
+    private _state;
+    private readonly _mediaType;
+    private lastConfig;
+    constructor(mediaType: 'video' | 'audio');
+    get state(): DecoderStateValue;
+    get mediaType(): 'video' | 'audio';
+    /**
+     * Provide codec configuration.
+     *
+     * If the config is identical to the last one, skip reconfiguration
+     * (stay in current state). This avoids resetting to NEEDS_KEYFRAME
+     * on every group boundary when the server sends videoConfig on
+     * every group's first object with unchanged codec parameters.
+     *
+     * Transitions IDLE/DECODING → NEEDS_KEYFRAME (video) or DECODING (audio)
+     * only when the config actually changes.
+     */
+    configure(config: Uint8Array): FrameDecision;
+    /** Byte-level config comparison. */
+    private configEquals;
+    /**
+     * Process a video chunk.
+     * @see draft-ietf-moq-loc-01 §2.3.2.2 (VideoFrameMarking)
+     */
+    processVideoChunk(chunk: VideoChunkInit, marking: VideoFrameMarking | undefined): FrameDecision;
+    /**
+     * Process an audio chunk. Audio codecs (Opus, AAC-LC) produce
+     * independently decodable frames — no keyframe gating needed.
+     */
+    processAudioChunk(chunk: AudioChunkInit): FrameDecision;
+    /**
+     * Signal a gap — decoder needs to wait for next keyframe (video only).
+     * Audio: stays in DECODING since all chunks are independently decodable.
+     */
+    notifyGap(): FrameDecision;
+    /**
+     * Signal track ended.
+     * @see draft-ietf-moq-transport-16 §10.2.1.1
+     */
+    notifyTrackEnded(): FrameDecision;
+}
+//# sourceMappingURL=decoder-state.d.ts.map

package/dist/decoder-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder-state.d.ts","sourceRoot":"","sources":["../src/decoder-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAItF;;GAEG;AACH,eAAO,MAAM,YAAY;IACrB,0BAA0B;;IAE1B,6CAA6C;;IAE7C,yBAAyB;;IAEzB,mBAAmB;;CAEb,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAIjF;;GAEG;AACH,MAAM,MAAM,aAAa,GACnB;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAAA;CAAE,GAC9E;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GAC7D;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAI5D;;;;GAIG;AACH,qBAAa,mBAAmB;IAC5B,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C,OAAO,CAAC,UAAU,CAA2B;gBAEjC,SAAS,EAAE,OAAO,GAAG,OAAO;IAIxC,IAAI,KAAK,IAAI,iBAAiB,CAE7B;IAED,IAAI,SAAS,IAAI,OAAO,GAAG,OAAO,CAEjC;IAED;;;;;;;;;;OAUG;IACH,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,aAAa;IAiB5C,oCAAoC;IACpC,OAAO,CAAC,YAAY;IAQpB;;;OAGG;IACH,iBAAiB,CACb,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,iBAAiB,GAAG,SAAS,GACvC,aAAa;IAmBhB;;;OAGG;IACH,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,aAAa;IAUvD;;;OAGG;IACH,SAAS,IAAI,aAAa;IAS1B;;;OAGG;IACH,gBAAgB,IAAI,aAAa;CAIpC"}

package/dist/decoder-state.js

@@ -0,0 +1,145 @@
+/**
+ * Decoder lifecycle FSM.
+ *
+ * Models the decoder's state without touching actual WebCodecs APIs.
+ * Tracks whether a keyframe is needed before delta frames can be decoded
+ * (after startup or after a gap).
+ *
+ * Audio is treated as independently decodable (Opus/AAC-LC frames are
+ * self-contained) — no keyframe wait needed.
+ *
+ * ```
+ * IDLE ──configure──► NEEDS_KEYFRAME ──keyframe──► DECODING ──gap──► NEEDS_KEYFRAME
+ *                                                      │
+ *                                                 END_OF_TRACK
+ *                                                      │
+ *                                                      ▼
+ *                                                    ENDED
+ * ```
+ *
+ * @see draft-ietf-moq-loc-01 §2.3.2.2 (VideoFrameMarking.independent)
+ * @module
+ */
+// ─── State constants ────────────────────────────────────────────────
+/**
+ * Decoder states.
+ */
+export const DecoderState = {
+    /** Not yet configured. */
+    IDLE: 'idle',
+    /** Configured but waiting for a keyframe. */
+    NEEDS_KEYFRAME: 'needs_keyframe',
+    /** Actively decoding. */
+    DECODING: 'decoding',
+    /** Track ended. */
+    ENDED: 'ended',
+};
+// ─── DecoderStateMachine ────────────────────────────────────────────
+/**
+ * Decoder lifecycle FSM.
+ *
+ * @see draft-ietf-moq-loc-01 §4.2 (decode order)
+ */
+export class DecoderStateMachine {
+    _state = DecoderState.IDLE;
+    _mediaType;
+    lastConfig = null;
+    constructor(mediaType) {
+        this._mediaType = mediaType;
+    }
+    get state() {
+        return this._state;
+    }
+    get mediaType() {
+        return this._mediaType;
+    }
+    /**
+     * Provide codec configuration.
+     *
+     * If the config is identical to the last one, skip reconfiguration
+     * (stay in current state). This avoids resetting to NEEDS_KEYFRAME
+     * on every group boundary when the server sends videoConfig on
+     * every group's first object with unchanged codec parameters.
+     *
+     * Transitions IDLE/DECODING → NEEDS_KEYFRAME (video) or DECODING (audio)
+     * only when the config actually changes.
+     */
+    configure(config) {
+        // Skip if config is unchanged
+        if (this.lastConfig !== null && this.configEquals(this.lastConfig, config)) {
+            return { action: 'skip', reason: 'config unchanged' };
+        }
+        this.lastConfig = config;
+        if (this._mediaType === 'audio') {
+            // Audio chunks are always independently decodable — go straight to DECODING
+            this._state = DecoderState.DECODING;
+        }
+        else {
+            this._state = DecoderState.NEEDS_KEYFRAME;
+        }
+        return { action: 'configure', config };
+    }
+    /** Byte-level config comparison. */
+    configEquals(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Process a video chunk.
+     * @see draft-ietf-moq-loc-01 §2.3.2.2 (VideoFrameMarking)
+     */
+    processVideoChunk(chunk, marking) {
+        if (this._state === DecoderState.IDLE || this._state === DecoderState.ENDED) {
+            return { action: 'skip', reason: `decoder is ${this._state}` };
+        }
+        if (this._state === DecoderState.NEEDS_KEYFRAME) {
+            // Need a confirmed independent frame to start decoding
+            const isKeyframe = marking?.independent === true;
+            if (!isKeyframe) {
+                return { action: 'skip', reason: 'waiting for keyframe' };
+            }
+            this._state = DecoderState.DECODING;
+            return { action: 'decode', chunk };
+        }
+        // DECODING — accept any frame
+        return { action: 'decode', chunk };
+    }
+    /**
+     * Process an audio chunk. Audio codecs (Opus, AAC-LC) produce
+     * independently decodable frames — no keyframe gating needed.
+     */
+    processAudioChunk(chunk) {
+        if (this._state === DecoderState.IDLE || this._state === DecoderState.ENDED) {
+            return { action: 'skip', reason: `decoder is ${this._state}` };
+        }
+        // Audio is always independently decodable — always decode
+        this._state = DecoderState.DECODING;
+        return { action: 'decode', chunk };
+    }
+    /**
+     * Signal a gap — decoder needs to wait for next keyframe (video only).
+     * Audio: stays in DECODING since all chunks are independently decodable.
+     */
+    notifyGap() {
+        if (this._mediaType === 'audio') {
+            // Audio can resume immediately — all chunks are key
+            return { action: 'reset', reason: 'gap detected (audio will resume immediately)' };
+        }
+        this._state = DecoderState.NEEDS_KEYFRAME;
+        return { action: 'reset', reason: 'gap detected' };
+    }
+    /**
+     * Signal track ended.
+     * @see draft-ietf-moq-transport-16 §10.2.1.1
+     */
+    notifyTrackEnded() {
+        this._state = DecoderState.ENDED;
+        return { action: 'flush' };
+    }
+}
+//# sourceMappingURL=decoder-state.js.map

package/dist/decoder-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder-state.js","sourceRoot":"","sources":["../src/decoder-state.ts"],"names":[],"mappings":"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"}

package/dist/gap-detector.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Group-level gap detection and skip-forward logic.
+ *
+ * Tracks the expected group sequence for a track. Detects when groups
+ * are missing (server dropped them under congestion via priority-based
+ * dropping). Decides whether to wait or skip forward.
+ *
+ * @see draft-ietf-moq-transport-16 §10.2.1.1 (Object Status)
+ * @see draft-ietf-moq-transport-16 §7 (Priority-based dropping)
+ * @module
+ */
+import type { ClockSource } from './types.js';
+/**
+ * Gap evaluation actions.
+ * @see draft-ietf-moq-transport-16 §10.2.1.1
+ */
+export declare const GapAction: {
+    /** Continue waiting for the missing group. */
+    readonly WAIT: "wait";
+    /** Skip forward to the next available group with a keyframe. */
+    readonly SKIP_FORWARD: "skip_forward";
+    /** Track has ended. */
+    readonly TRACK_ENDED: "track_ended";
+};
+export type GapActionValue = (typeof GapAction)[keyof typeof GapAction];
+/**
+ * Gap evaluation result.
+ */
+export interface GapDecision {
+    readonly action: GapActionValue;
+    /** If SKIP_FORWARD, the group to skip to. */
+    readonly targetGroupId?: bigint;
+}
+/**
+ * Detects missing groups and decides when to skip forward.
+ *
+ * @see draft-ietf-moq-transport-16 §10.2.1.1
+ */
+export declare class GapDetector {
+    private _gapTimeoutUs;
+    private readonly clock;
+    /** Set of group IDs explicitly terminated via END_OF_GROUP. */
+    private readonly endedGroups;
+    /** Whether END_OF_TRACK has been received. */
+    private trackEnded;
+    /** Earliest observation time for each group. */
+    private readonly groupFirstSeenUs;
+    constructor(config: {
+        gapTimeoutUs: number;
+        clock: ClockSource;
+    });
+    /** Current gap timeout in microseconds. Mutable for adaptive tolerance. */
+    get gapTimeoutUs(): number;
+    set gapTimeoutUs(value: number);
+    /**
+     * Notify that an object has been received for a group.
+     * Records the observation time for timeout calculations.
+     */
+    observeGroup(groupId: bigint): void;
+    /**
+     * Notify that an END_OF_GROUP status was received.
+     * @see draft-ietf-moq-transport-16 §10.2.1.1 — ObjectStatus 0x3
+     */
+    observeEndOfGroup(groupId: bigint): void;
+    /**
+     * Notify that an END_OF_TRACK status was received.
+     * @see draft-ietf-moq-transport-16 §10.2.1.1 — ObjectStatus 0x4
+     */
+    observeEndOfTrack(): void;
+    /** Whether the track has ended. */
+    get isTrackEnded(): boolean;
+    /** Reset all state — used when resuming after pause on a live stream. */
+    reset(): void;
+    /**
+     * Evaluate the current gap state.
+     *
+     * @param lastConsumedGroupId The last group fully consumed by the decoder
+     * @param availableGroupIds Groups currently buffered (sorted ascending)
+     * @returns Decision: WAIT, SKIP_FORWARD, or TRACK_ENDED
+     */
+    evaluate(lastConsumedGroupId: bigint, availableGroupIds: bigint[]): GapDecision;
+}
+//# sourceMappingURL=gap-detector.d.ts.map

package/dist/gap-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gap-detector.d.ts","sourceRoot":"","sources":["../src/gap-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI9C;;;GAGG;AACH,eAAO,MAAM,SAAS;IAClB,8CAA8C;;IAE9C,gEAAgE;;IAEhE,uBAAuB;;CAEjB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,6CAA6C;IAC7C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACnC;AAID;;;;GAIG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IAEpC,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IAEjD,8CAA8C;IAC9C,OAAO,CAAC,UAAU,CAAS;IAE3B,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA6B;gBAElD,MAAM,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,WAAW,CAAA;KAAE;IAKhE,2EAA2E;IAC3E,IAAI,YAAY,IAAI,MAAM,CAA+B;IACzD,IAAI,YAAY,CAAC,KAAK,EAAE,MAAM,EAAiC;IAE/D;;;OAGG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAMnC;;;OAGG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIxC;;;OAGG;IACH,iBAAiB,IAAI,IAAI;IAIzB,mCAAmC;IACnC,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,yEAAyE;IACzE,KAAK,IAAI,IAAI;IAMb;;;;;;OAMG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,GAAG,WAAW;CAiDlF"}

package/dist/gap-detector.js

@@ -0,0 +1,129 @@
+/**
+ * Group-level gap detection and skip-forward logic.
+ *
+ * Tracks the expected group sequence for a track. Detects when groups
+ * are missing (server dropped them under congestion via priority-based
+ * dropping). Decides whether to wait or skip forward.
+ *
+ * @see draft-ietf-moq-transport-16 §10.2.1.1 (Object Status)
+ * @see draft-ietf-moq-transport-16 §7 (Priority-based dropping)
+ * @module
+ */
+// ─── Action constants ───────────────────────────────────────────────
+/**
+ * Gap evaluation actions.
+ * @see draft-ietf-moq-transport-16 §10.2.1.1
+ */
+export const GapAction = {
+    /** Continue waiting for the missing group. */
+    WAIT: 'wait',
+    /** Skip forward to the next available group with a keyframe. */
+    SKIP_FORWARD: 'skip_forward',
+    /** Track has ended. */
+    TRACK_ENDED: 'track_ended',
+};
+// ─── GapDetector ────────────────────────────────────────────────────
+/**
+ * Detects missing groups and decides when to skip forward.
+ *
+ * @see draft-ietf-moq-transport-16 §10.2.1.1
+ */
+export class GapDetector {
+    _gapTimeoutUs;
+    clock;
+    /** Set of group IDs explicitly terminated via END_OF_GROUP. */
+    endedGroups = new Set();
+    /** Whether END_OF_TRACK has been received. */
+    trackEnded = false;
+    /** Earliest observation time for each group. */
+    groupFirstSeenUs = new Map();
+    constructor(config) {
+        this._gapTimeoutUs = config.gapTimeoutUs;
+        this.clock = config.clock;
+    }
+    /** Current gap timeout in microseconds. Mutable for adaptive tolerance. */
+    get gapTimeoutUs() { return this._gapTimeoutUs; }
+    set gapTimeoutUs(value) { this._gapTimeoutUs = value; }
+    /**
+     * Notify that an object has been received for a group.
+     * Records the observation time for timeout calculations.
+     */
+    observeGroup(groupId) {
+        if (!this.groupFirstSeenUs.has(groupId)) {
+            this.groupFirstSeenUs.set(groupId, this.clock.now());
+        }
+    }
+    /**
+     * Notify that an END_OF_GROUP status was received.
+     * @see draft-ietf-moq-transport-16 §10.2.1.1 — ObjectStatus 0x3
+     */
+    observeEndOfGroup(groupId) {
+        this.endedGroups.add(groupId);
+    }
+    /**
+     * Notify that an END_OF_TRACK status was received.
+     * @see draft-ietf-moq-transport-16 §10.2.1.1 — ObjectStatus 0x4
+     */
+    observeEndOfTrack() {
+        this.trackEnded = true;
+    }
+    /** Whether the track has ended. */
+    get isTrackEnded() {
+        return this.trackEnded;
+    }
+    /** Reset all state — used when resuming after pause on a live stream. */
+    reset() {
+        this.endedGroups.clear();
+        this.trackEnded = false;
+        this.groupFirstSeenUs.clear();
+    }
+    /**
+     * Evaluate the current gap state.
+     *
+     * @param lastConsumedGroupId The last group fully consumed by the decoder
+     * @param availableGroupIds Groups currently buffered (sorted ascending)
+     * @returns Decision: WAIT, SKIP_FORWARD, or TRACK_ENDED
+     */
+    evaluate(lastConsumedGroupId, availableGroupIds) {
+        // Track ended → always report
+        if (this.trackEnded) {
+            return { action: GapAction.TRACK_ENDED };
+        }
+        // Nothing available → wait
+        if (availableGroupIds.length === 0) {
+            return { action: GapAction.WAIT };
+        }
+        const nextExpected = lastConsumedGroupId + 1n;
+        const sorted = [...availableGroupIds].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+        const firstAvailable = sorted[0];
+        // Contiguous — next expected is available
+        if (firstAvailable <= nextExpected) {
+            return { action: GapAction.WAIT };
+        }
+        // Gap exists: firstAvailable > nextExpected
+        // Check if all intermediate groups are explicitly ended
+        let allEnded = true;
+        for (let g = nextExpected; g < firstAvailable; g++) {
+            if (!this.endedGroups.has(g)) {
+                allEnded = false;
+                break;
+            }
+        }
+        if (allEnded) {
+            // All intermediate groups are explicitly ended → skip immediately
+            return { action: GapAction.SKIP_FORWARD, targetGroupId: firstAvailable };
+        }
+        // Implicit gap — check if we've waited long enough since the first
+        // available group was observed (that's when the gap became detectable)
+        const now = this.clock.now();
+        const firstSeenAt = this.groupFirstSeenUs.get(firstAvailable);
+        if (firstSeenAt !== undefined) {
+            const elapsed = now - firstSeenAt;
+            if (elapsed >= this.gapTimeoutUs) {
+                return { action: GapAction.SKIP_FORWARD, targetGroupId: firstAvailable };
+            }
+        }
+        return { action: GapAction.WAIT };
+    }
+}
+//# sourceMappingURL=gap-detector.js.map

package/dist/gap-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gap-detector.js","sourceRoot":"","sources":["../src/gap-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,uEAAuE;AAEvE;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACrB,8CAA8C;IAC9C,IAAI,EAAE,MAAM;IACZ,gEAAgE;IAChE,YAAY,EAAE,cAAc;IAC5B,uBAAuB;IACvB,WAAW,EAAE,aAAa;CACpB,CAAC;AAaX,uEAAuE;AAEvE;;;;GAIG;AACH,MAAM,OAAO,WAAW;IACZ,aAAa,CAAS;IACb,KAAK,CAAc;IAEpC,+DAA+D;IAC9C,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;IAEjD,8CAA8C;IACtC,UAAU,GAAG,KAAK,CAAC;IAE3B,gDAAgD;IAC/B,gBAAgB,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE9D,YAAY,MAAoD;QAC5D,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC9B,CAAC;IAED,2EAA2E;IAC3E,IAAI,YAAY,KAAa,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;IACzD,IAAI,YAAY,CAAC,KAAa,IAAI,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC;IAE/D;;;OAGG;IACH,YAAY,CAAC,OAAe;QACxB,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YACtC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;QACzD,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,iBAAiB,CAAC,OAAe;QAC7B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,iBAAiB;QACb,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IAC3B,CAAC;IAED,mCAAmC;IACnC,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,yEAAyE;IACzE,KAAK;QACD,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,mBAA2B,EAAE,iBAA2B;QAC7D,8BAA8B;QAC9B,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,WAAW,EAAE,CAAC;QAC7C,CAAC;QAED,2BAA2B;QAC3B,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC;QACtC,CAAC;QAED,MAAM,YAAY,GAAG,mBAAmB,GAAG,EAAE,CAAC;QAC9C,MAAM,MAAM,GAAG,CAAC,GAAG,iBAAiB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACnF,MAAM,cAAc,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC;QAElC,0CAA0C;QAC1C,IAAI,cAAc,IAAI,YAAY,EAAE,CAAC;YACjC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC;QACtC,CAAC;QAED,4CAA4C;QAC5C,wDAAwD;QACxD,IAAI,QAAQ,GAAG,IAAI,CAAC;QACpB,KAAK,IAAI,CAAC,GAAG,YAAY,EAAE,CAAC,GAAG,cAAc,EAAE,CAAC,EAAE,EAAE,CAAC;YACjD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC3B,QAAQ,GAAG,KAAK,CAAC;gBACjB,MAAM;YACV,CAAC;QACL,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACX,kEAAkE;YAClE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC;QAC7E,CAAC;QAED,mEAAmE;QACnE,uEAAuE;QACvE,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAE9D,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,OAAO,GAAG,GAAG,GAAG,WAAW,CAAC;YAClC,IAAI,OAAO,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC/B,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC;YAC7E,CAAC;QACL,CAAC;QAED,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC;IACtC,CAAC;CACJ"}