@steve02081504/fount-p2p 0.0.19 → 0.0.21

package/utils/inflight_table.mjs

@@ -0,0 +1,95 @@
+/**
+ * In-flight 去重表：同 key 复用并 touch 到队尾；队满时仅淘汰「已超过 baseTimeout」的队首。
+ * 双窗口：size >= maxSize 且 entry 年龄 >= baseTimeoutMs 才 cancel。
+ *
+ * @template T
+ * @param {{ maxSize: number, baseTimeoutMs: number, now?: () => number }} options 容量与基础超时
+ * @returns {{
+ *   size: () => number,
+ *   has: (key: string) => boolean,
+ *   acquire: (key: string, start: () => { done: Promise<T>, cancel: () => void }) => Promise<T> | null,
+ *   clear: () => void,
+ * }} 表句柄
+ */
+export function createInflightTable(options) {
+	const maxSize = Math.max(1, Math.floor(Number(options.maxSize) || 1))
+	const baseTimeoutMs = Math.max(0, Number(options.baseTimeoutMs) || 0)
+	const now = options.now || Date.now
+
+	/** @type {Map<string, { done: Promise<T>, cancel: () => void, startedAt: number }>} */
+	const map = new Map()
+
+	/**
+	 * 队满时从队首取消已超时项。
+	 * @returns {void}
+	 */
+	function pruneAgedOverCap() {
+		const t = now()
+		while (map.size >= maxSize) {
+			const oldestKey = map.keys().next().value
+			const entry = map.get(oldestKey)
+			if (!entry || t - entry.startedAt < baseTimeoutMs) break
+			map.delete(oldestKey)
+			entry.cancel()
+		}
+	}
+
+	/**
+	 * @param {string} key 逻辑键
+	 * @param {{ done: Promise<T>, cancel: () => void, startedAt: number }} entry 条目
+	 * @returns {void}
+	 */
+	function track(key, entry) {
+		entry.done.finally(() => {
+			if (map.get(key) === entry) map.delete(key)
+		})
+		map.set(key, entry)
+	}
+
+	return {
+		/**
+		 * @returns {number} 当前 in-flight 数
+		 */
+		size: () => map.size,
+		/**
+		 * @param {string} key 逻辑键
+		 * @returns {boolean} 是否在飞
+		 */
+		has: key => map.has(key),
+		/**
+		 * 复用或启动；队满且无法淘汰超时项时返回 null（拒绝新开）。
+		 * @param {string} key 逻辑键
+		 * @param {() => { done: Promise<T>, cancel: () => void }} start 仅在未命中时调用
+		 * @returns {Promise<T> | null} 共享 Promise，或拒绝新开
+		 */
+		acquire(key, start) {
+			const existing = map.get(key)
+			if (existing) {
+				map.delete(key)
+				map.set(key, existing)
+				pruneAgedOverCap()
+				return existing.done
+			}
+
+			pruneAgedOverCap()
+			if (map.size >= maxSize) return null
+
+			const started = start()
+			const entry = {
+				done: started.done,
+				cancel: started.cancel,
+				startedAt: now(),
+			}
+			track(key, entry)
+			return entry.done
+		},
+		/**
+		 * 取消全部并清空（测试用）。
+		 * @returns {void}
+		 */
+		clear() {
+			for (const entry of map.values()) entry.cancel()
+			map.clear()
+		},
+	}
+}

package/wire/part_fanout.mjs

