openrtc 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { OpenRTC, type OpenRTCClient } from './OpenRTC';
+export { RuntimeClient } from './runtime/RuntimeClient';
+export { RuntimeClient as Client } from './runtime/RuntimeClient';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { OpenRTC } from './OpenRTC';
+export { RuntimeClient } from './runtime/RuntimeClient';
+export { RuntimeClient as Client } from './runtime/RuntimeClient';

package/dist/moq/MoQMediaTransport.d.ts

@@ -0,0 +1,6 @@
+import { MoQPublisher } from './MoQPublisher';
+export declare class MoQMediaTransport {
+    private publisher;
+    constructor(publisher: MoQPublisher);
+    sendTrack(track: MediaStreamTrack, namespace: string, name: string): Promise<void>;
+}

package/dist/moq/MoQMediaTransport.js

@@ -0,0 +1,106 @@
+export class MoQMediaTransport {
+    constructor(publisher) {
+        this.publisher = publisher;
+    }
+    async sendTrack(track, namespace, name) {
+        // Create publisher track
+        const trackPub = await this.publisher.createTrack(namespace, name);
+        if (!trackPub) {
+            console.log(`[MoQ] Track ${namespace}/${name} already being published. Skipping.`);
+            return;
+        }
+        if ((typeof VideoEncoder === 'undefined') && (typeof AudioEncoder === 'undefined')) {
+            console.error("WebCodecs API not supported.");
+            return;
+        }
+        const processor = new window.MediaStreamTrackProcessor({ track });
+        const reader = processor.readable.getReader();
+        let encoder = null;
+        if (track.kind === 'video') {
+            encoder = new window.VideoEncoder({
+                output: (chunk, metadata) => {
+                    // Framing: [timestamp 8B big-endian][encoded data]
+                    const buffer = new ArrayBuffer(8 + chunk.byteLength);
+                    const view = new DataView(buffer);
+                    view.setBigInt64(0, BigInt(chunk.timestamp), false);
+                    const data = new Uint8Array(buffer);
+                    chunk.copyTo(new Uint8Array(buffer, 8));
+                    trackPub.push(data, { isKey: chunk.type === 'key', timestamp: chunk.timestamp });
+                },
+                error: (e) => console.error("MoQ VideoEncoder error", e)
+            });
+            encoder.configure({
+                codec: 'vp09.00.10.08',
+                width: 640,
+                height: 480,
+                bitrate: 500000,
+                framerate: 24,
+                latencyMode: 'realtime',
+            });
+        }
+        else {
+            // Audio
+            let lastAudioKeyTimestamp = null;
+            const AUDIO_GROUP_INTERVAL_US = 100000; // ~100ms (matches reference moq-dev)
+            encoder = new window.AudioEncoder({
+                output: (chunk, metadata) => {
+                    // Determine if this audio chunk starts a new group
+                    let isKey = false;
+                    if (lastAudioKeyTimestamp === null ||
+                        chunk.timestamp - lastAudioKeyTimestamp >= AUDIO_GROUP_INTERVAL_US) {
+                        isKey = true;
+                        lastAudioKeyTimestamp = chunk.timestamp;
+                    }
+                    // Framing: [timestamp 8B big-endian][encoded data]
+                    const buffer = new ArrayBuffer(8 + chunk.byteLength);
+                    const view = new DataView(buffer);
+                    view.setBigInt64(0, BigInt(chunk.timestamp), false);
+                    const data = new Uint8Array(buffer);
+                    chunk.copyTo(new Uint8Array(buffer, 8));
+                    trackPub.push(data, { isKey, timestamp: chunk.timestamp });
+                },
+                error: (e) => console.error("MoQ AudioEncoder error", e)
+            });
+            encoder.configure({
+                codec: 'opus',
+                sampleRate: 48000,
+                numberOfChannels: 1
+            });
+        }
+        // Read Loop
+        (async () => {
+            let frameCount = 0;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (value) {
+                        try {
+                            if (encoder && encoder.state !== 'closed') {
+                                // For video: force a key frame every ~2 seconds (48 frames at 24fps)
+                                if (track.kind === 'video' && frameCount % 48 === 0) {
+                                    encoder.encode(value, { keyFrame: true });
+                                }
+                                else {
+                                    encoder.encode(value);
+                                }
+                                frameCount++;
+                            }
+                        }
+                        finally {
+                            value.close();
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`Read error`, e);
+            }
+            finally {
+                if (trackPub && trackPub.close)
+                    trackPub.close();
+            }
+        })();
+    }
+}

