openrtc 0.1.0

package/dist/moq/MoQSubscriber.js

@@ -0,0 +1,235 @@
+import { StreamBuffer } from './common';
+import { MsgType } from './messages';
+export class MoQSubscriber {
+    constructor(session, onObject) {
+        this.aliasMap = new Map();
+        this.nextAlias = 0;
+        this.nextSubscribeId = 1;
+        // Track pending subscriptions for retry on 404
+        this.pendingSubscriptions = new Map();
+        // Buffered delivery state per track alias
+        this.deliveryState = new Map();
+        // Map subscribeId -> trackAlias for active subscriptions
+        this.activeSubscriptions = new Map();
+        this.session = session;
+        this.onObject = onObject;
+    }
+    async subscribe(namespace, name) {
+        // Send SUBSCRIBE
+        const trackAlias = this.nextAlias++;
+        const subscribeId = this.nextSubscribeId++;
+        this.aliasMap.set(trackAlias, { namespace, name });
+        console.log(`[MoQ] Subscribing to ${namespace}/${name} with Alias ${trackAlias} ID ${subscribeId}`);
+        const msg = {
+            type: MsgType.SUBSCRIBE,
+            subscribeId: subscribeId,
+            trackAlias: trackAlias,
+            trackNamespace: namespace,
+            trackName: name
+        };
+        this.pendingSubscriptions.set(subscribeId, { namespace, name, trackAlias });
+        this.activeSubscriptions.set(subscribeId, trackAlias);
+        await this.session.sendControlMessage(msg);
+    }
+    onSubscribeOk(subscribeId) {
+        this.pendingSubscriptions.delete(subscribeId);
+    }
+    async onSubscribeError(subscribeId, code) {
+        const pending = this.pendingSubscriptions.get(subscribeId);
+        this.pendingSubscriptions.delete(subscribeId);
+        if (!pending)
+            return;
+        if (code === 404) {
+            // Peer hasn't announced yet — retry after delay
+            console.log(`[MoQ] Will retry subscription to ${pending.namespace}/${pending.name} in 2s...`);
+            await new Promise(r => setTimeout(r, 2000));
+            // Re-subscribe with a NEW subscribeId but SAME trackAlias
+            const newId = this.nextSubscribeId++;
+            const msg = {
+                type: MsgType.SUBSCRIBE,
+                subscribeId: newId,
+                trackAlias: pending.trackAlias,
+                trackNamespace: pending.namespace,
+                trackName: pending.name
+            };
+            this.pendingSubscriptions.set(newId, pending);
+            console.log(`[MoQ] Retrying subscription to ${pending.namespace}/${pending.name} with ID ${newId}`);
+            await this.session.sendControlMessage(msg);
+        }
+    }
+    onSubscribeDone(subscribeId, code, reason) {
+        const alias = this.activeSubscriptions.get(subscribeId);
+        if (alias !== undefined) {
+            console.warn(`[MoQ] Subscription ${subscribeId} (alias ${alias}) ended: ${code} ${reason}`);
+            this.activeSubscriptions.delete(subscribeId);
+            this.aliasMap.delete(alias);
+            this.deliveryState.delete(alias);
+        }
+        else {
+            console.warn(`[MoQ] Subscription ${subscribeId} ended (unknown alias): ${code} ${reason}`);
+        }
+    }
+    // Wake the delivery loop for a track alias so it can check for new frames
+    wakeDelivery(trackAlias) {
+        const state = this.deliveryState.get(trackAlias);
+        if (state?.notifyResolve) {
+            const resolve = state.notifyResolve;
+            state.notifyResolve = null;
+            resolve();
+        }
+    }
+    // Delivery loop: drains groups in sequence order, one per track alias.
+    // Matches the reference Consumer.next() pattern — oldest group first,
+    // advance only when a group is fully consumed.
+    async runDeliveryLoop(trackAlias) {
+        const state = this.deliveryState.get(trackAlias);
+        if (!state)
+            return;
+        const info = this.aliasMap.get(trackAlias);
+        const ns = info ? info.namespace : 'unknown';
+        const name = info ? info.name : 'unknown';
+        while (true) {
+            const group = state.groups.get(state.nextDeliverGroupId);
+            if (group) {
+                // Deliver all currently buffered frames from this group
+                while (group.frames.length > 0) {
+                    const frame = group.frames.shift();
+                    this.onObject(ns, name, frame.payload, { groupId: frame.groupId, objectId: frame.objectId });
+                }
+                if (group.done) {
+                    // Group fully consumed and reader finished — advance to next
+                    state.groups.delete(state.nextDeliverGroupId);
+                    state.nextDeliverGroupId++;
+                    continue; // Immediately check next group
+                }
+            }
+            else {
+                // Check if we're behind — a newer group exists but our current one never arrived.
+                // Skip forward to avoid blocking forever (handles gaps from relay).
+                let minFutureGroup = null;
+                for (const gid of state.groups.keys()) {
+                    if (gid > state.nextDeliverGroupId) {
+                        if (minFutureGroup === null || gid < minFutureGroup) {
+                            minFutureGroup = gid;
+                        }
+                    }
+                }
+                // Only skip if there are at least 2 newer groups buffered
+                // (the missing group is clearly not coming)
+                if (minFutureGroup !== null && minFutureGroup > state.nextDeliverGroupId + 1) {
+                    console.warn(`[MoQ] Skipping missing group ${state.nextDeliverGroupId}, jumping to ${minFutureGroup}`);
+                    state.nextDeliverGroupId = minFutureGroup;
+                    continue;
+                }
+            }
+            // Nothing to deliver right now — wait for a notification
+            await new Promise(resolve => {
+                state.notifyResolve = resolve;
+            });
+        }
+    }
+    // Process incoming UniStream — each group reads concurrently into a buffer
+    async handleIncomingUniStream(stream) {
+        const reader = stream.getReader();
+        const sb = new StreamBuffer();
+        // These are set during header parsing and used in the finally block
+        let trackAlias = -1;
+        let groupId = -1;
+        let groupBuffer = null;
+        try {
+            // Read Stream Header
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return;
+                if (value)
+                    sb.append(value);
+                try {
+                    sb.checkpoint();
+                    const type = Number(sb.readVarInt());
+                    const subscribeId = Number(sb.readVarInt()); // Draft-07: Subscribe ID
+                    trackAlias = Number(sb.readVarInt());
+                    groupId = Number(sb.readVarInt());
+                    sb.readVarInt(); // Subgroup ID
+                    sb.readUint8(); // Priority (8-bit)
+                    sb.commit();
+                    break;
+                }
+                catch (e) {
+                    if (e.message === 'EOF') {
+                        sb.rewind();
+                        continue; // Read more
+                    }
+                    throw e;
+                }
+            }
+            // Get or create delivery state for this track alias
+            let state = this.deliveryState.get(trackAlias);
+            if (!state) {
+                state = {
+                    groups: new Map(),
+                    nextDeliverGroupId: groupId,
+                    notifyResolve: null,
+                    loopRunning: false,
+                };
+                this.deliveryState.set(trackAlias, state);
+            }
+            // Skip truly stale groups (already delivered past this point)
+            if (groupId < state.nextDeliverGroupId) {
+                reader.cancel().catch(() => { });
+                return;
+            }
+            // Create buffer for this group
+            groupBuffer = { frames: [], done: false };
+            state.groups.set(groupId, groupBuffer);
+            // Start delivery loop if not already running
+            if (!state.loopRunning) {
+                state.loopRunning = true;
+                this.runDeliveryLoop(trackAlias);
+            }
+            // Read Objects from this group into buffer (runs concurrently with other groups)
+            while (true) {
+                if (!sb.has(1)) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (value)
+                        sb.append(value);
+                }
+                try {
+                    sb.checkpoint();
+                    const objectId = Number(sb.readVarInt());
+                    const length = Number(sb.readVarInt());
+                    const payload = sb.readBytes(length);
+                    sb.commit();
+                    // Buffer the frame
+                    groupBuffer.frames.push({ payload, groupId, objectId });
+                    // Wake delivery loop to check for new frames
+                    this.wakeDelivery(trackAlias);
+                }
+                catch (e) {
+                    if (e.message === 'EOF') {
+                        sb.rewind();
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        if (value)
+                            sb.append(value);
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+        }
+        catch (e) {
+            console.error("Subscriber Stream Error", e);
+        }
+        finally {
+            // Mark this group as done so the delivery loop can advance past it
+            if (groupBuffer) {
+                groupBuffer.done = true;
+                this.wakeDelivery(trackAlias);
+            }
+        }
+    }
+}

package/dist/moq/common.d.ts

@@ -0,0 +1,47 @@
+export declare class BufferReader {
+    private view;
+    private offset;
+    constructor(buffer: Uint8Array);
+    get eof(): boolean;
+    remaining(): number;
+    readUint8(): number;
+    readVarInt(): number;
+    readVarIntBig(): bigint;
+    readString(): string;
+    readBytes(len: number): Uint8Array;
+}
+export declare class StreamBuffer {
+    private buffer;
+    private offset;
+    constructor();
+    append(chunk: Uint8Array): void;
+    peekVarInt(): {
+        val: number | bigint;
+        len: number;
+    } | null;
+    advance(bytes: number): void;
+    has(bytes: number): boolean;
+    readBytes(len: number): Uint8Array;
+    readVarInt(): number | bigint;
+    readUint8(): number;
+    private checkpoints;
+    checkpoint(): void;
+    commit(): void;
+    rewind(): void;
+    readString(): string;
+}
+export declare class BufferWriter {
+    private chunks;
+    private length;
+    writeUint8(val: number): void;
+    writeVarInt(val: number | bigint): void;
+    writeString(str: string): void;
+    writeBytes(bytes: Uint8Array): void;
+    toUint8Array(): Uint8Array;
+}
+export declare class Mutex {
+    private mutex;
+    lock(): Promise<() => void>;
+    dispatch<T>(fn: (() => T | PromiseLike<T>)): Promise<T>;
+}
+export declare const DEFAULT_MOQ_RELAY_URL = "https://relay.cloudflare.mediaoverquic.com:443/moq";

package/dist/moq/common.js

@@ -0,0 +1,304 @@
+export class BufferReader {
+    constructor(buffer) {
+        this.offset = 0;
+        this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    get eof() {
+        return this.offset >= this.view.byteLength;
+    }
+    remaining() {
+        return this.view.byteLength - this.offset;
+    }
+    readUint8() {
+        if (this.remaining() < 1)
+            throw new Error("EOF");
+        const val = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return val;
+    }
+    readVarInt() {
+        const first = this.readUint8();
+        const prefix = first >> 6;
+        const b1 = first & 0x3f;
+        if (prefix === 0) {
+            return b1;
+        }
+        else if (prefix === 1) {
+            if (this.remaining() < 1)
+                throw new Error("EOF");
+            const b2 = this.readUint8();
+            return (b1 << 8) | b2;
+        }
+        else if (prefix === 2) {
+            if (this.remaining() < 3)
+                throw new Error("EOF");
+            const b2 = this.readUint8();
+            const b3 = this.readUint8();
+            const b4 = this.readUint8();
+            return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
+        }
+        else {
+            // Priority 3: 8 bytes (62 bits)
+            // JS numbers are doubles, safe integer is 2^53. 
+            // 62 bits might overflow JS number. For now we read as BigInt if needed or clamp?
+            // Let's use BigInt implementation for 8 bytes to be safe, then cast to Number.
+            if (this.remaining() < 7)
+                throw new Error("EOF");
+            // We already read byte 1 (b1). We need 7 more.
+            // But DataView.getBigUint64 expects 8 bytes.
+            // Let's manually reconstruct.
+            // b1 is the top 6 bits (technically top 6 bits of usage).
+            // This is getting messy. Let's peek generic Logic.
+            // Re-implement simpler:
+            // Backtrack 1 byte
+            this.offset--;
+            return Number(this.readVarIntBig());
+        }
+    }
+    readVarIntBig() {
+        if (this.remaining() < 1)
+            throw new Error("EOF");
+        const first = this.view.getUint8(this.offset);
+        const prefix = first >> 6;
+        if (prefix === 0) {
+            this.offset++;
+            return BigInt(first & 0x3f);
+        }
+        else if (prefix === 1) {
+            if (this.remaining() < 2)
+                throw new Error("EOF");
+            const val = this.view.getUint16(this.offset) & 0x3fff;
+            this.offset += 2;
+            return BigInt(val);
+        }
+        else if (prefix === 2) {
+            if (this.remaining() < 4)
+                throw new Error("EOF");
+            const val = this.view.getUint32(this.offset) & 0x3fffffff;
+            this.offset += 4;
+            return BigInt(val);
+        }
+        else {
+            if (this.remaining() < 8)
+                throw new Error("EOF");
+            const val = this.view.getBigUint64(this.offset) & BigInt("0x3fffffffffffffff");
+            this.offset += 8;
+            return val;
+        }
+    }
+    readString() {
+        const len = this.readVarInt();
+        if (this.remaining() < len)
+            throw new Error("EOF");
+        const bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, len);
+        this.offset += len;
+        return new TextDecoder().decode(bytes);
+    }
+    readBytes(len) {
+        if (this.remaining() < len)
+            throw new Error("EOF");
+        const bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, len);
+        this.offset += len;
+        // Should we copy? If not, it references original buffer. usage safety.
+        // Let's maintain reference for speed.
+        return bytes;
+    }
+}
+export class StreamBuffer {
+    constructor() {
+        this.offset = 0;
+        this.checkpoints = [];
+        this.buffer = new Uint8Array(0);
+    }
+    append(chunk) {
+        const newBuf = new Uint8Array(this.buffer.length + chunk.length);
+        newBuf.set(this.buffer);
+        newBuf.set(chunk, this.buffer.length);
+        this.buffer = newBuf;
+    }
+    // Try to read a VarInt without advancing if fails
+    peekVarInt() {
+        if (this.buffer.length - this.offset < 1)
+            return null;
+        const first = this.buffer[this.offset];
+        const prefix = first >> 6;
+        const b1 = first & 0x3f;
+        if (prefix === 0) {
+            return { val: b1, len: 1 };
+        }
+        else if (prefix === 1) {
+            if (this.buffer.length - this.offset < 2)
+                return null;
+            const view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+            const val = view.getUint16(this.offset) & 0x3fff;
+            return { val, len: 2 };
+        }
+        else if (prefix === 2) {
+            if (this.buffer.length - this.offset < 4)
+                return null;
+            const view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+            const val = view.getUint32(this.offset) & 0x3fffffff;
+            return { val, len: 4 };
+        }
+        else {
+            if (this.buffer.length - this.offset < 8)
+                return null;
+            const view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+            const val = view.getBigUint64(this.offset) & BigInt("0x3fffffffffffffff");
+            return { val, len: 8 };
+        }
+    }
+    // Commit a read operation (advance offset)
+    advance(bytes) {
+        this.offset += bytes;
+        // Optimization: slice buffer if offset gets too large?
+        if (this.offset > 1024 && this.offset > this.buffer.length / 2) {
+            this.buffer = this.buffer.slice(this.offset);
+            this.offset = 0;
+        }
+    }
+    // Check if we have N bytes available from current offset
+    has(bytes) {
+        return (this.buffer.length - this.offset) >= bytes;
+    }
+    readBytes(len) {
+        if (!this.has(len))
+            throw new Error("EOF");
+        const res = this.buffer.slice(this.offset, this.offset + len);
+        this.advance(len);
+        return res;
+    }
+    readVarInt() {
+        const res = this.peekVarInt();
+        if (!res)
+            throw new Error("EOF");
+        this.advance(res.len);
+        return res.val;
+    }
+    readUint8() {
+        if (!this.has(1))
+            throw new Error("EOF");
+        const val = this.buffer[this.offset];
+        this.advance(1);
+        return val;
+    }
+    checkpoint() {
+        this.checkpoints.push(this.offset);
+    }
+    commit() {
+        this.checkpoints.pop();
+        // If no more checkpoints, we could compact buffer logic here if desired
+    }
+    rewind() {
+        const cp = this.checkpoints.pop();
+        if (cp !== undefined) {
+            this.offset = cp;
+        }
+        else {
+            throw new Error("No checkpoint to rewind to");
+        }
+    }
+    readString() {
+        // Read Length (VarInt)
+        const lenRes = this.peekVarInt();
+        if (!lenRes)
+            throw new Error("EOF");
+        const strLen = Number(lenRes.val);
+        const totalLen = lenRes.len + strLen;
+        if (!this.has(totalLen))
+            throw new Error("EOF");
+        this.advance(lenRes.len); // Parse Len
+        const bytes = this.readBytes(strLen);
+        return new TextDecoder().decode(bytes);
+    }
+}
+export class BufferWriter {
+    constructor() {
+        this.chunks = [];
+        this.length = 0;
+    }
+    writeUint8(val) {
+        const buf = new Uint8Array(1);
+        buf[0] = val;
+        this.chunks.push(buf);
+        this.length += 1;
+    }
+    writeVarInt(val) {
+        const v = BigInt(val);
+        if (v < 64n) { // 6 bits, 1 byte
+            this.writeUint8(Number(v));
+        }
+        else if (v < 16384n) { // 14 bits, 2 bytes
+            const buf = new Uint8Array(2);
+            const view = new DataView(buf.buffer);
+            view.setUint16(0, Number(v) | 0x4000);
+            this.chunks.push(buf);
+            this.length += 2;
+        }
+        else if (v < 1073741824n) { // 30 bits, 4 bytes
+            const buf = new Uint8Array(4);
+            const view = new DataView(buf.buffer);
+            view.setUint32(0, Number(v) | 0x80000000);
+            this.chunks.push(buf);
+            this.length += 4;
+        }
+        else { // 62 bits, 8 bytes
+            const buf = new Uint8Array(8);
+            const view = new DataView(buf.buffer);
+            // 0xc0 = 1100 0000
+            // We rely on BigInt bitwise or
+            // But setBigUint64 takes bigint.
+            // 0xc0 << 56 is outside number range.
+            // BigInt literal
+            const magic = 0xc000000000000000n;
+            view.setBigUint64(0, v | magic);
+            this.chunks.push(buf);
+            this.length += 8;
+        }
+    }
+    writeString(str) {
+        const bytes = new TextEncoder().encode(str);
+        this.writeVarInt(bytes.length);
+        this.chunks.push(bytes);
+        this.length += bytes.length;
+    }
+    writeBytes(bytes) {
+        this.chunks.push(bytes);
+        this.length += bytes.byteLength;
+    }
+    toUint8Array() {
+        const res = new Uint8Array(this.length);
+        let offset = 0;
+        for (const chunk of this.chunks) {
+            res.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return res;
+    }
+}
+export class Mutex {
+    constructor() {
+        this.mutex = Promise.resolve();
+    }
+    lock() {
+        let unlock = () => { };
+        const next = new Promise(resolve => {
+            unlock = resolve;
+        });
+        // The caller waits for the previous operation to complete
+        const permission = this.mutex.then(() => unlock);
+        // Update the mutex to wait for the new operation
+        this.mutex = this.mutex.then(() => next);
+        return permission;
+    }
+    async dispatch(fn) {
+        const unlock = await this.lock();
+        try {
+            return await Promise.resolve(fn());
+        }
+        finally {
+            unlock();
+        }
+    }
+}
+export const DEFAULT_MOQ_RELAY_URL = "https://relay.cloudflare.mediaoverquic.com:443/moq";

package/dist/moq/messages.d.ts

@@ -0,0 +1,105 @@
+import { StreamBuffer } from './common';
+export declare enum MsgType {
+    SUBSCRIBE = 3,
+    SUBSCRIBE_OK = 4,
+    SUBSCRIBE_ERROR = 5,
+    ANNOUNCE = 6,
+    ANNOUNCE_OK = 7,
+    ANNOUNCE_ERROR = 8,
+    UNANNOUNCE = 9,
+    UNSUBSCRIBE = 10,
+    SUBSCRIBE_DONE = 11,
+    ANNOUNCE_CANCEL = 12,
+    TRACK_STATUS_REQUEST = 13,
+    TRACK_STATUS = 14,
+    GOAWAY = 16,
+    MAX_SUBSCRIBE_ID = 21,
+    CLIENT_SETUP = 64,
+    SERVER_SETUP = 65
+}
+export declare const SETUP_ROLE_PARAMETER_KEY = 0;
+export declare const SETUP_PATH_PARAMETER_KEY = 1;
+export interface MoQMessage {
+    type: MsgType;
+}
+export interface MsgClientSetup extends MoQMessage {
+    type: MsgType.CLIENT_SETUP;
+    supportedVersions: number[];
+    role: number;
+    path?: string;
+}
+export interface MsgServerSetup extends MoQMessage {
+    type: MsgType.SERVER_SETUP;
+    selectedVersion: number;
+    role: number;
+}
+export interface MsgSubscribe extends MoQMessage {
+    type: MsgType.SUBSCRIBE;
+    subscribeId: number;
+    trackAlias: number;
+    trackNamespace: string;
+    trackName: string;
+    subscriberPriority?: number;
+    groupOrder?: number;
+    startGroup?: number;
+    startObject?: number;
+    endGroup?: number;
+    endObject?: number;
+}
+export interface MsgSubscribeOk extends MoQMessage {
+    type: MsgType.SUBSCRIBE_OK;
+    subscribeId: number;
+    expires: number;
+}
+export interface MsgSubscribeError extends MoQMessage {
+    type: MsgType.SUBSCRIBE_ERROR;
+    subscribeId: number;
+    code: number;
+    reason: string;
+}
+export interface MsgAnnounce extends MoQMessage {
+    type: MsgType.ANNOUNCE;
+    trackNamespace: string;
+}
+export interface MsgAnnounceOk extends MoQMessage {
+    type: MsgType.ANNOUNCE_OK;
+    trackNamespace: string;
+}
+export interface MsgAnnounceError extends MoQMessage {
+    type: MsgType.ANNOUNCE_ERROR;
+    trackNamespace: string;
+    code: number;
+    reason: string;
+}
+export interface MsgMaxSubscribeId extends MoQMessage {
+    type: MsgType.MAX_SUBSCRIBE_ID;
+    subscribeId: number;
+}
+export interface MsgUnsubscribe extends MoQMessage {
+    type: MsgType.UNSUBSCRIBE;
+    subscribeId: number;
+}
+export interface MsgSubscribeDone extends MoQMessage {
+    type: MsgType.SUBSCRIBE_DONE;
+    subscribeId: number;
+    code: number;
+    reason: string;
+    finalGroup?: number;
+    finalObject?: number;
+}
+export interface MsgObjectHeader {
+    subscribeId: number;
+    trackAlias: number;
+    groupId: number;
+    objectId: number;
+    priority: number;
+}
+export declare class MoQSerializer {
+    /**
+     * Serialize a MoQ control message with proper framing:
+     * Type (varint) + Length (varint) + Payload (bytes)
+     * Per Draft-07: https://www.ietf.org/archive/id/draft-ietf-moq-transport-07.html
+     */
+    static serialize(msg: MoQMessage): Uint8Array;
+    static deserialize(sb: StreamBuffer): MoQMessage | null;
+}