@steve02081504/fount-p2p 0.0.10 → 0.0.12

package/transport/offer_answer.mjs

@@ -0,0 +1,194 @@
+import { randomBytes } from 'node:crypto'
+
+import { normalizeHex64 } from '../core/hexIds.mjs'
+import { sendSignal } from '../discovery/index.mjs'
+import { listLinkProviders } from '../link/providers/index.mjs'
+
+import { decryptSignalPacket, encryptSignalPacket, nodeRendezvousTopic } from './signal_crypto.mjs'
+
+/** accept/dial 挂起期间 ICE 信令 backlog 上限，防无 handler 时无限堆积 */
+const SIGNAL_BACKLOG_MAX = 64
+
+/**
+ * 创建带 backlog 的缓冲信令会话。
+ * @param {(message: unknown) => Promise<void>} sendRemote 远端发送回调
+ * @returns {{ send: (message: unknown) => Promise<void>, onRemote: (handler: (message: unknown) => void) => () => void, deliver: (message: unknown) => void, clear: () => void }} 信令会话
+ */
+export function createBufferedSignalSession(sendRemote) {
+	/** @type {Set<(message: unknown) => void>} */
+	const handlers = new Set()
+	/** @type {unknown[]} */
+	const backlog = []
+	return {
+		/**
+		 * 发送信令消息到远端。
+		 * @param {unknown} message 信令消息
+		 * @returns {Promise<void>}
+		 */
+		async send(message) {
+			await sendRemote(message)
+		},
+		/**
+		 * 注册远端信令 handler（含 backlog 回放）。
+		 * @param {(message: unknown) => void} handler 入站回调
+		 * @returns {() => void} 取消订阅函数
+		 */
+		onRemote(handler) {
+			handlers.add(handler)
+			for (const pending of backlog.splice(0))
+				handler(pending)
+			return () => handlers.delete(handler)
+		},
+		/**
+		 * 投递信令消息；无 handler 时入 backlog（有界）。
+		 * @param {unknown} message 信令消息
+		 * @returns {void}
+		 */
+		deliver(message) {
+			if (!handlers.size) {
+				if (backlog.length >= SIGNAL_BACKLOG_MAX) backlog.shift()
+				backlog.push(message)
+				return
+			}
+			for (const handler of handlers)
+				handler(message)
+		},
+		/**
+		 * 清空 backlog 与 handler。
+		 * @returns {void}
+		 */
+		clear() {
+			backlog.length = 0
+			handlers.clear()
+		},
+	}
+}
+
+/**
+ * 判断信令 body 是否为发起方 offer（据此决定入站是否新建应答 PC）。
+ * @param {unknown} body 信令 body
+ * @returns {boolean} 是 offer 则 true
+ */
+function isOfferSignalBody(body) {
+	return !!body && typeof body === 'object'
+		&& body.type === 'description'
+		&& body.description?.type === 'offer'
+}
+
+/**
+ * 找已注册的 offer/answer provider（按 level 降序的第一个）。
+ * @returns {import('../link/providers/index.mjs').LinkProvider | null} 命中的 provider；无则 null
+ */
+export function findOfferAnswerProvider() {
+	return listLinkProviders().find(provider => provider.caps?.needsOfferAnswer) ?? null
+}
+
+/**
+ * Offer/answer glare 拨号控制器（WebRTC 等 needsOfferAnswer provider）。
+ * @param {object} deps 依赖注入
+ * @param {{ nodeHash: string, nodePubKey: string, secretKey: Uint8Array }} deps.localIdentity 本地身份
+ * @param {RTCConfiguration['iceServers']} deps.iceServers ICE 服务器列表
+ * @param {string} deps.selfTopic 本机 rendezvous topic
+ * @param {Map<string, ReturnType<typeof createBufferedSignalSession>>} deps.signalSessions 按 connId 索引的信令会话
+ * @param {(remoteNodeHash: string, link: object) => Promise<void>} deps.registerResolvedLink 注册规范链
+ * @param {() => Promise<void>} deps.trimToBudget 超预算驱逐
+ * @param {(remoteNodeHash: string) => object | null | undefined} deps.getCanonicalLink 读取当前规范链
+ * @returns {{ handleIncomingSignal: (bytes: Uint8Array) => Promise<void>, dialOfferAnswer: (provider: import('../link/providers/index.mjs').LinkProvider, remoteNodeHash: string) => Promise<object | null> }} 入站信令与主动拨号
+ */
+export function createOfferAnswerDial(deps) {
+	const {
+		localIdentity,
+		iceServers,
+		selfTopic,
+		signalSessions,
+		registerResolvedLink,
+		trimToBudget,
+		getCanonicalLink,
+	} = deps
+
+	/**
+	 * 为单条 PC 创建按 connId 标记的信令会话。
+	 * @param {string} remoteNodeHash 远端节点 64 hex
+	 * @param {string} connId 连接标识
+	 * @returns {ReturnType<typeof createBufferedSignalSession>} 信令会话
+	 */
+	function createConnSession(remoteNodeHash, connId) {
+		const normalized = normalizeHex64(remoteNodeHash)
+		const topic = nodeRendezvousTopic(normalized)
+		return createBufferedSignalSession(async message => {
+			await sendSignal(topic, normalized, encryptSignalPacket(topic, {
+				type: 'signal',
+				from: localIdentity.nodeHash,
+				connId,
+				body: message,
+			}))
+		})
+	}
+
+	/**
+	 * Offer/answer provider：为一条 connId 会话建链并走 glare 择一。
+	 * @param {{ provider: import('../link/providers/index.mjs').LinkProvider, remoteNodeHash: string, connId: string, session: ReturnType<typeof createBufferedSignalSession>, initiator: boolean }} options 建链参数
+	 * @returns {Promise<object | null>} 当前规范链；失败 null
+	 */
+	async function buildConnLink({ provider, remoteNodeHash, connId, session, initiator }) {
+		try {
+			if (initiator) await trimToBudget()
+			const link = await (initiator ? provider.dial : provider.accept)({
+				nodeHash: remoteNodeHash,
+				signal: session,
+				iceServers,
+				localIdentity,
+			})
+			if (!link) {
+				signalSessions.delete(connId)
+				return null
+			}
+			link.onDown(() => signalSessions.delete(connId))
+			await link.ready
+			await registerResolvedLink(remoteNodeHash, link)
+			return getCanonicalLink(remoteNodeHash) ?? null
+		}
+		catch {
+			signalSessions.delete(connId)
+			return null
+		}
+	}
+
+	/**
+	 * 处理入站加密信令并可能发起被动建链。
+	 * @param {Uint8Array} bytes 加密信令字节
+	 * @returns {Promise<void>}
+	 */
+	async function handleIncomingSignal(bytes) {
+		const packet = decryptSignalPacket(selfTopic, bytes)
+		if (packet?.type !== 'signal') return
+		const remoteNodeHash = normalizeHex64(packet.from)
+		const connId = String(packet.connId || '')
+		if (!remoteNodeHash || remoteNodeHash === localIdentity.nodeHash || !connId) return
+		let session = signalSessions.get(connId)
+		if (!session) {
+			if (!isOfferSignalBody(packet.body)) return
+			const provider = findOfferAnswerProvider()
+			if (!provider) return
+			session = createConnSession(remoteNodeHash, connId)
+			signalSessions.set(connId, session)
+			void buildConnLink({ provider, remoteNodeHash, connId, session, initiator: false })
+		}
+		session.deliver(packet.body)
+	}
+
+	/**
+	 * 经 offer/answer provider 拨号（discovery signal + glare）。
+	 * @param {import('../link/providers/index.mjs').LinkProvider} provider 链路提供者
+	 * @param {string} remoteNodeHash 远端 64 hex
+	 * @returns {Promise<object | null>} 当前规范链；失败 null
+	 */
+	async function dialOfferAnswer(provider, remoteNodeHash) {
+		const connId = randomBytes(16).toString('hex')
+		const session = createConnSession(remoteNodeHash, connId)
+		signalSessions.set(connId, session)
+		return await buildConnLink({ provider, remoteNodeHash, connId, session, initiator: true })
+	}
+
+	return { handleIncomingSignal, dialOfferAnswer }
+}