package/dist/moq/MoQPublisher.d.ts

@@ -0,0 +1,22 @@
+import { MoQSession } from './MoQSession';
+export declare class MoQPublisher {
+    private session;
+    private tracks;
+    private activePublishers;
+    constructor(session: MoQSession);
+    private pendingAnnounces;
+    announce(namespace: string): Promise<void>;
+    onAnnounceResult(namespace: string, error?: {
+        code: number;
+        reason: string;
+    }): void;
+    onSubscribe(msg: any): void;
+    onUnsubscribe(subscribeId: number): void;
+    createTrack(namespace: string, name: string): Promise<{
+        close: () => void;
+        push: (data: Uint8Array, init: {
+            isKey: boolean;
+            timestamp: number;
+        }) => Promise<void>;
+    } | null>;
+}

package/dist/moq/MoQPublisher.js

@@ -0,0 +1,179 @@
+import { BufferWriter, Mutex } from './common';
+export class MoQPublisher {
+    constructor(session) {
+        this.tracks = new Map();
+        this.activePublishers = new Map();
+        this.pendingAnnounces = new Map();
+        this.session = session;
+    }
+    async announce(namespace) {
+        // Send ANNOUNCE (MsgType 0x6)
+        console.log(`[MoQ] Announcing namespace: ${namespace}`);
+        const msg = {
+            type: 0x6, // ANNOUNCE
+            trackNamespace: namespace,
+            params: {} // Draft-07: Announce Params
+        };
+        return new Promise(async (resolve, reject) => {
+            this.pendingAnnounces.set(namespace, { resolve, reject });
+            // Set a timeout strictly for the announce response
+            const timeout = setTimeout(() => {
+                if (this.pendingAnnounces.has(namespace)) {
+                    this.pendingAnnounces.delete(namespace);
+                    reject(new Error("Announce timed out"));
+                }
+            }, 5000);
+            try {
+                await this.session.sendControlMessage(msg);
+            }
+            catch (e) {
+                clearTimeout(timeout);
+                this.pendingAnnounces.delete(namespace);
+                reject(e);
+            }
+        });
+    }
+    onAnnounceResult(namespace, error) {
+        const pending = this.pendingAnnounces.get(namespace);
+        if (pending) {
+            this.pendingAnnounces.delete(namespace);
+            if (error && error.code !== 0) { // Code 0 is usually success/no-error in some contexts, but here we expect OK msg for success.
+                // Actually ANNOUNCE_ERROR is strictly error.
+                pending.reject(new Error(`Announce failed: code=${error.code} reason=${error.reason}`));
+            }
+            else {
+                pending.resolve();
+            }
+        }
+    }
+    onSubscribe(msg) {
+        const trackId = `${msg.trackNamespace}/${msg.trackName}`;
+        console.log(`[MoQ] Publisher received SUBSCRIBE for ${trackId} -> subId=${msg.subscribeId} alias=${msg.trackAlias}`);
+        this.tracks.set(trackId, { subscribeId: msg.subscribeId, trackAlias: msg.trackAlias });
+    }
+    onUnsubscribe(subscribeId) {
+        for (const [key, val] of this.tracks.entries()) {
+            if (val.subscribeId === subscribeId) {
+                console.log(`[MoQ] Publisher received UNSUBSCRIBE for ${key} (subId=${subscribeId})`);
+                this.tracks.delete(key);
+                break;
+            }
+        }
+    }
+    async createTrack(namespace, name) {
+        const trackId = `${namespace}/${name}`;
+        if (this.activePublishers.has(trackId)) {
+            // console.log(`[MoQ] Already publishing ${trackId} - skipping duplicate publisher.`);
+            return null;
+        }
+        // We return a pusher immediately. Data will be dropped inside push() if no subscriber exists.
+        // Log occasionally?
+        // console.log(`[MoQ] Push ${data.byteLength} bytes to ${trackId}`);
+        let currentGroupWriter = null;
+        let currentGroupId = 0;
+        let currentObjectId = 0;
+        const mutex = new Mutex(); // Serialize access to writer
+        const closeCurrentGroup = () => {
+            if (currentGroupWriter) {
+                const oldWriter = currentGroupWriter;
+                currentGroupWriter = null;
+                // Fire-and-forget: close old stream in background
+                // This prevents blocking audio push() during group transition
+                oldWriter.close().catch(() => { });
+            }
+        };
+        const cleanup = () => {
+            console.log(`[MoQ] Stopping publisher for ${trackId}`);
+            closeCurrentGroup();
+            this.activePublishers.delete(trackId);
+        };
+        const openNewGroup = async () => {
+            closeCurrentGroup();
+            currentGroupId++;
+            currentObjectId = 0;
+            // Resolve track info dynamically
+            const trackInfo = this.tracks.get(trackId);
+            if (trackInfo === undefined) {
+                // console.warn(`[MoQ] Dropping group for ${trackId} - No alias/subscription`);
+                return;
+            }
+            const { subscribeId, trackAlias: currentAlias } = trackInfo;
+            // Open UniStream
+            const stream = await this.session.transport.createUnidirectionalStream();
+            const writer = stream.getWriter();
+            if (currentGroupId <= 2) {
+                console.log(`[MoQ] Opening Group ${currentGroupId} for ${trackId} (subId=${subscribeId} alias=${currentAlias})`);
+            }
+            const w = new BufferWriter();
+            w.writeVarInt(0x04); // StreamType: STREAM_HEADER_SUBGROUP (0x4)
+            w.writeVarInt(subscribeId); // Subscribe ID (Draft-07)
+            w.writeVarInt(currentAlias); // Track Alias
+            w.writeVarInt(currentGroupId); // Group ID
+            w.writeVarInt(0); // Subgroup ID (0 for now)
+            w.writeUint8(0); // Publisher Priority (8-bit)
+            await writer.write(w.toUint8Array());
+            currentGroupWriter = writer;
+        };
+        const publisher = {
+            close: cleanup,
+            push: async (data, init) => {
+                await mutex.dispatch(async () => {
+                    // Check if we have a valid alias (subscription active)
+                    // If not, we MUST NOT send data (Relay will STOP_SENDING)
+                    if (!this.tracks.has(trackId)) {
+                        // We are not subscribed yet. Drop data.
+                        // Ideally we buffer keyframes, but for now just drop to avoid crash.
+                        // process.stdout.write('.'); // dropped
+                        return;
+                    }
+                    // Decision logic:
+                    // 1. If isKey, we MUST start a new group (GOP boundary).
+                    // 2. If !isKey but we have a writer, we continue current group.
+                    // 3. If !isKey and NO writer, we MUST DROP the frame (cannot start group with delta).
+                    if (init.isKey) {
+                        await openNewGroup();
+                    }
+                    else if (!currentGroupWriter) {
+                        // Orphan delta — drop it to enforce Group=Keyframe start
+                        // This happens if group was closed (error/timeout) or joining mid-stream logic
+                        return;
+                    }
+                    // If openNewGroup failed (e.g. no alias), currentGroupWriter is null
+                    if (!currentGroupWriter)
+                        return;
+                    // Write Object
+                    // ObjectHeader:
+                    // VarInt ObjectId
+                    // VarInt Length
+                    // Payload
+                    const w = new BufferWriter();
+                    w.writeVarInt(currentObjectId++);
+                    w.writeVarInt(data.length);
+                    w.writeBytes(data);
+                    if (currentGroupWriter) {
+                        try {
+                            // @ts-ignore
+                            await currentGroupWriter.write(w.toUint8Array());
+                        }
+                        catch (e) {
+                            // Check for STOP_SENDING or similar WebTransport errors
+                            const msg = e.message || "";
+                            if (msg.includes("STOP_SENDING") || e.name === "WebTransportError") {
+                                // STOP_SENDING on a Group Stream just means the subscriber dropped this specific group
+                                // (e.g. because it was late or they skipped ahead).
+                                // We should continue publishing the next group.
+                                console.warn(`[MoQ] Group stream closed by remote (STOP_SENDING) for ${trackId}.`);
+                                currentGroupWriter = null;
+                            }
+                            else {
+                                console.error(`[MoQ] Writer error for ${trackId}:`, e);
+                            }
+                        }
+                    }
+                });
+            }
+        };
+        this.activePublishers.set(trackId, publisher);
+        return publisher;
+    }
+}

