openrtc 0.1.0

package/dist/core/Connection.d.ts

@@ -0,0 +1,67 @@
+import { ConnectionOptions } from './types';
+export declare class Connection {
+    private static readonly textDecoder;
+    private static readonly textEncoder;
+    private listeners;
+    private closeListeners;
+    private writer;
+    private reader;
+    private _isClosed;
+    get isClosed(): boolean;
+    private receiveBuffer;
+    readonly id: string;
+    readonly remoteNodeId: string;
+    /** @deprecated Compatibility alias for legacy consumers. This is the remote node id, not a device id. */
+    readonly deviceId: string;
+    readonly localNodeId: string;
+    private options;
+    private writeMutex;
+    private webrtcTransport;
+    private upgradeState;
+    constructor(id: string, localNodeId: string, remoteNodeId: string, writer: WritableStreamDefaultWriter<Uint8Array>, reader: ReadableStreamDefaultReader<Uint8Array>, options?: ConnectionOptions);
+    get transportType(): 'iroh' | 'webrtc' | 'moq';
+    peerMoQReady: boolean;
+    private mediaListeners;
+    /**
+     * Send a message to the other peer.
+     * Messages can be strings or objects (JSON stringified).
+     */
+    send(message: string | object | ArrayBuffer | Uint8Array): Promise<void>;
+    /**
+     * Send media data (video/audio header + payload)
+     * Internal use for now.
+     */
+    sendMedia(type: 'audio' | 'video', data: Uint8Array): Promise<void>;
+    private sendTyped;
+    /**
+     * Disconnect the connection
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Listen for incoming messages
+     */
+    onMessage(callback: (message: any) => void): void;
+    /**
+     * Listen for incoming media
+     */
+    onMedia(callback: (type: 'audio' | 'video', data: Uint8Array) => void): void;
+    /**
+     * Listen for disconnection
+     */
+    onDisconnect(callback: () => void): void;
+    private close;
+    private readLoop;
+    injectData(chunk: Uint8Array): void;
+    private handleData;
+    private processDataPayload;
+    private isLikelyTextPayload;
+    private emitMedia;
+    private emitMessage;
+    private trackListeners;
+    addTrack(track: MediaStreamTrack): RTCRtpSender | null;
+    addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver | null;
+    onTrack(callback: (event: RTCTrackEvent) => void): void;
+    private attemptUpgrade;
+    private sendInternalSignal;
+    private handleInternalSignal;
+}

package/dist/core/Connection.js

