@steve02081504/fount-p2p 0.0.5 → 0.0.7

package/link/providers/webrtc.mjs

@@ -0,0 +1,385 @@
+import { getSignalingRuntimeConfig } from '../../node/instance.mjs'
+import { ms } from '../../utils/duration.mjs'
+import { createLruMap } from '../../utils/lru.mjs'
+import {
+	CHANNEL_BULK,
+	CHANNEL_CONTROL,
+	CHANNEL_LOW_THRESHOLD_BYTES,
+	configureBufferedAmountLowThreshold,
+	createChannelSendQueues,
+	onBufferedAmountLow,
+} from '../channel_mux.mjs'
+import { asLinkHandle, createLinkPipe } from '../pipe.mjs'
+import {
+	attachDataChannelListener,
+	attachIceCandidateListener,
+	loadNodeRtcPolyfill,
+	signalDataToBytes,
+	waitForChannelState,
+} from '../rtc.mjs'
+import { extractDtlsFingerprint } from '../sdp_fingerprint.mjs'
+
+import { LINK_LEVEL_WEBRTC } from './levels.mjs'
+
+/**
+ * 将错误对象格式化为短字符串。
+ * @param {unknown} error 原始错误
+ * @returns {string} 短 reason
+ */
+function formatErrorReason(error) {
+	return String(error?.message ?? error ?? 'unknown-error').replace(/\s+/g, ' ').slice(0, 240)
+}
+
+/**
+ * 绑定 data channel message 回调。
+ * @param {RTCDataChannel} channel RTC 数据通道
+ * @param {(data: unknown) => void} handler 消息处理器
+ * @returns {void}
+ */
+function attachChannelMessageListener(channel, handler) {
+	channel.addEventListener?.('message', event => handler(event?.data))
+	/**
+	 * @param {MessageEvent} event 消息事件
+	 * @returns {void}
+	 */
+	channel.onmessage = event => handler(event?.data)
+	channel.onMessage?.subscribe(message => handler(message))
+}
+
+let cachedAvailable = null
+
+/**
+ * 探测 WebRTC（node-datachannel）是否可用。
+ * @returns {Promise<boolean>} 可用为 true
+ */
+export async function canUseWebRtcLink() {
+	if (cachedAvailable !== null) return cachedAvailable
+	try {
+		await loadNodeRtcPolyfill()
+		cachedAvailable = true
+	}
+	catch {
+		cachedAvailable = false
+	}
+	return cachedAvailable
+}
+
+/**
+ * 建立 WebRTC link（双 DataChannel + discovery 信令）。
+ * @param {object} options link 配置
+ * @param {string | null} [options.nodeHash] 期望的对端 nodeHash
+ * @param {boolean} options.initiator 是否为连接发起方
+ * @param {{ send: (message: unknown) => void | Promise<void>, onRemote: (handler: (message: unknown) => void) => (() => void) | void }} options.signal 信令收发接口
+ * @param {RTCConfiguration['iceServers']} [options.iceServers] ICE 服务器列表
+ * @param {number} [options.heartbeatMs] 心跳间隔
+ * @param {number} [options.idleTimeoutMs] 无入站流量超时
+ * @param {number} [options.handshakeTimeoutMs] 握手超时
+ * @param {{ RTCPeerConnection: typeof RTCPeerConnection } | null} [options.rtc] RTC 构造器
+ * @param {{ nodeHash?: string, nodePubKey?: string, secretKey?: Uint8Array, nonce?: string } | null} [options.localIdentity] 本地握手身份
+ * @returns {Promise<import('./index.mjs').LinkHandle>} link 句柄
+ */
+export async function createWebRtcLink(options) {
+	const handshakeTimeoutMs = Number(options.handshakeTimeoutMs) || ms('10s')
+	const channelOpenTimeoutMs = Math.max(handshakeTimeoutMs, ms('30s'))
+	const trickleIceOff = getSignalingRuntimeConfig().trickleIceOff === true
+	const rtc = options.rtc ?? await loadNodeRtcPolyfill()
+	const pc = new rtc.RTCPeerConnection(options.iceServers?.length ? { iceServers: options.iceServers } : undefined)
+	const remoteSignalQueue = []
+	const seenRemoteSignals = createLruMap(1024)
+	let remoteDescriptionSet = false
+	let controlChannel = null
+	let bulkChannel = null
+	let unlistenRemote = null
+	let sendQueues = null
+	let controlLowEvents = 0
+	let bulkLowEvents = 0
+	let reconnectCount = 0
+
+	/**
+	 * @param {unknown} message 信令载荷
+	 * @returns {Promise<void>}
+	 */
+	async function sendSignal(message) {
+		await Promise.resolve(options.signal.send(message))
+	}
+
+	const pipe = createLinkPipe({
+		providerId: 'webrtc',
+		level: LINK_LEVEL_WEBRTC,
+		initiator: !!options.initiator,
+		nodeHash: options.nodeHash,
+		localIdentity: options.localIdentity,
+		heartbeatMs: options.heartbeatMs,
+		idleTimeoutMs: options.idleTimeoutMs,
+		handshakeTimeoutMs,
+		/** @returns {string} 本端 DTLS fingerprint */
+		getLocalBinding: () => extractDtlsFingerprint(pc.localDescription?.sdp || ''),
+		/** @returns {string} 对端 DTLS fingerprint */
+		getRemoteBinding: () => extractDtlsFingerprint(pc.remoteDescription?.sdp || ''),
+		/**
+		 * @param {string} text control JSON
+		 * @returns {void}
+		 */
+		sendControlText(text) {
+			if (!controlChannel) throw new Error('p2p: control channel unavailable')
+			controlChannel.send(text)
+		},
+		/**
+		 * @param {string} action envelope action
+		 * @param {Uint8Array} frame 帧字节
+		 * @returns {void}
+		 */
+		sendFrame(action, frame) {
+			if (!sendQueues) throw new Error('p2p: send queues unavailable')
+			sendQueues.enqueue(action, frame)
+		},
+		/**
+		 * @returns {Promise<void>}
+		 */
+		async closeTransport() {
+			unlistenRemote?.()
+			sendQueues?.clear()
+			try { controlChannel?.close() } catch { /* ignore */ }
+			try { bulkChannel?.close() } catch { /* ignore */ }
+			try { await pc.close() } catch { /* ignore */ }
+		},
+		/**
+		 * @returns {object} WebRTC 附加 stats
+		 */
+		extraStats() {
+			return {
+				connectionState: pc.connectionState,
+				iceConnectionState: pc.iceConnectionState,
+				reconnectCount,
+				pending: sendQueues?.pending() ?? { control: 0, bulk: 0 },
+				controlBufferedAmount: controlChannel?.bufferedAmount ?? 0,
+				bulkBufferedAmount: bulkChannel?.bufferedAmount ?? 0,
+				controlLowEvents,
+				bulkLowEvents,
+			}
+		},
+	})
+
+	/**
+	 * @param {RTCDataChannel} channel RTC 数据通道
+	 * @returns {void}
+	 */
+	function attachBackpressurePump(channel) {
+		configureBufferedAmountLowThreshold(channel, CHANNEL_LOW_THRESHOLD_BYTES)
+		onBufferedAmountLow(channel, () => {
+			if (channel.label === CHANNEL_CONTROL) controlLowEvents++
+			if (channel.label === CHANNEL_BULK) bulkLowEvents++
+			if (channel.label === CHANNEL_CONTROL) sendQueues?.flush(CHANNEL_CONTROL)
+			if (channel.label === CHANNEL_BULK) sendQueues?.flush(CHANNEL_BULK)
+		})
+	}
+
+	/**
+	 * @param {RTCSessionDescriptionInit | RTCSessionDescription} description 远端会话描述
+	 * @returns {Promise<void>}
+	 */
+	async function applyRemoteDescription(description) {
+		await pc.setRemoteDescription(description)
+		remoteDescriptionSet = true
+		await flushQueuedIceCandidates()
+	}
+
+	/**
+	 * @param {unknown} error addIceCandidate 错误
+	 * @returns {boolean} 是否应暂存后重试
+	 */
+	function shouldRetryQueuedIce(error) {
+		return /without ice transport/i.test(String(error?.message ?? error ?? ''))
+	}
+
+	/**
+	 * @returns {Promise<void>}
+	 */
+	async function waitForIceGatheringComplete() {
+		if (!trickleIceOff || pc.iceGatheringState === 'complete') return
+		const deadline = Date.now() + handshakeTimeoutMs
+		while (pc.iceGatheringState !== 'complete' && Date.now() < deadline)
+			await new Promise(resolve => setTimeout(resolve, 50))
+	}
+
+	/**
+	 * @returns {Promise<void>}
+	 */
+	async function flushQueuedIceCandidates() {
+		if (!remoteDescriptionSet || !pc.localDescription) return
+		while (remoteSignalQueue.length) {
+			const candidate = remoteSignalQueue.shift()
+			try {
+				await pc.addIceCandidate(candidate)
+			}
+			catch (error) {
+				if (shouldRetryQueuedIce(error)) {
+					remoteSignalQueue.unshift(candidate)
+					return
+				}
+				throw error
+			}
+		}
+	}
+
+	/**
+	 * @param {unknown} message 信令消息
+	 * @returns {Promise<void>}
+	 */
+	async function handleRemoteSignal(message) {
+		if (!message || typeof message !== 'object') return
+		const signalKey = JSON.stringify(message)
+		if (seenRemoteSignals.has(signalKey)) return
+		seenRemoteSignals.touch(signalKey, true)
+		if (message.type === 'description' && message.description) {
+			if (message.description.type === 'answer' && pc.signalingState === 'stable') return
+			await applyRemoteDescription(message.description)
+			if (message.description.type === 'offer') {
+				const answer = await pc.createAnswer()
+				await pc.setLocalDescription(answer)
+				await flushQueuedIceCandidates()
+				await waitForIceGatheringComplete()
+				await sendSignal({
+					type: 'description',
+					description: pc.localDescription?.toJSON?.() ?? pc.localDescription ?? answer,
+				})
+				await pipe.maybeSendAuth()
+			}
+			return
+		}
+		if (message.type === 'ice' && message.candidate) {
+			if (!remoteDescriptionSet || !pc.localDescription || pc.signalingState !== 'stable') {
+				remoteSignalQueue.push(message.candidate)
+				return
+			}
+			try {
+				await pc.addIceCandidate(message.candidate)
+			}
+			catch (error) {
+				if (shouldRetryQueuedIce(error)) {
+					remoteSignalQueue.push(message.candidate)
+					return
+				}
+				throw error
+			}
+		}
+	}
+
+	/**
+	 * @param {RTCDataChannel} channel RTC 数据通道
+	 * @returns {Promise<void>}
+	 */
+	async function attachChannel(channel) {
+		if (channel.label === CHANNEL_CONTROL) controlChannel = channel
+		else if (channel.label === CHANNEL_BULK) bulkChannel = channel
+		else return
+		attachChannelMessageListener(channel, data => {
+			try {
+				if (typeof data === 'string') pipe.handleInbound(data)
+				else pipe.handleInbound(signalDataToBytes(data))
+			}
+			catch { /* drop */ }
+		})
+		attachBackpressurePump(channel)
+	}
+
+	/**
+	 * @returns {Promise<void>}
+	 */
+	async function maybeStartPostOpenFlow() {
+		if (!controlChannel || !bulkChannel) return
+		await Promise.all([
+			waitForChannelState(controlChannel, 'open', channelOpenTimeoutMs),
+			waitForChannelState(bulkChannel, 'open', channelOpenTimeoutMs),
+		])
+		if (!sendQueues)
+			sendQueues = createChannelSendQueues({
+				/**
+				 * @param {'control' | 'bulk'} name 通道名
+				 * @returns {RTCDataChannel | null | undefined} 对应通道
+				 */
+				getChannel: name => name === CHANNEL_CONTROL ? controlChannel : bulkChannel,
+			})
+		await pipe.startHandshake()
+	}
+
+	unlistenRemote = options.signal.onRemote(message => {
+		void handleRemoteSignal(message).catch(error => pipe.close(`signal-error:${formatErrorReason(error)}`))
+	}) ?? null
+
+	attachIceCandidateListener(pc, event => {
+		if (trickleIceOff || !event.candidate) return
+		void sendSignal({
+			type: 'ice',
+			candidate: typeof event.candidate.toJSON === 'function' ? event.candidate.toJSON() : event.candidate,
+		}).catch(error => pipe.close(`signal-send-failed:${formatErrorReason(error)}`))
+	})
+	attachDataChannelListener(pc, event => {
+		void attachChannel(event.channel)
+			.then(() => maybeStartPostOpenFlow())
+			.catch(error => pipe.close(`channel-attach-failed:${error?.message ?? error}`))
+	})
+
+	/** 连接失败/关闭时关掉 pipe。 */
+	pc.onconnectionstatechange = () => {
+		if (['failed', 'closed', 'disconnected'].includes(pc.connectionState)) {
+			reconnectCount++
+			void pipe.close(`connection-${pc.connectionState}`)
+		}
+	}
+
+	if (options.initiator) {
+		await attachChannel(pc.createDataChannel(CHANNEL_CONTROL))
+		await attachChannel(pc.createDataChannel(CHANNEL_BULK))
+		const offer = await pc.createOffer()
+		await pc.setLocalDescription(offer)
+		await waitForIceGatheringComplete()
+		await sendSignal({
+			type: 'description',
+			description: pc.localDescription?.toJSON?.() ?? pc.localDescription ?? offer,
+		})
+	}
+
+	void maybeStartPostOpenFlow().catch(error => pipe.close(`open-flow-failed:${error?.message ?? error}`))
+
+	return asLinkHandle(pipe, {
+		/**
+		 * @internal 仅 live 背压测试用，不属公开 LinkHandle
+		 * @param {'control' | 'bulk'} name 通道名
+		 * @returns {RTCDataChannel | null} 测试用通道
+		 */
+		_channelForTest(name) {
+			return name === CHANNEL_CONTROL ? controlChannel : bulkChannel
+		},
+	})
+}
+
+/**
+ * 创建 WebRTC LinkProvider。
+ * @param {object} [options] 可选覆盖
+ * @param {typeof createWebRtcLink} [options.createWebRtcLink] 链路工厂（测试注入）
+ * @returns {import('./index.mjs').LinkProvider} WebRTC provider
+ */
+export function createWebRtcLinkProvider(options = {}) {
+	const createImpl = options.createWebRtcLink ?? createWebRtcLink
+	return {
+		id: 'webrtc',
+		level: LINK_LEVEL_WEBRTC,
+		caps: { needsOfferAnswer: true, needsDiscoverySignal: true },
+		isAvailable: canUseWebRtcLink,
+		/**
+		 * @param {object} dialOptions dial 参数（含 signal / iceServers 等）
+		 * @returns {Promise<import('./index.mjs').LinkHandle>} 已建链句柄
+		 */
+		async dial(dialOptions) {
+			return createImpl({ ...dialOptions, initiator: true })
+		},
+		/**
+		 * @param {object} acceptOptions accept 参数
+		 * @returns {Promise<import('./index.mjs').LinkHandle>} 已建链句柄
+		 */
+		async accept(acceptOptions) {
+			return createImpl({ ...acceptOptions, initiator: false })
+		},
+	}
+}

