openrtc 0.1.0

package/dist/api/PlutoPeerConnection.js

@@ -0,0 +1,434 @@
+import { MediaTransport } from './MediaTransport';
+import { MoQMediaTransport } from '../moq/MoQMediaTransport';
+import { TransportFactory } from '../core/transports/TransportFactory';
+// Tiny SDP helpers to make the ticket look like an SDP so generic parsers don't choke immediately
+// although we usually just pass the string. The demo code uses desc.sdp.
+function toSDP(ticket) {
+    return `v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\na=pluto-ticket:${ticket}\r\n`;
+}
+function fromSDP(sdp) {
+    const match = sdp.match(/a=pluto-ticket:(.+)(\r\n|$)/);
+    return match ? match[1] : null;
+}
+export class PlutoPeerConnection extends EventTarget {
+    static setDefaultClient(client) {
+        this.defaultClient = client;
+    }
+    // MoQ State helpers using Client
+    get useMoq() {
+        return this.client.moqState === 'ready';
+    }
+    get transportInfo() {
+        return {
+            signaling: this.connection?.transportType || 'disconnected',
+            media: this.useMoq ? 'moq' : (this.connection?.transportType || 'disconnected')
+        };
+    }
+    constructor(configuration, clientInstance) {
+        super();
+        this.onicecandidate = null;
+        this.oniceconnectionstatechange = null;
+        this.ontrack = null;
+        this.onsignalingstatechange = null;
+        this.connectionState = 'new';
+        this.iceConnectionState = 'new';
+        this.signalingState = 'stable';
+        this.localDescription = null;
+        this.remoteDescription = null;
+        this.connection = null;
+        /**
+         * Manually provide an existing connection (e.g. from an incoming connection listener)
+         */
+        this.bufferTracks = [];
+        this.receivers = {};
+        // MoQ receivers: direct WebCodecs decode (bypass MediaTransport framing)
+        this.moqDecoders = {};
+        this.moqGenerators = {};
+        this.mediaSenders = {};
+        TransportFactory.assertProtocolAvailable('webrtc');
+        // Try to resolve client: constructor arg -> config arg (custom) -> static default
+        const client = clientInstance || configuration?.client || PlutoPeerConnection.defaultClient;
+        if (!client) {
+            throw new Error("PlutoPeerConnection requires a 'Client' instance. Pass it in constructor or use PlutoPeerConnection.setDefaultClient().");
+        }
+        this.client = client;
+        // MoQ is configured at Client level via experimental.moq
+    }
+    async createOffer(options) {
+        // Get our ticket
+        let ticket;
+        try {
+            ticket = await this.client.getTicket();
+        }
+        catch (e) {
+            console.error("Failed to get ticket for offer:", e);
+            ticket = "error-no-ticket";
+        }
+        const sdp = toSDP(ticket);
+        return { type: 'offer', sdp };
+    }
+    async createAnswer(options) {
+        // Return dummy answer. 
+        return { type: 'answer', sdp: toSDP('answer-dummy') };
+    }
+    async setLocalDescription(desc) {
+        this.localDescription = desc;
+        this.signalingState = (desc.type === 'offer') ? 'have-local-offer' : 'stable';
+        // If we just set a local offer, we should simulate gathering candidates (immediate finish)
+        if (desc.type === 'offer') {
+            setTimeout(() => {
+                // Emit a null candidate to signal end of candidates
+                const event = new Event('icecandidate');
+                event.candidate = null;
+                if (this.onicecandidate)
+                    this.onicecandidate(event);
+                this.dispatchEvent(event);
+            }, 10);
+        }
+    }
+    async setRemoteDescription(desc) {
+        this.remoteDescription = desc;
+        this.signalingState = (desc.type === 'offer') ? 'have-remote-offer' : 'stable';
+        // Check if description has a ticket
+        const ticket = fromSDP(desc.sdp || '');
+        if (ticket && ticket !== 'answer-dummy' && ticket !== 'error-no-ticket') {
+            // We received a ticket! Connect to it.
+            this.connect(ticket);
+        }
+    }
+    async addIceCandidate(candidate) {
+        // No-op for Iroh/Pluto
+        return;
+    }
+    async handleIncomingConnection(connection) {
+        this.connection = connection;
+        this.setupHooks();
+        // Flush buffered tracks
+        this.bufferTracks.forEach(t => this.addTrack(t.track));
+        this.bufferTracks = [];
+    }
+    setupHooks() {
+        if (!this.connection)
+            return;
+        this.connection.onDisconnect(() => this.close());
+        this.connection.onTrack((ev) => {
+            // Native WebRTC Track
+            if (this.ontrack)
+                this.ontrack(ev);
+            const newEvent = new RTCTrackEvent('track', {
+                track: ev.track,
+                streams: [...ev.streams],
+                receiver: ev.receiver,
+                transceiver: ev.transceiver
+            });
+            this.dispatchEvent(newEvent);
+        });
+        // Use Client-level MoQ listeners
+        // Only process objects where namespace == remote deviceId
+        const moqObjectHandler = (ns, name, obj, meta) => {
+            if (this.connection && ns === this.connection.remoteNodeId) {
+                if (name.startsWith('data/')) {
+                    this.handleMoQData(obj);
+                }
+                else {
+                    this.handleMoQMedia(ns, name, obj, meta);
+                }
+            }
+        };
+        this.client.onMoQObject(moqObjectHandler);
+        // Iroh media fallback (used when MoQ is not available)
+        this.connection.onMedia((type, data) => {
+            if (!this.useMoq) {
+                this.handleLegacyMedia(type, data);
+            }
+        });
+        // MoQ Subscription Logic
+        const subscribeMoQ = () => {
+            if (this.client.moq && this.connection) {
+                console.log(`[PPC] MoQ Ready — subscribing to ${this.connection.remoteNodeId} media`);
+                this.client.moq.subscriber.subscribe(this.connection.remoteNodeId, "audio");
+                this.client.moq.subscriber.subscribe(this.connection.remoteNodeId, "video");
+                // Data Tracks
+                this.client.moq.subscriber.subscribe(this.connection.remoteNodeId, "data/broadcast");
+                this.client.getNodeId().then(myId => {
+                    if (this.connection)
+                        this.client.moq?.subscriber.subscribe(this.connection.remoteNodeId, `data/${myId}`);
+                });
+            }
+        };
+        if (this.client.moqState === 'ready') {
+            subscribeMoQ();
+        }
+        else if (this.client.moqState === 'connecting') {
+            this.client.onMoQReady(subscribeMoQ);
+        }
+    }
+    handleLegacyMedia(type, data) {
+        let track = this.receivers[type];
+        if (!track) {
+            // New track received!
+            track = MediaTransport.receiveTrack(type, () => {
+                this.connection?.send({ type: 'PLI', kind: type }).catch(console.error);
+            });
+            if (track) {
+                this.receivers[type] = track;
+                this.fireTrackEvent(track);
+            }
+        }
+        if (track)
+            (track.feed(data));
+    }
+    handleMoQMedia(namespace, name, object, meta) {
+        const trackId = `${namespace}/${name}`;
+        const kind = name.includes('video') ? 'video' : 'audio';
+        // Create receiver track + decoder on first object
+        if (!this.receivers[trackId]) {
+            const generator = new window.MediaStreamTrackGenerator({ kind });
+            const writer = generator.writable.getWriter();
+            this.moqGenerators[trackId] = generator;
+            if (kind === 'video') {
+                const decoder = new window.VideoDecoder({
+                    output: (frame) => {
+                        try {
+                            writer.write(frame);
+                        }
+                        finally {
+                            frame.close();
+                        }
+                    },
+                    error: (e) => console.error("MoQ VideoDecoder error", e)
+                });
+                decoder.configure({ codec: 'vp09.00.10.08' });
+                decoder.waitingForKeyFrame = true;
+                this.moqDecoders[trackId] = decoder;
+            }
+            else {
+                const decoder = new window.AudioDecoder({
+                    output: (data) => { writer.write(data); },
+                    error: (e) => console.error("MoQ AudioDecoder error", e)
+                });
+                decoder.configure({ codec: 'opus', sampleRate: 48000, numberOfChannels: 1 });
+                this.moqDecoders[trackId] = decoder;
+            }
+            this.receivers[trackId] = generator;
+            this.fireTrackEvent(generator);
+        }
+        const decoder = this.moqDecoders[trackId];
+        if (!decoder || decoder.state === 'closed')
+            return;
+        if (kind === 'video') {
+            // First object in a group (objectId=0) is assumed to be the keyframe
+            const isKey = meta.objectId === 0;
+            if (!isKey && decoder.waitingForKeyFrame) {
+                return; // Drop delta frames until we get a keyframe
+            }
+            try {
+                // Parse [timestamp 8B big-endian][encoded data]
+                const view = new DataView(object.buffer, object.byteOffset, object.byteLength);
+                const timestamp = Number(view.getBigInt64(0, false));
+                const encodedData = object.slice(8);
+                const chunk = new window.EncodedVideoChunk({
+                    type: isKey ? 'key' : 'delta',
+                    timestamp,
+                    data: encodedData
+                });
+                decoder.decode(chunk);
+                // If we got here without error, this keyframe was valid
+                if (isKey) {
+                    decoder.waitingForKeyFrame = false;
+                }
+            }
+            catch (e) {
+                // VP8 realtime encoder can report type='key' but produce delta bitstream.
+                // Reset decoder and wait for next group's real keyframe.
+                if (isKey) {
+                    console.warn("[MoQ] Video keyframe rejected by decoder — waiting for next group");
+                }
+                decoder.waitingForKeyFrame = true;
+                // Reset decoder to clear any corrupted state
+                try {
+                    decoder.reset();
+                    decoder.configure({ codec: 'vp09.00.10.08' });
+                }
+                catch (_) { /* decoder may already be closed */ }
+            }
+        }
+        else {
+            // Audio: all Opus frames are independently decodable
+            try {
+                // Parse [timestamp 8B big-endian][encoded data]
+                const view = new DataView(object.buffer, object.byteOffset, object.byteLength);
+                const timestamp = Number(view.getBigInt64(0, false));
+                const encodedData = object.slice(8);
+                const chunk = new window.EncodedAudioChunk({
+                    type: 'key',
+                    timestamp,
+                    data: encodedData
+                });
+                decoder.decode(chunk);
+            }
+            catch (e) {
+                console.error("[MoQ] Audio decode error:", e);
+            }
+        }
+    }
+    handleMoQData(object) {
+        // MoQ Data Payload: [Len][Type][Payload] ??
+        // In Connection.sendTyped, we framed it: [Len 4][Type 1][Payload].
+        // So `object` here IS the frame.
+        // We can pass it directly to `connection.handleData`?
+        // `connection.handleData` expects streamed chunks and buffers them.
+        // `object` is a discrete unit.
+        // We can synthesize a chunk push to Connection?
+        // Or unpack here?
+        // If we pass to `connection.handleData`, it will parse the length header.
+        // Since `object` IS the frame (as sent by sendTyped), this works!
+        // We just need to expose `handleData` or similar on Connection?
+        // `Connection.handleData` is private.
+        // But `Connection` reads from `reader`.
+        // We can push to `reader` stream?
+        // `Connection` constructor takes `reader`.
+        // We can't access `reader` easily from outside.
+        // Alternative: Add `injectData(chunk: Uint8Array)` to Connection.
+        if (this.connection) {
+            // @ts-ignore - Accessing private for now or add public method
+            if (typeof this.connection['handleData'] === 'function') {
+                // @ts-ignore
+                this.connection['handleData'](object);
+            }
+        }
+    }
+    fireTrackEvent(track) {
+        const event = new Event('track');
+        event.track = track;
+        event.streams = [new MediaStream([track])];
+        event.receiver = { track };
+        event.transceiver = { receiver: event.receiver, sender: {}, direction: 'receiveonly' };
+        if (this.ontrack)
+            this.ontrack(event);
+        this.dispatchEvent(event);
+    }
+    addTrack(track, ...streams) {
+        const sender = {
+            track,
+            replaceTrack: async () => { },
+            getStats: async () => new Map()
+        };
+        if (this.connection) {
+            // Transport Choice: MoQ (via Client) > Iroh
+            if (this.client.moqState === 'ready') {
+                this.startMoQStream(track);
+            }
+            else if (this.client.moqState === 'connecting') {
+                console.log("[PPC] addTrack: MoQ connecting, waiting...");
+                const onReady = () => {
+                    console.log("[PPC] MoQ ready, starting stream");
+                    this.startMoQStream(track);
+                };
+                const onFailed = () => {
+                    console.warn("[PPC] MoQ failed, falling back to Iroh");
+                    this.startIrohStream(track);
+                };
+                this.client.onMoQReady(onReady);
+                this.client.onMoQFailed(onFailed);
+            }
+            else {
+                // Legacy Iroh
+                this.startIrohStream(track);
+            }
+        }
+        else {
+            this.bufferTracks.push({ track });
+        }
+        return sender;
+    }
+    async startIrohStream(track) {
+        if (!this.connection)
+            return;
+        const conn = this.connection;
+        try {
+            const sender = await MediaTransport.sendTrack(track, async (data) => {
+                if (!this.connection || this.connection.isClosed)
+                    throw new Error("Connection closed");
+                try {
+                    await conn.sendMedia(track.kind, data);
+                }
+                catch (e) {
+                    if (e.message && e.message.includes('Connection is closed'))
+                        return;
+                    console.error("Iroh send failed", e);
+                }
+            });
+            if (sender) {
+                this.mediaSenders[track.kind] = sender;
+            }
+        }
+        catch (e) {
+            console.error("Failed to start Iroh stream", e);
+        }
+    }
+    async startMoQStream(track) {
+        if (this.client.moqState !== 'ready' || !this.client.moq)
+            return;
+        console.log(`[PPC] Starting MoQ Stream for ${track.kind}`);
+        try {
+            // Use shared transport
+            const transport = new MoQMediaTransport(this.client.moq.publisher);
+            // Namespace is LOCAL node ID (client knows it)
+            const namespace = await this.client.getNodeId();
+            await transport.sendTrack(track, namespace, track.kind);
+            console.log(`[MoQ] Started publishing track: ${track.kind} to ${namespace}`);
+        }
+        catch (e) {
+            console.error("Failed to start MoQ stream", e);
+        }
+    }
+    createDataChannel(label) {
+        // We return a proxy that calls connection.send
+        return new PlutoDataChannel(label, this);
+    }
+    sendData(data) {
+        this.connection?.send(data);
+    }
+    async connect(ticket) {
+        this.connection = await this.client.connect(ticket);
+        this.setupHooks();
+        // Flush any buffered tracks now that we are connected
+        this.bufferTracks.forEach(t => this.addTrack(t.track));
+        this.bufferTracks = [];
+        this.updateState('connected');
+    }
+    close() {
+        this.connection?.disconnect();
+        // Stop all legacy senders
+        Object.values(this.mediaSenders).forEach(sender => {
+            try {
+                sender.stop();
+            }
+            catch (e) {
+                console.warn("Error stopping sender", e);
+            }
+        });
+        this.mediaSenders = {};
+        this.updateState('closed');
+    }
+    updateState(state) {
+        this.connectionState = state;
+        this.iceConnectionState = (state === 'closed') ? 'closed' : 'connected'; // aprox
+        this.dispatchEvent(new Event('connectionstatechange'));
+        this.dispatchEvent(new Event('iceconnectionstatechange'));
+    }
+}
+PlutoPeerConnection.defaultClient = null;
+// ... Simple Data Channel Proxy ...
+class PlutoDataChannel extends EventTarget {
+    constructor(label, pc) {
+        super();
+        this.label = label;
+        this.pc = pc;
+        setTimeout(() => this.emitOpen(), 0);
+    }
+    send(data) { this.pc.sendData(data); }
+    emitOpen() { this.dispatchEvent(new Event('open')); if (this.onopen)
+        this.onopen(new Event('open')); }
+}

