@hashtree/worker 0.1.26 → 0.2.1

package/dist/p2p/webrtcController.js

@@ -1,902 +0,0 @@
-/**
- * Worker WebRTC Controller
- *
- * Controls WebRTC connections from the worker thread.
- * Main thread proxy executes RTCPeerConnection operations.
- *
- * Worker owns:
- * - Peer state tracking
- * - Connection lifecycle decisions
- * - Data protocol (request/response)
- * - Signaling message handling
- *
- * Main thread proxy owns:
- * - RTCPeerConnection instances (not available in workers)
- * - Data channel I/O
- */
-import { fromHex, sha256, toHex } from '@hashtree/core';
-import { MAX_HTL, MSG_TYPE_REQUEST, MSG_TYPE_RESPONSE, FRAGMENT_SIZE, PeerId, encodeRequest, encodeResponse, parseMessage, createRequest, createResponse, createFragmentResponse, hashToKey, verifyHash, generatePeerHTLConfig, PeerSelector, buildHedgedWavePlan, normalizeDispatchConfig, syncSelectorPeers, } from '@hashtree/nostr';
-import { LRUCache } from './lruCache.js';
-import { MeshQueryRouter, encodeForwardRequest } from './meshQueryRouter.js';
-const PEER_METADATA_POINTER_SLOT_KEY = 'hashtree-webrtc/peer-metadata/latest/v1';
-const DEFAULT_REQUEST_DISPATCH = {
-    initialFanout: 2,
-    hedgeFanout: 1,
-    maxFanout: 8,
-    hedgeIntervalMs: 120,
-};
-// ============================================================================
-// Controller
-// ============================================================================
-export class WebRTCController {
-    myPeerId;
-    peers = new Map();
-    pendingRemoteCandidates = new Map();
-    localStore;
-    sendCommand;
-    sendSignaling;
-    classifyPeer;
-    requestTimeout;
-    debug;
-    recentRequests = new LRUCache(1000);
-    meshRouter;
-    peerSelector;
-    routing;
-    // Pool configuration - reasonable defaults, settings sync will override
-    poolConfig = {
-        follows: { maxConnections: 20, satisfiedConnections: 10 },
-        other: { maxConnections: 16, satisfiedConnections: 8 },
-    };
-    // Hello interval - 5s for faster peer discovery
-    helloInterval;
-    HELLO_INTERVAL = 5000;
-    constructor(config) {
-        this.myPeerId = new PeerId(config.pubkey);
-        this.localStore = config.localStore;
-        this.sendCommand = config.sendCommand;
-        this.sendSignaling = config.sendSignaling;
-        this.requestTimeout = config.requestTimeout ?? 1000;
-        this.debug = config.debug ?? false;
-        this.routing = {
-            selectionStrategy: config.requestSelectionStrategy ?? 'titForTat',
-            fairnessEnabled: config.requestFairnessEnabled ?? true,
-            dispatch: config.requestDispatch ?? DEFAULT_REQUEST_DISPATCH,
-        };
-        this.peerSelector = PeerSelector.withStrategy(this.routing.selectionStrategy);
-        this.peerSelector.setFairness(this.routing.fairnessEnabled);
-        this.meshRouter = new MeshQueryRouter({
-            localStore: this.localStore,
-            requestTimeoutMs: this.requestTimeout,
-            upstreamFetch: config.upstreamFetch,
-            maxForwardsPerPeerWindow: config.forwardRateLimit?.maxForwardsPerPeerWindow,
-            forwardRateLimitWindowMs: config.forwardRateLimit?.windowMs,
-        });
-        // Default classifier: check if pubkey is in follows
-        const getFollows = config.getFollows ?? (() => new Set());
-        this.classifyPeer = (pubkey) => {
-            const follows = getFollows();
-            const isFollow = follows.has(pubkey);
-            return isFollow ? 'follows' : 'other';
-        };
-    }
-    // ============================================================================
-    // Lifecycle
-    // ============================================================================
-    start() {
-        this.log('Starting WebRTC controller');
-        // Send hello periodically
-        this.helloInterval = setInterval(() => {
-            this.sendHello();
-        }, this.HELLO_INTERVAL);
-        // Send initial hello
-        this.sendHello();
-    }
-    stop() {
-        this.log('Stopping WebRTC controller');
-        if (this.helloInterval) {
-            clearInterval(this.helloInterval);
-            this.helloInterval = undefined;
-        }
-        // Close all peers
-        for (const peerId of this.peers.keys()) {
-            this.closePeer(peerId);
-        }
-        this.meshRouter.stop();
-    }
-    // ============================================================================
-    // Signaling
-    // ============================================================================
-    sendHello() {
-        const msg = {
-            type: 'hello',
-            peerId: this.myPeerId.toString(),
-        };
-        this.sendSignaling(msg).catch(err => {
-            console.error('[WebRTC] sendSignaling error:', err);
-        });
-    }
-    /**
-     * Public method to trigger a hello broadcast.
-     * Used for testing to force peer discovery after follows are set up.
-     */
-    broadcastHello() {
-        this.sendHello();
-    }
-    /**
-     * Handle incoming signaling message (from Nostr kind 25050)
-     *
-     * `peerId` is the remote endpoint identity.
-     */
-    async handleSignalingMessage(msg, senderPubkey) {
-        this.log(`Signaling from ${senderPubkey.slice(0, 8)}:`, msg.type);
-        switch (msg.type) {
-            case 'hello':
-                await this.handleHello(senderPubkey);
-                break;
-            case 'offer':
-                if (msg.peerId === this.myPeerId.toString()) {
-                    return; // Skip messages from ourselves
-                }
-                if (this.isMessageForUs(msg)) {
-                    // Construct RTCSessionDescriptionInit from flat sdp field
-                    await this.handleOffer(msg.peerId, senderPubkey, { type: 'offer', sdp: msg.sdp });
-                }
-                break;
-            case 'answer':
-                if (msg.peerId === this.myPeerId.toString()) {
-                    return;
-                }
-                if (this.isMessageForUs(msg)) {
-                    // Construct RTCSessionDescriptionInit from flat sdp field
-                    await this.handleAnswer(msg.peerId, { type: 'answer', sdp: msg.sdp });
-                }
-                break;
-            case 'candidate':
-                if (msg.peerId === this.myPeerId.toString()) {
-                    return;
-                }
-                if (this.isMessageForUs(msg)) {
-                    // Construct RTCIceCandidateInit from flat fields
-                    await this.handleIceCandidate(msg.peerId, {
-                        candidate: msg.candidate,
-                        sdpMLineIndex: msg.sdpMLineIndex,
-                        sdpMid: msg.sdpMid,
-                    });
-                }
-                break;
-            case 'candidates':
-                if (msg.peerId === this.myPeerId.toString()) {
-                    return;
-                }
-                if (this.isMessageForUs(msg)) {
-                    for (const c of msg.candidates) {
-                        await this.handleIceCandidate(msg.peerId, {
-                            candidate: c.candidate,
-                            sdpMLineIndex: c.sdpMLineIndex,
-                            sdpMid: c.sdpMid,
-                        });
-                    }
-                }
-                break;
-        }
-    }
-    isMessageForUs(msg) {
-        if ('targetPeerId' in msg && msg.targetPeerId) {
-            return msg.targetPeerId === this.myPeerId.toString();
-        }
-        return true;
-    }
-    async handleHello(senderPubkey) {
-        const peerId = new PeerId(senderPubkey).toString();
-        // Already connected?
-        if (this.peers.has(peerId)) {
-            return;
-        }
-        // Check pool limits
-        const pool = this.classifyPeer(senderPubkey);
-        if (!this.shouldConnect(pool)) {
-            this.log(`Pool ${pool} at capacity, ignoring hello`);
-            return;
-        }
-        // In 'other' pool, only allow 1 connection per pubkey
-        if (pool === 'other' && this.hasOtherPoolPubkey(senderPubkey)) {
-            this.log(`Already have connection from ${senderPubkey.slice(0, 8)} in other pool`);
-            return;
-        }
-        // Tie-breaking: lower endpoint ID initiates
-        const shouldInitiate = this.myPeerId.toString() < peerId;
-        if (shouldInitiate) {
-            this.log(`Initiating connection to ${peerId.slice(0, 20)}`);
-            await this.createOutboundPeer(peerId, senderPubkey, pool);
-        }
-        else {
-            this.log(`Waiting for offer from ${peerId.slice(0, 20)}`);
-        }
-    }
-    async handleOffer(peerId, pubkey, offer) {
-        this.log(`handleOffer from ${pubkey.slice(0, 8)}, peerId: ${peerId.slice(0, 20)}`);
-        let peer = this.peers.get(peerId);
-        if (!peer) {
-            const pool = this.classifyPeer(pubkey);
-            if (!this.shouldConnect(pool)) {
-                this.log(`Pool ${pool} at capacity, rejecting offer`);
-                return;
-            }
-            if (pool === 'other' && this.hasOtherPoolPubkey(pubkey)) {
-                this.log(`Already have connection from ${pubkey.slice(0, 8)} in other pool, rejecting offer`);
-                return;
-            }
-            this.log(`Creating inbound peer for ${pubkey.slice(0, 8)}`);
-            peer = this.createPeer(peerId, pubkey, pool, 'inbound');
-        }
-        else if (peer.direction === 'outbound' && peer.state === 'connecting') {
-            const isPolite = this.myPeerId.toString() < peerId;
-            if (!isPolite) {
-                this.log(`Ignoring offer collision from ${pubkey.slice(0, 8)} as impolite peer`);
-                return;
-            }
-            // Perfect negotiation: the polite peer abandons its local offer and
-            // switches into answerer mode for the remote offer.
-            peer.direction = 'inbound';
-            peer.answerCreated = false;
-        }
-        this.log(`Setting remote description for ${peerId.slice(0, 20)}`);
-        this.sendCommand({ type: 'rtc:setRemoteDescription', peerId, sdp: offer });
-    }
-    async handleAnswer(peerId, answer) {
-        const peer = this.peers.get(peerId);
-        if (!peer) {
-            this.log(`Answer for unknown peer: ${peerId}`);
-            return;
-        }
-        this.sendCommand({ type: 'rtc:setRemoteDescription', peerId, sdp: answer });
-    }
-    async handleIceCandidate(peerId, candidate) {
-        const peer = this.peers.get(peerId);
-        if (!peer) {
-            const queued = this.pendingRemoteCandidates.get(peerId) ?? [];
-            queued.push(candidate);
-            this.pendingRemoteCandidates.set(peerId, queued);
-            return;
-        }
-        this.sendCommand({ type: 'rtc:addIceCandidate', peerId, candidate });
-    }
-    // ============================================================================
-    // Peer Management
-    // ============================================================================
-    shouldConnect(pool) {
-        const config = this.poolConfig[pool];
-        const count = this.getPoolCount(pool);
-        return count < config.maxConnections;
-    }
-    getPoolCount(pool) {
-        let count = 0;
-        for (const peer of this.peers.values()) {
-            if (peer.pool === pool && peer.state !== 'disconnected') {
-                count++;
-            }
-        }
-        return count;
-    }
-    /**
-     * Check if we already have a connection from this pubkey in the 'other' pool.
-     * In the 'other' pool, we only allow 1 connection per pubkey to prevent spam.
-     */
-    hasOtherPoolPubkey(pubkey) {
-        for (const peer of this.peers.values()) {
-            if (peer.pool === 'other' && peer.pubkey === pubkey && peer.state !== 'disconnected') {
-                return true;
-            }
-        }
-        return false;
-    }
-    createPeer(peerId, pubkey, pool, direction) {
-        const peer = {
-            peerId,
-            pubkey,
-            pool,
-            direction,
-            state: 'connecting',
-            dataChannelReady: false,
-            answerCreated: false,
-            htlConfig: generatePeerHTLConfig(),
-            pendingRequests: new Map(),
-            stats: {
-                requestsSent: 0,
-                requestsReceived: 0,
-                responsesSent: 0,
-                responsesReceived: 0,
-                bytesSent: 0,
-                bytesReceived: 0,
-                forwardedRequests: 0,
-                forwardedResolved: 0,
-                forwardedSuppressed: 0,
-            },
-            createdAt: Date.now(),
-            bufferPaused: false,
-            deferredRequests: [],
-        };
-        this.peers.set(peerId, peer);
-        this.peerSelector.addPeer(peerId);
-        this.meshRouter.registerPeer({
-            peerId,
-            canSend: () => peer.dataChannelReady,
-            getHtlConfig: () => peer.htlConfig,
-            sendRequest: (hash, htl) => this.sendRequestToPeer(peer, hash, htl),
-            sendResponse: async (hash, data) => this.sendResponse(peer, hash, data),
-            onForwardedRequest: () => {
-                peer.stats.forwardedRequests++;
-            },
-            onForwardedResolved: () => {
-                peer.stats.forwardedResolved++;
-            },
-            onForwardedSuppressed: () => {
-                peer.stats.forwardedSuppressed++;
-            },
-        });
-        this.sendCommand({ type: 'rtc:createPeer', peerId, pubkey });
-        return peer;
-    }
-    async createOutboundPeer(peerId, pubkey, pool) {
-        this.createPeer(peerId, pubkey, pool, 'outbound');
-        // Proxy will create peer and we'll get rtc:peerCreated, then request offer
-    }
-    closePeer(peerId) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        // Clear pending requests
-        for (const pending of peer.pendingRequests.values()) {
-            clearTimeout(pending.timeout);
-            pending.resolve(null);
-        }
-        peer.state = 'disconnected';
-        this.sendCommand({ type: 'rtc:closePeer', peerId });
-        this.peers.delete(peerId);
-        this.pendingRemoteCandidates.delete(peerId);
-        this.peerSelector.removePeer(peerId);
-        this.meshRouter.removePeer(peerId);
-        this.log(`Closed peer: ${peerId.slice(0, 20)}`);
-    }
-    // ============================================================================
-    // Proxy Events
-    // ============================================================================
-    /**
-     * Handle event from main thread proxy
-     */
-    handleProxyEvent(event) {
-        switch (event.type) {
-            case 'rtc:peerCreated':
-                this.onPeerCreated(event.peerId);
-                break;
-            case 'rtc:peerStateChange':
-                this.onPeerStateChange(event.peerId, event.state);
-                break;
-            case 'rtc:peerClosed':
-                this.onPeerClosed(event.peerId);
-                break;
-            case 'rtc:offerCreated':
-                this.onOfferCreated(event.peerId, event.sdp);
-                break;
-            case 'rtc:answerCreated':
-                this.onAnswerCreated(event.peerId, event.sdp);
-                break;
-            case 'rtc:descriptionSet':
-                this.onDescriptionSet(event.peerId, event.error);
-                break;
-            case 'rtc:iceCandidate':
-                this.onIceCandidate(event.peerId, event.candidate);
-                break;
-            case 'rtc:dataChannelOpen':
-                this.onDataChannelOpen(event.peerId);
-                break;
-            case 'rtc:dataChannelMessage':
-                this.onDataChannelMessage(event.peerId, event.data);
-                break;
-            case 'rtc:dataChannelClose':
-                this.onDataChannelClose(event.peerId);
-                break;
-            case 'rtc:dataChannelError':
-                this.onDataChannelError(event.peerId, event.error);
-                break;
-            case 'rtc:bufferHigh':
-                this.onBufferHigh(event.peerId);
-                break;
-            case 'rtc:bufferLow':
-                this.onBufferLow(event.peerId);
-                break;
-        }
-    }
-    onPeerCreated(peerId) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        const queuedCandidates = this.pendingRemoteCandidates.get(peerId);
-        if (queuedCandidates?.length) {
-            for (const candidate of queuedCandidates) {
-                this.sendCommand({ type: 'rtc:addIceCandidate', peerId, candidate });
-            }
-            this.pendingRemoteCandidates.delete(peerId);
-        }
-        // If outbound, create offer
-        if (peer.direction === 'outbound') {
-            this.sendCommand({ type: 'rtc:createOffer', peerId });
-        }
-    }
-    onPeerStateChange(peerId, state) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        this.log(`Peer ${peerId.slice(0, 20)} state: ${state}`);
-        if (state === 'connected') {
-            peer.state = 'connected';
-            peer.connectedAt = Date.now();
-        }
-        else if (state === 'failed' || state === 'closed') {
-            this.closePeer(peerId);
-        }
-    }
-    onPeerClosed(peerId) {
-        this.peers.delete(peerId);
-        this.peerSelector.removePeer(peerId);
-    }
-    onOfferCreated(peerId, sdp) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        // Set local description
-        this.sendCommand({ type: 'rtc:setLocalDescription', peerId, sdp });
-        // Send offer via signaling using endpoint identities.
-        const msg = {
-            type: 'offer',
-            sdp: sdp.sdp,
-            targetPeerId: peerId,
-            peerId: this.myPeerId.toString(),
-        };
-        this.sendSignaling(msg, peer.pubkey);
-    }
-    onAnswerCreated(peerId, sdp) {
-        this.log(`onAnswerCreated for ${peerId.slice(0, 20)}`);
-        const peer = this.peers.get(peerId);
-        if (!peer) {
-            this.log(`onAnswerCreated: peer not found for ${peerId.slice(0, 20)}`);
-            return;
-        }
-        this.sendCommand({ type: 'rtc:setLocalDescription', peerId, sdp });
-        this.log(`Sending answer to ${peer.pubkey.slice(0, 8)}`);
-        const msg = {
-            type: 'answer',
-            sdp: sdp.sdp,
-            targetPeerId: peerId,
-            peerId: this.myPeerId.toString(),
-        };
-        this.sendSignaling(msg, peer.pubkey);
-    }
-    onDescriptionSet(peerId, error) {
-        if (error) {
-            this.log(`Description set error for ${peerId.slice(0, 20)}: ${error}`);
-            return;
-        }
-        const peer = this.peers.get(peerId);
-        if (!peer) {
-            this.log(`onDescriptionSet: peer not found for ${peerId.slice(0, 20)}`);
-            return;
-        }
-        this.log(`onDescriptionSet for ${peerId.slice(0, 20)}: direction=${peer.direction}, state=${peer.state}, answerCreated=${peer.answerCreated}`);
-        if (peer.direction === 'inbound' && peer.state === 'connecting' && !peer.answerCreated) {
-            peer.answerCreated = true;
-            this.log(`Creating answer for ${peerId.slice(0, 20)}`);
-            this.sendCommand({ type: 'rtc:createAnswer', peerId });
-        }
-    }
-    onIceCandidate(peerId, candidate) {
-        if (!candidate || !candidate.candidate)
-            return;
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        // Send candidate via signaling using endpoint identities.
-        const msg = {
-            type: 'candidate',
-            candidate: candidate.candidate,
-            sdpMLineIndex: candidate.sdpMLineIndex ?? undefined,
-            sdpMid: candidate.sdpMid ?? undefined,
-            targetPeerId: peerId,
-            peerId: this.myPeerId.toString(),
-        };
-        this.sendSignaling(msg, peer.pubkey);
-    }
-    onDataChannelOpen(peerId) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        peer.dataChannelReady = true;
-        this.log(`Data channel open: ${peerId.slice(0, 20)}`);
-    }
-    onDataChannelClose(peerId) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        peer.dataChannelReady = false;
-        this.closePeer(peerId);
-    }
-    onDataChannelError(peerId, error) {
-        this.log(`Data channel error for ${peerId}: ${error}`);
-    }
-    onBufferHigh(peerId) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        peer.bufferPaused = true;
-        this.log(`Buffer high for ${peerId.slice(0, 20)}, pausing responses`);
-    }
-    onBufferLow(peerId) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        peer.bufferPaused = false;
-        this.log(`Buffer low for ${peerId.slice(0, 20)}, resuming responses`);
-        // Process deferred requests
-        this.processDeferredRequests(peer);
-    }
-    async processDeferredRequests(peer) {
-        while (!peer.bufferPaused && peer.deferredRequests.length > 0) {
-            const req = peer.deferredRequests.shift();
-            await this.processRequest(peer, req);
-        }
-    }
-    orderedConnectedPeers(excludePeerId) {
-        const connectedAll = Array.from(this.peers.values())
-            .filter((peer) => peer.dataChannelReady);
-        if (connectedAll.length === 0)
-            return [];
-        const peerIds = connectedAll.map((peer) => peer.peerId);
-        syncSelectorPeers(this.peerSelector, peerIds);
-        const connectedPeers = connectedAll
-            .filter((peer) => !excludePeerId || peer.peerId !== excludePeerId);
-        const selectorOrder = this.peerSelector.selectPeers();
-        const rank = new Map(selectorOrder.map((peerId, idx) => [peerId, idx]));
-        connectedPeers.sort((a, b) => {
-            if (a.pool === 'follows' && b.pool !== 'follows')
-                return -1;
-            if (a.pool !== 'follows' && b.pool === 'follows')
-                return 1;
-            return (rank.get(a.peerId) ?? Number.MAX_SAFE_INTEGER) - (rank.get(b.peerId) ?? Number.MAX_SAFE_INTEGER);
-        });
-        return connectedPeers;
-    }
-    async peerMetadataPointerHash() {
-        return sha256(new TextEncoder().encode(PEER_METADATA_POINTER_SLOT_KEY));
-    }
-    createInFlightRequest(peer, hash, htl) {
-        const hashKey = hashToKey(hash);
-        const startedAt = Date.now();
-        this.peerSelector.recordRequest(peer.peerId, 40);
-        const promise = new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                peer.pendingRequests.delete(hashKey);
-                this.peerSelector.recordTimeout(peer.peerId);
-                resolve({ peerId: peer.peerId, data: null, elapsedMs: Math.max(1, Date.now() - startedAt) });
-            }, this.requestTimeout);
-            peer.pendingRequests.set(hashKey, {
-                hash,
-                startedAt,
-                resolve: (data) => {
-                    resolve({ peerId: peer.peerId, data, elapsedMs: Math.max(1, Date.now() - startedAt) });
-                },
-                timeout,
-            });
-            peer.stats.requestsSent++;
-            const req = createRequest(hash, htl);
-            const encoded = new Uint8Array(encodeRequest(req));
-            this.sendDataToPeer(peer, encoded);
-        });
-        return {
-            peerId: peer.peerId,
-            settled: false,
-            promise,
-        };
-    }
-    async waitForInFlightResult(inFlight, waitMs) {
-        const active = inFlight.filter((task) => !task.settled);
-        if (active.length === 0 || waitMs <= 0)
-            return null;
-        const timeout = new Promise((resolve) => {
-            setTimeout(() => resolve(null), waitMs);
-        });
-        const outcome = await Promise.race([
-            timeout,
-            ...active.map((task) => task.promise.then((result) => ({
-                task,
-                data: result.data,
-                elapsedMs: result.elapsedMs,
-            }))),
-        ]);
-        if (!outcome)
-            return null;
-        outcome.task.settled = true;
-        return outcome;
-    }
-    clearPendingHashFromPeers(hashKey, keepPeerId) {
-        for (const peer of this.peers.values()) {
-            if (keepPeerId && peer.peerId === keepPeerId)
-                continue;
-            const pending = peer.pendingRequests.get(hashKey);
-            if (!pending)
-                continue;
-            clearTimeout(pending.timeout);
-            peer.pendingRequests.delete(hashKey);
-        }
-    }
-    /**
-     * Persist selector metadata snapshot to local store.
-     * Returns the snapshot hash.
-     */
-    async persistPeerMetadata() {
-        const snapshot = this.peerSelector.exportPeerMetadataSnapshot();
-        const bytes = new TextEncoder().encode(JSON.stringify(snapshot));
-        const snapshotHash = await sha256(bytes);
-        await this.localStore.put(snapshotHash, bytes);
-        const pointerHash = await this.peerMetadataPointerHash();
-        await this.localStore.delete(pointerHash);
-        await this.localStore.put(pointerHash, new TextEncoder().encode(toHex(snapshotHash)));
-        return snapshotHash;
-    }
-    /**
-     * Load selector metadata snapshot from local store.
-     */
-    async loadPeerMetadata() {
-        const pointerHash = await this.peerMetadataPointerHash();
-        const pointerBytes = await this.localStore.get(pointerHash);
-        if (!pointerBytes)
-            return false;
-        const pointerHex = new TextDecoder().decode(pointerBytes).trim();
-        if (pointerHex.length !== 64)
-            return false;
-        const snapshotHash = fromHex(pointerHex);
-        if (snapshotHash.length !== 32)
-            return false;
-        const snapshotBytes = await this.localStore.get(snapshotHash);
-        if (!snapshotBytes)
-            return false;
-        let snapshot;
-        try {
-            snapshot = JSON.parse(new TextDecoder().decode(snapshotBytes));
-        }
-        catch {
-            return false;
-        }
-        this.peerSelector.importPeerMetadataSnapshot(snapshot);
-        syncSelectorPeers(this.peerSelector, Array.from(this.peers.keys()));
-        return true;
-    }
-    // ============================================================================
-    // Data Protocol
-    // ============================================================================
-    sendDataToPeer(peer, data) {
-        peer.stats.bytesSent += data.byteLength;
-        this.sendCommand({ type: 'rtc:sendData', peerId: peer.peerId, data });
-    }
-    async onDataChannelMessage(peerId, data) {
-        const peer = this.peers.get(peerId);
-        if (!peer)
-            return;
-        // Count all inbound DataChannel bytes (requests + responses + protocol overhead).
-        peer.stats.bytesReceived += data.byteLength;
-        const msg = parseMessage(data);
-        if (!msg) {
-            this.log(`Failed to parse message from ${peerId}`);
-            return;
-        }
-        if (msg.type === MSG_TYPE_REQUEST) {
-            await this.handleRequest(peer, msg.body);
-        }
-        else if (msg.type === MSG_TYPE_RESPONSE) {
-            await this.handleResponse(peer, msg.body);
-        }
-    }
-    async handleRequest(peer, req) {
-        peer.stats.requestsReceived++;
-        // If buffer is full, defer the request for later processing
-        if (peer.bufferPaused) {
-            // Limit deferred requests to prevent memory issues
-            if (peer.deferredRequests.length < 100) {
-                peer.deferredRequests.push(req);
-            }
-            return;
-        }
-        await this.processRequest(peer, req);
-    }
-    async processRequest(peer, req) {
-        await this.meshRouter.handleRequest(peer.peerId, req);
-    }
-    async handleResponse(peer, res) {
-        peer.stats.responsesReceived++;
-        const hashKey = hashToKey(res.h);
-        const pending = peer.pendingRequests.get(hashKey);
-        if (!pending) {
-            const hasRequesters = this.meshRouter.hasInFlight(hashKey);
-            // Late response: cache if we requested this hash recently
-            const requestedAt = this.recentRequests.get(hashKey);
-            if (!requestedAt && !hasRequesters)
-                return;
-            if (requestedAt && Date.now() - requestedAt > 60000) {
-                this.recentRequests.delete(hashKey);
-                if (!hasRequesters)
-                    return;
-            }
-            const valid = await verifyHash(res.d, res.h);
-            if (valid) {
-                await this.localStore.put(res.h, res.d);
-                if (requestedAt) {
-                    this.recentRequests.delete(hashKey);
-                }
-                if (hasRequesters) {
-                    await this.meshRouter.resolve(res.h, res.d);
-                }
-            }
-            return;
-        }
-        clearTimeout(pending.timeout);
-        peer.pendingRequests.delete(hashKey);
-        // Verify hash
-        const valid = await verifyHash(res.d, res.h);
-        const elapsedMs = pending.startedAt ? Math.max(1, Date.now() - pending.startedAt) : this.requestTimeout;
-        if (valid) {
-            // Store locally
-            await this.localStore.put(res.h, res.d);
-            this.peerSelector.recordSuccess(peer.peerId, elapsedMs, res.d.length);
-            pending.resolve(res.d);
-            await this.meshRouter.resolve(res.h, res.d);
-        }
-        else {
-            this.log(`Hash mismatch from ${peer.peerId}`);
-            this.peerSelector.recordFailure(peer.peerId);
-            pending.resolve(null);
-        }
-    }
-    async sendResponse(peer, hash, data) {
-        if (!peer.dataChannelReady)
-            return;
-        peer.stats.responsesSent++;
-        // Fragment if needed
-        if (data.length > FRAGMENT_SIZE) {
-            const totalFragments = Math.ceil(data.length / FRAGMENT_SIZE);
-            for (let i = 0; i < totalFragments; i++) {
-                const start = i * FRAGMENT_SIZE;
-                const end = Math.min(start + FRAGMENT_SIZE, data.length);
-                const fragment = data.slice(start, end);
-                const res = createFragmentResponse(hash, fragment, i, totalFragments);
-                const encoded = new Uint8Array(encodeResponse(res));
-                this.sendDataToPeer(peer, encoded);
-            }
-        }
-        else {
-            const res = createResponse(hash, data);
-            const encoded = new Uint8Array(encodeResponse(res));
-            this.sendDataToPeer(peer, encoded);
-        }
-    }
-    sendRequestToPeer(peer, hash, htl) {
-        if (!peer.dataChannelReady) {
-            return false;
-        }
-        const encoded = encodeForwardRequest(hash, htl);
-        this.sendDataToPeer(peer, encoded);
-        return true;
-    }
-    // ============================================================================
-    // Public API
-    // ============================================================================
-    /**
-     * Request data from peers
-     */
-    async get(hash) {
-        const orderedPeers = this.orderedConnectedPeers();
-        if (orderedPeers.length === 0)
-            return null;
-        const dispatch = normalizeDispatchConfig(this.routing.dispatch, orderedPeers.length);
-        const wavePlan = buildHedgedWavePlan(orderedPeers.length, dispatch);
-        if (wavePlan.length === 0)
-            return null;
-        const hashKey = hashToKey(hash);
-        this.recentRequests.set(hashKey, Date.now());
-        const deadline = Date.now() + this.requestTimeout;
-        const inFlight = [];
-        let nextPeerIdx = 0;
-        for (let waveIdx = 0; waveIdx < wavePlan.length; waveIdx++) {
-            const waveSize = wavePlan[waveIdx];
-            const from = nextPeerIdx;
-            const to = Math.min(from + waveSize, orderedPeers.length);
-            nextPeerIdx = to;
-            for (const peer of orderedPeers.slice(from, to)) {
-                inFlight.push(this.createInFlightRequest(peer, hash, MAX_HTL));
-            }
-            const isLastWave = waveIdx === wavePlan.length - 1 || nextPeerIdx >= orderedPeers.length;
-            const windowEnd = isLastWave
-                ? deadline
-                : Math.min(deadline, Date.now() + dispatch.hedgeIntervalMs);
-            while (Date.now() < windowEnd) {
-                const remaining = windowEnd - Date.now();
-                const result = await this.waitForInFlightResult(inFlight, remaining);
-                if (!result)
-                    break;
-                if (!result.data)
-                    continue;
-                this.clearPendingHashFromPeers(hashKey, result.task.peerId);
-                return result.data;
-            }
-            if (Date.now() >= deadline)
-                break;
-        }
-        this.clearPendingHashFromPeers(hashKey);
-        return null;
-    }
-    /**
-     * Get peer stats for UI
-     */
-    getPeerStats() {
-        return Array.from(this.peers.values()).map(peer => ({
-            peerId: peer.peerId,
-            pubkey: peer.pubkey,
-            connected: peer.state === 'connected' && peer.dataChannelReady,
-            pool: peer.pool,
-            requestsSent: peer.stats.requestsSent,
-            requestsReceived: peer.stats.requestsReceived,
-            responsesSent: peer.stats.responsesSent,
-            responsesReceived: peer.stats.responsesReceived,
-            bytesSent: peer.stats.bytesSent,
-            bytesReceived: peer.stats.bytesReceived,
-            forwardedRequests: peer.stats.forwardedRequests,
-            forwardedResolved: peer.stats.forwardedResolved,
-            forwardedSuppressed: peer.stats.forwardedSuppressed,
-        }));
-    }
-    /**
-     * Get connected peer count
-     */
-    getConnectedCount() {
-        let count = 0;
-        for (const peer of this.peers.values()) {
-            if (peer.state === 'connected' && peer.dataChannelReady) {
-                count++;
-            }
-        }
-        return count;
-    }
-    /**
-     * Set pool configuration
-     */
-    setPoolConfig(config) {
-        this.poolConfig = {
-            follows: { maxConnections: config.follows.max, satisfiedConnections: config.follows.satisfied },
-            other: { maxConnections: config.other.max, satisfiedConnections: config.other.satisfied },
-        };
-        this.log('Pool config updated:', this.poolConfig);
-        // Re-broadcast hello to trigger peer discovery with new limits
-        this.sendHello();
-    }
-    /**
-     * Update identity (pubkey) and restart signaling if already running.
-     * This keeps peerId consistent with the current account.
-     */
-    setIdentity(pubkey) {
-        if (this.myPeerId.pubkey === pubkey)
-            return;
-        const wasStarted = !!this.helloInterval;
-        this.stop();
-        this.myPeerId = new PeerId(pubkey);
-        if (wasStarted) {
-            this.start();
-        }
-    }
-    // ============================================================================
-    // Helpers
-    // ============================================================================
-    log(...args) {
-        if (this.debug) {
-            console.log('[WebRTC]', ...args);
-        }
-    }
-}
-//# sourceMappingURL=webrtcController.js.map