@hashtree/worker 0.1.1

package/dist/p2p/webrtcController.js

@@ -0,0 +1,813 @@
+/**
+ * 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 { MAX_HTL, MSG_TYPE_REQUEST, MSG_TYPE_RESPONSE, FRAGMENT_SIZE, PeerId, generateUuid, encodeRequest, encodeResponse, parseMessage, createRequest, createResponse, createFragmentResponse, hashToKey, verifyHash, generatePeerHTLConfig, decrementHTL, shouldForward, } from '@hashtree/nostr';
+import { LRUCache } from './lruCache.js';
+import { QueryForwardingMachine } from './queryForwardingMachine.js';
+// ============================================================================
+// Controller
+// ============================================================================
+export class WebRTCController {
+    myPeerId;
+    peers = new Map();
+    localStore;
+    sendCommand;
+    sendSignaling;
+    classifyPeer;
+    requestTimeout;
+    debug;
+    recentRequests = new LRUCache(1000);
+    forwardingMachine;
+    // 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, generateUuid());
+        this.localStore = config.localStore;
+        this.sendCommand = config.sendCommand;
+        this.sendSignaling = config.sendSignaling;
+        this.requestTimeout = config.requestTimeout ?? 1000;
+        this.debug = config.debug ?? false;
+        this.forwardingMachine = new QueryForwardingMachine({
+            requestTimeoutMs: this.requestTimeout,
+            maxForwardsPerPeerWindow: config.forwardRateLimit?.maxForwardsPerPeerWindow,
+            forwardRateLimitWindowMs: config.forwardRateLimit?.windowMs,
+            onForwardTimeout: ({ hashKey, requesterIds }) => {
+                this.clearRequesterMarkers(hashKey, requesterIds);
+            },
+        });
+        // 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.forwardingMachine.stop();
+    }
+    // ============================================================================
+    // Signaling
+    // ============================================================================
+    sendHello() {
+        const msg = {
+            type: 'hello',
+            peerId: this.myPeerId.uuid,
+        };
+        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)
+     *
+     * Note: For hello messages, msg.peerId is just the UUID (from Nostr tag).
+     * For directed messages (offer/answer/candidate), msg.peerId is already the full
+     * pubkey:uuid format from Rust's SignalingMessage.
+     */
+    async handleSignalingMessage(msg, senderPubkey) {
+        this.log(`Signaling from ${senderPubkey.slice(0, 8)}:`, msg.type);
+        switch (msg.type) {
+            case 'hello':
+                // For hello, msg.peerId is just UUID - handleHello constructs the full peer ID
+                {
+                    const senderUuid = msg.peerId.includes(':') ? msg.peerId.split(':').slice(-1)[0] : msg.peerId;
+                    await this.handleHello(senderPubkey, senderUuid);
+                }
+                break;
+            case 'offer':
+                // For directed messages, msg.peerId is already full pubkey:uuid format
+                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, senderUuid) {
+        const peerId = `${senderPubkey}:${senderUuid}`;
+        // 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 UUID initiates
+        const shouldInitiate = this.myPeerId.uuid < senderUuid;
+        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');
+        }
+        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) {
+            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(),
+            theirRequests: new LRUCache(200),
+            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.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.forwardingMachine.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;
+        // 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);
+    }
+    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 (use Rust-compatible format: full pubkey:uuid for peerId)
+        const msg = {
+            type: 'offer',
+            sdp: sdp.sdp,
+            targetPeerId: peerId,
+            peerId: this.myPeerId.toString(), // Full pubkey:uuid
+        };
+        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 (use Rust-compatible format: full pubkey:uuid for peerId)
+        const msg = {
+            type: 'candidate',
+            candidate: candidate.candidate,
+            sdpMLineIndex: candidate.sdpMLineIndex ?? undefined,
+            sdpMid: candidate.sdpMid ?? undefined,
+            targetPeerId: peerId,
+            peerId: this.myPeerId.toString(), // Full pubkey:uuid
+        };
+        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);
+        }
+    }
+    // ============================================================================
+    // 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) {
+        const hashKey = hashToKey(req.h);
+        // Try to get from local store
+        const data = await this.localStore.get(req.h);
+        if (data) {
+            // Send response
+            await this.sendResponse(peer, req.h, data);
+        }
+        else {
+            // Track their request for later push
+            peer.theirRequests.set(hashKey, {
+                hash: req.h,
+                requestedAt: Date.now(),
+            });
+            // Forward if HTL allows
+            const htl = req.htl ?? MAX_HTL;
+            if (shouldForward(htl)) {
+                const newHtl = decrementHTL(htl, peer.htlConfig);
+                const decision = this.forwardingMachine.beginForward(hashKey, peer.peerId, this.getForwardTargets(peer.peerId));
+                if (decision.kind === 'suppressed') {
+                    peer.stats.forwardedSuppressed++;
+                    return;
+                }
+                if (decision.kind === 'rate_limited') {
+                    peer.theirRequests.delete(hashKey);
+                    this.log(`Forward rate-limited for ${peer.peerId.slice(0, 20)} hash ${hashKey.slice(0, 16)}`);
+                    return;
+                }
+                if (decision.kind === 'no_targets') {
+                    peer.theirRequests.delete(hashKey);
+                    return;
+                }
+                const forwarded = this.forwardRequest(req.h, decision.targets, newHtl);
+                if (forwarded <= 0) {
+                    const requesterIds = this.forwardingMachine.cancelForward(hashKey);
+                    this.clearRequesterMarkers(hashKey, requesterIds);
+                    return;
+                }
+                peer.stats.forwardedRequests++;
+            }
+        }
+    }
+    async handleResponse(peer, res) {
+        peer.stats.responsesReceived++;
+        const hashKey = hashToKey(res.h);
+        const pending = peer.pendingRequests.get(hashKey);
+        if (!pending) {
+            const hasRequesters = Array.from(this.peers.values()).some(p => p.theirRequests.has(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.pushToRequesters(res.h, res.d, peer.peerId);
+                    this.forwardingMachine.resolveForward(hashKey);
+                }
+            }
+            return;
+        }
+        clearTimeout(pending.timeout);
+        peer.pendingRequests.delete(hashKey);
+        // Verify hash
+        const valid = await verifyHash(res.d, res.h);
+        if (valid) {
+            // Store locally
+            await this.localStore.put(res.h, res.d);
+            pending.resolve(res.d);
+            // Push to peers who requested this
+            await this.pushToRequesters(res.h, res.d, peer.peerId);
+            this.forwardingMachine.resolveForward(hashKey);
+        }
+        else {
+            this.log(`Hash mismatch from ${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);
+        }
+    }
+    getForwardTargets(excludePeerId) {
+        const targets = [];
+        for (const [peerId, peer] of this.peers) {
+            if (peerId === excludePeerId)
+                continue;
+            if (!peer.dataChannelReady)
+                continue;
+            targets.push(peerId);
+        }
+        return targets;
+    }
+    forwardRequest(hash, targetPeerIds, htl) {
+        const hashKey = hashToKey(hash);
+        let forwarded = 0;
+        for (const peerId of targetPeerIds) {
+            const peer = this.peers.get(peerId);
+            if (!peer || !peer.dataChannelReady)
+                continue;
+            // Set up pending request so we can process the response
+            const timeout = setTimeout(() => {
+                peer.pendingRequests.delete(hashKey);
+            }, this.requestTimeout);
+            peer.pendingRequests.set(hashKey, {
+                hash,
+                resolve: () => {
+                    // Response will be pushed to original requester via pushToRequesters
+                },
+                timeout,
+            });
+            const req = createRequest(hash, htl);
+            const encoded = new Uint8Array(encodeRequest(req));
+            this.sendDataToPeer(peer, encoded);
+            forwarded++;
+        }
+        return forwarded;
+    }
+    async pushToRequesters(hash, data, excludePeerId) {
+        const hashKey = hashToKey(hash);
+        for (const [peerId, peer] of this.peers) {
+            if (peerId === excludePeerId)
+                continue;
+            const theirReq = peer.theirRequests.get(hashKey);
+            if (theirReq) {
+                peer.theirRequests.delete(hashKey);
+                peer.stats.forwardedResolved++;
+                await this.sendResponse(peer, hash, data);
+            }
+        }
+    }
+    clearRequesterMarkers(hashKey, requesterIds) {
+        for (const requesterId of requesterIds) {
+            this.peers.get(requesterId)?.theirRequests.delete(hashKey);
+        }
+    }
+    // ============================================================================
+    // Public API
+    // ============================================================================
+    /**
+     * Request data from peers
+     */
+    async get(hash) {
+        // Try connected peers
+        const connectedPeers = Array.from(this.peers.values())
+            .filter(p => p.dataChannelReady);
+        if (connectedPeers.length === 0) {
+            return null;
+        }
+        // Send request to all peers, first response wins
+        return new Promise((resolve) => {
+            let resolved = false;
+            const hashKey = hashToKey(hash);
+            this.recentRequests.set(hashKey, Date.now());
+            for (const peer of connectedPeers) {
+                const timeout = setTimeout(() => {
+                    peer.pendingRequests.delete(hashKey);
+                    checkDone();
+                }, this.requestTimeout);
+                peer.pendingRequests.set(hashKey, {
+                    hash,
+                    resolve: (data) => {
+                        if (!resolved && data) {
+                            resolved = true;
+                            resolve(data);
+                        }
+                        checkDone();
+                    },
+                    timeout,
+                });
+                peer.stats.requestsSent++;
+                const req = createRequest(hash, MAX_HTL);
+                const encoded = new Uint8Array(encodeRequest(req));
+                this.sendDataToPeer(peer, encoded);
+            }
+            let pending = connectedPeers.length;
+            const checkDone = () => {
+                pending--;
+                if (pending === 0 && !resolved) {
+                    resolve(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, generateUuid());
+        if (wasStarted) {
+            this.start();
+        }
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    log(...args) {
+        if (this.debug) {
+            console.log('[WebRTC]', ...args);
+        }
+    }
+}
+//# sourceMappingURL=webrtcController.js.map