package/transport/peer_pool.mjs

@@ -8,6 +8,7 @@ import { loadPeerPoolView, mergeNetworkPeerPools } from '../node/network.mjs'
 import { loadReputation } from '../node/reputation_store.mjs'
 import { isQuarantinedPure } from '../reputation/engine.mjs'
 import { clampReputationScore } from '../reputation/math.mjs'
+import { shuffleInPlace } from '../utils/shuffle.mjs'
 
 /**
  * 解析联邦池槽位参数（从 groupSettings 读取，含低功耗缩减）。
@@ -91,14 +92,8 @@ export function mergeTrustedWithAnchors(existingTrusted, rankedCandidates, limit
  */
 export function selectExploreWithSourceQuota(exploreIds, exploreSources, k, maxPerSource = EXPLORE_MAX_PER_SOURCE) {
 	if (k <= 0 || !exploreIds.length) return []
-	if (!exploreSources?.size) {
-		const copy = [...exploreIds]
-		for (let i = copy.length - 1; i > 0; i--) {
-			const j = Math.floor(Math.random() * (i + 1))
-				;[copy[i], copy[j]] = [copy[j], copy[i]]
-		}
-		return copy.slice(0, k)
-	}
+	if (!exploreSources?.size)
+		return shuffleInPlace([...exploreIds]).slice(0, k)
 	/** @type {Map<string, string[]>} */
 	const bySource = new Map()
 	for (const id of exploreIds) {
@@ -106,11 +101,7 @@ export function selectExploreWithSourceQuota(exploreIds, exploreSources, k, maxP
 		if (!bySource.has(src)) bySource.set(src, [])
 		bySource.get(src).push(id)
 	}
-	for (const ids of bySource.values())
-		for (let i = ids.length - 1; i > 0; i--) {
-			const j = Math.floor(Math.random() * (i + 1))
-				;[ids[i], ids[j]] = [ids[j], ids[i]]
-		}
+	for (const ids of bySource.values()) shuffleInPlace(ids)
 	const out = []
 	/** @type {Map<string, number>} */
 	const picked = new Map()
@@ -148,7 +139,7 @@ export function selectPeerIdsFromPool({ roster, peers, rep, limits, selfNodeHash
 	const blocked = new Set(peers.blockedPeers)
 	const roomSet = inRoomNodeHashes instanceof Set
 		? inRoomNodeHashes
-		: new Set(Array.isArray(inRoomNodeHashes) ? inRoomNodeHashes : [])
+		: new Set(inRoomNodeHashes || [])
 	const onlineAll = roster.filter(
 		rosterEntry => rosterEntry.peerId
 			&& rosterEntry.remoteNodeHash
@@ -175,10 +166,11 @@ export function selectPeerIdsFromPool({ roster, peers, rep, limits, selfNodeHash
 	}
 
 	const anchoredTrusted = peers.trustedPeers.filter(nodeHash => trustedSet.has(nodeHash))
-	const extraTrusted = [...trustedSet]
-		.filter(nodeHash => !anchoredTrusted.includes(nodeHash))
-		.sort((a, b) => repScore(b, rep) - repScore(a, rep))
-	for (const nodeId of [...anchoredTrusted, ...extraTrusted].slice(0, limits.trustedSlots)) {
+	for (const nodeId of mergeTrustedWithAnchors(
+		anchoredTrusted,
+		[...trustedSet].sort((a, b) => repScore(b, rep) - repScore(a, rep)),
+		limits,
+	)) {
 		if (outPeerIds.size >= limits.maxPeers) break
 		pushNode(nodeId)
 	}
@@ -216,15 +208,14 @@ export function selectPeerIdsFromPool({ roster, peers, rep, limits, selfNodeHash
  * @returns {string[]} 应建链的 nodeHash 列表（去重）
  */
 export function selectLinkTargetsFromMembers({ members, selfNodeHash, rep, peers, limits, anchors = [] }) {
-	const self = String(selfNodeHash || '')
 	const blocked = new Set(peers?.blockedPeers || [])
 	const now = Date.now()
-	const candidates = [...new Set([...members].map(id => String(id)))]
-		.filter(id => id && id !== self && !blocked.has(id) && !isQuarantinedPure(rep, id, now))
+	const candidates = [...new Set(members)]
+		.filter(id => id && id !== selfNodeHash && !blocked.has(id) && !isQuarantinedPure(rep, id, now))
 	const ranked = candidates.slice().sort((a, b) => repScore(b, rep) - repScore(a, rep))
 	const candidateSet = new Set(candidates)
 	// 锚点（如 introducer/creator/seed）必连、且不占 trustedSlots——保证引导期连通。
-	const forced = [...new Set([...anchors].map(id => String(id)))].filter(id => candidateSet.has(id))
+	const forced = [...new Set(anchors)].filter(id => candidateSet.has(id))
 	const chosen = new Set(forced)
 	// trusted 槽只从非锚点候选填：既有 trusted 优先保留，再按信誉补至 trustedSlots。
 	const nonForced = ranked.filter(id => !chosen.has(id))
@@ -237,29 +228,24 @@ export function selectLinkTargetsFromMembers({ members, selfNodeHash, rep, peers
 }
 
 /**
- * 将新 PEX 节点线索合并进 explore 池，并按信誉重新填充 trusted 槽。
- * 纯计算版本，不含 I/O：接受 peers 对象，返回新对象。
- *
+ * 将候选 id 并入 explore，并按信誉重填 trusted。
  * @param {{
  *   peers: { trustedPeers: string[], explorePeers: string[], blockedPeers: string[] },
  *   rep: { byNodeHash?: Record<string, { score?: number }> },
- *   hints: string[],
+ *   addIds: Iterable<string>,
  *   limits: ReturnType<typeof resolveFederationPoolLimits>,
- * }} options 合并参数（peers、rep、hints、limits）
- * @returns {{ trustedPeers: string[], explorePeers: string[] }} 更新后的 trusted/explore 列表
+ * }} options 池状态与增量
+ * @returns {{ trustedPeers: string[], explorePeers: string[] }} 重算后的 trusted/explore
  */
-export function applyPexHints({ peers, rep, hints, limits }) {
-	const ids = [...new Set(
-		(Array.isArray(hints) ? hints : [])
-			.map(id => String(id).trim())
-			.filter(Boolean),
-	)]
+function rebuildExploreAndTrusted(options) {
+	const { peers, rep, addIds, limits } = options
+	const blocked = new Set(peers.blockedPeers)
 	const explore = new Set(peers.explorePeers)
-	for (const id of ids)
-		if (!peers.blockedPeers.includes(id)) explore.add(id)
-	const newExplorePeers = [...explore].slice(-500)
+	for (const id of addIds)
+		if (id && !blocked.has(id)) explore.add(id)
+	const newExplorePeers = [...explore].filter(id => !blocked.has(id)).slice(-500)
 	const ranked = [...new Set([...peers.trustedPeers, ...newExplorePeers])]
-		.filter(id => !peers.blockedPeers.includes(id))
+		.filter(id => !blocked.has(id))
 		.sort((a, b) => repScore(b, rep) - repScore(a, rep))
 	return {
 		trustedPeers: mergeTrustedWithAnchors(peers.trustedPeers, ranked, limits, peers.blockedPeers),
@@ -268,32 +254,39 @@ export function applyPexHints({ peers, rep, hints, limits }) {
 }
 
 /**
- * 从 roster 观测中更新 explore 池并重新填充 trusted 槽（纯计算版本）。
- *
+ * PEX 线索并入 explore 并重填 trusted（纯计算）。
  * @param {{
  *   peers: { trustedPeers: string[], explorePeers: string[], blockedPeers: string[] },
  *   rep: { byNodeHash?: Record<string, { score?: number }> },
- *   roster: Array<{ remoteNodeHash?: string }>,
+ *   hints: string[],
  *   limits: ReturnType<typeof resolveFederationPoolLimits>,
- * }} options roster 更新参数（peers、rep、roster、limits）
- * @returns {{ trustedPeers: string[], explorePeers: string[] }} 更新后的 trusted/explore 列表
+ * }} options 池状态与 PEX hints
+ * @returns {{ trustedPeers: string[], explorePeers: string[] }} 重算后的 trusted/explore
  */
-export function applyRosterToPeerPool({ peers, rep, roster, limits }) {
-	const explore = new Set(peers.explorePeers)
-	for (const rosterEntry of roster) {
-		const nodeId = rosterEntry.remoteNodeHash?.trim()
-		if (nodeId && !peers.blockedPeers.includes(nodeId)) explore.add(nodeId)
-	}
-	const newExplorePeers = [...explore]
-		.filter(id => !peers.blockedPeers.includes(id))
-		.slice(-500)
-	const candidates = [...new Set([...peers.trustedPeers, ...newExplorePeers])]
-		.filter(id => !peers.blockedPeers.includes(id))
-		.sort((a, b) => repScore(b, rep) - repScore(a, rep))
-	return {
-		trustedPeers: mergeTrustedWithAnchors(peers.trustedPeers, candidates, limits, peers.blockedPeers),
-		explorePeers: newExplorePeers,
-	}
+export function applyPexHints(options) {
+	const { peers, rep, hints, limits } = options
+	return rebuildExploreAndTrusted({
+		peers, rep, limits,
+		addIds: hints || [],
+	})
+}
+
+/**
+ * roster 观测并入 explore 并重填 trusted（纯计算）。
+ * @param {{
+ *   peers: { trustedPeers: string[], explorePeers: string[], blockedPeers: string[] },
+ *   rep: { byNodeHash?: Record<string, { score?: number }> },
+ *   roster: { remoteNodeHash?: string }[],
+ *   limits: ReturnType<typeof resolveFederationPoolLimits>,
+ * }} options 池状态与 roster
+ * @returns {{ trustedPeers: string[], explorePeers: string[] }} 重算后的 trusted/explore
+ */
+export function applyRosterToPeerPool(options) {
+	const { peers, rep, roster, limits } = options
+	return rebuildExploreAndTrusted({
+		peers, rep, limits,
+		addIds: roster.map(entry => entry.remoteNodeHash).filter(Boolean),
+	})
 }
 
 /**
@@ -308,17 +301,13 @@ export function pickFederationTargetPeerIds(groupId, roster, groupSettings, self
 	const limits = resolveFederationPoolLimits(groupSettings)
 	const peers = loadPeerPoolView(groupId)
 	const rep = loadReputation()
-	const inRoomNodeHashes = roster
-		.map(p => p.remoteNodeHash)
-		.map(id => String(id).trim())
-		.filter(Boolean)
 	return selectPeerIdsFromPool({
 		roster,
 		peers,
 		rep,
 		limits,
 		selfNodeHash,
-		inRoomNodeHashes,
+		inRoomNodeHashes: roster.map(entry => entry.remoteNodeHash).filter(Boolean),
 		hintSources: peers.hintSources,
 	})
 }

package/transport/remote_user_room.mjs

@@ -12,15 +12,13 @@ import { USER_ROOM_SCOPE } from './room_scopes.mjs'
  * }} RemoteUserRoomSlot
  */
 
-/** @type {Map<string, RemoteUserRoomSlot | null>} nodeHash → slot（null 表示加入失败/进行中） */
+/** @type {Map<string, RemoteUserRoomSlot>} nodeHash → slot */
 const slots = new Map()
 /** @type {Map<string, Promise<RemoteUserRoomSlot | null>>} nodeHash → 进行中的 promise */
 const inflights = new Map()
 
 registerFederationRoomProvider('remote-user-room', () => {
-	return [...slots.values()]
-		.filter(Boolean)
-		.map(s => s.roomSlot)
+	return [...slots.values()].map(s => s.roomSlot)
 })
 
 /**
@@ -32,16 +30,14 @@ registerFederationRoomProvider('remote-user-room', () => {
 export async function ensureRemoteUserRoom(username, targetNodeHash) {
 	void username
 	const key = targetNodeHash.toLowerCase()
-	if (slots.has(key)) return slots.get(key) || null
-	const existing = inflights.get(key)
-	if (existing) return await existing
+	const existing = slots.get(key)
+	if (existing) return existing
+	const inflight = inflights.get(key)
+	if (inflight) return await inflight
 
 	const task = (async () => {
 		try {
-			if (!await ensureLinkToNode(key)) {
-				slots.set(key, null)
-				return null
-			}
+			if (!await ensureLinkToNode(key)) return null
 
 			/** @type {import('../registries/room_provider.mjs').FederationRoomSlot} */
 			const roomSlot = {
@@ -66,17 +62,20 @@ export async function ensureRemoteUserRoom(username, targetNodeHash) {
 				 * @returns {void}
 				 */
 				sendToPeer(peerId, actionName, payload) {
-					void getLink(key)?.send({ scope: 'node', action: String(actionName), payload }).catch(() => { })
+					void getLink(key)?.send({ scope: 'node', action: actionName, payload }).catch(() => { })
 				},
 			}
 
 			const slot = {
 				roomSlot,
 				/**
-				 * 关闭远端用户房间链路。
+				 * 关闭远端用户房间链路并释放槽位。
 				 * @returns {Promise<void>} 关闭完成
 				 */
-				leave() { return closeLink(key, 'remote-user-room-release') },
+				leave() {
+					slots.delete(key)
+					return closeLink(key, 'remote-user-room-release')
+				},
 			}
 			slots.set(key, slot)
 			invalidateTrustGraphCache()
@@ -84,7 +83,6 @@ export async function ensureRemoteUserRoom(username, targetNodeHash) {
 		}
 		catch (error) {
 			console.error('p2p: failed to join remote user room', key, error)
-			slots.set(key, null)
 			return null
 		}
 		finally {

package/transport/rtc_connection_budget.mjs

@@ -23,7 +23,7 @@ export function resolveRtcBudgetLimits(limits = {}) {
 		maxActive: Math.max(4, Math.min(128, Number(limits.maxActive) || 32)),
 		maxJoinsPerMin: Math.max(1, Math.min(120, Number(limits.maxJoinsPerMin) || 12)),
 		overloadCooldownMs: Math.max(1000, Number(limits.overloadCooldownMs) || 15_000),
-		trustedPeers: Array.isArray(limits.trustedPeers) ? limits.trustedPeers.map(String) : [],
+		trustedPeers: limits.trustedPeers || [],
 		trustedReserveFraction: Math.max(0.1, Math.min(0.5, Number(limits.trustedReserveFraction) || DEFAULT_TRUSTED_RESERVE_FRACTION)),
 		minTrustedReserved: Math.max(1, Math.floor(Number(limits.minTrustedReserved) || DEFAULT_MIN_TRUSTED_RESERVED)),
 	}
@@ -85,10 +85,14 @@ export function takeRtcJoinSlot(roomKey, peerId, limits = {}, sourceId = 'peer')
 	const isTrusted = peerId && bucket.trustedPeers.has(peerId)
 	const trustedReserved = Math.max(minTrustedReserved, Math.floor(maxActive * trustedReserveFraction))
 	const maxNonTrusted = Math.max(1, maxActive - trustedReserved)
-	const nonTrustedCount = [...bucket.active].filter(id => !bucket.trustedPeers.has(id)).length
+	let nonTrustedCount = 0
+	for (const id of bucket.active)
+		if (!bucket.trustedPeers.has(id)) nonTrustedCount++
 	if (!isTrusted) {
 		const source = String(sourceId || 'peer')
-		const sameSource = [...bucket.sourceByPeer.entries()].filter(([, s]) => s === source).length
+		let sameSource = 0
+		for (const peerSource of bucket.sourceByPeer.values())
+			if (peerSource === source) sameSource++
 		const sourceCap = Math.max(1, Math.floor(maxActive * MAX_SOURCE_SLOT_FRACTION))
 		if (sameSource >= sourceCap) return false
 		if (nonTrustedCount >= maxNonTrusted && bucket.active.size >= maxActive) {
@@ -149,6 +153,16 @@ export function releaseRtcPeer(roomKey, peerId) {
 	bucket.active.delete(peerId)
 	bucket.sourceByPeer.delete(peerId)
 	bucket.peerNodeHash.delete(peerId)
+	// 房间空闲后丢掉桶，避免 leave 过的 roomKey 永久占内存
+	if (!bucket.active.size) budgets.delete(roomKey)
+}
+
+/**
+ * 当前预算桶数量（测试用）。
+ * @returns {number} 房间桶数
+ */
+export function rtcBudgetRoomCount() {
+	return budgets.size
 }
 
 /** RTC 过载时跳过的非关键联邦 action */
@@ -180,5 +194,5 @@ const NON_CRITICAL_FED_ACTIONS = new Set([
  */
 export function isFederationActionAllowedUnderLoad(roomKey, actionName, limits = {}) {
 	if (!isRtcRoomOverloaded(roomKey, limits)) return true
-	return !NON_CRITICAL_FED_ACTIONS.has(String(actionName || '').trim())
+	return !NON_CRITICAL_FED_ACTIONS.has(actionName)
 }