@steve02081504/fount-p2p 0.0.10 → 0.0.12

package/discovery/mdns.mjs

@@ -6,6 +6,7 @@ const DEFAULT_GROUP = '239.255.42.99'
 
 /**
  * 轻量 multicast 发现插件：不做完整 DNS-SD，只复用 mDNS 的 LAN multicast 发现思路。
+ * 引用计数为 0 时关闭 UDP socket，避免 shutdown 后句柄拖住进程。
  *
  * @param {{ port?: number, group?: string }} [options] 组播端口与组地址
  * @returns {import('./index.mjs').DiscoveryProvider} mDNS 发现提供者
@@ -13,14 +14,24 @@ const DEFAULT_GROUP = '239.255.42.99'
 export function createMdnsDiscoveryProvider(options = {}) {
 	const port = Number(options.port) || DEFAULT_PORT
 	const group = String(options.group || DEFAULT_GROUP)
-	const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true })
+	/** @type {import('node:dgram').Socket | null} */
+	let socket = null
 	let bound = false
 	let bindPromise = null
+	let refs = 0
 	/** @type {Map<string, Set<Function>>} */
 	const advertListeners = new Map()
 	/** @type {Map<string, Set<Function>>} */
 	const signalListeners = new Map()
 
+	/**
+	 * 懒创建或返回当前 UDP socket。
+	 * @returns {import('node:dgram').Socket} 用于组播 bind/send 的 socket
+	 */
+	function getSocket() {
+		return socket ||= dgram.createSocket({ type: 'udp4', reuseAddr: true })
+	}
+
 	/**
 	 * 绑定 UDP socket 并注册组播消息处理器。
 	 * @returns {Promise<void>}
@@ -29,16 +40,24 @@ export function createMdnsDiscoveryProvider(options = {}) {
 		if (bound) return
 		if (!bindPromise)
 			bindPromise = (async () => {
+				const sock = getSocket()
 				await new Promise((resolve, reject) => {
-					socket.once('error', reject)
-					socket.bind(port, '0.0.0.0', () => {
-						socket.off('error', reject)
-						socket.addMembership(group)
-						socket.setMulticastTTL(1)
+					sock.once('error', reject)
+					sock.bind(port, '0.0.0.0', () => {
+						sock.off('error', reject)
+						sock.addMembership(group)
+						sock.setMulticastTTL(1)
 						resolve()
 					})
 				})
-				socket.on('message', (raw, rinfo) => {
+				// acquire 已全部释放：关掉刚 bind 的 socket，避免泄漏句柄。
+				if (refs <= 0) {
+					try { sock.close() } catch { /* ignore */ }
+					if (socket === sock) socket = null
+					bound = false
+					return
+				}
+				sock.on('message', (raw, rinfo) => {
 					let packet
 					try { packet = JSON.parse(String(raw)) } catch { return }
 					const listeners = packet.type === 'advert'
@@ -70,16 +89,34 @@ export function createMdnsDiscoveryProvider(options = {}) {
 	 */
 	async function multicast(type, topic, bytes) {
 		await ensureBound()
+		const sock = getSocket()
 		const packet = Buffer.from(JSON.stringify({
 			type,
 			topic,
 			data: Buffer.from(bytes).toString('base64'),
 		}))
 		await new Promise((resolve, reject) => {
-			socket.send(packet, port, group, error => error ? reject(error) : resolve())
+			sock.send(packet, port, group, error => error ? reject(error) : resolve())
 		})
 	}
 
+	/**
+	 * 占用 socket；归还后若无引用则关闭。
+	 * @returns {() => void} 释放函数
+	 */
+	function acquire() {
+		refs++
+		void ensureBound().catch(() => { })
+		return () => {
+			refs = Math.max(0, refs - 1)
+			if (refs > 0 || !socket) return
+			try { socket.close() } catch { /* ignore */ }
+			socket = null
+			bound = false
+			bindPromise = null
+		}
+	}
+
 	/**
 	 * 向 topic bucket 注册监听器。
 	 * @param {Map<string, Set<Function>>} bucket topic → 监听器集合
@@ -90,7 +127,17 @@ export function createMdnsDiscoveryProvider(options = {}) {
 	function addListener(bucket, topic, listener) {
 		if (!bucket.has(topic)) bucket.set(topic, new Set())
 		bucket.get(topic).add(listener)
-		return () => bucket.get(topic)?.delete(listener)
+		const release = acquire()
+		return () => {
+			const set = bucket.get(topic)
+			if (!set) {
+				release()
+				return
+			}
+			set.delete(listener)
+			if (!set.size) bucket.delete(topic)
+			release()
+		}
 	}
 
 	return {
@@ -98,24 +145,27 @@ export function createMdnsDiscoveryProvider(options = {}) {
 		priority: 10,
 		caps: { canDiscover: true, canSignal: true, canRelay: false },
 		/**
-		 * 周期性组播广播 advert。
+		 * 周期性组播广播 advert（首发后台，不阻塞调用方）。
 		 * @param {string} topic advert 主题
 		 * @param {Uint8Array} bytes advert 载荷
 		 * @returns {Promise<() => void>} 取消广播函数
 		 */
 		async advertise(topic, bytes) {
-			await multicast('advert', topic, bytes)
+			const release = acquire()
+			void multicast('advert', topic, bytes).catch(() => { })
 			const timer = setInterval(() => { void multicast('advert', topic, bytes).catch(() => { }) }, 30_000)
-			return () => clearInterval(timer)
+			return () => {
+				clearInterval(timer)
+				release()
+			}
 		},
 		/**
-		 * 订阅组播 advert。
+		 * 订阅组播 advert（立即返回；UDP bind 后台完成）。
 		 * @param {string} topic advert 主题
 		 * @param {Function} onAdvert advert 回调
 		 * @returns {Promise<() => void>} 取消订阅函数
 		 */
 		async subscribe(topic, onAdvert) {
-			await ensureBound()
 			return addListener(advertListeners, topic, onAdvert)
 		},
 		/**
@@ -126,16 +176,21 @@ export function createMdnsDiscoveryProvider(options = {}) {
 		 * @returns {Promise<void>}
 		 */
 		async sendSignal(topic, _to, bytes) {
-			await multicast('signal', topic, bytes)
+			const release = acquire()
+			try {
+				await multicast('signal', topic, bytes)
+			}
+			finally {
+				release()
+			}
 		},
 		/**
-		 * 订阅组播信令。
+		 * 订阅组播信令（立即返回；UDP bind 后台完成）。
 		 * @param {string} topic 信令 topic
 		 * @param {Function} onSignal 信令回调
 		 * @returns {Promise<() => void>} 取消订阅函数
 		 */
 		async onSignal(topic, onSignal) {
-			await ensureBound()
 			return addListener(signalListeners, topic, onSignal)
 		},
 	}

package/discovery/nostr.mjs

@@ -1,7 +1,9 @@
 import { randomBytes } from 'node:crypto'
 
 import { schnorr } from '@noble/curves/secp256k1.js'
+import WebSocket from 'ws'
 
+import { base64ToBytes, hexToBytes, bytesToBase64, bytesToHex } from '../core/bytes_codec.mjs'
 import { sha256Hex } from '../crypto/crypto.mjs'
 
 /** 默认 Nostr 中继 URL 列表。 */
@@ -11,67 +13,64 @@ export const DEFAULT_RELAY_URLS = [
 	'wss://relay.nostr.band',
 ]
 
+/** 单中继 WebSocket 首连超时（短超时 + 并行，避免串行 10s×N）。 */
+export const NOSTR_CONNECT_TIMEOUT_MS = 2_000
+/** 先 close，超时未 CLOSED 再 terminate（给对端优雅关闭的窗口）。 */
+export const NOSTR_CLOSE_GRACE_MS = 1_000
+
 /** Nostr advert 事件 kind。 */
 export const NOSTR_ADVERT_KIND = 27235
 /** Nostr signal 事件 kind。 */
 export const NOSTR_SIGNAL_KIND = 27236
 
 /**
- * 合并默认与用户配置的中继 URL（去重）。
- * @param {string[] | undefined | null} userRelayUrls 用户自定义中继列表
- * @returns {string[]} 合并后的中继 URL 列表
+ * 关掉 WebSocket：已连上则先 close，grace 内未 CLOSED 再 terminate。
+ * 连接中直接 terminate（无握手可优雅收尾）。
+ * @param {import('ws').WebSocket} ws 连接
+ * @returns {void}
  */
-export function mergeSignalingRelayUrls(userRelayUrls) {
-	const seen = new Set()
-	/** @type {string[]} */
-	const merged = []
-	for (const url of [...DEFAULT_RELAY_URLS, ...Array.isArray(userRelayUrls) ? userRelayUrls : []]) {
-		const trimmed = String(url || '').trim()
-		if (!trimmed || seen.has(trimmed)) continue
-		seen.add(trimmed)
-		merged.push(trimmed)
+function dropWebSocket(ws) {
+	if (ws.readyState === WebSocket.CLOSED) return
+	if (ws.readyState === WebSocket.CONNECTING) {
+		try { ws.terminate() } catch { /* ignore */ }
+		return
+	}
+	const timer = setTimeout(() => {
+		if (ws.readyState !== WebSocket.CLOSED)
+			try { ws.terminate() } catch { /* ignore */ }
+	}, NOSTR_CLOSE_GRACE_MS)
+	// Grace is polite to the peer; must not pin the process after shutdown.
+	timer.unref()
+	ws.once('close', () => clearTimeout(timer))
+	try {
+		ws.close()
+	}
+	catch {
+		clearTimeout(timer)
+		try { ws.terminate() } catch { /* ignore */ }
 	}
-	return merged.length ? merged : [...DEFAULT_RELAY_URLS]
-}
-
-/**
- * 字节数组转十六进制字符串。
- * @param {Uint8Array} bytes 输入字节
- * @returns {string} 小写 hex 字符串
- */
-function bytesToHex(bytes) {
-	return [...bytes].map(byte => byte.toString(16).padStart(2, '0')).join('')
-}
-
-/**
- * 十六进制字符串转字节数组。
- * @param {string} hex 输入 hex 字符串
- * @returns {Uint8Array} 解码后的字节
- */
-function hexToBytes(hex) {
-	const normalized = String(hex || '').trim().toLowerCase()
-	const out = new Uint8Array(Math.floor(normalized.length / 2))
-	for (let index = 0; index < out.length; index++)
-		out[index] = parseInt(normalized.slice(index * 2, index * 2 + 2), 16)
-	return out
 }
 
 /**
- * 字节数组转 base64 字符串。
- * @param {Uint8Array} bytes 输入字节
- * @returns {string} base64 编码
+ * 去重并清洗中继 URL 列表。
+ * @param {string[] | undefined | null} urls 原始列表
+ * @returns {string[]} 清洗后的列表
  */
-function bytesToBase64(bytes) {
-	return btoa(String.fromCharCode(...bytes))
+function dedupeRelayUrls(urls) {
+	const seen = new Set()
+	return (urls || [])
+		.map(url => url.trim())
+		.filter(trimmed => trimmed && !seen.has(trimmed) && (seen.add(trimmed), true))
 }
 
 /**
- * base64 字符串转字节数组。
- * @param {string} base64 输入 base64 字符串
- * @returns {Uint8Array} 解码后的字节
+ * 合并默认与用户配置的中继 URL（去重）。
+ * @param {string[] | undefined | null} userRelayUrls 用户自定义中继列表
+ * @returns {string[]} 合并后的中继 URL 列表
  */
-function base64ToBytes(base64) {
-	return Uint8Array.from(atob(base64).split('').map(ch => ch.charCodeAt(0)))
+export function mergeSignalingRelayUrls(userRelayUrls) {
+	const merged = dedupeRelayUrls([...DEFAULT_RELAY_URLS, ...userRelayUrls || []])
+	return merged.length ? merged : [...DEFAULT_RELAY_URLS]
 }
 
 /**
@@ -92,40 +91,67 @@ async function signNostrEvent(kind, tags, content, secretKey) {
 }
 
 /**
- * 连接 Nostr 中继 WebSocket。
+ * 连接 Nostr 中继 WebSocket（`ws` 包，支持 terminate）。
  * @param {string} relayUrl 中继 URL
- * @returns {Promise<WebSocket>} 已打开的 WebSocket
+ * @param {number} [timeoutMs] 超时毫秒
+ * @param {AbortSignal} [signal] 取消信号
+ * @returns {Promise<import('ws').WebSocket>} 已打开的 WebSocket
  */
-function connectRelay(relayUrl) {
+function connectRelay(relayUrl, timeoutMs = NOSTR_CONNECT_TIMEOUT_MS, signal) {
 	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new Error('nostr: aborted'))
+			return
+		}
 		const ws = new WebSocket(relayUrl)
-		const timer = setTimeout(() => {
-			try { ws.close() } catch { /* ignore */ }
-			reject(new Error(`nostr: connect timeout for ${relayUrl}`))
-		}, 10_000)
-		ws.addEventListener('open', () => {
+		let settled = false
+		/**
+		 * @param {Error} error 失败原因
+		 * @returns {void}
+		 */
+		const fail = error => {
+			if (settled) return
+			settled = true
 			clearTimeout(timer)
-			resolve(ws)
-		}, { once: true })
-		ws.addEventListener('error', () => {
+			signal?.removeEventListener('abort', onAbort)
+			dropWebSocket(ws)
+			reject(error)
+		}
+		/**
+		 * @returns {void}
+		 */
+		const onAbort = () => fail(new Error('nostr: aborted'))
+		const timer = setTimeout(() => fail(new Error(`nostr: connect timeout for ${relayUrl}`)), timeoutMs)
+		timer.unref()
+		signal?.addEventListener('abort', onAbort, { once: true })
+		ws.once('open', () => {
+			if (settled) return
+			settled = true
 			clearTimeout(timer)
-			reject(new Error(`nostr: websocket error for ${relayUrl}`))
-		}, { once: true })
+			signal?.removeEventListener('abort', onAbort)
+			resolve(ws)
+		})
+		ws.once('error', () => {
+			fail(new Error(`nostr: websocket error for ${relayUrl}`))
+		})
 	})
 }
 
 /**
- * 向多个中继发布 Nostr 事件。
+ * 向多个中继并行发布 Nostr 事件（任一成功即可）。
  * @param {string[]} relayUrls 中继 URL 列表
  * @param {object} event 待发布事件
+ * @param {AbortSignal} [signal] 取消信号
  * @returns {Promise<void>}
  */
-async function publishEvent(relayUrls, event) {
+async function publishEvent(relayUrls, event, signal) {
 	let published = false
 	let lastError = null
 	await Promise.allSettled(relayUrls.map(async relayUrl => {
-		const ws = await connectRelay(relayUrl)
+		if (signal?.aborted) throw new Error('nostr: aborted')
+		const ws = await connectRelay(relayUrl, NOSTR_CONNECT_TIMEOUT_MS, signal)
 		try {
+			if (signal?.aborted) throw new Error('nostr: aborted')
 			ws.send(JSON.stringify(['EVENT', event]))
 			published = true
 		}
@@ -134,91 +160,123 @@ async function publishEvent(relayUrls, event) {
 			throw error
 		}
 		finally {
-			setTimeout(() => { try { ws.close() } catch { /* ignore */ } }, 250)
+			dropWebSocket(ws)
 		}
 	}))
 	if (!published) throw lastError || new Error('nostr: no relay accepted publish')
 }
 
+/**
+ * 并行渐进连接中继：立刻返回，连上后回调；abort 后 stop 接入并 drop 已开 socket。
+ * @param {string[]} relayUrls 中继列表
+ * @param {(ws: import('ws').WebSocket, relayUrl: string) => void} onOpen 连上回调
+ * @param {AbortSignal} signal 取消信号
+ * @param {import('ws').WebSocket[]} sockets 已打开 socket 收集
+ * @returns {void}
+ */
+function connectRelaysProgressive(relayUrls, onOpen, signal, sockets) {
+	for (const relayUrl of relayUrls)
+		void connectRelay(relayUrl, NOSTR_CONNECT_TIMEOUT_MS, signal).then(ws => {
+			if (signal.aborted) {
+				dropWebSocket(ws)
+				return
+			}
+			sockets.push(ws)
+			onOpen(ws, relayUrl)
+		}).catch(() => { /* 单路失败正常降级 */ })
+}
+
+/**
+ * 订阅指定 kind 的 Nostr 事件（渐进连中继，立即返回 cleanup）。
+ * @param {string[]} relayUrls 中继 URL 列表
+ * @param {{ kind: number, topic: string, tagX: string, onPayload: (bytes: Uint8Array, meta: { relayUrl: string, event: object }) => void }} options 订阅选项
+ * @returns {() => void} 取消订阅
+ */
+function subscribeNostrKind(relayUrls, options) {
+	const { kind, topic, tagX, onPayload } = options
+	const abortController = new AbortController()
+	/** @type {import('ws').WebSocket[]} */
+	const sockets = []
+	const subscriptionId = randomBytes(8).toString('hex')
+	connectRelaysProgressive(relayUrls, (ws, relayUrl) => {
+		ws.on('message', data => {
+			if (abortController.signal.aborted) return
+			let parsed
+			try { parsed = JSON.parse(String(data)) } catch { return }
+			if (parsed?.[0] !== 'EVENT') return
+			const nostrEvent = parsed[2]
+			if (nostrEvent?.kind !== kind) return
+			try { onPayload(base64ToBytes(nostrEvent.content), { relayUrl, event: nostrEvent }) }
+			catch { /* ignore */ }
+		})
+		ws.send(JSON.stringify(['REQ', subscriptionId, { kinds: [kind], '#t': [topic], '#x': [tagX] }]))
+	}, abortController.signal, sockets)
+	return () => {
+		abortController.abort()
+		for (const ws of sockets) dropWebSocket(ws)
+	}
+}
+
 /**
  * 创建 Nostr discovery provider。
- * @param {{ relayUrls?: string[] }} [options] 可选中继 URL 覆盖
+ * subscribe/onSignal/advertise 首调用不阻塞等公网中继；连上后渐进生效。
+ * `options.relayUrls` 为最终列表（调用方 `mergeSignalingRelayUrls`，或直接传入 `relayOverride`）。
+ * 省略 / `undefined` → 默认公网中继；显式 `[]` 表示无中继（不再回填默认）。
+ * @param {{ relayUrls?: string[] | null }} [options] 可选最终中继 URL 列表
  * @returns {import('./index.mjs').DiscoveryProvider} Nostr 发现提供者
  */
 export function createNostrDiscoveryProvider(options = {}) {
-	const relayUrls = mergeSignalingRelayUrls(options.relayUrls)
+	const relayUrls = dedupeRelayUrls(options.relayUrls || DEFAULT_RELAY_URLS)
 	const secretKey = randomBytes(32)
 	return {
 		id: 'nostr',
 		priority: 100,
 		caps: { canDiscover: true, canSignal: true, canRelay: false },
 		/**
-		 * 周期性向中继发布 advert 事件。
+		 * 周期性向中继发布 advert 事件（首发后台，不阻塞 ensureRuntime）。
 		 * @param {string} topic advert 主题
 		 * @param {Uint8Array} bytes advert 载荷
 		 * @returns {Promise<() => void>} 取消广播函数
 		 */
 		async advertise(topic, bytes) {
-			let closed = false
+			const abortController = new AbortController()
 			/**
 			 * 向中继发布当前 advert。
 			 * @returns {Promise<void>}
 			 */
 			const publish = async () => {
-				if (closed) return
+				if (abortController.signal.aborted) return
 				const event = await signNostrEvent(
 					NOSTR_ADVERT_KIND,
 					[['t', topic], ['x', 'advert']],
 					bytesToBase64(bytes),
 					secretKey,
 				)
-				await publishEvent(relayUrls, event)
+				await publishEvent(relayUrls, event, abortController.signal)
 			}
-			await publish()
+			void publish().catch(() => { })
 			const timer = setInterval(() => { void publish().catch(() => { }) }, 5 * 60_000)
 			return () => {
-				closed = true
+				abortController.abort()
 				clearInterval(timer)
 			}
 		},
 		/**
-		 * 订阅中继上的 advert 事件。
+		 * 订阅中继上的 advert 事件（并行渐进连中继，立即返回 cleanup）。
 		 * @param {string} topic advert 主题
 		 * @param {Function} onAdvert advert 回调
 		 * @returns {Promise<() => void>} 取消订阅函数
 		 */
 		async subscribe(topic, onAdvert) {
-			let closed = false
-			const sockets = []
-			const subscriptionId = randomBytes(8).toString('hex')
-			let connected = 0
-			for (const relayUrl of relayUrls) {
-				let ws
-				try { ws = await connectRelay(relayUrl) }
-				catch { continue }
-				connected++
-				sockets.push(ws)
-				ws.addEventListener('message', event => {
-					if (closed) return
-					let parsed
-					try { parsed = JSON.parse(String(event.data)) } catch { return }
-					if (!Array.isArray(parsed) || parsed[0] !== 'EVENT') return
-					const nostrEvent = parsed[2]
-					if (nostrEvent?.kind !== NOSTR_ADVERT_KIND) return
-					try { onAdvert(base64ToBytes(String(nostrEvent.content || '')), { relayUrl, event: nostrEvent }) }
-					catch { /* ignore */ }
-				})
-				ws.send(JSON.stringify(['REQ', subscriptionId, { kinds: [NOSTR_ADVERT_KIND], '#t': [topic], '#x': ['advert'] }]))
-			}
-			if (!connected) throw new Error('nostr: no relay available for advert subscribe')
-			return () => {
-				closed = true
-				for (const ws of sockets)
-					try { ws.close() } catch { /* ignore */ }
-			}
+			return subscribeNostrKind(relayUrls, {
+				kind: NOSTR_ADVERT_KIND,
+				topic,
+				tagX: 'advert',
+				onPayload: onAdvert,
+			})
 		},
 		/**
-		 * 向中继发布 signal 事件。
+		 * 向中继发布 signal 事件（按需发送，仍等待至少一路成功）。
 		 * @param {string} topic 信令 topic
 		 * @param {string} to 目标节点标识
 		 * @param {Uint8Array} bytes 信令载荷
@@ -234,40 +292,18 @@ export function createNostrDiscoveryProvider(options = {}) {
 			await publishEvent(relayUrls, event)
 		},
 		/**
-		 * 订阅中继上的 signal 事件。
+		 * 订阅中继上的 signal 事件（并行渐进连中继，立即返回 cleanup）。
 		 * @param {string} topic 信令 topic
 		 * @param {Function} onSignal 信令回调
 		 * @returns {Promise<() => void>} 取消订阅函数
 		 */
 		async onSignal(topic, onSignal) {
-			let closed = false
-			const sockets = []
-			const subscriptionId = randomBytes(8).toString('hex')
-			let connected = 0
-			for (const relayUrl of relayUrls) {
-				let ws
-				try { ws = await connectRelay(relayUrl) }
-				catch { continue }
-				connected++
-				sockets.push(ws)
-				ws.addEventListener('message', event => {
-					if (closed) return
-					let parsed
-					try { parsed = JSON.parse(String(event.data)) } catch { return }
-					if (!Array.isArray(parsed) || parsed[0] !== 'EVENT') return
-					const nostrEvent = parsed[2]
-					if (nostrEvent?.kind !== NOSTR_SIGNAL_KIND) return
-					try { onSignal(base64ToBytes(String(nostrEvent.content || '')), { relayUrl, event: nostrEvent }) }
-					catch { /* ignore */ }
-				})
-				ws.send(JSON.stringify(['REQ', subscriptionId, { kinds: [NOSTR_SIGNAL_KIND], '#t': [topic], '#x': ['signal'] }]))
-			}
-			if (!connected) throw new Error('nostr: no relay available for signal subscribe')
-			return () => {
-				closed = true
-				for (const ws of sockets)
-					try { ws.close() } catch { /* ignore */ }
-			}
+			return subscribeNostrKind(relayUrls, {
+				kind: NOSTR_SIGNAL_KIND,
+				topic,
+				tagX: 'signal',
+				onPayload: onSignal,
+			})
 		},
 	}
 }

package/federation/chunk_fetch_pending.mjs

@@ -1,4 +1,4 @@
-import { b64ToU8 } from '../core/bytes_codec.mjs'
+import { base64ToBytes } from '../core/bytes_codec.mjs'
 import { verifiedChunkBytes } from '../files/chunk_fetch_verify.mjs'
 
 /** @type {Map<string, { expectedHash: string, timer: ReturnType<typeof setTimeout>, resolve: (v: Uint8Array | null) => void, reject?: (e: Error) => void }>} */
@@ -109,14 +109,13 @@ export function resolveChunkFetchWait(key, expectedHash, bytes) {
  * @returns {boolean} 是否命中 pending
  */
 export function resolvePendingChunkFetch(payload) {
-	const requestId = String(payload?.requestId || '')
+	const requestId = typeof payload?.requestId === 'string' ? payload.requestId : ''
 	if (!requestId) return false
 	const entry = pendingChunkFetches.get(requestId)
 	if (!entry) return false
-	if (payload?.dataB64) {
+	if (typeof payload?.dataBase64 === 'string') {
 		try {
-			const bytes = b64ToU8(String(payload.dataB64))
-			return resolveChunkFetchWait(requestId, entry.expectedHash, bytes)
+			return resolveChunkFetchWait(requestId, entry.expectedHash, base64ToBytes(payload.dataBase64))
 		}
 		catch { /* keep waiting */ }
 		return false

package/federation/dag_order_cache.mjs

@@ -56,7 +56,7 @@ export function resolveEventTopologicalOrder(events, cache, options = {}) {
 	const tipsHash = computeLocalTipsHash(tips)
 	const eventCount = events.length
 
-	if (cache && Array.isArray(cache.order) && cache.order.length) {
+	if (cache?.order?.length) {
 		if (cache.tipsHash === tipsHash && cache.eventCount === eventCount) {
 			const ok = cache.order.length === eventCount && cache.order.every(id => byId.has(id))
 			if (ok) return cache.order

package/federation/entity_key_chain.mjs

@@ -131,9 +131,8 @@ export function reduceEntityKeyRotate(state, event) {
 export function reduceEntityKeyRevoke(state, event) {
 	const newGeneration = Number(event.content?.newGeneration)
 	const activePubKeyHex = normalizeHex64(event.content?.activePubKeyHex || '')
-	const revokeGenerations = Array.isArray(event.content?.revokeGenerations)
-		? event.content.revokeGenerations.map(g => Number(g)).filter(Number.isFinite)
-		: []
+	const revokeGenerations = (event.content?.revokeGenerations || [])
+		.map(Number).filter(Number.isFinite)
 	if (!Number.isFinite(newGeneration) || newGeneration < 0 || !isHex64(activePubKeyHex))
 		return state
 	state.entityKeyHistory = state.entityKeyHistory || []
@@ -181,7 +180,7 @@ export function foldEntityKeyHistoryFromEvents(events) {
  */
 export function entityKeyRevokeSignBytes(revokeBody) {
 	const body = {
-		revokeGenerations: (revokeBody.revokeGenerations || []).map(g => Number(g)),
+		revokeGenerations: (revokeBody.revokeGenerations || []).map(Number),
 		newGeneration: Number(revokeBody.newGeneration),
 		activePubKeyHex: normalizeHex64(revokeBody.activePubKeyHex || ''),
 		entityHash: String(revokeBody.entityHash || '').trim().toLowerCase(),

package/federation/topo_order_memo.mjs

@@ -1,5 +1,10 @@
-/** @type {Map<string, { fp: string, order: string[] }>} */
-const memoByKey = new Map()
+import { createLruMap } from '../utils/lru.mjs'
+
+/** 进程内拓扑序 memo 上限（每条目持有整份 order 数组） */
+const MEMO_MAX = 64
+
+/** @type {ReturnType<typeof createLruMap<string, { fp: string, order: string[] }>>} */
+const memoByKey = createLruMap(MEMO_MAX)
 
 /**
  * 进程内拓扑序 memo；`resolveOrder` 可接入磁盘缓存等实现。
@@ -12,11 +17,13 @@ const memoByKey = new Map()
 export function resolveTopologicalOrderMemoCached(memoKey, fingerprint, resolveOrder, options = {}) {
 	if (!options.force) {
 		const cached = memoByKey.get(memoKey)
-		if (cached?.fp === fingerprint && cached.order.length)
+		if (cached?.fp === fingerprint && cached.order.length) {
+			memoByKey.touch(memoKey, cached)
 			return cached.order
+		}
 	}
 	const order = resolveOrder()
-	memoByKey.set(memoKey, { fp: fingerprint, order })
+	memoByKey.touch(memoKey, { fp: fingerprint, order })
 	return order
 }