openrtc 0.1.0

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "openrtc",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "description": "A Rust-first realtime runtime for browser and native apps, exposed through TypeScript and WASM.",
+  "keywords": [
+    "realtime",
+    "p2p",
+    "networking",
+    "iroh",
+    "wasm",
+    "tauri",
+    "runtime"
+  ],
+  "author": "Bryant Hargreaves",
+  "license": "MIT",
+  "homepage": "https://openrtc.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bluestarburst/Plutonium.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "wasm/openrtc.js",
+    "wasm/openrtc.d.ts",
+    "wasm/openrtc_bg.wasm",
+    "wasm/openrtc_bg.wasm.d.ts",
+    "wasm/package.json",
+    "wasm/README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js"
+    },
+    "./runtime/wasm": {
+      "types": "./dist/runtime/WasmRuntimeAdapter.d.ts",
+      "import": "./dist/runtime/WasmRuntimeAdapter.js"
+    },
+    "./runtime/tauri": {
+      "types": "./dist/runtime/tauri.d.ts",
+      "import": "./dist/runtime/tauri.js"
+    },
+    "./auth": {
+      "types": "./dist/auth/index.d.ts",
+      "import": "./dist/auth/index.js"
+    },
+    "./auth/internal": {
+      "types": "./dist/auth/internal.d.ts",
+      "import": "./dist/auth/internal.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:wasm": "cd ../rust && wasm-pack build --target web --out-dir ../ts/wasm && rm -rf ../ts/wasm/.gitignore",
+    "test": "pnpm run test:deterministic",
+    "test:deterministic": "OPENRTC_LIVE_TESTS=0 vitest run tests/unit tests/contract",
+    "test:live": "pnpm run build:wasm && pnpm run build && OPENRTC_LIVE_TESTS=1 vitest run tests/live",
+    "test:live:emulator": "OPENRTC_LIVE_TESTS=1 FIREBASE_AUTH_EMULATOR_HOST=127.0.0.1:9099 vitest run tests/live",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build:wasm && npm run build"
+  },
+  "dependencies": {
+    "firebase": "^9.0.0 || ^10.0.0 || ^11.0.0 || ^12.0.0",
+    "tweetnacl": "^1.0.3"
+  },
+  "peerDependencies": {
+    "firebase": "^9.0.0 || ^10.0.0 || ^11.0.0 || ^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "happy-dom": "^20.5.0",
+    "playwright": "^1.58.2",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
+  },
+  "directories": {
+    "example": "examples",
+    "test": "tests"
+  },
+  "bugs": {
+    "url": "https://github.com/bluestarburst/Plutonium/issues"
+  }
+}

package/wasm/README.md

@@ -0,0 +1,64 @@
+# Pluto RTC Rust Core
+
+The Rust crate is the realtime engine behind Pluto RTC.
+
+It powers:
+- the native runtime used by Tauri and other native hosts
+- the WASM runtime loaded by the npm package in browsers
+
+## Core Responsibilities
+- app-scoped device discovery
+- presence publishing and cleanup
+- signaling messages and sessions
+- room membership
+- peer identity resolution
+- iroh endpoint lifecycle and connection management
+- shared runtime records used by both native and WASM hosts
+
+## Native vs WASM
+
+### Native
+Used for:
+- Tauri desktop/mobile-style hosts
+- headless or CLI-style runners
+- advanced endpoint and router integration
+
+Native-only features include:
+- endpoint adoption/export
+- custom router / no-internal-router mode
+- native auth relay helpers
+- protocol registry and plugin registration
+
+### WASM
+The same runtime logic compiles to WebAssembly for browser hosts.
+
+The npm package loads that WASM build and forwards auth/runtime configuration into it. The browser path should behave like the native path at the runtime-contract level.
+
+## Recommended Native Shape
+- use `ClientBuilder` / injected runtime construction
+- keep host-specific behavior outside the core where possible
+- use the runtime manager and protocol registry for advanced native composition
+
+## Peer Sessions and Custom Protocols
+
+The Rust core owns one peer-session view per `deviceId`. Host layers should
+consume connected peer-session snapshots rather than reason about transport
+records directly.
+
+Protocol authors have two supported extension paths:
+
+1. **Session-adjacent stream composition**
+   - wait for a connected peer session
+   - open `open_bi` / `open_uni` streams
+   - define framing and message semantics externally
+
+2. **ALPN protocol plugins**
+   - register protocol plugins through `RuntimeManager` / `ProtocolRegistry`
+   - use `SessionAdjacent` plugins for runtime-ready hooks without ALPN routing
+   - use `Alpn` plugins when the native runtime should register a dedicated ALPN
+
+WASM/browser consumers should prefer the first model. The second is a
+Rust-first advanced capability.
+
+## Important Rule
+Rust owns discovery, signaling, presence, lifecycle, and peer identity. TypeScript should wrap those contracts, not duplicate them.