@@ -27,7 +27,7 @@ export async function collectPartInvokeResponses(username, partpath, invoke, tim
 
 	const waitForResponses = new Promise(resolve => {
 		/**
-		 *
+		 * 超时或收齐响应后结束等待并清理 pending part_invoke。
 		 */
 		const finish = () => {
 			clearTimeout(timer)

package/link/rtc.mjs

@@ -1,130 +0,0 @@
-import process from 'node:process'
-
-import { toBytes } from '../core/bytes_codec.mjs'
-import { getSignalingRuntimeConfig } from '../node/instance.mjs'
-import { wrapRtcPeerConnectionForIceLocalHostname } from '../transport/rtc_ice_local_hostname.mjs'
-
-/** @type {boolean} */
-let exitCleanupHooked = false
-
-/**
- * 注册进程退出时销毁 libdatachannel 原生资源（首次成功加载后挂一次）。
- * libdatachannel 的原生线程在 pc.close() 后仍需时间回收；进程退出时若原生资源未同步销毁，
- * Windows 上会触发堆损坏（退出码 0xC0000374）。
- * @returns {Promise<void>}
- */
-async function ensureNodeDatachannelExitCleanup() {
-	if (exitCleanupHooked) return
-	exitCleanupHooked = true
-	const { cleanup = undefined } = await import('node-datachannel').catch(() => ({}))
-	process.on('exit', () => {
-		try { cleanup?.() } catch { /* already torn down */ }
-	})
-}
-
-/**
- * 加载 node-datachannel polyfill，并按配置包装 RTCPeerConnection。
- * @returns {Promise<{ RTCPeerConnection: typeof RTCPeerConnection, RTCIceCandidate: typeof RTCIceCandidate }>} RTC 构造器
- */
-export async function loadNodeRtcPolyfill() {
-	const mod = await import('node-datachannel/polyfill')
-	await ensureNodeDatachannelExitCleanup()
-	const { iceLocalHostnamePolicy } = getSignalingRuntimeConfig()
-	return {
-		RTCPeerConnection: wrapRtcPeerConnectionForIceLocalHostname(mod.RTCPeerConnection, mod.RTCIceCandidate, iceLocalHostnamePolicy),
-		RTCIceCandidate: mod.RTCIceCandidate,
-	}
-}
-
-/**
- * 绑定 ICE candidate 回调，兼容 onicecandidate 与 onIceCandidate.subscribe。
- * @param {RTCPeerConnection} pc 对等连接
- * @param {(event: { candidate: RTCIceCandidate | null }) => void} handler candidate 事件处理器
- * @returns {void}
- */
-export function attachIceCandidateListener(pc, handler) {
-	pc.onicecandidate = handler
-	pc.onIceCandidate?.subscribe?.(candidate =>
-		handler({ candidate: candidate ?? null })
-	)
-}
-
-/**
- * 绑定远端 data channel 回调，兼容 ondatachannel 与 onDataChannel.subscribe。
- * @param {RTCPeerConnection} pc 对等连接
- * @param {(event: { channel: RTCDataChannel }) => void} handler data channel 事件处理器
- * @returns {void}
- */
-export function attachDataChannelListener(pc, handler) {
-	pc.ondatachannel = handler
-	pc.onDataChannel?.subscribe?.(channel => handler({ channel }))
-}
-
-/**
- * 等待 data channel 进入 open 或 close 状态，超时则 reject。
- * @param {RTCDataChannel} channel RTC 数据通道
- * @param {'open' | 'close'} eventName 目标状态事件名
- * @param {number} timeoutMs 超时毫秒数
- * @returns {Promise<void>}
- */
-export function waitForChannelState(channel, eventName, timeoutMs) {
-	return new Promise((resolve, reject) => {
-		if (eventName === 'open' && channel.readyState === 'open') {
-			resolve()
-			return
-		}
-		if (eventName === 'close' && channel.readyState === 'closed') {
-			resolve()
-			return
-		}
-		const timer = setTimeout(() => {
-			cleanup()
-			reject(new Error(`p2p: data channel ${eventName} timeout after ${timeoutMs}ms`))
-		}, timeoutMs)
-		/**
-		 * 通道状态变化处理函数。
-		 * @returns {void}
-		 */
-		const handler = () => {
-			cleanup()
-			resolve()
-		}
-		/**
-		 * 移除监听器并清除超时定时器。
-		 * @returns {void}
-		 */
-		const cleanup = () => {
-			clearTimeout(timer)
-			channel.removeEventListener?.(eventName, handler)
-			if (eventName === 'open' && channel.onopen === handler) channel.onopen = null
-			if (eventName === 'close' && channel.onclose === handler) channel.onclose = null
-		}
-		channel.addEventListener?.(eventName, handler)
-		if (eventName === 'open') channel.onopen = handler
-		if (eventName === 'close') channel.onclose = handler
-	})
-}
-
-/**
- * 绑定 data channel message 回调（addEventListener / onmessage / onMessage.subscribe）。
- * @param {RTCDataChannel} channel data channel
- * @param {(data: unknown) => void} handler 消息回调
- * @returns {void}
- */
-export function attachChannelMessageListener(channel, handler) {
-	channel.addEventListener?.('message', event => handler(event?.data))
-	/**
-	 * @param {{ data?: unknown }} event message 事件
-	 * @returns {void}
-	 */
-	channel.onmessage = event => handler(event?.data)
-	channel.onMessage?.subscribe(message => handler(message))
-}
-
-/**
- * @param {unknown} data 通道原始数据
- * @returns {Uint8Array} 字节
- */
-export function dataToBytes(data) {
-	return toBytes(data, { allowString: true })
-}

package/transport/rtc_ice_local_hostname.mjs

@@ -1,118 +0,0 @@
-/**
- * 服务端 WebRTC polyfill 在 Windows 等环境常产出 `.local` host candidate，
- * 远端无法解析。按 iceLocalHostnamePolicy 改写为 loopback 或丢弃。
- */
-
-/** @typedef {'none' | 'rewrite-loopback' | 'drop'} IceLocalHostnamePolicy */
-
-/**
- * @param {string | null | undefined} candidateSdp ICE candidate SDP 行
- * @param {IceLocalHostnamePolicy} policy 处理策略
- * @returns {string | null} 处理后的 SDP；drop 策略下不可用时返回 null
- */
-export function applyIceLocalHostnamePolicy(candidateSdp, policy) {
-	const sdp = String(candidateSdp || '').trim()
-	if (!sdp || !/\.local/i.test(sdp)) return sdp || null
-	if (!/\btyp host\b/i.test(sdp)) return sdp
-	if (policy === 'drop') return null
-	if (policy === 'rewrite-loopback') {
-		const rewritten = sdp.replace(/(\s)[\w-]+\.local(\s|$)/gi, '$1127.0.0.1$2')
-		return rewritten === sdp ? null : rewritten
-	}
-	return sdp
-}
-
-/**
- * @param {RTCIceCandidate | { candidate?: string } | null | undefined} candidate ICE candidate
- * @param {typeof RTCIceCandidate} RTCIceCandidateCtor 构造函数
- * @param {IceLocalHostnamePolicy} policy 处理策略
- * @returns {RTCIceCandidate | { candidate?: string } | null | undefined} 过滤/改写后的 candidate
- */
-export function filterIceLocalHostnameCandidate(candidate, RTCIceCandidateCtor, policy) {
-	if (!candidate || policy === 'none') return candidate
-	const raw = typeof candidate === 'string'
-		? candidate
-		: candidate.candidate ?? candidate.toJSON?.()?.candidate ?? ''
-	const rewritten = applyIceLocalHostnamePolicy(raw, policy)
-	if (!rewritten) return null
-	if (rewritten === raw) return candidate
-	try {
-		const init = typeof candidate.toJSON === 'function'
-			? { ...candidate.toJSON(), candidate: rewritten }
-			: { candidate: rewritten, sdpMid: candidate.sdpMid, sdpMLineIndex: candidate.sdpMLineIndex }
-		return new RTCIceCandidateCtor(init)
-	}
-	catch {
-		return { ...candidate, candidate: rewritten }
-	}
-}
-
-/**
- * @param {typeof RTCPeerConnection} BaseRTC 原始 polyfill 类
- * @param {typeof RTCIceCandidate} [RTCIceCandidate] ICE candidate 构造函数
- * @param {IceLocalHostnamePolicy} [policy='drop'] 策略
- * @returns {typeof RTCPeerConnection} 包装后的 RTCPeerConnection 类（none 时原样返回）
- */
-export function wrapRtcPeerConnectionForIceLocalHostname(BaseRTC, RTCIceCandidate = globalThis.RTCIceCandidate, policy = 'drop') {
-	if (policy === 'none') return BaseRTC
-
-	/**
-	 * @param {RTCPeerConnectionIceEvent} event ICE 候选事件
-	 * @param {(event: RTCPeerConnectionIceEvent) => void} handler 用户 handler
-	 * @returns {void}
-	 */
-	function invokeFilteredIceHandler(event, handler) {
-		if (!event?.candidate) {
-			handler(event)
-			return
-		}
-		const filtered = filterIceLocalHostnameCandidate(event.candidate, RTCIceCandidate, policy)
-		if (!filtered) return
-		if (filtered === event.candidate) {
-			handler(event)
-			return
-		}
-		handler({ ...event, candidate: filtered })
-	}
-
-	return class IceLocalHostnameFilteredRTCPeerConnection extends BaseRTC {
-		/** @type {((event: RTCPeerConnectionIceEvent) => void) | null} */
-		#userIceHandler = null
-
-		/**
-		 * @param {RTCConfiguration} [config] RTC 配置
-		 */
-		constructor(config) {
-			super(config)
-			/** @param {RTCPeerConnectionIceEvent} event ICE 候选事件 */
-			const relayIce = event => {
-				if (this.#userIceHandler)
-					invokeFilteredIceHandler(event, this.#userIceHandler)
-			}
-			super.onicecandidate = relayIce
-			const iceObs = this.onIceCandidate
-			if (iceObs && typeof iceObs.subscribe === 'function')
-				iceObs.subscribe(candidate => {
-					if (!this.#userIceHandler) return
-					if (!candidate) {
-						this.#userIceHandler({ candidate: null })
-						return
-					}
-					const filtered = filterIceLocalHostnameCandidate(candidate, RTCIceCandidate, policy)
-					if (filtered)
-						this.#userIceHandler({ candidate: filtered })
-				})
-
-		}
-
-		/** @returns {((event: RTCPeerConnectionIceEvent) => void) | null} 用户 ICE 处理器 */
-		get onicecandidate() {
-			return this.#userIceHandler
-		}
-
-		/** @param {((event: RTCPeerConnectionIceEvent) => void) | null} handler ICE 处理器 */
-		set onicecandidate(handler) {
-			this.#userIceHandler = handler
-		}
-	}
-}