openrtc 0.1.0 → 0.1.2

package/wasm/openrtc_bg.wasm.d.ts

@@ -5,6 +5,9 @@ export const __wbg_bistream_free: (a: number, b: number) => void;
 export const bistream_recv: (a: number) => any;
 export const bistream_send: (a: number) => any;
 export const bistream_endpoint_id: (a: number) => [number, number];
+export const __wbg_wasmconnection_free: (a: number, b: number) => void;
+export const wasmconnection_new: () => [number, number, number];
+export const wasmconnection_create_data_channel: (a: number, b: number, c: number) => any;
 export const __wbg_wasmclient_free: (a: number, b: number) => void;
 export const wasmclient_new: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const wasmclient_newWithAppTag: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -25,6 +28,7 @@ export const wasmclient_endpoint_id_from_ticket: (a: number, b: number, c: numbe
 export const wasmclient_connect: (a: number, b: number, c: number) => any;
 export const wasmclient_disconnect: (a: number, b: number, c: number) => any;
 export const wasmclient_is_connected: (a: number, b: number, c: number) => any;
+export const wasmclient_runtime_policy: (a: number) => [number, number, number];
 export const wasmclient_add_peer_scope: (a: number, b: number, c: number, d: number, e: number) => any;
 export const wasmclient_release_peer_scope: (a: number, b: number, c: number, d: number, e: number) => any;
 export const wasmclient_peer_scopes: (a: number, b: number, c: number) => any;
@@ -38,11 +42,16 @@ export const wasmclient_connection_states: (a: number) => any;
 export const wasmclient_wait_for_settled_peer: (a: number, b: number, c: number, d: number) => any;
 export const wasmclient_resolve_peer_connection_records: (a: number, b: number, c: number) => any;
 export const wasmclient_list_managed_connections: (a: number) => any;
+export const wasmclient_bind_connection_device_id: (a: number, b: number, c: number, d: number, e: number) => any;
 export const wasmclient_report_managed_connection_settled: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const wasmclient_report_transport_status: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
 export const wasmclient_open_bi: (a: number, b: number, c: number) => any;
 export const wasmclient_open_peer_bi: (a: number, b: number, c: number, d: number) => any;
+export const wasmclient_open_peer_bi_transport_only: (a: number, b: number, c: number, d: number) => any;
 export const wasmclient_open_uni: (a: number, b: number, c: number) => any;
 export const wasmclient_open_peer_uni: (a: number, b: number, c: number, d: number) => any;
+export const wasmclient_send_peer: (a: number, b: number, c: number, d: number, e: number) => any;
+export const wasmclient_iroh_path_kind: (a: number, b: number, c: number) => any;
 export const wasmclient_incoming_streams: (a: number) => any;
 export const wasmclient_update_presence: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: bigint) => any;
 export const wasmclient_send_message: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