package/dist/moq/MoQSession.d.ts

@@ -0,0 +1,35 @@
+import { MoQPublisher } from './MoQPublisher';
+import { MoQSubscriber } from './MoQSubscriber';
+export interface TransportInterface {
+    createBidirectionalStream(): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    createUnidirectionalStream(): Promise<WritableStream<Uint8Array>>;
+    incomingBidirectionalStreams: ReadableStream<any>;
+    incomingUnidirectionalStreams: ReadableStream<ReadableStream<Uint8Array>>;
+    close(): void;
+    ready: Promise<void>;
+}
+export declare class MoQSession {
+    transport: TransportInterface;
+    private controlStreamWriter;
+    private controlStreamReader;
+    private role;
+    setupComplete: boolean;
+    private setupResolve;
+    private setupPromise;
+    maxSubscribeId: number;
+    private streamBuffer;
+    publisher: MoQPublisher;
+    subscriber: MoQSubscriber;
+    constructor(transport: TransportInterface, onObject?: (ns: string, name: string, obj: Uint8Array, meta: any) => void, role?: number);
+    /** Wait for handshake to complete before sending ANNOUNCE/SUBSCRIBE */
+    waitForSetup(): Promise<void>;
+    init(): Promise<void>;
+    private readUniStreams;
+    sendControlMessage(msg: any): Promise<void>;
+    private readLoop;
+    private processBuffer;
+    private handleControlMessage;
+}

