@steve02081504/fount-p2p 0.0.30 → 0.0.31

package/link/providers/webrtc.mjs

@@ -68,8 +68,7 @@ export async function createWebRtcLink(options) {
 	const handshakeTimeoutMs = Number(options.handshakeTimeoutMs) || ms('10s')
 	const channelOpenTimeoutMs = Math.max(handshakeTimeoutMs, ms('30s'))
 	const rtc = options.rtc ?? await loadNodeRtcPolyfill()
-	// 纯 JS 后端只做 trickle（SDP 不含 candidate）；强制开启 trickle。
-	const trickleIceOff = !rtc.forcesTrickleIce && getSignalingRuntimeConfig().trickleIceOff === true
+	const trickleIceOff = getSignalingRuntimeConfig().trickleIceOff === true
 	const peerConnection = new rtc.RTCPeerConnection(options.iceServers?.length ? { iceServers: options.iceServers } : undefined)
 	const remoteSignalQueue = []
 	const seenRemoteSignals = createLruMap(1024)
@@ -183,6 +182,10 @@ export async function createWebRtcLink(options) {
 		const deadline = Date.now() + handshakeTimeoutMs
 		while (peerConnection.iceGatheringState !== 'complete' && Date.now() < deadline)
 			await new Promise(resolve => setTimeout(resolve, 50))
+		if (peerConnection.iceGatheringState !== 'complete') {
+			await pipe.close('ice-gathering-timeout')
+			throw new Error(`p2p: ice gathering incomplete after ${handshakeTimeoutMs}ms`)
+		}
 	}
 
 	/**

package/link/rtc/ice_local_hostname.mjs

@@ -50,18 +50,12 @@ export function filterIceLocalHostnameCandidate(candidate, RTCIceCandidateCtor,
 export function wrapRtcPeerConnectionForIceLocalHostname(BaseRTC, RTCIceCandidate, policy = 'drop') {
 	if (policy === 'none') return BaseRTC
 
-	const baseRoutesIce = !!BaseRTC.prototype.prepareIceCandidateEvent
-
 	return class IceLocalHostnameFilteredRTCPeerConnection extends BaseRTC {
 		/** @type {((event: RTCPeerConnectionIceEvent) => void) | null} */
 		#userIceHandler = null
-		/** @type {Set<(event: unknown) => void>} */
-		#iceListeners = new Set()
-		/** 去重：同一次 native 派发可能既走 attribute 又走 listener */
-		#lastIceEvent = null
 
 		/**
-		 * drop：不派发；rewrite：仅派发替换 candidate 后的事件。
+		 * drop：不派发；rewrite：构造仅携带替换 candidate 的派生事件。
 		 * @param {RTCPeerConnectionIceEvent | { candidate?: unknown }} event 原始 ICE 事件
 		 * @returns {RTCPeerConnectionIceEvent | { candidate?: unknown } | null} 规范化后的事件；drop 时为 null
 		 */
@@ -69,7 +63,10 @@ export function wrapRtcPeerConnectionForIceLocalHostname(BaseRTC, RTCIceCandidat
 			if (!event?.candidate) return event
 			const filtered = filterIceLocalHostnameCandidate(event.candidate, RTCIceCandidate, policy)
 			if (!filtered) return null
-			return filtered === event.candidate ? event : { candidate: filtered }
+			if (filtered === event.candidate) return event
+			const rewritten = new event.constructor('icecandidate')
+			rewritten.candidate = filtered
+			return rewritten
 		}
 
 		/**
@@ -77,9 +74,6 @@ export function wrapRtcPeerConnectionForIceLocalHostname(BaseRTC, RTCIceCandidat
 		 */
 		constructor(config) {
 			super(config)
-			if (baseRoutesIce) return
-
-			// native EventTarget：在派发前规范化，自管 listener，不依赖 stopImmediatePropagation。
 			Object.defineProperty(this, 'onicecandidate', {
 				configurable: true,
 				enumerable: true,
@@ -93,48 +87,22 @@ export function wrapRtcPeerConnectionForIceLocalHostname(BaseRTC, RTCIceCandidat
 				 */
 				set: handler => { this.#userIceHandler = handler },
 			})
-			super.addEventListener('icecandidate', event => this.#deliverIce(event))
 		}
 
 		/**
-		 * @param {RTCPeerConnectionIceEvent | { candidate?: unknown }} event 原始 ICE 事件
-		 * @returns {void}
+		 * 先完成 candidate 转换，再走标准 EventTarget 派发（保留 once/AbortSignal/capture 语义）。
+		 * addEventListener / removeEventListener 交由基类，故 once / AbortSignal / capture 均保留。
+		 * drop：不派发；pass-through：派发原事件；rewrite：派发替换 candidate 后的派生事件。
+		 * @param {Event} event 待派发事件
+		 * @returns {boolean} 事件是否未被取消
 		 */
-		#deliverIce = event => {
-			if (this.#lastIceEvent === event) return
-			this.#lastIceEvent = event
+		dispatchEvent(event) {
+			if (event?.type !== 'icecandidate') return super.dispatchEvent(event)
 			const normalized = this.prepareIceCandidateEvent(event)
-			if (normalized == null) return
+			if (normalized == null) return true
 			this.#userIceHandler?.(normalized)
-			for (const listener of this.#iceListeners) listener(normalized)
-		}
-
-		/**
-		 * @param {string} type 事件名
-		 * @param {(event: unknown) => void} listener 回调
-		 * @param {boolean | AddEventListenerOptions} [options] 监听选项
-		 * @returns {void}
-		 */
-		addEventListener(type, listener, options) {
-			if (!baseRoutesIce && type === 'icecandidate') {
-				this.#iceListeners.add(listener)
-				return
-			}
-			return super.addEventListener(type, listener, options)
-		}
-
-		/**
-		 * @param {string} type 事件名
-		 * @param {(event: unknown) => void} listener 回调
-		 * @param {boolean | EventListenerOptions} [options] 监听选项
-		 * @returns {void}
-		 */
-		removeEventListener(type, listener, options) {
-			if (!baseRoutesIce && type === 'icecandidate') {
-				this.#iceListeners.delete(listener)
-				return
-			}
-			return super.removeEventListener(type, listener, options)
+			if (normalized === event) return super.dispatchEvent(event)
+			return super.dispatchEvent(normalized)
 		}
 	}
 }

package/link/rtc/polyfill.mjs

@@ -4,7 +4,6 @@ import { getRtcPolyfillCacheEpoch, getSignalingRuntimeConfig } from '../../node/
 import { nodeDebug } from '../../node/log.mjs'
 
 import { wrapRtcPeerConnectionForIceLocalHostname } from './ice_local_hostname.mjs'
-import { bridgePeerConnection } from './w3c_bridge.mjs'
 
 /** @type {boolean} */
 let exitCleanupHooked = false
@@ -20,11 +19,9 @@ let cachedDefaultPolyfillEpoch = -1
  *   RTCPeerConnection: typeof RTCPeerConnection,
  *   RTCIceCandidate: typeof RTCIceCandidate,
  *   backend: string,
- *   forcesTrickleIce: boolean,
  * }} LoadedRtcPolyfill
  * @typedef {{
  *   id: string,
- *   forcesTrickleIce?: boolean,
  *   load: () => Promise<{ RTCPeerConnection: typeof RTCPeerConnection, RTCIceCandidate: typeof RTCIceCandidate }>,
  * }} RtcBackend
  */
@@ -57,12 +54,9 @@ async function ensureNodeDatachannelExitCleanup() {
  * @returns {Promise<{ RTCPeerConnection: typeof RTCPeerConnection, RTCIceCandidate: typeof RTCIceCandidate }>} node-datachannel 构造器
  */
 async function loadNodeDatachannelBackend() {
-	const mod = await import('node-datachannel/polyfill')
+	const module = await import('node-datachannel/polyfill')
 	await ensureNodeDatachannelExitCleanup()
-	return {
-		RTCPeerConnection: mod.RTCPeerConnection,
-		RTCIceCandidate: mod.RTCIceCandidate,
-	}
+	return module
 }
 
 /**
@@ -70,17 +64,12 @@ async function loadNodeDatachannelBackend() {
  * @returns {Promise<{ RTCPeerConnection: typeof RTCPeerConnection, RTCIceCandidate: typeof RTCIceCandidate }>} node-rtc-connection 构造器
  */
 async function loadNodeRtcConnectionBackend() {
-	const module = await import('node-rtc-connection')
-	return {
-		RTCPeerConnection: /** @type {typeof RTCPeerConnection} */ bridgePeerConnection(module.RTCPeerConnection),
-		RTCIceCandidate: module.RTCIceCandidate,
-	}
+	return import('node-rtc-connection')
 }
 
 /** @type {RtcBackend} */
 const PURE_JS_BACKEND = {
 	id: 'node-rtc-connection',
-	forcesTrickleIce: true,
 	load: loadNodeRtcConnectionBackend,
 }
 
@@ -119,7 +108,6 @@ async function loadNodeRtcPolyfillUncached(options) {
 				),
 				RTCIceCandidate: mod.RTCIceCandidate,
 				backend: backend.id,
-				forcesTrickleIce: backend.forcesTrickleIce === true,
 			}
 		}
 		catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@steve02081504/fount-p2p",
-	"version": "0.0.30",
+	"version": "0.0.31",
 	"description": "fount federation P2P layer — link, trust graph, mailbox, DAG, EVFS.",
 	"keywords": [
 		"network",

package/link/rtc/w3c_bridge.mjs

@@ -1,152 +0,0 @@
-/**
- * 把 EventEmitter 风格的 RTC（如 node-rtc-connection）桥成 W3C 属性 handler。
- * 其余链路只认 onicecandidate / onmessage / onbufferedamountlow 等。
- */
-
-/** @type {WeakSet<object>} */
-const bridgedChannels = new WeakSet()
-
-/**
- * @param {object} target EventEmitter 目标
- * @param {string} property W3C 属性名（如 onmessage）
- * @param {string} eventName EventEmitter 事件名
- * @param {(payload: unknown) => unknown} [adapt] 事件载荷适配
- * @returns {void}
- */
-function defineEmitterHandler(target, property, eventName, adapt = payload => payload) {
-	let handler = null
-	target.on(eventName, payload => handler?.(adapt(payload)))
-	Object.defineProperty(target, property, {
-		configurable: true,
-		enumerable: true,
-		/**
-		 * @returns {((payload: unknown) => void) | null} 当前 handler
-		 */
-		get: () => handler,
-		/**
-		 * @param {((payload: unknown) => void) | null} value 新 handler
-		 * @returns {void}
-		 */
-		set: value => { handler = value },
-	})
-}
-
-/**
- * @param {RTCDataChannel} channel 原始 data channel
- * @returns {RTCDataChannel} 已挂 W3C handler 的通道
- */
-export function bridgeDataChannel(channel) {
-	if (bridgedChannels.has(channel) || !channel.on) return channel
-	bridgedChannels.add(channel)
-	defineEmitterHandler(channel, 'onmessage', 'message')
-	defineEmitterHandler(channel, 'onopen', 'open')
-	defineEmitterHandler(channel, 'onclose', 'close')
-	defineEmitterHandler(channel, 'onbufferedamountlow', 'bufferedamountlow')
-	return channel
-}
-
-/**
- * @param {typeof RTCPeerConnection} BaseRTC EventEmitter 风格 RTCPeerConnection
- * @returns {typeof RTCPeerConnection} W3C handler 版
- */
-export function bridgePeerConnection(BaseRTC) {
-	return class W3cRtcPeerConnection extends BaseRTC {
-		/** @type {((event: RTCPeerConnectionIceEvent) => void) | null} */
-		#iceHandler = null
-		/** @type {((event: { channel: RTCDataChannel }) => void) | null} */
-		#dataChannelHandler = null
-		/** @type {(() => void) | null} */
-		#connectionStateHandler = null
-		/** @type {Map<string, Set<(event: unknown) => void>>} */
-		#listeners = new Map()
-
-		/**
-		 * @param {RTCConfiguration} [config] RTC 配置
-		 */
-		constructor(config) {
-			super(config)
-			super.on('icecandidate', event => {
-				const normalized = this.prepareIceCandidateEvent(event)
-				if (normalized == null) return
-				this.#iceHandler?.(normalized)
-				this.#emit('icecandidate', normalized)
-			})
-			super.on('datachannel', event => {
-				const adapted = { channel: bridgeDataChannel(event.channel) }
-				this.#dataChannelHandler?.(adapted)
-				this.#emit('datachannel', adapted)
-			})
-			super.on('connectionstatechange', () => {
-				this.#connectionStateHandler?.()
-				this.#emit('connectionstatechange', undefined)
-			})
-		}
-
-		/**
-		 * ICE 事件规范化钩子；子类可覆盖（drop 返回 null，rewrite 返回替换后的事件）。
-		 * @param {RTCPeerConnectionIceEvent | { candidate?: unknown }} event 原始 ICE 事件
-		 * @returns {RTCPeerConnectionIceEvent | { candidate?: unknown } | null} 规范化后的事件
-		 */
-		prepareIceCandidateEvent(event) {
-			return event
-		}
-
-		/**
-		 * @param {string} type 事件名
-		 * @param {unknown} event 事件载荷（icecandidate 须已规范化）
-		 * @returns {void}
-		 */
-		#emit(type, event) {
-			const listeners = this.#listeners.get(type)
-			if (!listeners) return
-			for (const listener of listeners) listener(event)
-		}
-
-		/**
-		 * @param {string} type 事件名
-		 * @param {(event: unknown) => void} listener 回调
-		 * @returns {void}
-		 */
-		addEventListener(type, listener) {
-			let listeners = this.#listeners.get(type)
-			if (!listeners) {
-				listeners = new Set()
-				this.#listeners.set(type, listeners)
-			}
-			listeners.add(listener)
-		}
-
-		/**
-		 * @param {string} type 事件名
-		 * @param {(event: unknown) => void} listener 回调
-		 * @returns {void}
-		 */
-		removeEventListener(type, listener) {
-			this.#listeners.get(type)?.delete(listener)
-		}
-
-		/** @returns {((event: RTCPeerConnectionIceEvent) => void) | null} ICE candidate handler */
-		get onicecandidate() { return this.#iceHandler }
-		/** @param {((event: RTCPeerConnectionIceEvent) => void) | null} handler ICE candidate handler */
-		set onicecandidate(handler) { this.#iceHandler = handler }
-
-		/** @returns {((event: { channel: RTCDataChannel }) => void) | null} data channel handler */
-		get ondatachannel() { return this.#dataChannelHandler }
-		/** @param {((event: { channel: RTCDataChannel }) => void) | null} handler data channel handler */
-		set ondatachannel(handler) { this.#dataChannelHandler = handler }
-
-		/** @returns {(() => void) | null} connection state handler */
-		get onconnectionstatechange() { return this.#connectionStateHandler }
-		/** @param {(() => void) | null} handler connection state handler */
-		set onconnectionstatechange(handler) { this.#connectionStateHandler = handler }
-
-		/**
-		 * @param {string} label data channel 标签
-		 * @param {RTCDataChannelInit} [init] 创建选项
-		 * @returns {RTCDataChannel} 已桥接 W3C handler 的通道
-		 */
-		createDataChannel(label, init) {
-			return bridgeDataChannel(super.createDataChannel(label, init))
-		}
-	}
-}