@@ -52,7 +61,10 @@ export const wasmclient_delete_device: (a: number, b: number, c: number, d: numb
 export const wasmclient_force_reconnect_snapshot: (a: number) => void;
 export const wasmclient_stop_presence_loop: (a: number) => void;
 export const wasmclient_stop_auto_connect: (a: number) => void;
-export const wasmclient_set_auto_connect_excluded: (a: number, b: number, c: number, d: number) => void;
+export const wasmclient_start_auto_connect: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wasmclient_set_auto_connect_excluded: (a: number, b: number, c: number, d: number) => any;
+export const wasmclient_is_auto_connect_excluded: (a: number, b: number, c: number) => number;
+export const wasmclient_disconnect_device: (a: number, b: number, c: number, d: number, e: number) => any;
 export const wasmclient_stop_auth_scoped_activity: (a: number) => void;
 export const wasmclient_start_presence_loop: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
 export const wasmclient_search_devices: (a: number, b: number, c: number) => any;
@@ -66,12 +78,6 @@ export const wasmclient_get_members: (a: number, b: number, c: number, d: number
 export const wasmclient_leave_room: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
 export const wasmclient_heartbeat_tick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
 export const start: () => void;
-export const __wbg_wasmconnection_free: (a: number, b: number) => void;
-export const wasmconnection_new: () => [number, number, number];
-export const wasmconnection_create_data_channel: (a: number, b: number, c: number) => any;
-export const __wbg_intounderlyingsource_free: (a: number, b: number) => void;
-export const intounderlyingsource_pull: (a: number, b: any) => any;
-export const intounderlyingsource_cancel: (a: number) => void;
 export const __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
 export const intounderlyingbytesource_type: (a: number) => number;
 export const intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
@@ -82,29 +88,26 @@ export const __wbg_intounderlyingsink_free: (a: number, b: number) => void;
 export const intounderlyingsink_write: (a: number, b: any) => any;
 export const intounderlyingsink_close: (a: number) => any;
 export const intounderlyingsink_abort: (a: number, b: any) => any;
+export const __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+export const intounderlyingsource_pull: (a: number, b: any) => any;
+export const intounderlyingsource_cancel: (a: number) => void;
 export const ring_core_0_17_14__bn_mul_mont: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const wasm_bindgen__closure__destroy__h371e680d2c9813cc: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__h80a0a4202b98bec2: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__hdda622e051292cf2: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__h0b41a02fbe6471ce: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__h8e81dd7dd6597798: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__hc4385c46a735f91a: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__h65fdc278f5332d1f: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__h2853267a0cbc2b04: (a: number, b: number) => void;
-export const wasm_bindgen__convert__closures_____invoke__h517a56e03d34d888: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h3f605e54c3ccc792: (a: number, b: number, c: any, d: any) => void;
-export const wasm_bindgen__convert__closures_____invoke__hf53043a3aa608bb3: (a: number, b: number, c: any) => void;
-export const wasm_bindgen__convert__closures_____invoke__h14717fdf60edc0ad: (a: number, b: number, c: any) => void;
-export const wasm_bindgen__convert__closures_____invoke__hb5064d1dd77b5d01: (a: number, b: number, c: any) => void;
-export const wasm_bindgen__convert__closures_____invoke__h3736bba9aeac8b38: (a: number, b: number) => void;
-export const wasm_bindgen__convert__closures_____invoke__h3b2823c6a5a88a62: (a: number, b: number) => void;
-export const wasm_bindgen__convert__closures_____invoke__h9f65334fdbabfcc8: (a: number, b: number) => void;
-export const wasm_bindgen__convert__closures_____invoke__hc3d2296b352a462d: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__hd47f17ba87c541ec: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h776304867400b4e4: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h4dc49b34d4d77b81: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__hf679ef60a72d1948: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h4b742547b50caebd: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h509d1e5f9a719179: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__h1ecdc95d38c8111b: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__h47f09f7820fbff6c: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__ha910581f00459fa9: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__h1893948438c6db09: (a: number, b: number) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;
 export const __externref_table_alloc: () => number;
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_destroy_closure: (a: number, b: number) => void;
 export const __externref_table_dealloc: (a: number) => void;
 export const __wbindgen_start: () => void;

package/wasm/package.json

@@ -2,7 +2,7 @@
   "name": "openrtc",
   "type": "module",
   "description": "OpenRTC: a Rust-first P2P runtime for device discovery, signaling, and iroh/QUIC networking.",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "files": [
     "openrtc_bg.wasm",
     "openrtc.js",

package/dist/OpenRTC.d.ts

@@ -1,71 +0,0 @@
-/**
- * OpenRTC — simplified developer-facing entry point.
- *
- * Usage:
- *   import { OpenRTC } from 'openrtc';
- *   const client = OpenRTC({ apiKey: 'pk_live_...' });
- *   await client.connect();
- *
- * For native (Tauri) apps:
- *   const client = OpenRTC.native({ apiKey: 'pk_live_...' });
- *
- * The returned Client object combines RuntimeClient methods with
- * auth helpers (setAuth, syncPlutoAuth, bindPlutoAuthHost, signIn, signOut).
- *
- * Backward compatibility:
- *   - createWasmClient() and createIpcClient() remain available from `openrtc/runtime`
- *   - PlutoRuntimeAssembly remains available from `openrtc/runtime`
- *   - RuntimeClient is still re-exported as Client
- */
-import type { AuthContext } from './core/IEngineBridge';
-import type { ClientOptions } from './core/types';
-import { RuntimeClient } from './runtime/RuntimeClient';
-import { type PlutoRuntimeAssembly } from './runtime/factories';
-import { type PlutoIpcBridge } from './runtime/ipc';
-/**
- * OpenRTCClient extends RuntimeClient with auth helpers that were
- * previously only available on PlutoRuntimeAssembly.
- *
- * This is the unified type returned by OpenRTC() and OpenRTC.native().
- */
-export interface OpenRTCClient extends RuntimeClient {
-    /** @deprecated Use setAuth() instead */
-    setAuthContext(context: AuthContext | null): Promise<void>;
-    /** Set auth context for the runtime */
-    setAuth(context: AuthContext | null): Promise<void>;
-    /** Sync Pluto-hosted auth to the runtime */
-    syncPlutoAuth(options?: {
-        userId?: string | null;
-        forceRefresh?: boolean;
-    }): Promise<void>;
-    /** Bind Pluto auth host to auto-sync on token changes */
-    bindPlutoAuthHost(): () => void;
-    /** Sign in via Pluto SSO */
-    signIn(): Promise<void>;
-    /** Sign out and clear auth context */
-    signOut(): Promise<void>;
-    /**
-     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
-     * @deprecated Access methods directly on the client instead.
-     */
-    readonly runtime: RuntimeClient;
-    /**
-     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
-     * @internal
-     */
-    readonly _assembly: PlutoRuntimeAssembly;
-}
-/**
- * Create an OpenRTC client for browser/WASM environments.
- *
- * @example
- * ```typescript
- * import { OpenRTC } from 'openrtc';
- * const client = OpenRTC({ apiKey: 'pk_live_...' });
- * await client.connect();
- * ```
- */
-export declare function OpenRTC(options: ClientOptions): OpenRTCClient;
-export declare namespace OpenRTC {
-    var native: (options: ClientOptions, bridge?: PlutoIpcBridge) => OpenRTCClient;
-}

package/dist/OpenRTC.js

@@ -1,130 +0,0 @@
-/**
- * OpenRTC — simplified developer-facing entry point.
- *
- * Usage:
- *   import { OpenRTC } from 'openrtc';
- *   const client = OpenRTC({ apiKey: 'pk_live_...' });
- *   await client.connect();
- *
- * For native (Tauri) apps:
- *   const client = OpenRTC.native({ apiKey: 'pk_live_...' });
- *
- * The returned Client object combines RuntimeClient methods with
- * auth helpers (setAuth, syncPlutoAuth, bindPlutoAuthHost, signIn, signOut).
- *
- * Backward compatibility:
- *   - createWasmClient() and createIpcClient() remain available from `openrtc/runtime`
- *   - PlutoRuntimeAssembly remains available from `openrtc/runtime`
- *   - RuntimeClient is still re-exported as Client
- */
-import { createWasmClient, createIpcClient } from './runtime/factories';
-import { createCompatTauriIpcBridge } from './runtime/ipc';
-function resolveOptions(options) {
-    // Map new option names to old ones (new names take priority)
-    const resolved = { ...options };
-    // auth → authMode
-    if ('auth' in options && !options.authMode) {
-        const auth = options.auth;
-        resolved.authMode = auth === 'none' ? 'anonymous' : auth;
-    }
-    // identity → nodeIdPersistence
-    if ('identity' in options && !options.nodeIdPersistence) {
-        const identity = options.identity;
-        resolved.nodeIdPersistence = identity === 'temporary' ? 'ephemeral' : identity;
-    }
-    // namespace → storagePrefix
-    if ('namespace' in options && !options.storagePrefix) {
-        resolved.storagePrefix = options.namespace;
-    }
-    // privacy → strictMode
-    if ('privacy' in options && options.strictMode === undefined) {
-        resolved.strictMode = !!options.privacy;
-    }
-    return resolved;
-}
-function wrapAssembly(assembly) {
-    const runtime = assembly.runtime;
-    // Create a proxy that delegates to RuntimeClient but adds assembly helpers
-    const client = Object.create(runtime);
-    // Assembly auth helpers as direct methods
-    Object.defineProperties(client, {
-        setAuth: {
-            value: (context) => assembly.setAuthContext(context),
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        },
-        setAuthContext: {
-            value: (context) => assembly.setAuthContext(context),
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        },
-        syncPlutoAuth: {
-            value: (options) => assembly.syncPlutoAuth(options),
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        },
-        bindPlutoAuthHost: {
-            value: () => assembly.bindPlutoAuthHost(),
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        },
-        signIn: {
-            value: () => assembly.signInWithPluto(),
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        },
-        signOut: {
-            value: () => assembly.signOut(),
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        },
-        // Backward compat: .runtime returns the RuntimeClient
-        runtime: {
-            get: () => runtime,
-            enumerable: false,
-        },
-        _assembly: {
-            get: () => assembly,
-            enumerable: false,
-        },
-    });
-    return client;
-}
-/**
- * Create an OpenRTC client for browser/WASM environments.
- *
- * @example
- * ```typescript
- * import { OpenRTC } from 'openrtc';
- * const client = OpenRTC({ apiKey: 'pk_live_...' });
- * await client.connect();
- * ```
- */
-export function OpenRTC(options) {
-    const resolved = resolveOptions(options);
-    const assembly = createWasmClient(resolved);
-    return wrapAssembly(assembly);
-}
-/**
- * Create an OpenRTC client for native (Tauri/IPC) environments.
- * Auto-detects the Tauri IPC bridge.
- *
- * @example
- * ```typescript
- * import { OpenRTC } from 'openrtc';
- * const client = OpenRTC.native({ apiKey: 'pk_live_...' });
- * await client.connect();
- * ```
- */
-OpenRTC.native = function (options, bridge) {
-    const resolved = resolveOptions(options);
-    const ipcBridge = bridge ?? createCompatTauriIpcBridge();
-    const assembly = createIpcClient(resolved, ipcBridge);
-    return wrapAssembly(assembly);
-};

package/dist/api/MediaTransport.d.ts

@@ -1,7 +0,0 @@
-export declare class MediaTransport {
-    static sendTrack(track: MediaStreamTrack, sendFn: (data: Uint8Array) => Promise<void>): Promise<{
-        stop: () => void;
-        requestKeyFrame: () => void;
-    } | void>;
-    static receiveTrack(kind: 'audio' | 'video', onKeyFrameRequest?: () => void): MediaStreamTrack | null;
-}

package/dist/api/MediaTransport.js

@@ -1,262 +0,0 @@
-// Protocol-ish logic for transforming MediaStreamTracks into Chunks and back.
-// Since we don't have VideoEncoder/VideoDecoder in standard ts environment (it's web only),
-// we will just define the interfaces or classes here.
-// We use type 'any' for WebCodecs interfaces to avoid TS errors in environemnts without @types/dom-webcodecs
-export class MediaTransport {
-    // Encodes a track into the connection
-    static async sendTrack(track, sendFn) {
-        console.log(`[MediaTransport] sendTrack called for ${track.kind}`);
-        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();
-        // Very basic encoder setup. 
-        // In reality we need to negotiate codecs. We assume VP8 for video and Opus for audio.
-        let encoder = null;
-        if (track.kind === 'video') {
-            let seqNum = 0;
-            encoder = new window.VideoEncoder({
-                output: (chunk, metadata) => {
-                    if (chunk.type === 'key') {
-                        console.log(`[MediaTransport] Generated KEY frame for video. Size: ${chunk.byteLength}`);
-                    }
-                    // console.log(`[MediaTransport] Encoded video chunk. Key: ${chunk.type}, Size: ${chunk.byteLength}`);
-                    // Send chunk
-                    // We need to serialize the chunk. 
-                    // [MAGIC 1b][timestamp 8 bytes][isKey 1 byte][seq 2 bytes][data...]
-                    const buffer = new ArrayBuffer(12 + chunk.byteLength);
-                    const view = new DataView(buffer);
-                    view.setUint8(0, 0x77); // Magic byte
-                    view.setBigInt64(1, BigInt(chunk.timestamp), false); // Big Endian
-                    view.setUint8(9, chunk.type === 'key' ? 1 : 0);
-                    const seq = (seqNum++) % 65536;
-                    view.setUint16(10, seq, false);
-                    const data = new Uint8Array(buffer);
-                    chunk.copyTo(new Uint8Array(buffer, 12));
-                    sendFn(data).catch(e => {
-                        const msg = (e.message || String(e)).toLowerCase();
-                        if (msg.includes("connection is closed") || msg.includes("connection closed") || msg.includes("sending stopped by peer")) {
-                            console.log(`[MediaTransport] Connection closed/stopped, stopping video encoder.`);
-                            if (encoder) {
-                                encoder.close();
-                                encoder = null;
-                            }
-                        }
-                        else {
-                            console.error("Send media failed", e);
-                        }
-                    });
-                },
-                error: (e) => console.error("VideoEncoder error", e)
-            });
-            encoder.configure({
-                codec: 'vp8',
-                width: 640,
-                height: 480,
-                bitrate: 500000, // 500 Kbps - Reduce congestion
-                framerate: 24, // slightly lower framerate
-                latencyMode: 'realtime', // Critical for low latency streaming
-            });
-        }
-        else if (track.kind === 'audio') {
-            encoder = new window.AudioEncoder({
-                output: (chunk, metadata) => {
-                    const buffer = new ArrayBuffer(9 + chunk.byteLength);
-                    const view = new DataView(buffer);
-                    view.setUint8(0, 0x77); // Magic
-                    view.setBigInt64(1, BigInt(chunk.timestamp), false);
-                    const data = new Uint8Array(buffer);
-                    chunk.copyTo(new Uint8Array(buffer, 9));
-                    sendFn(data).catch(e => {
-                        const msg = (e.message || String(e)).toLowerCase();
-                        if (msg.includes("connection is closed") || msg.includes("connection closed")) {
-                            console.log(`[MediaTransport] Connection closed, stopping audio encoder.`);
-                            if (encoder) {
-                                encoder.close();
-                                encoder = null;
-                            }
-                        }
-                        else {
-                            console.error("Send audio failed", e);
-                        }
-                    });
-                },
-                error: (e) => console.error("AudioEncoder error", e)
-            });
-            encoder.configure({
-                codec: 'opus',
-                sampleRate: 48000,
-                numberOfChannels: 1
-            });
-        }
-        // Read loop - Run asynchronously so we can return the controller immediately
-        (async () => {
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        console.log(`[MediaTransport] Reader done for ${track.kind}`);
-                        break;
-                    }
-                    if (value) {
-                        try {
-                            if (encoder && encoder.state !== 'closed') {
-                                const forceKey = encoder.forceKeyFrame;
-                                if (forceKey) {
-                                    console.log(`[MediaTransport] Forcing Key Frame now.`);
-                                    encoder.encode(value, { keyFrame: true });
-                                    encoder.forceKeyFrame = false;
-                                }
-                                else {
-                                    encoder.encode(value);
-                                }
-                            }
-                        }
-                        finally {
-                            value.close();
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                console.error(`[MediaTransport] Read loop error for ${track.kind}:`, e);
-            }
-        })();
-        // Return controller
-        return {
-            stop: () => {
-                // TODO: Close processor and reader
-            },
-            requestKeyFrame: () => {
-                if (encoder && encoder.state === 'configured') {
-                    console.log(`[MediaTransport] Key Frame Requested for ${track.kind}`);
-                    // We can't force it here directly because we are in a read loop.
-                    // But we can set a flag that the loop checks.
-                    encoder.forceKeyFrame = true;
-                }
-                else {
-                    console.warn(`[MediaTransport] Impossible to request KeyFrame: Encoder state is ${encoder?.state}`);
-                }
-            }
-        };
-    }
-    // Receives chunks and outputs a MediaStreamTrack
-    static receiveTrack(kind, onKeyFrameRequest) {
-        if ((typeof VideoDecoder === 'undefined') && (typeof AudioDecoder === 'undefined')) {
-            console.warn("WebCodecs API not supported.");
-            return null;
-        }
-        const generator = new window.MediaStreamTrackGenerator({ kind });
-        const writer = generator.writable.getWriter();
-        let decoder = null;
-        // Throttling for PLI
-        let lastPli = 0;
-        let expectedSeq = null;
-        if (kind === 'video') {
-            decoder = new window.VideoDecoder({
-                output: (frame) => {
-                    try {
-                        writer.write(frame);
-                    }
-                    finally {
-                        frame.close();
-                    }
-                },
-                error: (e) => console.error("VideoDecoder error", e)
-            });
-            decoder.configure({
-                codec: 'vp8'
-            });
-            // Force wait for key frame immediately
-            decoder.waitingForKeyFrame = true;
-        }
-        else {
-            decoder = new window.AudioDecoder({
-                output: (data) => {
-                    writer.write(data);
-                    data.close();
-                },
-                error: (e) => console.error("AudioDecoder error", e)
-            });
-            decoder.configure({
-                codec: 'opus',
-                sampleRate: 48000,
-                numberOfChannels: 1
-            });
-        }
-        // Attach a method to the track object or return a controller?
-        // We will just return the track, but we need a way to feed data into the decoder.
-        // We can monkey-patch the track or store it in a map in PeerConnection.
-        generator.feed = (data) => {
-            if (decoder.state === 'closed')
-                return;
-            // Verify Magic
-            if (data.byteLength < 1 || data[0] !== 0x77) {
-                console.error("[MediaTransport] Invalid magic byte in media stream! Dropping packet.");
-                return;
-            }
-            if (kind === 'video') {
-                // Parse
-                const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-                const timestamp = Number(view.getBigInt64(1, false));
-                const isKey = view.getUint8(9) === 1;
-                const seq = view.getUint16(10, false);
-                const chunkData = data.slice(12);
-                // Sequence Check
-                if (expectedSeq !== null) {
-                    if (seq !== expectedSeq) {
-                        console.warn(`[MediaTransport] Sequence Mismatch! Expected ${expectedSeq}, got ${seq}. Dropping and requesting PLI.`);
-                        decoder.waitingForKeyFrame = true;
-                        if (onKeyFrameRequest)
-                            onKeyFrameRequest();
-                        // We also reset expectedSeq to this new one + 1? 
-                        // No, we better wait for KeyFrame.
-                        // But we must update expectedSeq to avoid infinite loops if the stream just continues.
-                        expectedSeq = (seq + 1) % 65536;
-                        return;
-                    }
-                }
-                expectedSeq = (seq + 1) % 65536;
-                const chunk = new window.EncodedVideoChunk({
-                    type: isKey ? 'key' : 'delta',
-                    timestamp: timestamp,
-                    data: chunkData
-                });
-                if (decoder.state === 'configured' && !isKey && decoder.waitingForKeyFrame !== false) {
-                    // Drop delta frames until we get a keyframe
-                    const now = Date.now();
-                    if (now - lastPli > 1000) {
-                        console.log("[MediaTransport] Dropping delta frame, waiting for key frame. Requesting PLI.");
-                        if (onKeyFrameRequest)
-                            onKeyFrameRequest();
-                        lastPli = now;
-                    }
-                    return;
-                }
-                if (isKey) {
-                    decoder.waitingForKeyFrame = false;
-                }
-                try {
-                    decoder.decode(chunk);
-                }
-                catch (e) {
-                    console.error("[MediaTransport] Decode error:", e);
-                }
-            }
-            else {
-                const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-                const timestamp = Number(view.getBigInt64(1, false));
-                const chunkData = data.slice(9);
-                const chunk = new window.EncodedAudioChunk({
-                    type: 'key', // Audio usually all key frames or dependent? Opus is complicated.
-                    timestamp: timestamp,
-                    data: chunkData
-                });
-                decoder.decode(chunk);
-            }
-        };
-        return generator;
-    }
-}

package/dist/api/PlutoPeerConnection.d.ts

@@ -1,50 +0,0 @@
-import { Client } from '../core/Client';
-import { Connection } from '../core/Connection';
-export declare class PlutoPeerConnection extends EventTarget {
-    static defaultClient: Client | null;
-    static setDefaultClient(client: Client): void;
-    onicecandidate: ((ev: RTCPeerConnectionIceEvent) => any) | null;
-    oniceconnectionstatechange: ((ev: Event) => any) | null;
-    ontrack: ((ev: RTCTrackEvent) => any) | null;
-    onsignalingstatechange: ((ev: Event) => any) | null;
-    connectionState: RTCPeerConnectionState;
-    iceConnectionState: RTCIceConnectionState;
-    signalingState: RTCSignalingState;
-    localDescription: RTCSessionDescription | null;
-    remoteDescription: RTCSessionDescription | null;
-    private client;
-    private connection;
-    private get useMoq();
-    get transportInfo(): {
-        signaling: string;
-        media: string;
-    };
-    constructor(configuration?: RTCConfiguration, clientInstance?: Client);
-    createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
-    createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit>;
-    setLocalDescription(desc: RTCSessionDescriptionInit): Promise<void>;
-    setRemoteDescription(desc: RTCSessionDescriptionInit): Promise<void>;
-    addIceCandidate(candidate: RTCIceCandidateInit | RTCIceCandidate): Promise<void>;
-    /**
-     * Manually provide an existing connection (e.g. from an incoming connection listener)
-     */
-    private bufferTracks;
-    handleIncomingConnection(connection: Connection): Promise<void>;
-    private receivers;
-    private setupHooks;
-    private handleLegacyMedia;
-    private moqDecoders;
-    private moqGenerators;
-    private handleMoQMedia;
-    private handleMoQData;
-    private fireTrackEvent;
-    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender;
-    private mediaSenders;
-    private startIrohStream;
-    private startMoQStream;
-    createDataChannel(label: string): RTCDataChannel;
-    sendData(data: any): void;
-    private connect;
-    close(): void;
-    private updateState;
-}