package/mailbox/deliver_or_store.mjs

@@ -59,26 +59,26 @@ async function resolveRouting(username) {
 
 /**
  * @param {string} username 副本用户名（trust graph 投递上下文）
- * @param {object} opts 投递选项
+ * @param {object} options 投递选项
  * @returns {Promise<{ stored: boolean, delivered: boolean, relayed: number }>} 存转结果
  */
-export async function deliverOrStoreMailboxPut(username, opts) {
+export async function deliverOrStoreMailboxPut(username, options) {
 	const routing = await resolveRouting(username)
-	const toPubKeyHash = normalizeHex64(opts.toPubKeyHash)
+	const toPubKeyHash = normalizeHex64(options.toPubKeyHash)
 	if (!toPubKeyHash) return { stored: false, delivered: false, relayed: 0 }
-	const hop = normalizeMailboxHop(opts.hop)
+	const hop = normalizeMailboxHop(options.hop)
 	if (hop >= routing.maxHop) return { stored: false, delivered: false, relayed: 0 }
 	const tier = mailboxTierFromHop(hop)
 	const nodeHash = getNodeHash()
 	const record = {
-		...opts.record,
+		...options.record,
 		toPubKeyHash,
 		hop,
 		tier,
-		fromNodeHash: opts.record?.fromNodeHash || nodeHash,
+		fromNodeHash: options.record?.fromNodeHash || nodeHash,
 	}
 	const stored = await storeMailboxRecord(record)
-	const toNodeHash = opts.toNodeHash?.trim().toLowerCase()
+	const toNodeHash = options.toNodeHash?.trim().toLowerCase()
 	const delivered = toNodeHash && isMailboxRecordWithinSizeLimit(record)
 		? await requireTrustGraphProvider(DEFAULT_TRUST_GRAPH_OWNER).sendToNode(username, toNodeHash, 'mailbox_put', { nodeHash, record })
 		: false
@@ -108,17 +108,17 @@ export async function publishMailboxRecord(username, toPubKeyHash, record, toNod
 }
 
 /**
- * @param {{ replicaUsername?: string }} ctx 入站上下文
+ * @param {{ replicaUsername?: string }} wireContext 入站上下文
  * @param {object} put 入站 mailbox_put
  * @param {string} [peerId] Trystero 对端 id（有则校验 nodeHash 绑定）
  * @returns {Promise<void>}
  */
-export async function ingestMailboxPut(ctx, put, peerId = '') {
+export async function ingestMailboxPut(wireContext, put, peerId = '') {
 	const { record } = put
 	if (!record?.envelope || !record?.toPubKeyHash) return
 	const fromNode = normalizeHex64(put.nodeHash)
 	if (!fromNode || !takeIncomingMailboxPutSlot(fromNode)) return
-	const username = String(ctx?.replicaUsername || '').trim()
+	const username = String(wireContext.replicaUsername || '').trim()
 	if (!username) return
 	if (peerId) {
 		const remote = await resolveRemoteNodeHashForPeer(username, peerId)
@@ -157,14 +157,14 @@ export async function respondMailboxWant(want, sendGive, peerId) {
 }
 
 /**
- * @param {{ replicaUsername?: string }} ctx 入站上下文
+ * @param {{ replicaUsername?: string }} wireContext 入站上下文
  * @param {object} give mailbox_give 载荷
  * @returns {Promise<number>} 投递给消费者的记录数
  */
-export async function ingestMailboxGive(ctx, give) {
+export async function ingestMailboxGive(wireContext, give) {
 	const records = (give.records || []).filter(isDeliverableMailboxRecord)
 	if (!records.length) return 0
-	const username = String(ctx?.replicaUsername || '').trim()
+	const username = String(wireContext.replicaUsername || '').trim()
 	if (!username) return 0
 	const { dispatchMailboxRecordsToConsumers } = await import('./consumer_registry.mjs')
 	const { deleteMailboxRecords } = await import('./store.mjs')

package/mailbox/wire.mjs

@@ -10,15 +10,15 @@ import { parseMailboxGive, parseMailboxPut, parseMailboxWant } from './parse.mjs
  */
 
 /**
- * @param {MailboxWireContext} ctx 入站上下文
+ * @param {MailboxWireContext} wireContext 入站上下文
  * @param {{ on: (name: string, handler: (payload: unknown, peerId: string) => void) => void, send: (name: string, payload: unknown, peerId: string | null) => void }} wire Trystero 适配器
  * @returns {void}
  */
-export function attachMailboxWire(ctx, wire) {
+export function attachMailboxWire(wireContext, wire) {
 	wire.on('mailbox_put', (payload, peerId) => {
 		const put = parseMailboxPut(payload)
 		if (!put.ok) return
-		void ingestMailboxPut(ctx, put.value, peerId).catch(err => console.error('mailbox: put ingest failed', err))
+		void ingestMailboxPut(wireContext, put.value, peerId).catch(err => console.error('mailbox: put ingest failed', err))
 	})
 
 	wire.on('mailbox_want', (payload, peerId) => {
@@ -35,6 +35,6 @@ export function attachMailboxWire(ctx, wire) {
 	wire.on('mailbox_give', payload => {
 		const give = parseMailboxGive(payload)
 		if (!give.ok) return
-		void ingestMailboxGive(ctx, give.value).catch(err => console.error('mailbox: give ingest failed', err))
+		void ingestMailboxGive(wireContext, give.value).catch(err => console.error('mailbox: give ingest failed', err))
 	})
 }

package/node/reputation_store.mjs

@@ -26,12 +26,12 @@ import { readNodeJsonSync, writeNodeJsonSync } from './storage.mjs'
 
 const DATA_NAME = 'reputation'
 
-/** @type {((opts: object) => Promise<boolean>) | null} */
+/** @type {((options: object) => Promise<boolean>) | null} */
 let blockReputationHandler = null
 
 /**
  * Shell Load 时注册：公开 block/unblock → 信誉传导。
- * @param {(opts: object) => Promise<boolean>} handler block/unblock 信誉传导回调
+ * @param {(options: object) => Promise<boolean>} handler block/unblock 信誉传导回调
  * @returns {void}
  */
 export function registerBlockReputationHandler(handler) {
@@ -308,10 +308,10 @@ export function pickNodeScore(nodeId) {
 }
 
 /**
- * @param {object} opts applyFollowedBlockSignal 参数
+ * @param {object} options applyFollowedBlockSignal 参数
  * @returns {Promise<boolean>} 是否已应用
  */
-export async function applyBlockReputationSignal(opts) {
+export async function applyBlockReputationSignal(options) {
 	if (!blockReputationHandler) return false
-	return blockReputationHandler(opts)
+	return blockReputationHandler(options)
 }

package/node/retention_policy.mjs

@@ -8,16 +8,16 @@ import {
  * 在共识分支上计算须保留的事件 id（连通子图，不用拓扑下标切片）。
  * @param {string[]} order 规范拓扑序
  * @param {Map<string, object>} byId id → 事件
- * @param {object} opts 保留策略
- * @param {number} opts.maxDepth 分支上最大事件深度
- * @param {number} opts.cutoffWall 最早保留的 HLC wall
- * @param {Set<string>} opts.anchorTypes 权限锚点事件类型
- * @param {string | null} [opts.checkpointTipId] checkpoint 尖
- * @param {string | null} [opts.branchTipId] 共识分支尖
+ * @param {object} options 保留策略
+ * @param {number} options.maxDepth 分支上最大事件深度
+ * @param {number} options.cutoffWall 最早保留的 HLC wall
+ * @param {Set<string>} options.anchorTypes 权限锚点事件类型
+ * @param {string | null} [options.checkpointTipId] checkpoint 尖
+ * @param {string | null} [options.branchTipId] 共识分支尖
  * @returns {Set<string>} 保留 id
  */
-export function computeRetentionKeepIds(order, byId, opts) {
-	const { maxDepth, cutoffWall, anchorTypes, checkpointTipId, branchTipId } = opts
+export function computeRetentionKeepIds(order, byId, options) {
+	const { maxDepth, cutoffWall, anchorTypes, checkpointTipId, branchTipId } = options
 	const branchOrder = authzFoldOrderIds(order, byId, branchTipId)
 	const branchSet = new Set(branchOrder)
 	if (!branchSet.size) return new Set()

package/overlay/index.mjs

@@ -131,15 +131,15 @@ export function createOverlayRouter(registry, ttl = 3) {
 		/**
 		 * 发现到目标节点的签名路由路径。
 		 * @param {string} targetNodeHash 目标节点 64 hex
-		 * @param {object} [opts] 选项
-		 * @param {number} [opts.ttl] 路由 TTL
-		 * @param {number} [opts.timeoutMs] 超时毫秒
+		 * @param {object} [options] 选项
+		 * @param {number} [options.ttl] 路由 TTL
+		 * @param {number} [options.timeoutMs] 超时毫秒
 		 * @returns {Promise<string[]>} 从本节点到目标的 nodeHash 路径
 		 */
-		async discoverRoute(targetNodeHash, opts = {}) {
+		async discoverRoute(targetNodeHash, options = {}) {
 			const reqId = randomMsgIdHex()
-			const maxTtl = Number(opts.ttl) || ttl
-			const timeoutMs = Number(opts.timeoutMs) || 10_000
+			const maxTtl = Number(options.ttl) || ttl
+			const timeoutMs = Number(options.timeoutMs) || 10_000
 			const promise = new Promise((resolve, reject) => {
 				const timer = setTimeout(() => {
 					pendingRoutes.delete(reqId)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@steve02081504/fount-p2p",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "fount federation P2P layer — link, trust graph, mailbox, DAG, EVFS.",
 	"keywords": [
 		"network",
@@ -39,8 +39,9 @@
 		"./schemas/*": "./schemas/*.mjs",
 		"./node/*": "./node/*.mjs",
 		"./discovery": "./discovery/index.mjs",
+		"./discovery/bt": "./discovery/bt/index.mjs",
+		"./discovery/bt/*": "./discovery/bt/*.mjs",
 		"./discovery/*": "./discovery/*.mjs",
-		"./link/*": "./link/*.mjs",
 		"./transport/*": "./transport/*.mjs",
 		"./rooms/*": "./rooms/*.mjs",
 		"./overlay": "./overlay/index.mjs",

package/registries/inbound.mjs

@@ -10,11 +10,11 @@
  */
 
 /**
- * @typedef {(ctx: InboundContext, message: object) => Promise<PartInvokeResponse | null>} RpcInboundHandler
+ * @typedef {(inboundContext: InboundContext, message: object) => Promise<PartInvokeResponse | null>} RpcInboundHandler
  */
 
 /**
- * @typedef {(ctx: InboundContext, message: object) => Promise<void>} DeliveryInboundHandler
+ * @typedef {(inboundContext: InboundContext, message: object) => Promise<void>} DeliveryInboundHandler
  */
 
 /** @type {Map<string, RpcInboundHandler>} */
@@ -42,27 +42,27 @@ export function registerDeliveryInboundHandler(type, handler) {
 }
 
 /**
- * @param {InboundContext} ctx 入站上下文
+ * @param {InboundContext} inboundContext 入站上下文
  * @param {object} message 已校验的线载荷（含 type）
  * @returns {Promise<PartInvokeResponse | null>} 处理器返回值
  */
-export async function dispatchRpcInbound(ctx, message) {
+export async function dispatchRpcInbound(inboundContext, message) {
 	const type = String(message?.type || '').trim()
 	if (!type) return null
 	const handler = rpcHandlers.get(type)
 	if (!handler) return null
-	return handler(ctx, message)
+	return handler(inboundContext, message)
 }
 
 /**
- * @param {InboundContext} ctx 入站上下文
+ * @param {InboundContext} inboundContext 入站上下文
  * @param {object} message 已校验的线载荷（含 type）
  * @returns {Promise<void>}
  */
-export async function dispatchDeliveryInbound(ctx, message) {
+export async function dispatchDeliveryInbound(inboundContext, message) {
 	const type = String(message?.type || '').trim()
 	if (!type) return
 	const handler = deliveryHandlers.get(type)
 	if (!handler) return
-	await handler(ctx, message)
+	await handler(inboundContext, message)
 }