@steve02081504/fount-p2p 0.0.28 → 0.0.29

package/discovery/nostr.mjs

@@ -34,6 +34,8 @@ export const NOSTR_CLOSE_GRACE_MS = 1_000
 export const NOSTR_PUBLISH_OK_TIMEOUT_MS = 3_000
 /** 共享 relay 会话断线后重连间隔。 */
 export const NOSTR_RECONNECT_DELAY_MS = 500
+/** 无 sub/publish 工作时共享 relay 空闲回收延迟（给连续 send 复用窗口）。 */
+export const NOSTR_IDLE_DROP_MS = 2_000
 
 /** Nostr network advert 事件 kind（addressable，可存储）。 */
 export const NOSTR_ADVERT_KIND = 30787
@@ -265,9 +267,10 @@ function connectRelay(relayUrl, timeoutMs = NOSTR_CONNECT_TIMEOUT_MS, signal) {
  * @param {string} relayUrl 中继 URL
  * @param {object} event 待发布事件
  * @param {AbortSignal} [signal] 取消信号
+ * @param {() => boolean} [isCurrent] 该尝试是否仍是 publishRequest 的当前尝试（断线重发后过期）
  * @returns {Promise<boolean>} relay 是否接受 EVENT
  */
-function publishEventOnRelay(ws, relayUrl, event, signal) {
+function publishEventOnRelay(ws, relayUrl, event, signal, isCurrent) {
 	return new Promise((resolve, reject) => {
 		if (signal?.aborted) {
 			reject(new Error('nostr: aborted'))
@@ -285,6 +288,8 @@ function publishEventOnRelay(ws, relayUrl, event, signal) {
 			clearTimeout(timer)
 			signal?.removeEventListener('abort', onAbort)
 			ws.off('message', onMessage)
+			// 过期的 in-flight 尝试：只清理自身监听器/定时器，不结算，避免影响重发后的当前尝试。
+			if (!isCurrent()) return
 			if (error) reject(error)
 			else resolve(ok)
 		}
@@ -331,42 +336,93 @@ function publishEventOnRelay(ws, relayUrl, event, signal) {
  * @returns {Promise<void>}
  */
 async function publishEvent(relayUrls, event, signal) {
-	if (!relayUrls.length) throw new Error('nostr: no relay')
+	const urls = dedupeRelayUrls(relayUrls)
+	if (!urls.length) throw new Error('nostr: no relay')
 	let published = false
 	let lastError = null
-	await Promise.allSettled(relayUrls.map(async relayUrl => {
-		if (signal?.aborted) throw new Error('nostr: aborted')
-		const ws = await connectRelay(relayUrl, NOSTR_CONNECT_TIMEOUT_MS, signal)
+	await Promise.allSettled(urls.map(async relayUrl => {
 		try {
-			if (signal?.aborted) throw new Error('nostr: aborted')
-			const ok = await publishEventOnRelay(ws, relayUrl, event, signal)
-			if (ok) published = true
+			if (await publishViaSharedRelay(relayUrl, event, signal)) published = true
 		}
 		catch (error) {
 			lastError = error
-			throw error
-		}
-		finally {
-			dropWebSocket(ws)
 		}
 	}))
 	if (!published) throw lastError || new Error('nostr: no relay accepted publish')
 }
 
 /**
- * 共享 relay 会话：多 SUB 复用同一 URL 的 WebSocket，避免 signal/presence/advert 各建一池。
- * 仍有活跃 sub 时断线会自动重连并重发 REQ。
+ * 一次共享 relay publish 请求：入队（pending）与已派发（inflight）时共用同一结构。
+ * attempt 标识每次实际发送尝试，断线重发会递增；旧的 in-flight 尝试据此自检为过期后自我清理，
+ * 不再结算当前尝试。
+ * @typedef {{
+ *   event: object,
+ *   signal: AbortSignal | undefined,
+ *   attempt: number,
+ *   onAbort: (() => void) | null,
+ *   removeAbort: (() => void) | null,
+ *   resolve: (ok: boolean) => void,
+ *   reject: (err: Error) => void,
+ * }} NostrPublishRequest
+ */
+
+/**
+ * 共享 relay 会话：多 SUB / publish 复用同一 URL 的 WebSocket，避免 signal/presence/advert 各建一池、
+ * 以及每次 send 重开一条连接（内存泄漏）。
+ * 仍有活跃 sub 或待发 publish 时断线会自动重连并重发 REQ / 重发 EVENT。
  * @typedef {{
  *   ws: import('ws').WebSocket | null,
  *   connecting: boolean,
  *   reconnectTimer: ReturnType<typeof setTimeout> | null,
+ *   idleTimer: ReturnType<typeof setTimeout> | null,
  *   subs: Map<string, { filter: object, onEvent: (event: object, relayUrl: string) => void }>,
+ *   pendingPublishes: Array<NostrPublishRequest>,
+ *   inflightPublishes: Array<NostrPublishRequest>,
  * }} SharedRelaySession
  */
 
 /** @type {Map<string, SharedRelaySession>} */
 const sharedRelaySessions = new Map()
 
+/**
+ * 会话是否仍有需要连接的工作（sub 或待发 publish）。
+ * @param {SharedRelaySession} session 会话
+ * @returns {boolean} 是否有活跃工作
+ */
+function hasPendingWork(session) {
+	return session.subs.size  || session.pendingPublishes.length  || session.inflightPublishes.length
+}
+
+/**
+ * 取消会话的空闲回收定时器。
+ * @param {SharedRelaySession} session 会话
+ * @returns {void}
+ */
+function clearIdleDrop(session) {
+	if (!session.idleTimer) return
+	clearTimeout(session.idleTimer)
+	session.idleTimer = null
+}
+
+/**
+ * 会话无 sub 时，待 publish 清空后延迟回收空闲 socket（给连续 send 复用窗口）。
+ * @param {string} relayUrl 中继 URL
+ * @param {SharedRelaySession} session 会话
+ * @returns {void}
+ */
+function scheduleIdleDrop(relayUrl, session) {
+	if (session.subs.size || session.idleTimer) return
+	session.idleTimer = setTimeout(() => {
+		session.idleTimer = null
+		if (!isLiveSharedSession(relayUrl, session) || hasPendingWork(session)) return
+		sharedRelaySessions.delete(relayUrl)
+		clearSharedRelayReconnect(session)
+		if (session.ws) dropWebSocket(session.ws)
+		session.ws = null
+	}, NOSTR_IDLE_DROP_MS)
+	session.idleTimer.unref?.()
+}
+
 /**
  * @param {string} relayUrl 中继 URL
  * @param {SharedRelaySession} session 会话
@@ -408,7 +464,14 @@ function attachSharedRelaySocket(relayUrl, session, ws) {
 	ws.once('close', () => {
 		if (!isLiveSharedSession(relayUrl, session)) return
 		session.ws = null
-		if (!session.subs.size) {
+		// 尚未确认的 inflight publish 重新入队，重连后由 flushPendingPublishes 重发。
+		if (session.inflightPublishes.length) {
+			session.pendingPublishes.push(...session.inflightPublishes)
+			for (const publishRequest of session.inflightPublishes)
+				attachQueuedAbort(session, publishRequest)
+			session.inflightPublishes = []
+		}
+		if (!hasPendingWork(session)) {
 			sharedRelaySessions.delete(relayUrl)
 			return
 		}
@@ -416,6 +479,8 @@ function attachSharedRelaySocket(relayUrl, session, ws) {
 	})
 	for (const [subId, sub] of session.subs)
 		try { ws.send(JSON.stringify(['REQ', subId, sub.filter])) } catch { /* ignore */ }
+	flushPendingPublishes(relayUrl, session, ws)
+	if (!hasPendingWork(session)) scheduleIdleDrop(relayUrl, session)
 }
 
 /**
@@ -433,16 +498,15 @@ function scheduleSharedRelayConnect(relayUrl, session, delayMs = 0) {
 	const start = () => {
 		session.reconnectTimer = null
 		if (!isLiveSharedSession(relayUrl, session) || session.connecting || session.ws) return
-		if (!session.subs.size) {
+		if (!hasPendingWork(session)) {
 			sharedRelaySessions.delete(relayUrl)
 			return
 		}
 		session.connecting = true
 		void connectRelay(relayUrl, NOSTR_CONNECT_TIMEOUT_MS).then(ws => {
 			session.connecting = false
-			if (!isLiveSharedSession(relayUrl, session) || !session.subs.size) {
-				if (!session.subs.size && isLiveSharedSession(relayUrl, session))
-					sharedRelaySessions.delete(relayUrl)
+			if (!isLiveSharedSession(relayUrl, session) || !hasPendingWork(session)) {
+				sharedRelaySessions.delete(relayUrl)
 				dropWebSocket(ws)
 				return
 			}
@@ -454,7 +518,7 @@ function scheduleSharedRelayConnect(relayUrl, session, delayMs = 0) {
 				url: relayUrl,
 				err: String(error?.message || error),
 			})
-			if (!session.subs.size) {
+			if (!hasPendingWork(session)) {
 				sharedRelaySessions.delete(relayUrl)
 				return
 			}
@@ -483,7 +547,10 @@ function acquireSharedRelay(relayUrl) {
 		ws: null,
 		connecting: false,
 		reconnectTimer: null,
+		idleTimer: null,
 		subs: new Map(),
+		pendingPublishes: [],
+		inflightPublishes: [],
 	}
 	sharedRelaySessions.set(relayUrl, session)
 	scheduleSharedRelayConnect(relayUrl, session)
@@ -502,9 +569,10 @@ function releaseSharedRelaySub(relayUrl, subscriptionId) {
 	const { ws } = session
 	if (ws?.readyState === WebSocket.OPEN)
 		try { ws.send(JSON.stringify(['CLOSE', subscriptionId])) } catch { /* ignore */ }
-	if (session.subs.size) return
+	if (hasPendingWork(session)) return
 	sharedRelaySessions.delete(relayUrl)
 	clearSharedRelayReconnect(session)
+	clearIdleDrop(session)
 	if (ws) dropWebSocket(ws)
 }
 
@@ -518,11 +586,112 @@ function releaseSharedRelaySub(relayUrl, subscriptionId) {
  */
 function registerSharedRelaySub(session, subscriptionId, filter, onEvent) {
 	session.subs.set(subscriptionId, { filter, onEvent })
+	clearIdleDrop(session)
 	const { ws } = session
 	if (ws?.readyState !== WebSocket.OPEN) return
 	try { ws.send(JSON.stringify(['REQ', subscriptionId, filter])) } catch { /* ignore */ }
 }
 
+/**
+ * 将已入队的 publish 逐个派发到已打开 socket 上；复用 publishEventOnRelay 等 OK 回执。
+ * 每个 publish 独立携带自己的 message/abort 监听，socket 共享安全。
+ * @param {string} relayUrl 中继 URL
+ * @param {SharedRelaySession} session 会话
+ * @param {import('ws').WebSocket} socket 已打开连接
+ * @returns {void}
+ */
+function flushPendingPublishes(relayUrl, session, socket) {
+	const pending = session.pendingPublishes
+	session.pendingPublishes = []
+	for (const publishRequest of pending) {
+		publishRequest.removeAbort?.()
+		publishRequest.onAbort = null
+		publishRequest.removeAbort = null
+		const attempt = ++publishRequest.attempt
+		session.inflightPublishes.push(publishRequest)
+		void publishEventOnRelay(socket, relayUrl, publishRequest.event, publishRequest.signal, () => publishRequest.attempt === attempt)
+			.then(
+				ok => settleInflightPublish(relayUrl, session, publishRequest, attempt, () => publishRequest.resolve(ok)),
+				error => settleInflightPublish(relayUrl, session, publishRequest, attempt, () => publishRequest.reject(error)),
+			)
+	}
+}
+
+/**
+ * 为队列中的 publish 挂上 abort 处理：先移除监听器（释放 signal 对回调/event/session 的引用），
+ * 再从队列删除并 reject。
+ * @param {SharedRelaySession} session 会话
+ * @param {SharedRelaySession['pendingPublishes'][number]} publishRequest 待发请求
+ * @returns {void}
+ */
+function attachQueuedAbort(session, publishRequest) {
+	const { signal, reject } = publishRequest
+	/**
+	 * 处理 abort 事件
+	 */
+	publishRequest.onAbort = () => {
+		publishRequest.removeAbort?.()
+		const pendingIndex = session.pendingPublishes.indexOf(publishRequest)
+		if (pendingIndex < 0) return
+		session.pendingPublishes.splice(pendingIndex, 1)
+		reject(new Error('nostr: aborted'))
+	}
+	/**
+	 * 移除 abort 监听器
+	 */
+	publishRequest.removeAbort = () => {
+		if (signal) signal.removeEventListener('abort', publishRequest.onAbort)
+	}
+	if (signal) signal.addEventListener('abort', publishRequest.onAbort, { once: true })
+}
+
+/**
+ * publish 在 socket 上得到 OK / 失败 / abort 后结算：从 inflight 移除并 settle。
+ * 仅结算仍与当前 attempt 匹配的请求：断线重发后 attempt 已递增，旧尝试的结算在此短路，
+ * 避免提前结算重发后的当前尝试。已被 requeue（断线重发）的请求不在 inflight，跳过结算。
+ * @param {string} relayUrl 中继 URL
+ * @param {SharedRelaySession} session 会话
+ * @param {SharedRelaySession['inflightPublishes'][number]} publishRequest 已发送请求
+ * @param {number} attempt 本次发送的 attempt 标识
+ * @param {() => void} settle 结算回调（resolve/reject）
+ * @returns {void}
+ */
+function settleInflightPublish(relayUrl, session, publishRequest, attempt, settle) {
+	if (publishRequest.attempt !== attempt) return
+	const inflightIndex = session.inflightPublishes.indexOf(publishRequest)
+	if (inflightIndex < 0) return
+	session.inflightPublishes.splice(inflightIndex, 1)
+	settle()
+	if (!hasPendingWork(session)) scheduleIdleDrop(relayUrl, session)
+}
+
+/**
+ * 通过共享 relay 会话发布 EVENT：复用已打开 socket，避免每次 send 重开一条连接（内存泄漏）。
+ * 无现成连接时入队并触发连接，连上后由 flushPendingPublishes 统一派发。
+ * @param {string} relayUrl 中继 URL
+ * @param {object} event 待发布事件
+ * @param {AbortSignal} [signal] 取消信号
+ * @returns {Promise<boolean>} relay 是否接受 EVENT
+ */
+function publishViaSharedRelay(relayUrl, event, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new Error('nostr: aborted'))
+			return
+		}
+		const session = acquireSharedRelay(relayUrl)
+		clearIdleDrop(session)
+		/** @type {SharedRelaySession['pendingPublishes'][number]} */
+		const publishRequest = { event, signal, attempt: 0, resolve, reject, onAbort: null, removeAbort: null }
+		attachQueuedAbort(session, publishRequest)
+		session.pendingPublishes.push(publishRequest)
+		if (session.ws?.readyState === WebSocket.OPEN)
+			flushPendingPublishes(relayUrl, session, session.ws)
+		else
+			scheduleSharedRelayConnect(relayUrl, session)
+	})
+}
+
 /**
  * 内部：按 rendezvous 键订阅 Nostr kind（topic 不导出）。多订阅共享每 URL 一条连接。
  * @param {string[]} relayUrls 中继 URL 列表

package/package.json

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