openrtc 0.1.0 → 0.1.2

package/dist/core/trust.d.ts

@@ -1,23 +0,0 @@
-export declare const TRANSPORT_TRUST_VERSION = 1;
-export interface TrustedDeviceMetadataRecord {
-    version: number;
-    identityPublicKey: string;
-    identityFingerprint: string;
-}
-export interface LocalTrustedIdentityRecord {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
-    fingerprint: string;
-}
-export interface TransportTrustPayload {
-    version: number;
-    deviceId: string;
-    identityFingerprint: string;
-    challenge?: string;
-    signedChallenge?: string;
-}
-export declare function createTransportTrustChallenge(byteLength?: number): string;
-export declare function signTransportTrustChallenge(challenge: string, identitySecretKey: Uint8Array): string;
-export declare function verifyTransportTrustChallenge(challenge: string, signedChallenge: string, identityPublicKey: string): boolean;
-export declare function parseTrustedDeviceMetadata(metadata?: string | null): TrustedDeviceMetadataRecord | null;
-export declare function getLocalTrustedIdentity(): Promise<LocalTrustedIdentityRecord | null>;

package/dist/core/trust.js

@@ -1,99 +0,0 @@
-import * as nacl from 'tweetnacl';
-const TRUSTED_DEVICE_METADATA_KEY = 'trustedDevice';
-const TRUSTED_IDENTITY_STORAGE_KEY = 'plutonium:e2ee:identity:v1';
-export const TRANSPORT_TRUST_VERSION = 1;
-function decodeBase64(value) {
-    const binary = atob(value);
-    const bytes = new Uint8Array(binary.length);
-    for (let index = 0; index < binary.length; index += 1) {
-        bytes[index] = binary.charCodeAt(index);
-    }
-    return bytes;
-}
-function encodeBase64(value) {
-    let binary = '';
-    for (let index = 0; index < value.length; index += 1) {
-        binary += String.fromCharCode(value[index]);
-    }
-    return btoa(binary);
-}
-async function computeFingerprint(publicKey) {
-    const hashBuffer = await crypto.subtle.digest('SHA-256', publicKey);
-    const hashBytes = new Uint8Array(hashBuffer);
-    return Array.from(hashBytes)
-        .map((byte) => byte.toString(16).padStart(2, '0'))
-        .join('');
-}
-export function createTransportTrustChallenge(byteLength = 32) {
-    const challenge = crypto.getRandomValues(new Uint8Array(byteLength));
-    return encodeBase64(challenge);
-}
-export function signTransportTrustChallenge(challenge, identitySecretKey) {
-    const signature = nacl.sign.detached(decodeBase64(challenge), identitySecretKey);
-    return encodeBase64(signature);
-}
-export function verifyTransportTrustChallenge(challenge, signedChallenge, identityPublicKey) {
-    try {
-        return nacl.sign.detached.verify(decodeBase64(challenge), decodeBase64(signedChallenge), decodeBase64(identityPublicKey));
-    }
-    catch {
-        return false;
-    }
-}
-export function parseTrustedDeviceMetadata(metadata) {
-    if (!metadata || !metadata.trim()) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(metadata);
-        const record = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-            ? parsed[TRUSTED_DEVICE_METADATA_KEY]
-            : null;
-        if (!record || typeof record !== 'object' || Array.isArray(record)) {
-            return null;
-        }
-        const normalized = record;
-        const version = typeof normalized.version === 'number' ? normalized.version : null;
-        const identityPublicKey = typeof normalized.identityPublicKey === 'string' ? normalized.identityPublicKey : null;
-        const identityFingerprint = typeof normalized.identityFingerprint === 'string'
-            ? normalized.identityFingerprint
-            : null;
-        if (!version || !identityPublicKey || !identityFingerprint) {
-            return null;
-        }
-        return {
-            version,
-            identityPublicKey,
-            identityFingerprint,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function getLocalTrustedIdentity() {
-    if (typeof localStorage === 'undefined') {
-        return null;
-    }
-    const raw = localStorage.getItem(TRUSTED_IDENTITY_STORAGE_KEY);
-    if (!raw) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.publicKey !== 'string' || typeof parsed.secretKey !== 'string') {
-            return null;
-        }
-        const publicKey = decodeBase64(parsed.publicKey);
-        const secretKey = decodeBase64(parsed.secretKey);
-        const fingerprint = await computeFingerprint(publicKey);
-        return {
-            publicKey,
-            secretKey,
-            fingerprint,
-        };
-    }
-    catch {
-        return null;
-    }
-}

package/dist/core/types.js

@@ -1,19 +0,0 @@
-// --- Billing / Plan Types ---
-export const DEFAULT_FREE_LIMITS = {
-    devicesPerUser: 2,
-    maxRooms: 10,
-    maxMembersPerRoom: 5,
-    maxPersonalDevices: 50, // free: 10 rooms * 5 members = 50
-};
-// --- Constants ---
-export const DEFAULT_MOQ_RELAY_URL = 'https://relay.cloudflare.mediaoverquic.com';
-export const DEFAULT_ICE_SERVERS = [
-    { urls: 'stun:stun.l.google.com:19302' },
-    { urls: 'stun:stun.cloudflare.com:3478' }
-];
-export const DEFAULT_WEBRTC_CONFIG = {
-    iceServers: DEFAULT_ICE_SERVERS
-};
-export const DEFAULT_MOQ_CONFIG = {
-    relayUrl: DEFAULT_MOQ_RELAY_URL
-};

package/dist/moq/MoQMediaTransport.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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>;
-}