@vdoninja/ninja-p2p 0.1.4 → 0.2.0

package/dist/vdo-bridge.d.ts

@@ -11,6 +11,7 @@ import { EventEmitter } from "node:events";
 import { MessageBus, type MessageBusOptions } from "./message-bus.js";
 import { PeerRegistry } from "./peer-registry.js";
 import { type AgentProfile, type FileOfferPayload, type AnnouncePayload, type MessageEnvelope, type MessageType, type PeerIdentity } from "./protocol.js";
+import type { VDONinja } from "./vdoninja-sdk-types.js";
 export type VDOBridgeOptions = {
     room: string;
     streamId: string;
@@ -44,10 +45,24 @@ export declare class VDOBridge extends EventEmitter {
     private version;
     private agentProfile;
     private readonly viewedStreamIds;
+    private disconnecting;
+    /** Set while the SDK is re-establishing signalling and replaying its intent. */
+    private restoring;
+    private restoringUntil;
     constructor(options: VDOBridgeOptions);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
+    /** Whether the SDK is mid-reconnect, or just finished and still settling. */
+    isRestoring(): boolean;
+    /**
+     * Resolve once the SDK has genuinely finished tearing down.
+     *
+     * Fallback for an overridden pre-1.4.1 SDK or a teardown promise that rejects.
+     * The early socket-phase "disconnected" event is not completion, so observe
+     * the state the cleanup clears and cap the wait.
+     */
+    private waitForSdkTeardown;
     private emitBridgeError;
     /** Update skills and broadcast the change. */
     updateSkills(skills: string[]): void;
@@ -71,6 +86,35 @@ export declare class VDOBridge extends EventEmitter {
     sendImage(targetStreamId: string, filePath: string): FileOfferPayload;
     /** Send raw data through the underlying SDK without envelope wrapping. */
     sendRaw(data: unknown, targetStreamId?: string): boolean;
+    /**
+     * Whether this build can put raw bytes on the wire.
+     *
+     * False on SDK versions before 1.4.1, where everything was JSON-stringified
+     * before it reached the data channel. Callers fall back to base64 rather than
+     * failing: a swarm with a mix of old and new peers still works, just slower
+     * with the old ones.
+     */
+    supportsBinary(): boolean;
+    /**
+     * Send raw bytes to one peer, bypassing JSON entirely.
+     *
+     * Resolves false rather than throwing when the peer is unknown or the SDK is
+     * too old, so a caller can treat it as "try binary, else base64" in one line.
+     */
+    sendBinaryTo(targetStreamId: string, bytes: Uint8Array): Promise<boolean>;
+    /**
+     * Bytes still queued for a peer on the binary lane, or null if unknown.
+     *
+     * Note this is the binary lane specifically. Reading the control channel
+     * while bulk traffic queues on `x-bin` reports a permanent zero, which is
+     * exactly how the SDK's own docs concluded that the value never moves under
+     * `@roamhq/wrtc` — see docs/sdk-wishlist.md.
+     */
+    bufferedBytesFor(targetStreamId: string): number | null;
+    /** Negotiated SCTP message limit for a peer, or null if not reported. */
+    maxMessageSizeFor(targetStreamId: string): number | null;
+    /** Smallest limit any connected peer reports, or null if none report one. */
+    smallestMaxMessageSize(): number | null;
     /** Reply to a received message using its sender as the target. */
     reply(message: MessageEnvelope, type: MessageType, payload: unknown): MessageEnvelope;
     /** Acknowledge receipt of a received message. */
@@ -80,11 +124,28 @@ export declare class VDOBridge extends EventEmitter {
     /** Ask a peer to replay recent message history to this bridge. */
     requestHistory(targetStreamId: string, count?: number): MessageEnvelope;
     /** Access the underlying VDO.Ninja SDK instance for advanced media workflows. */
-    getSDK(): InstanceType<typeof import("@vdoninja/sdk")> | null;
+    getSDK(): VDONinja | null;
     private wireSDKEvents;
+    /**
+     * The SDK types enumerate the stable public events but the bridge also
+     * listens to long-standing compatibility aliases. Keep the cast at this one
+     * boundary rather than weakening every handler.
+     */
+    private addSDKEventListener;
     private startHeartbeat;
     private stopHeartbeat;
     private respondPong;
     private broadcastSkillUpdate;
+    /**
+     * Tear down and rebuild the connection to one peer.
+     *
+     * A peer connection can report `open` on the sending side while nothing
+     * actually crosses it — measured after a signalling blip, where chunk
+     * requests arrived, the sender's `send()` returned success, and the bytes
+     * never landed. Nothing below us notices, because every layer believes it is
+     * fine. The only evidence is at the application layer: a peer that keeps
+     * failing to deliver. This is how that evidence gets acted on.
+     */
+    revivePeer(streamId: string): boolean;
     private maybeViewPeer;
 }

package/dist/vdo-bridge.js

@@ -7,11 +7,35 @@
  *
  * Zero dependencies on stevesbot internals.
  */
+import { createRequire } from "node:module";
 import { EventEmitter } from "node:events";
+import { setTimeout as delay } from "node:timers/promises";
 import { sendFileFromPath } from "./file-transfer.js";
 import { MessageBus } from "./message-bus.js";
 import { PeerRegistry } from "./peer-registry.js";
 import { createEnvelope, createInstanceId, envelopeToWire, parseEnvelope, } from "./protocol.js";
+/**
+ * The version advertised to peers.
+ *
+ * Read from package.json rather than typed in. It was a literal, and had
+ * already drifted from the released version — peers were told whatever someone
+ * last remembered to edit, which is worse than no version at all because it
+ * looks authoritative.
+ */
+function readPackageVersion() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkg = require("../package.json");
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/** Cap on how long a shutdown waits for the SDK, so it can never wedge an exit. */
+const TEARDOWN_TIMEOUT_MS = 5000;
+/** Quiet period after a reconnect, while the SDK replays its own view intent. */
+const RESTORE_GRACE_MS = 8000;
 // ── Class ────────────────────────────────────────────────────────────────────
 export class VDOBridge extends EventEmitter {
     peers;
@@ -24,9 +48,13 @@ export class VDOBridge extends EventEmitter {
     skills;
     status = "idle";
     statusDetail = "";
-    version = "0.1.4";
+    version = readPackageVersion();
     agentProfile;
     viewedStreamIds = new Set();
+    disconnecting = false;
+    /** Set while the SDK is re-establishing signalling and replaying its intent. */
+    restoring = false;
+    restoringUntil = 0;
     constructor(options) {
         super();
         this.options = options;
@@ -88,6 +116,8 @@ export class VDOBridge extends EventEmitter {
     async disconnect() {
         if (!this.connected || !this.sdk)
             return;
+        const sdk = this.sdk;
+        this.disconnecting = true;
         this.stopHeartbeat();
         // Send a leaving event to all peers
         try {
@@ -95,15 +125,40 @@ export class VDOBridge extends EventEmitter {
             this.sdk.sendData(envelopeToWire(envelope));
         }
         catch { /* best effort */ }
+        // Every viewed peer holds an RTCPeerConnection. Under @roamhq/wrtc those
+        // are native handles that keep Node's event loop alive, so a CLI that only
+        // dropped the bookkeeping set would connect, do its work, and then hang
+        // forever instead of exiting.
+        for (const streamId of this.viewedStreamIds) {
+            try {
+                this.sdk.stopViewing(streamId);
+            }
+            catch { /* best effort */ }
+        }
         try {
             this.sdk.leaveRoom();
         }
         catch { /* best effort */ }
+        // Tearing the process down before the SDK has finished closing peer
+        // connections kills the native WebRTC module mid-cleanup, so wait for real
+        // completion. The 1.4.1 floor resolves exactly then; the state-poll fallback
+        // keeps forced older installs and a rejected teardown from exiting halfway.
         try {
-            this.sdk.disconnect();
+            const result = sdk.disconnect();
+            if (result && typeof result.then === "function") {
+                await Promise.race([result, delay(TEARDOWN_TIMEOUT_MS)]);
+            }
+            else {
+                await this.waitForSdkTeardown(sdk);
+            }
+        }
+        catch {
+            // A disconnect that throws has not cleaned up, so fall back to observing
+            // the state rather than exiting into a half-torn-down native module.
+            await this.waitForSdkTeardown(sdk);
         }
-        catch { /* best effort */ }
         this.connected = false;
+        this.disconnecting = false;
         this.sdk = null;
         this.viewedStreamIds.clear();
         this.peers.clear();
@@ -113,6 +168,28 @@ export class VDOBridge extends EventEmitter {
     isConnected() {
         return this.connected;
     }
+    /** Whether the SDK is mid-reconnect, or just finished and still settling. */
+    isRestoring() {
+        return this.restoring || Date.now() < this.restoringUntil;
+    }
+    /**
+     * Resolve once the SDK has genuinely finished tearing down.
+     *
+     * Fallback for an overridden pre-1.4.1 SDK or a teardown promise that rejects.
+     * The early socket-phase "disconnected" event is not completion, so observe
+     * the state the cleanup clears and cap the wait.
+     */
+    async waitForSdkTeardown(sdk, timeoutMs = TEARDOWN_TIMEOUT_MS) {
+        const state = sdk;
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const connectionsClosed = (state.connections?.size ?? 0) === 0;
+            const signalingClosed = !state.signaling;
+            if (connectionsClosed && signalingClosed)
+                return;
+            await delay(50);
+        }
+    }
     emitBridgeError(err) {
         if (this.listenerCount("error") > 0) {
             this.emit("error", err);
@@ -197,6 +274,88 @@ export class VDOBridge extends EventEmitter {
             return false;
         }
     }
+    // ── Binary lane ──────────────────────────────────────────────────────────
+    /**
+     * Whether this build can put raw bytes on the wire.
+     *
+     * False on SDK versions before 1.4.1, where everything was JSON-stringified
+     * before it reached the data channel. Callers fall back to base64 rather than
+     * failing: a swarm with a mix of old and new peers still works, just slower
+     * with the old ones.
+     */
+    supportsBinary() {
+        return typeof this.sdk?.sendBinary === "function";
+    }
+    /**
+     * Send raw bytes to one peer, bypassing JSON entirely.
+     *
+     * Resolves false rather than throwing when the peer is unknown or the SDK is
+     * too old, so a caller can treat it as "try binary, else base64" in one line.
+     */
+    async sendBinaryTo(targetStreamId, bytes) {
+        const sdk = this.sdk;
+        if (!sdk || typeof sdk.sendBinary !== "function")
+            return false;
+        const uuid = this.peers.getPeer(targetStreamId)?.uuid;
+        if (!uuid)
+            return false;
+        try {
+            return await sdk.sendBinary(bytes, uuid);
+        }
+        catch (err) {
+            this.emitBridgeError(err);
+            return false;
+        }
+    }
+    /**
+     * Bytes still queued for a peer on the binary lane, or null if unknown.
+     *
+     * Note this is the binary lane specifically. Reading the control channel
+     * while bulk traffic queues on `x-bin` reports a permanent zero, which is
+     * exactly how the SDK's own docs concluded that the value never moves under
+     * `@roamhq/wrtc` — see docs/sdk-wishlist.md.
+     */
+    bufferedBytesFor(targetStreamId) {
+        const sdk = this.sdk;
+        if (!sdk || typeof sdk.getBufferedAmount !== "function")
+            return null;
+        const uuid = this.peers.getPeer(targetStreamId)?.uuid;
+        if (!uuid)
+            return null;
+        try {
+            return sdk.getBufferedAmount(uuid, "bin");
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Negotiated SCTP message limit for a peer, or null if not reported. */
+    maxMessageSizeFor(targetStreamId) {
+        const sdk = this.sdk;
+        if (!sdk || typeof sdk.getMaxMessageSize !== "function")
+            return null;
+        const uuid = this.peers.getPeer(targetStreamId)?.uuid;
+        if (!uuid)
+            return null;
+        try {
+            return sdk.getMaxMessageSize(uuid);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Smallest limit any connected peer reports, or null if none report one. */
+    smallestMaxMessageSize() {
+        let smallest = null;
+        for (const peer of this.peers.getConnectedPeers()) {
+            const limit = this.maxMessageSizeFor(peer.streamId);
+            if (limit === null)
+                continue;
+            if (smallest === null || limit < smallest)
+                smallest = limit;
+        }
+        return smallest;
+    }
     /** Reply to a received message using its sender as the target. */
     reply(message, type, payload) {
         return this.bus.send(message.from.streamId, type, payload);
@@ -237,14 +396,14 @@ export class VDOBridge extends EventEmitter {
         if (!this.sdk)
             return;
         // Peer connected (WebRTC connection established)
-        this.sdk.addEventListener("peerConnected", (event) => {
+        this.addSDKEventListener("peerConnected", (event) => {
             const uuid = event.detail?.uuid ?? "unknown";
             const streamId = event.detail?.streamID ?? uuid;
             this.peers.addPeer(streamId, uuid);
             this.emit("peer:connected", { streamId, uuid });
         });
         // Data channel opened — send our announce
-        this.sdk.addEventListener("dataChannelOpen", (event) => {
+        this.addSDKEventListener("dataChannelOpen", (event) => {
             const uuid = event.detail?.uuid ?? "unknown";
             const mappedStreamId = this.peers.streamIdForUuid(uuid);
             const eventStreamId = event.detail?.streamID;
@@ -252,7 +411,7 @@ export class VDOBridge extends EventEmitter {
             // Send announce to this specific peer
             const announce = createEnvelope(this.identity, "announce", this.getAnnouncePayload(), { to: streamId });
             try {
-                this.sdk.sendData(envelopeToWire(announce), { UUID: uuid });
+                this.sdk.sendData(envelopeToWire(announce), { uuid });
             }
             catch { /* peer may have disconnected */ }
             // Flush any queued offline messages for this peer
@@ -263,7 +422,7 @@ export class VDOBridge extends EventEmitter {
             this.emit("datachannel:open", { streamId, uuid });
         });
         // Data received — parse and route through MessageBus
-        this.sdk.addEventListener("dataReceived", (event) => {
+        this.addSDKEventListener("dataReceived", (event) => {
             const raw = event.detail?.data;
             const uuid = event.detail?.uuid ?? "unknown";
             const envelope = parseEnvelope(raw);
@@ -274,7 +433,20 @@ export class VDOBridge extends EventEmitter {
             }
             // If we don't have a streamId mapping for this uuid, use the envelope's from
             const senderStreamId = envelope.from.streamId;
-            if (!this.peers.getPeer(senderStreamId)) {
+            const mappedSender = this.peers.streamIdForUuid(uuid);
+            const claimedPeer = this.peers.getPeer(senderStreamId);
+            if ((mappedSender && mappedSender !== uuid && mappedSender !== senderStreamId) ||
+                (claimedPeer && claimedPeer.uuid !== uuid && claimedPeer.connected)) {
+                if (this.options.debug) {
+                    console.warn(`[P2P] Rejected identity switch on ${uuid}: ` +
+                        `${mappedSender ?? "unmapped"} -> ${senderStreamId}`);
+                }
+                return;
+            }
+            if (claimedPeer && claimedPeer.uuid !== uuid && !claimedPeer.connected) {
+                this.peers.addPeer(senderStreamId, uuid);
+            }
+            else if (!claimedPeer) {
                 const orphanPeer = this.peers.getPeer(uuid);
                 if (orphanPeer && orphanPeer.streamId === uuid) {
                     this.peers.rekeyPeer(uuid, senderStreamId);
@@ -301,15 +473,26 @@ export class VDOBridge extends EventEmitter {
                     // Just update last-seen (already done in bus.handleIncoming)
                     break;
                 case "history_request": {
-                    // Send recent history to the requesting peer
-                    const count = typeof envelope.payload === "object" && envelope.payload !== null
-                        ? envelope.payload.count ?? 50
+                    // A peer may see broadcasts and its own conversation with us, but
+                    // never direct messages exchanged with somebody else. Filtering
+                    // after taking the last N entries could let unrelated traffic crowd
+                    // out every eligible message, so filter the bounded history ring
+                    // first and slice second.
+                    const requested = typeof envelope.payload === "object" && envelope.payload !== null
+                        ? envelope.payload.count
+                        : undefined;
+                    const count = Number.isInteger(requested) && requested > 0
+                        ? Math.min(requested, 200)
                         : 50;
-                    const history = this.bus.getHistory(count);
+                    const history = this.bus.getHistory()
+                        .filter((message) => !message.to ||
+                        message.to === senderStreamId ||
+                        message.from.streamId === senderStreamId)
+                        .slice(-count);
                     for (const msg of history) {
                         const replay = createEnvelope(this.identity, "history_replay", msg, { to: senderStreamId });
                         try {
-                            this.sdk.sendData(envelopeToWire(replay), { UUID: uuid });
+                            this.sdk.sendData(envelopeToWire(replay), { uuid });
                         }
                         catch { /* best effort */ }
                     }
@@ -320,7 +503,7 @@ export class VDOBridge extends EventEmitter {
             this.bus.handleIncoming(envelope);
         });
         // Peer disconnected
-        this.sdk.addEventListener("peerDisconnected", (event) => {
+        this.addSDKEventListener("peerDisconnected", (event) => {
             const uuid = event.detail?.uuid ?? "unknown";
             const streamId = event.detail?.streamID ?? this.peers.streamIdForUuid(uuid) ?? uuid;
             this.viewedStreamIds.delete(streamId);
@@ -328,17 +511,48 @@ export class VDOBridge extends EventEmitter {
             console.log(`[P2P] Peer disconnected: ${streamId}`);
             this.emit("peer:disconnected", { streamId, uuid });
         });
+        // Raw bytes from a peer's sendBinary(). No envelope, no routing beyond the
+        // sender, so whatever framing the payload needs lives inside the bytes.
+        this.addSDKEventListener("binaryReceived", (event) => {
+            const raw = event.detail?.bytes;
+            if (!(raw instanceof Uint8Array))
+                return;
+            const uuid = event.detail?.uuid ?? "unknown";
+            const streamId = this.peers.streamIdForUuid(uuid) ?? event.detail?.streamID ?? uuid;
+            this.emit("binary", { streamId, uuid, bytes: raw });
+        });
         // SDK-level connection events
-        this.sdk.addEventListener("disconnected", () => {
-            console.log("[P2P] WebSocket disconnected, SDK will attempt reconnect...");
-            this.emit("ws:disconnected");
+        this.addSDKEventListener("disconnected", (event) => {
+            // From SDK v1.4.1 the event says whether a reconnect is actually coming.
+            // Older builds say nothing, so fall back to our own shutdown flag rather
+            // than claiming a reconnect that will never happen.
+            const detail = event?.detail;
+            const willReconnect = typeof detail?.willReconnect === "boolean" ? detail.willReconnect : !this.disconnecting;
+            if (willReconnect) {
+                console.log("[P2P] WebSocket disconnected, SDK will attempt reconnect...");
+            }
+            this.emit("ws:disconnected", { willReconnect, phase: detail?.phase });
+        });
+        this.addSDKEventListener("reconnecting", () => {
+            this.restoring = true;
         });
-        this.sdk.addEventListener("reconnected", () => {
+        this.addSDKEventListener("reconnected", () => {
             console.log("[P2P] WebSocket reconnected.");
+            // The SDK replays its own view intent right after this. Rebuilding a
+            // connection on top of that replay races it — both sides manipulate the
+            // same pending-view state — so hold off briefly and let it finish.
+            this.restoring = false;
+            this.restoringUntil = Date.now() + RESTORE_GRACE_MS;
+            // Every peer connection was established under the old socket. The SDK
+            // replays its own view intent, but our bookkeeping said "already viewing"
+            // for all of them, so anything the replay missed could never be
+            // re-established by us — the set was only ever cleared on shutdown.
+            // Forget it, and let the fresh room listing decide what to view.
+            this.viewedStreamIds.clear();
             this.emit("ws:reconnected");
         });
         // Room listing (existing peers when we join)
-        this.sdk.addEventListener("listing", (event) => {
+        this.addSDKEventListener("listing", (event) => {
             const list = event.detail?.list ?? [];
             for (const entry of list) {
                 if (entry.streamID && entry.streamID !== this.options.streamId) {
@@ -346,18 +560,26 @@ export class VDOBridge extends EventEmitter {
                 }
             }
         });
-        this.sdk.addEventListener("videoaddedtoroom", (event) => {
+        this.addSDKEventListener("videoaddedtoroom", (event) => {
             this.maybeViewPeer(event.detail?.streamID);
         });
-        this.sdk.addEventListener("streamAdded", (event) => {
+        this.addSDKEventListener("streamAdded", (event) => {
             this.maybeViewPeer(event.detail?.streamID);
         });
         // Error handling
-        this.sdk.addEventListener("error", (event) => {
+        this.addSDKEventListener("error", (event) => {
             console.error("[P2P] SDK error:", event.detail?.error);
             this.emitBridgeError(event.detail?.error);
         });
     }
+    /**
+     * The SDK types enumerate the stable public events but the bridge also
+     * listens to long-standing compatibility aliases. Keep the cast at this one
+     * boundary rather than weakening every handler.
+     */
+    addSDKEventListener(name, handler) {
+        this.sdk?.addEventListener(name, handler);
+    }
     // ── Heartbeat ────────────────────────────────────────────────────────────
     startHeartbeat() {
         const interval = this.options.heartbeatMs ?? 30_000;
@@ -391,7 +613,7 @@ export class VDOBridge extends EventEmitter {
         const peer = this.peers.getPeer(targetStreamId);
         if (peer) {
             try {
-                this.sdk.sendData(envelopeToWire(pong), { UUID: peer.uuid });
+                this.sdk.sendData(envelopeToWire(pong), { uuid: peer.uuid });
             }
             catch { /* best effort */ }
         }
@@ -406,6 +628,34 @@ export class VDOBridge extends EventEmitter {
             agent: this.agentProfile,
         });
     }
+    /**
+     * Tear down and rebuild the connection to one peer.
+     *
+     * A peer connection can report `open` on the sending side while nothing
+     * actually crosses it — measured after a signalling blip, where chunk
+     * requests arrived, the sender's `send()` returned success, and the bytes
+     * never landed. Nothing below us notices, because every layer believes it is
+     * fine. The only evidence is at the application layer: a peer that keeps
+     * failing to deliver. This is how that evidence gets acted on.
+     */
+    revivePeer(streamId) {
+        if (!this.sdk || streamId === this.options.streamId)
+            return false;
+        // Never while the SDK is restoring: it is already rebuilding these very
+        // connections, and doing it underneath was measured as slower than doing
+        // nothing. With signalling healthy, a rebuild restores a path in ~260ms.
+        if (this.isRestoring())
+            return false;
+        try {
+            this.sdk.stopViewing(streamId);
+        }
+        catch { /* it may already be gone; rebuilding is still worth trying */ }
+        this.viewedStreamIds.delete(streamId);
+        this.peers.markDisconnected(streamId);
+        console.log(`[P2P] Rebuilding the connection to ${streamId}`);
+        this.maybeViewPeer(streamId);
+        return true;
+    }
     maybeViewPeer(streamId) {
         if (!this.sdk || !streamId || streamId === this.options.streamId || this.viewedStreamIds.has(streamId)) {
             return;

package/dist/vdoninja-sdk-types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Narrow compatibility types for @vdoninja/sdk.
+ *
+ * SDK 1.4.1's package metadata points at `vdoninja-sdk.d.ts`, but the npm
+ * tarball published on 2026-07-25 does not contain that file. Keep this local
+ * interface until the declared SDK floor resolves to a registry package that
+ * actually ships its declarations. It is compiled into ninja-p2p's own public
+ * types, so consumers do not inherit the broken declaration reference.
+ */
+export type VDONinjaOptions = {
+    host?: string;
+    room?: string;
+    password?: string | false;
+    salt?: string;
+    debug?: boolean;
+    turnServers?: unknown;
+    forceTURN?: boolean;
+    maxReconnectAttempts?: number;
+};
+export interface VDONinja {
+    connect(): Promise<void>;
+    disconnect(): void | Promise<void>;
+    joinRoom(options?: {
+        room?: string;
+        password?: string | false;
+    }): Promise<void>;
+    leaveRoom(): void;
+    announce(options?: {
+        streamID?: string;
+        label?: string;
+        meta?: string;
+    }): Promise<void>;
+    view(streamID: string, options?: {
+        audio?: boolean;
+        video?: boolean;
+        label?: string;
+    }): Promise<unknown>;
+    stopViewing(streamID: string): void;
+    sendData(data: unknown, target?: unknown): boolean;
+    sendPing(uuid: string): void;
+    sendBinary?(data: ArrayBuffer | ArrayBufferView, uuid: string, options?: {
+        ordered?: boolean;
+        maxRetransmits?: number;
+        maxPacketLifeTime?: number;
+        waitForDrain?: boolean;
+    }): Promise<boolean>;
+    openChannel?(uuid: string, label: string, options?: {
+        ordered?: boolean;
+        maxRetransmits?: number;
+        maxPacketLifeTime?: number;
+        timeout?: number;
+    }): Promise<unknown>;
+    getChannel?(uuid: string, label: string): unknown;
+    getBufferedAmount?(uuid: string, label?: string): number | null;
+    getMaxMessageSize?(uuid: string): number | null;
+    getPeerQuality?(uuid: string): Promise<{
+        rttMs: number | null;
+        lossRate: number | null;
+        candidatePairType: string | null;
+        relayed: boolean | null;
+        availableOutgoingBitrate: number | null;
+        bytesSent: number;
+        bytesReceived: number;
+    } | null>;
+    publish(stream: unknown, options?: Record<string, unknown>): Promise<void>;
+    stopPublishing(): void;
+    getStats(uuid?: string): Promise<unknown>;
+    addEventListener(event: string, handler: EventListenerOrEventListenerObject): void;
+    removeEventListener(event: string, handler: EventListenerOrEventListenerObject): void;
+    on(event: string, handler: EventListenerOrEventListenerObject): void;
+    off(event: string, handler: EventListenerOrEventListenerObject): void;
+    once(event: string, handler: EventListenerOrEventListenerObject): void;
+    debug: boolean;
+}
+export type VDONinjaConstructor = new (options?: VDONinjaOptions) => VDONinja;

package/dist/vdoninja-sdk-types.js

@@ -0,0 +1,10 @@
+/**
+ * Narrow compatibility types for @vdoninja/sdk.
+ *
+ * SDK 1.4.1's package metadata points at `vdoninja-sdk.d.ts`, but the npm
+ * tarball published on 2026-07-25 does not contain that file. Keep this local
+ * interface until the declared SDK floor resolves to a registry package that
+ * actually ships its declarations. It is compiled into ninja-p2p's own public
+ * types, so consumers do not inherit the broken declaration reference.
+ */
+export {};