package/wasm/openrtc.d.ts

@@ -0,0 +1,284 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * The `ReadableStreamType` enum.
+ *
+ * *This API requires the following crate features to be activated: `ReadableStreamType`*
+ */
+
+type ReadableStreamType = "bytes";
+
+export class BiStream {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly endpoint_id: string;
+    readonly recv: ReadableStream;
+    readonly send: WritableStream;
+}
+
+export class IntoUnderlyingByteSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableByteStreamController): Promise<any>;
+    start(controller: ReadableByteStreamController): void;
+    readonly autoAllocateChunkSize: number;
+    readonly type: ReadableStreamType;
+}
+
+export class IntoUnderlyingSink {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    abort(reason: any): Promise<any>;
+    close(): Promise<any>;
+    write(chunk: any): Promise<any>;
+}
+
+export class IntoUnderlyingSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableStreamDefaultController): Promise<any>;
+}
+
+export class WasmClient {
+    free(): void;
+    [Symbol.dispose](): void;
+    add_peer_scope(id: string, scope: string): Promise<any>;
+    /**
+     * Clear all short-lived session tokens and admission state.
+     */
+    clear_session_tokens(): void;
+    connect(ticket: string): Promise<ReadableStream>;
+    connect_device(device_id: string | null | undefined, endpoint_ticket: string): Promise<any>;
+    connection_state(connection_id: string): Promise<any>;
+    connection_states(): Promise<any>;
+    create_room(room_id: string, user_id: string, ticket_str: string, my_node_id: string, tag: string, max_members?: number | null): Promise<boolean>;
+    create_session(session_json: string): Promise<void>;
+    delete_device(user_id: string, device_id: string): Promise<void>;
+    devices_with_status(user_id: string): Promise<any>;
+    disconnect(endpoint_id: string): Promise<void>;
+    endpoint_id_from_ticket(ticket: string): string;
+    endpoint_ticket(): Promise<string>;
+    /**
+     * Build a compound ticket with an embedded session token.
+     * Registers the token on the canonical Rust client and returns the compound ticket string.
+     * `scope`: logical label (e.g. "share"). `max_connections`: 0 = unlimited.
+     */
+    endpoint_ticket_with_token(grant_scope: string, max_connections: number): Promise<string>;
+    force_reconnect_snapshot(): void;
+    get_members(room_id: string, my_node_id: string, tag: string): Promise<string>;
+    heartbeat_tick(room_id: string, member_id: string, tag: string): Promise<void>;
+    incoming_streams(): Promise<ReadableStream>;
+    init_iroh(secret_key?: Uint8Array | null): Promise<string>;
+    iroh_secret_key(): Promise<Uint8Array>;
+    is_connected(endpoint_id: string): Promise<boolean>;
+    join_room(room_id: string, user_id: string, ticket_str: string, my_node_id: string, tag: string): Promise<void>;
+    leave_room(room_id: string, my_node_id: string, tag: string): Promise<void>;
+    list_managed_connections(): Promise<any>;
+    constructor(project_id: string, tag: string);
+    static newWithAppTag(project_id: string, app_tag: string): WasmClient;
+    node_addr(): Promise<string>;
+    open_bi(endpoint_id: string): Promise<BiStream>;
+    open_peer_bi(id: string, timeout_ms?: number | null): Promise<BiStream>;
+    open_peer_uni(id: string, timeout_ms?: number | null): Promise<WritableStream>;
+    open_uni(endpoint_id: string): Promise<WritableStream>;
+    peer_scopes(id: string): Promise<any>;
+    peer_session(id: string): Promise<any>;
+    peer_sessions(): Promise<any>;
+    peer_snapshot(id: string): Promise<any>;
+    peer_snapshots(): Promise<any>;
+    /**
+     * Present a session token to the remote host over the SDK-owned
+     * native main stream before application traffic starts.
+     * Returns the approved scope string once the host acknowledges admission.
+     */
+    present_session_token_to_host(endpoint_id: string, token: string): Promise<string>;
+    /**
+     * Register a session token on the canonical Rust client.
+     */
+    register_session_token(token: string, grant_scope: string, max_connections: number): void;
+    release_peer_scope(id: string, scope?: string | null): Promise<any>;
+    report_managed_connection_settled(connection_id: string, settled: boolean, device_id?: string | null): Promise<any>;
+    resolve_peer_connection_records(id: string): Promise<any>;
+    /**
+     * Revoke a single token by value.
+     */
+    revoke_session_token(token: string): void;
+    /**
+     * Revoke all tokens that match the given scope and disconnect affected peers.
+     */
+    revoke_tokens_by_scope(grant_scope: string): Promise<any>;
+    same_peer(left: string, right: string): Promise<boolean>;
+    search_devices(user_id: string): Promise<any>;
+    send_message(target_id: string, payload: string, state?: string | null, reply_payload?: string | null): Promise<string>;
+    set_auth_token(token?: string | null): void;
+    set_auto_connect_excluded(device_id: string, excluded: boolean): void;
+    set_offline(user_id: string): Promise<void>;
+    start_presence_loop(user_id: string, device_name: string, ticket: string, metadata?: string | null): void;
+    stop_auth_scoped_activity(): void;
+    stop_auto_connect(): void;
+    stop_presence_loop(): void;
+    update_device(user_id: string, device_id: string, device_name?: string | null, capabilities?: any | null, metadata?: string | null): Promise<void>;
+    update_presence(user_id: string, device_name: string, ticket: string, metadata?: string | null, ttl_ms?: bigint | null): Promise<void>;
+    update_session(session_id: string, update_json: string): Promise<void>;
+    /**
+     * Validate (and consume one use of) a session token.
+     * Returns the scope string on success, throws on failure.
+     * If the registry is empty, always succeeds (backward-compat gate).
+     */
+    validate_session_token(token: string): string;
+    /**
+     * Validate and record token admission for a specific connection.
+     */
+    validate_session_token_for_connection(token: string, connection_id: string): Promise<string>;
+    wait_for_settled_peer(id: string, timeout_ms?: number | null): Promise<any>;
+}
+
+export class WasmConnection {
+    free(): void;
+    [Symbol.dispose](): void;
+    create_data_channel(label: string): RTCDataChannel;
+    constructor();
+}
+
+export function start(): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_bistream_free: (a: number, b: number) => void;
+    readonly bistream_recv: (a: number) => any;
+    readonly bistream_send: (a: number) => any;
+    readonly bistream_endpoint_id: (a: number) => [number, number];
+    readonly __wbg_wasmclient_free: (a: number, b: number) => void;
+    readonly wasmclient_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly wasmclient_newWithAppTag: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly wasmclient_set_auth_token: (a: number, b: number, c: number) => void;
+    readonly wasmclient_init_iroh: (a: number, b: number, c: number) => any;
+    readonly wasmclient_iroh_secret_key: (a: number) => any;
+    readonly wasmclient_node_addr: (a: number) => any;
+    readonly wasmclient_endpoint_ticket: (a: number) => any;
+    readonly wasmclient_endpoint_ticket_with_token: (a: number, b: number, c: number, d: number) => any;
+    readonly wasmclient_register_session_token: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmclient_validate_session_token: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly wasmclient_validate_session_token_for_connection: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmclient_present_session_token_to_host: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmclient_revoke_session_token: (a: number, b: number, c: number) => void;
+    readonly wasmclient_revoke_tokens_by_scope: (a: number, b: number, c: number) => any;
+    readonly wasmclient_clear_session_tokens: (a: number) => void;
+    readonly wasmclient_endpoint_id_from_ticket: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly wasmclient_connect: (a: number, b: number, c: number) => any;
+    readonly wasmclient_disconnect: (a: number, b: number, c: number) => any;
+    readonly wasmclient_is_connected: (a: number, b: number, c: number) => any;
+    readonly wasmclient_add_peer_scope: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmclient_release_peer_scope: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmclient_peer_scopes: (a: number, b: number, c: number) => any;
+    readonly wasmclient_same_peer: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmclient_peer_snapshot: (a: number, b: number, c: number) => any;
+    readonly wasmclient_peer_snapshots: (a: number) => any;
+    readonly wasmclient_peer_session: (a: number, b: number, c: number) => any;
+    readonly wasmclient_peer_sessions: (a: number) => any;
+    readonly wasmclient_connection_state: (a: number, b: number, c: number) => any;
+    readonly wasmclient_connection_states: (a: number) => any;
+    readonly wasmclient_wait_for_settled_peer: (a: number, b: number, c: number, d: number) => any;
+    readonly wasmclient_resolve_peer_connection_records: (a: number, b: number, c: number) => any;
+    readonly wasmclient_list_managed_connections: (a: number) => any;
+    readonly wasmclient_report_managed_connection_settled: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+    readonly wasmclient_open_bi: (a: number, b: number, c: number) => any;
+    readonly wasmclient_open_peer_bi: (a: number, b: number, c: number, d: number) => any;
+    readonly wasmclient_open_uni: (a: number, b: number, c: number) => any;
+    readonly wasmclient_open_peer_uni: (a: number, b: number, c: number, d: number) => any;
+    readonly wasmclient_incoming_streams: (a: number) => any;
+    readonly 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;
+    readonly wasmclient_send_message: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
+    readonly wasmclient_set_offline: (a: number, b: number, c: number) => any;
+    readonly wasmclient_update_device: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => any;
+    readonly wasmclient_delete_device: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmclient_force_reconnect_snapshot: (a: number) => void;
+    readonly wasmclient_stop_presence_loop: (a: number) => void;
+    readonly wasmclient_stop_auto_connect: (a: number) => void;
+    readonly wasmclient_set_auto_connect_excluded: (a: number, b: number, c: number, d: number) => void;
+    readonly wasmclient_stop_auth_scoped_activity: (a: number) => void;
+    readonly wasmclient_start_presence_loop: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly wasmclient_search_devices: (a: number, b: number, c: number) => any;
+    readonly wasmclient_devices_with_status: (a: number, b: number, c: number) => any;
+    readonly wasmclient_connect_device: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmclient_create_session: (a: number, b: number, c: number) => any;
+    readonly wasmclient_update_session: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmclient_create_room: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => any;
+    readonly wasmclient_join_room: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => any;
+    readonly wasmclient_get_members: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+    readonly wasmclient_leave_room: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+    readonly wasmclient_heartbeat_tick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+    readonly start: () => void;
+    readonly __wbg_wasmconnection_free: (a: number, b: number) => void;
+    readonly wasmconnection_new: () => [number, number, number];
+    readonly wasmconnection_create_data_channel: (a: number, b: number, c: number) => any;
+    readonly __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+    readonly intounderlyingsource_pull: (a: number, b: any) => any;
+    readonly intounderlyingsource_cancel: (a: number) => void;
+    readonly __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_type: (a: number) => number;
+    readonly intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
+    readonly intounderlyingbytesource_start: (a: number, b: any) => void;
+    readonly intounderlyingbytesource_pull: (a: number, b: any) => any;
+    readonly intounderlyingbytesource_cancel: (a: number) => void;
+    readonly __wbg_intounderlyingsink_free: (a: number, b: number) => void;
+    readonly intounderlyingsink_write: (a: number, b: any) => any;
+    readonly intounderlyingsink_close: (a: number) => any;
+    readonly intounderlyingsink_abort: (a: number, b: any) => any;
+    readonly ring_core_0_17_14__bn_mul_mont: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasm_bindgen__closure__destroy__h371e680d2c9813cc: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h80a0a4202b98bec2: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__hdda622e051292cf2: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h0b41a02fbe6471ce: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h8e81dd7dd6597798: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__hc4385c46a735f91a: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h65fdc278f5332d1f: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h2853267a0cbc2b04: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h517a56e03d34d888: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h3f605e54c3ccc792: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hf53043a3aa608bb3: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h14717fdf60edc0ad: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hb5064d1dd77b5d01: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h3736bba9aeac8b38: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h3b2823c6a5a88a62: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h9f65334fdbabfcc8: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hc3d2296b352a462d: (a: number, b: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;