package/dist/api/PlutoWebSocket.d.ts

@@ -0,0 +1,24 @@
+import { Client } from '../core/Client';
+export declare class PlutoWebSocket extends EventTarget {
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    readonly url: string;
+    readyState: number;
+    bufferedAmount: number;
+    extensions: string;
+    protocol: string;
+    binaryType: "blob" | "arraybuffer";
+    onopen: ((this: PlutoWebSocket, ev: Event) => any) | null;
+    onmessage: ((this: PlutoWebSocket, ev: MessageEvent) => any) | null;
+    onclose: ((this: PlutoWebSocket, ev: CloseEvent) => any) | null;
+    onerror: ((this: PlutoWebSocket, ev: Event) => any) | null;
+    private client;
+    private connection;
+    constructor(url: string, protocols?: string | string[], clientInstance?: Client);
+    private connect;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    private handleClose;
+}

package/dist/api/PlutoWebSocket.js

@@ -0,0 +1,113 @@
+import { TransportFactory } from '../core/transports/TransportFactory';
+export class PlutoWebSocket extends EventTarget {
+    constructor(url, protocols, clientInstance) {
+        super();
+        this.readyState = PlutoWebSocket.CONNECTING;
+        this.bufferedAmount = 0;
+        this.extensions = "";
+        this.protocol = "";
+        this.binaryType = "blob";
+        this.onopen = null;
+        this.onmessage = null;
+        this.onclose = null;
+        this.onerror = null;
+        this.connection = null;
+        this.url = url;
+        TransportFactory.assertProtocolAvailable('websocket');
+        // We need a Client instance. If not provided, we have to throw or use a singleton?
+        // Since Pluto requires setup (tag, auth), it's hard to make a 100% drop-in without configuration.
+        // We will assume the user has a Client initialized or we provide one via a static method,
+        // BUT for a true new WebSocket replacement, we might rely on a global or strictly require a passed client if not configuring here.
+        // However, the standard WebSocket(url) doesn't take a client.
+        // To make it easy, we will support passing the client in the 2nd arg if protocols is ignored/abused, 
+        // or just expect the developer to instantiate this class with the client.
+        if (clientInstance) {
+            this.client = clientInstance;
+        }
+        else {
+            throw new Error("PlutoWebSocket requires a 'Client' instance to be passed in constructor currently.");
+        }
+        this.connect();
+    }
+    async connect() {
+        try {
+            // URL format: pluto://<ticket>
+            let ticket = this.url;
+            if (ticket.startsWith('pluto://')) {
+                ticket = ticket.replace('pluto://', '');
+            }
+            else if (ticket.startsWith('wss://') || ticket.startsWith('ws://')) {
+                // Ignore standard WS urls or treat as ticket?
+                // Assume ticket only for now.
+            }
+            this.connection = await this.client.connect(ticket);
+            this.readyState = PlutoWebSocket.OPEN;
+            const event = new Event('open');
+            if (this.onopen)
+                this.onopen(event);
+            this.dispatchEvent(event);
+            this.connection.onMessage((msg) => {
+                let data = msg;
+                // If msg is buffer/uint8array, respect binaryType
+                if (this.binaryType === 'arraybuffer' && (msg instanceof Uint8Array)) {
+                    data = msg.buffer;
+                }
+                const msgEvent = new MessageEvent('message', {
+                    data,
+                    origin: this.url,
+                });
+                if (this.onmessage)
+                    this.onmessage(msgEvent);
+                this.dispatchEvent(msgEvent);
+            });
+            this.connection.onDisconnect(() => {
+                this.handleClose();
+            });
+        }
+        catch (e) {
+            console.error("WebSocket connection failure:", e);
+            const event = new Event('error');
+            if (this.onerror)
+                this.onerror(event);
+            this.dispatchEvent(event);
+            this.handleClose(1006, "Connection failed");
+        }
+    }
+    send(data) {
+        if (this.readyState !== PlutoWebSocket.OPEN || !this.connection) {
+            throw new Error("WebSocket is not open");
+        }
+        if (data instanceof Blob) {
+            data.arrayBuffer().then(buf => {
+                this.connection?.send(buf);
+            });
+        }
+        else {
+            // @ts-ignore - Connection.send handles these
+            this.connection.send(data);
+        }
+    }
+    close(code, reason) {
+        if (this.readyState === PlutoWebSocket.CLOSED)
+            return;
+        this.readyState = PlutoWebSocket.CLOSING;
+        if (this.connection) {
+            this.connection.disconnect();
+        }
+        // Force close if it takes too long? 
+        this.handleClose(code, reason);
+    }
+    handleClose(code = 1000, reason = "") {
+        if (this.readyState === PlutoWebSocket.CLOSED)
+            return;
+        this.readyState = PlutoWebSocket.CLOSED;
+        const event = new CloseEvent('close', { code, reason, wasClean: true });
+        if (this.onclose)
+            this.onclose(event);
+        this.dispatchEvent(event);
+    }
+}
+PlutoWebSocket.CONNECTING = 0;
+PlutoWebSocket.OPEN = 1;
+PlutoWebSocket.CLOSING = 2;
+PlutoWebSocket.CLOSED = 3;

package/dist/api/PlutoWebTransport.d.ts

@@ -0,0 +1,29 @@
+import { Client } from '../core/Client';
+export declare class PlutoWebTransport {
+    readonly ready: Promise<void>;
+    closed: Promise<void>;
+    datagrams: any;
+    incomingBidirectionalStreams: ReadableStream<WebTransportBidirectionalStream>;
+    incomingUnidirectionalStreams: ReadableStream<ReadableStream<Uint8Array>>;
+    private client;
+    private connection;
+    private url;
+    private _readyResolve;
+    private _readyReject;
+    private _closedResolve;
+    private _closedReject;
+    private incomingBiController;
+    private incomingUniController;
+    private remoteNodeId;
+    private offIncomingStreams;
+    constructor(url: string, options?: any, clientInstance?: Client);
+    private setupListeners;
+    private connect;
+    createBidirectionalStream(): Promise<WebTransportBidirectionalStream>;
+    createUnidirectionalStream(): Promise<WritableStream<Uint8Array>>;
+    close(): void;
+}
+export interface WebTransportBidirectionalStream {
+    readable: ReadableStream<Uint8Array>;
+    writable: WritableStream<Uint8Array>;
+}