@@ -0,0 +1,404 @@
+import { TransportFactory } from './transports/TransportFactory';
+export class Connection {
+    get isClosed() { return this._isClosed; }
+    constructor(id, localNodeId, remoteNodeId, writer, reader, options = {}) {
+        this.listeners = [];
+        this.closeListeners = [];
+        // We'll keep track of the internal stream
+        this.writer = null;
+        this.reader = null;
+        this._isClosed = false;
+        // Buffer for incoming data
+        this.receiveBuffer = new Uint8Array(0);
+        this.writeMutex = Promise.resolve();
+        // Transports
+        this.webrtcTransport = null;
+        this.upgradeState = 'none';
+        this.peerMoQReady = false;
+        this.mediaListeners = [];
+        // --- Transports and Plugins API ---
+        this.trackListeners = [];
+        this.id = id;
+        this.localNodeId = localNodeId;
+        this.remoteNodeId = remoteNodeId;
+        this.deviceId = remoteNodeId;
+        this.writer = writer;
+        this.reader = reader;
+        this.options = options;
+        this.readLoop();
+        if (this.options.rtcConfig) {
+            this.attemptUpgrade();
+        }
+    }
+    get transportType() {
+        if (this.upgradeState === 'upgraded')
+            return 'webrtc';
+        if (this.peerMoQReady)
+            return 'moq';
+        return 'iroh';
+    }
+    /**
+     * Send a message to the other peer.
+     * Messages can be strings or objects (JSON stringified).
+     */
+    async send(message) {
+        return this.sendTyped(0, message);
+    }
+    /**
+     * Send media data (video/audio header + payload)
+     * Internal use for now.
+     */
+    async sendMedia(type, data) {
+        const typeId = type === 'video' ? 1 : 2;
+        // Media always prioritizes efficient transport (MoQ/WebRTC) but fallbacks to Iroh
+        // For media, we usually use separate tracks. 
+        // This method is for "Legacy Iroh Media" or "Datagram Media".
+        return this.sendTyped(typeId, data);
+    }
+    async sendTyped(typeId, message) {
+        const context = this.options.transportContext;
+        const priorities = context?.priorities || ['webrtc', 'moq', 'iroh'];
+        // Prepare Payload
+        let payload;
+        if (typeof message === 'string') {
+            payload = new TextEncoder().encode(message);
+        }
+        else if (message instanceof Uint8Array) {
+            payload = message;
+        }
+        else if (message instanceof ArrayBuffer) {
+            payload = new Uint8Array(message);
+        }
+        else {
+            payload = new TextEncoder().encode(JSON.stringify(message));
+        }
+        // Construct Frame (for Iroh/Stream transports)
+        // [Len 4][Type 1][Payload N]
+        const totalLen = 4 + 1 + payload.length;
+        const frame = new Uint8Array(totalLen);
+        const view = new DataView(frame.buffer);
+        view.setUint32(0, 1 + payload.length, false);
+        frame[4] = typeId;
+        frame.set(payload, 5);
+        // --- Priority Loop ---
+        for (const transport of priorities) {
+            if (transport === 'webrtc') {
+                if (this.webrtcTransport && this.upgradeState === 'upgraded') {
+                    try {
+                        if (typeId === 0) {
+                            const data = (typeof message === 'object' && !(message instanceof Uint8Array) && !(message instanceof ArrayBuffer))
+                                ? JSON.stringify(message)
+                                : message;
+                            const buffer = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+                            await this.webrtcTransport.send(buffer);
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        console.warn("[Connection] WebRTC Send Failed:", e);
+                    }
+                }
+            }
+            else if (transport === 'moq') {
+                if (context && context.isMoQReady() && this.peerMoQReady) {
+                    try {
+                        // MoQ Data is usually Type 0 (User Data).
+                        // MoQ tracks are streams.
+                        // We use `sendMoQ` provided by context.
+                        // We send the Payload (not the frame) because MoQ framing handle it?
+                        // The receiver `handleMoQObject` needs to know it's a message.
+                        // We are sending on `data/peerId`.
+                        // Receiver processes that track.
+                        await context.sendMoQ(frame); // Send FRAMED data so receiver can parse Type?
+                        // Wait, `Frame` includes length header.
+                        // If we send `Frame` as an object, receiver gets `[Len][Type][Payload]`.
+                        // We should check how receiver consumes it.
+                        return;
+                    }
+                    catch (e) {
+                        console.warn("[Connection] MoQ Send Failed:", e);
+                    }
+                }
+            }
+            else if (transport === 'iroh') {
+                if (context?.disableIrohFallback && typeId !== 0) {
+                    // Start exception: Allow Type 0 (Signaling)? 
+                    // No, `disableIrohFallback` means "Only use for initial bootstrap".
+                    // If we are here, other transports failed.
+                    console.warn("[Connection] Iroh fallback disabled, dropping packet.");
+                    return;
+                }
+                // Iroh Send Logic (Mutex + Writer)
+                if (this.isClosed || !this.writer)
+                    break; // Should throw?
+                const previousMutex = this.writeMutex;
+                let releaseMutex;
+                this.writeMutex = new Promise((resolve) => { releaseMutex = resolve; });
+                try {
+                    await previousMutex;
+                    if (this.writer) {
+                        await this.writer.write(frame);
+                        return; // Success
+                    }
+                }
+                catch (err) {
+                    console.error('[Connection] Iroh Send error:', err);
+                    this.close(`Send Error: ${err}`);
+                    throw err; // Stop loop
+                }
+                finally {
+                    releaseMutex();
+                }
+            }
+        }
+        // If we get here, all transports failed
+        // throw new Error("All transports failed");
+    }
+    /**
+     * Disconnect the connection
+     */
+    async disconnect() {
+        this.close('Explicit Disconnect');
+    }
+    /**
+     * Listen for incoming messages
+     */
+    onMessage(callback) {
+        this.listeners.push(callback);
+    }
+    /**
+     * Listen for incoming media
+     */
+    onMedia(callback) {
+        this.mediaListeners.push(callback);
+    }
+    /**
+     * Listen for disconnection
+     */
+    onDisconnect(callback) {
+        this.closeListeners.push(callback);
+    }
+    close(reason) {
+        if (this._isClosed)
+            return;
+        console.log(`[Connection] Closing connection ${this.id}. Reason: ${reason || 'Unknown'}`);
+        this._isClosed = true;
+        // Close writer/reader
+        this.writer?.close().catch(() => { });
+        this.reader?.cancel().catch(() => { });
+        this.writer = null;
+        this.reader = null;
+        // MoQ session is now managed at the Client level
+        // Notify listeners
+        this.closeListeners.forEach(cb => cb());
+    }
+    async readLoop() {
+        if (!this.reader)
+            return;
+        try {
+            while (!this.isClosed) {
+                const { done, value } = await this.reader.read();
+                if (done) {
+                    this.close('Read Done (Remote Closed)');
+                    break;
+                }
+                if (value) {
+                    this.handleData(value);
+                }
+            }
+        }
+        catch (err) {
+            console.error('[Connection] Read loop error:', err);
+            this.close(`Read Error: ${err}`);
+        }
+    }
+    injectData(chunk) {
+        this.handleData(chunk);
+    }
+    handleData(chunk) {
+        // Append to buffer
+        const newBuffer = new Uint8Array(this.receiveBuffer.length + chunk.length);
+        newBuffer.set(this.receiveBuffer);
+        newBuffer.set(chunk, this.receiveBuffer.length);
+        this.receiveBuffer = newBuffer;
+        // Process messages
+        while (true) {
+            if (this.receiveBuffer.length < 4)
+                break; // Need at least length header
+            const view = new DataView(this.receiveBuffer.buffer, this.receiveBuffer.byteOffset, this.receiveBuffer.byteLength);
+            const length = view.getUint32(0, false);
+            if (this.receiveBuffer.length < 4 + length)
+                break; // Wait for full message
+            // Extract message
+            // First byte of body is Type
+            // Body is technically at index 4, length includes Type
+            const body = this.receiveBuffer.slice(4, 4 + length);
+            // However, we need to handle Legacy fallback? 
+            // If we upgrade, we assume all traffic is upgraded.
+            // If the user connects to an old client, the old client sends [Len][Data].
+            // We interpret [Data[0]] as Type. This is RISKY if old client sends binary starting with 0, 1, 2.
+            // But since old client sends JSON strings usually, '{' is 123.
+            // Strings start with chars.
+            // We can try to heuristic?
+            // Actually, if we control both ends (deployment), we enforce new protocol.
+            // Assuming this is a breaking change OR we are careful.
+            // New Protocol: Length = N (where N includes the type byte).
+            // So if payload is 10 bytes, N=11.
+            if (body.length > 0) {
+                const typeId = body[0];
+                const payload = body.slice(1);
+                // console.log(`[Connection] Packet received. Type: ${typeId}, Payload Len: ${payload.length}`);
+                if (typeId === 1) {
+                    this.emitMedia('video', payload);
+                }
+                else if (typeId === 2) {
+                    this.emitMedia('audio', payload);
+                }
+                else {
+                    // Type 0 or unknown -> Treat as Data
+                    this.processDataPayload(payload);
+                }
+            }
+            this.receiveBuffer = this.receiveBuffer.slice(4 + length);
+        }
+    }
+    processDataPayload(messageData) {
+        try {
+            const text = Connection.textDecoder.decode(messageData);
+            if (!this.isLikelyTextPayload(messageData, text)) {
+                this.emitMessage(messageData);
+                return;
+            }
+            const json = JSON.parse(text);
+            // Intercept Internal Signals
+            if (json && typeof json === 'object' && json.type === '#pluto-signal') {
+                this.handleInternalSignal(json);
+                return;
+            }
+            if (typeof json === 'object' && json !== null) {
+                this.emitMessage(json);
+            }
+            else {
+                this.emitMessage(text);
+            }
+        }
+        catch {
+            try {
+                const text = Connection.textDecoder.decode(messageData);
+                if (this.isLikelyTextPayload(messageData, text)) {
+                    this.emitMessage(text);
+                    return;
+                }
+            }
+            catch {
+                // fall through to raw binary payload
+            }
+            this.emitMessage(messageData);
+        }
+    }
+    isLikelyTextPayload(messageData, text) {
+        try {
+            for (let index = 0; index < text.length; index += 1) {
+                const code = text.charCodeAt(index);
+                if (code < 0x20 && code !== 0x09 && code !== 0x0a && code !== 0x0d) {
+                    return false;
+                }
+            }
+            const roundTrip = Connection.textEncoder.encode(text);
+            if (roundTrip.byteLength !== messageData.byteLength) {
+                return false;
+            }
+            for (let index = 0; index < roundTrip.byteLength; index += 1) {
+                if (roundTrip[index] !== messageData[index]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    emitMedia(type, data) {
+        this.mediaListeners.forEach(cb => cb(type, data));
+    }
+    emitMessage(msg) {
+        this.listeners.forEach(cb => cb(msg));
+    }
+    addTrack(track) {
+        const native = this.webrtcTransport?.getNativeTransport?.();
+        if (native && typeof native.addTrack === 'function') {
+            return native.addTrack(track);
+        }
+        return null;
+    }
+    addTransceiver(trackOrKind, init) {
+        const native = this.webrtcTransport?.getNativeTransport?.();
+        if (native && typeof native.addTransceiver === 'function') {
+            return native.addTransceiver(trackOrKind, init);
+        }
+        return null;
+    }
+    onTrack(callback) {
+        this.trackListeners.push(callback);
+    }
+    async attemptUpgrade() {
+        if (this.upgradeState !== 'none')
+            return;
+        this.upgradeState = 'upgrading';
+        try {
+            this.webrtcTransport = TransportFactory.createTransport('webrtc');
+        }
+        catch (error) {
+            this.upgradeState = 'failed';
+            console.warn('[Connection] WebRTC upgrade unavailable:', error);
+            return;
+        }
+        // @ts-ignore Set up internal signal sender if the transport is castable to WebRTCTransport
+        if (typeof this.webrtcTransport.setSignalSender === 'function') {
+            // @ts-ignore
+            this.webrtcTransport.setSignalSender((msg) => this.sendInternalSignal(msg));
+        }
+        this.webrtcTransport.onMessage((data) => {
+            this.processDataPayload(data);
+        });
+        this.webrtcTransport.onStateChange((state) => {
+            console.log(`[Connection] 🌐 Native PC State: ${state}`);
+            if (state === 'connected') {
+                this.upgradeState = 'upgraded';
+                console.log("%c[Connection] 🚀 UPGRADE COMPLETE: Switched to Native WebRTC", "color: green; font-weight: bold;");
+            }
+            else if (state === 'failed' || state === 'disconnected') {
+                this.upgradeState = 'failed';
+                console.warn("%c[Connection] ⚠️ Native Connection Failed. Falling back to Iroh Relay.", "color: orange; font-weight: bold;");
+            }
+        });
+        await this.webrtcTransport.init(this.localNodeId, this.deviceId, { rtcConfig: this.options.rtcConfig });
+        const native = this.webrtcTransport.getNativeTransport?.();
+        if (native && native.ontrack !== undefined) {
+            native.ontrack = (ev) => {
+                console.log(`[Connection] Peer -> Track: ${ev.track.kind}`);
+                this.trackListeners.forEach(cb => cb(ev));
+            };
+        }
+    }
+    async sendInternalSignal(msg) {
+        const envelope = {
+            type: '#pluto-signal',
+            content: msg
+        };
+        return this.send(envelope);
+    }
+    handleInternalSignal(msg) {
+        if (msg.content && msg.content.transport === 'webrtc' && this.webrtcTransport?.handleSignalingMessage) {
+            this.webrtcTransport.handleSignalingMessage(msg.content);
+        }
+        else if (msg.content && !msg.content.transport && this.webrtcTransport?.handleSignalingMessage) {
+            // Legacy WebRTC signaling compatibility where transport identifier was absent
+            msg.content.transport = 'webrtc';
+            this.webrtcTransport.handleSignalingMessage(msg.content);
+        }
+    }
+}
+Connection.textDecoder = new TextDecoder('utf-8', { fatal: true });
+Connection.textEncoder = new TextEncoder();

package/dist/core/IEngineBridge.d.ts

@@ -0,0 +1,18 @@
+import type { Device, SignalingSession } from './types';
+export type AuthContext = {
+    userId: string;
+    token?: string | null;
+    refreshToken?: string | null;
+    customToken?: string | null;
+    tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+    expiresAtMs?: number | null;
+};
+export interface IEngineBridge {
+    setAuthContext(context: AuthContext | null): Promise<void> | void;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void): Promise<() => void>;
+    updatePresence(localNodeId: string, ticket: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    forceReconnectSnapshot(): void;
+}

package/dist/core/IEngineBridge.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ISignalingTransport.d.ts

@@ -0,0 +1,13 @@
+import type { Device, SignalingSession } from './types';
+export type AuthContext = {
+    userId: string;
+    token?: string | null;
+};
+export interface ISignalingTransport {
+    setAuthContext(context: AuthContext | null): Promise<void> | void;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void): Promise<() => void>;
+    updatePresence(localNodeId: string, ticket: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+}

package/dist/core/ISignalingTransport.js

@@ -0,0 +1 @@
+export {};

package/dist/core/PeerLifecycleManager.d.ts

@@ -0,0 +1,43 @@
+import type { Device, PeerHealth, PeerLifecycleStatus, PeerScope, PeerState } from './types';
+export type PeerLifecycleUpsert = {
+    peerId?: string;
+    deviceId?: string;
+    deviceIdHint?: string;
+    nodeId?: string;
+    connectionId?: string;
+    ticket?: string;
+    online?: boolean;
+    deviceName?: string;
+    platformType?: string;
+    status?: PeerLifecycleStatus;
+    health?: PeerHealth;
+    transportState?: string;
+    protocolState?: string;
+    routable?: boolean;
+    scopes?: Iterable<PeerScope>;
+    error?: string;
+    lastSeenAt?: number;
+};
+export declare class PeerLifecycleManager {
+    private readonly peers;
+    private readonly aliases;
+    private readonly watchers;
+    private resolveCanonicalPeerId;
+    private setAlias;
+    private snapshot;
+    private emit;
+    private rekeyPeer;
+    upsert(input: PeerLifecycleUpsert): PeerState;
+    upsertDevice(device: Device): PeerState;
+    watch(callback: (peers: PeerState[]) => void): () => void;
+    get(id: string): PeerState | undefined;
+    list(): PeerState[];
+    listConnected(): PeerState[];
+    addScope(id: string, scope?: PeerScope): PeerState | undefined;
+    releaseScope(id: string, scope?: PeerScope): PeerState | undefined;
+    hasScope(id: string, scope: PeerScope): boolean;
+    hasScopes(id: string): boolean;
+    removeConnection(id: string): PeerState | undefined;
+    updateHealth(id: string, health: PeerHealth, status?: PeerLifecycleStatus): PeerState | undefined;
+    private resolveRecord;
+}