package/dist/moq/MoQSession.js

@@ -0,0 +1,166 @@
+import { MoQSerializer, MsgType } from './messages';
+import { StreamBuffer } from './common';
+import { MoQPublisher } from './MoQPublisher';
+import { MoQSubscriber } from './MoQSubscriber';
+export class MoQSession {
+    constructor(transport, onObject, role = 3) {
+        this.controlStreamWriter = null;
+        this.controlStreamReader = null;
+        this.setupComplete = false;
+        this.setupResolve = null;
+        this.maxSubscribeId = 0;
+        this.streamBuffer = new StreamBuffer();
+        this.transport = transport;
+        this.role = role;
+        this.setupPromise = new Promise((resolve) => {
+            this.setupResolve = resolve;
+        });
+        this.publisher = new MoQPublisher(this);
+        this.subscriber = new MoQSubscriber(this, onObject || ((ns, n, o, m) => console.log(`[MoQ] Object: ${ns}/${n}`, m)));
+    }
+    /** Wait for handshake to complete before sending ANNOUNCE/SUBSCRIBE */
+    async waitForSetup() {
+        return this.setupPromise;
+    }
+    async init() {
+        await this.transport.ready;
+        // Initiate Control Stream
+        // For Client, we open a BiStream.
+        const stream = await this.transport.createBidirectionalStream();
+        this.controlStreamWriter = stream.writable.getWriter();
+        this.controlStreamReader = stream.readable.getReader();
+        // Send CLIENT_SETUP
+        const setupMsg = {
+            type: MsgType.CLIENT_SETUP,
+            supportedVersions: [0xff000007],
+            role: this.role,
+        };
+        await this.sendControlMessage(setupMsg);
+        // Start Reading Control
+        this.readLoop();
+        // Start Reading UniStreams (Data)
+        this.readUniStreams();
+    }
+    async readUniStreams() {
+        const uniReader = this.transport.incomingUnidirectionalStreams.getReader();
+        try {
+            while (true) {
+                const { done, value } = await uniReader.read();
+                if (done)
+                    break;
+                if (value && this.subscriber) {
+                    this.subscriber.handleIncomingUniStream(value);
+                }
+            }
+        }
+        catch (e) {
+            console.error("UniStream Loop Error", e);
+        }
+    }
+    async sendControlMessage(msg) {
+        const bytes = MoQSerializer.serialize(msg);
+        if (!this.controlStreamWriter)
+            throw new Error("Control stream not open");
+        await this.controlStreamWriter.write(bytes);
+    }
+    async readLoop() {
+        if (!this.controlStreamReader)
+            return;
+        try {
+            while (true) {
+                const { done, value } = await this.controlStreamReader.read();
+                if (done) {
+                    console.warn("[MoQ] Control Stream Closed by Remote");
+                    break;
+                }
+                if (value) {
+                    console.log(`[MoQ] Control Stream RX: ${value.byteLength} bytes`);
+                    this.streamBuffer.append(value);
+                    this.processBuffer();
+                }
+            }
+        }
+        catch (e) {
+            console.error("Control stream error", e);
+        }
+        console.log("[MoQ] Read Loop Exited");
+    }
+    processBuffer() {
+        while (true) {
+            // console.log(`[MoQ] Processing Buffer. Offset: ${(this.streamBuffer as any).offset}, Remaining: ${(this.streamBuffer as any).buffer.length - (this.streamBuffer as any).offset}`);
+            // Try to deserialize a message
+            let msg;
+            try {
+                msg = MoQSerializer.deserialize(this.streamBuffer);
+            }
+            catch (e) {
+                console.error("[MoQ] Deserialization Error:", e);
+                // fatal?
+                break;
+            }
+            if (!msg) {
+                // Not enough data yet (encountered EOF during parse)
+                // Rewind happens in deserialize if it catches EOF
+                break;
+            }
+            // Msg Successfully Parsed
+            this.handleControlMessage(msg);
+        }
+    }
+    handleControlMessage(msg) {
+        switch (msg.type) {
+            case MsgType.SERVER_SETUP:
+                console.log(`[MoQ] Handshake Complete. Server selected version: 0x${msg.selectedVersion.toString(16)}`);
+                this.setupComplete = true;
+                if (this.setupResolve) {
+                    this.setupResolve();
+                    this.setupResolve = null;
+                }
+                break;
+            case MsgType.MAX_SUBSCRIBE_ID:
+                this.maxSubscribeId = msg.subscribeId;
+                console.log(`[MoQ] Max Subscribe ID updated: ${this.maxSubscribeId}`);
+                break;
+            case MsgType.SUBSCRIBE:
+                // Relay (or Peer) wants to subscribe to our track.
+                this.publisher.onSubscribe(msg);
+                // Send SUBSCRIBE_OK
+                const subOk = {
+                    type: MsgType.SUBSCRIBE_OK,
+                    subscribeId: msg.subscribeId,
+                    expires: 0
+                };
+                this.sendControlMessage(subOk).catch(console.error);
+                break;
+            case MsgType.SUBSCRIBE_OK:
+                console.log(`[MoQ] SUBSCRIBE_OK for id=${msg.subscribeId}`);
+                this.subscriber.onSubscribeOk(msg.subscribeId);
+                break;
+            case MsgType.SUBSCRIBE_ERROR:
+                console.error(`[MoQ] SUBSCRIBE_ERROR for id=${msg.subscribeId} code=${msg.code}`);
+                this.subscriber.onSubscribeError(msg.subscribeId, msg.code).catch(console.error);
+                break;
+            case MsgType.ANNOUNCE_OK:
+                console.log(`[MoQ] ANNOUNCE_OK for ns=${msg.trackNamespace}`);
+                this.publisher.onAnnounceResult(msg.trackNamespace);
+                break;
+            case MsgType.ANNOUNCE_ERROR:
+                console.error(`[MoQ] ANNOUNCE_ERROR for ns=${msg.trackNamespace} code=${msg.code}`);
+                this.publisher.onAnnounceResult(msg.trackNamespace, { code: msg.code, reason: msg.reasonPhrase || "Unknown" });
+                break;
+            case MsgType.UNSUBSCRIBE:
+                // Relay (or Peer) wants to stop receiving our track.
+                this.publisher.onUnsubscribe(msg.subscribeId);
+                break;
+            case MsgType.SUBSCRIBE_DONE:
+                // Relay (or Peer) says the stream is finished.
+                this.subscriber.onSubscribeDone(msg.subscribeId, msg.code, msg.reason);
+                break;
+            case MsgType.GOAWAY:
+                console.warn(`[MoQ] GOAWAY received`);
+                break;
+            default:
+                console.log(`[MoQ] Received Control Message type=0x${msg.type.toString(16)}`);
+        }
+    }
+}

package/dist/moq/MoQSubscriber.d.ts

@@ -0,0 +1,19 @@
+import { MoQSession } from './MoQSession';
+export declare class MoQSubscriber {
+    private session;
+    private onObject;
+    constructor(session: MoQSession, onObject: (ns: string, name: string, obj: Uint8Array, meta: any) => void);
+    private aliasMap;
+    private nextAlias;
+    private nextSubscribeId;
+    private pendingSubscriptions;
+    private deliveryState;
+    private activeSubscriptions;
+    subscribe(namespace: string, name: string): Promise<void>;
+    onSubscribeOk(subscribeId: number): void;
+    onSubscribeError(subscribeId: number, code: number): Promise<void>;
+    onSubscribeDone(subscribeId: number, code: number, reason: string): void;
+    private wakeDelivery;
+    private runDeliveryLoop;
+    handleIncomingUniStream(stream: ReadableStream<Uint8Array>): Promise<void>;
+}