@steve02081504/fount-p2p 0.0.50 → 0.0.51

package/discovery/nostr/constants.mjs

@@ -26,6 +26,8 @@ export const STALE_PENALTY = 2
 export const NIP66_REFRESH_MS = 6 * 3600 * 1000
 /** 超过此时间未探测视为 stale。 */
 export const PROBE_STALE_MS = 24 * 3600 * 1000
+/** 发布失败后暂时避开 relay，冷却结束后允许再次尝试。 */
+export const PUBLISH_FAILURE_COOLDOWN_MS = 30 * 60 * 1000
 /** 路由退避基数。 */
 export const BACKOFF_BASE_MS = 2000
 /** 路由退避上限。 */

package/discovery/nostr/index.mjs

@@ -26,6 +26,7 @@ import {
 	getPoolByUrl,
 	isRelayDestinationAllowed,
 	probeRelay,
+	recordPublishResult,
 	registerProviderTrustedRelayUrls,
 	resolveRelayConnectTarget,
 	setPeerRoute,
@@ -202,6 +203,20 @@ async function signNostrEvent(kind, tags, content, secretKey) {
 	return { id, pubkey, created_at, kind, tags, content, sig: bytesToHex(await schnorr.sign(hexToBytes(id), secretKey)) }
 }
 
+/**
+ * 记录一次发布结果并回报同一个布尔值，供 `Promise.any` 直接消费。
+ * 调用方已取消时不记：那不是 relay 的过错，不该压它的健康分。
+ * @param {string} relayUrl 中继 URL
+ * @param {boolean} ok 是否成功
+ * @param {AbortSignal} [signal] 取消信号
+ * @returns {boolean} ok
+ */
+function recordPublishOutcome(relayUrl, ok, signal) {
+	if (signal?.aborted) return ok
+	recordPublishResult(relayUrl, ok)
+	return ok
+}
+
 /**
  * 全量发布到给定 relay：任一成功即返回，其余 relay 的发布留在后台自行结算。
  * 每个 relay 尝试都有界（连接超时 / OK 超时 / 入队等待上限），故后台不会永久悬挂。
@@ -213,29 +228,36 @@ async function signNostrEvent(kind, tags, content, secretKey) {
 async function publishEvent(relayUrls, event, signal) {
 	const urls = dedupeRelayUrls(relayUrls)
 	if (!urls.length) throw new Error('nostr: no relay')
-	const targets = (await Promise.all(urls.map(async relayUrl => {
+	/** @type {Map<string, { hostname: string, addresses: string[] }>} */
+	const targets = new Map()
+	await Promise.all(urls.map(async relayUrl => {
 		try {
-			return { relayUrl, connectTarget: await resolveRelayConnectTarget(relayUrl) }
+			const connectTarget = await resolveRelayConnectTarget(relayUrl)
+			if (connectTarget) targets.set(relayUrl, connectTarget)
+			else recordPublishOutcome(relayUrl, false, signal)
 		}
-		catch {
-			return { relayUrl, connectTarget: null }
+		catch (error) {
+			recordPublishOutcome(relayUrl, false, signal)
+			nodeDebug('p2p:nostr relay target resolve fail', { relay: relayUrl, err: String(error?.message || error) })
 		}
-	}))).filter(target => target.connectTarget)
+	}))
+	if (!targets.size) throw new Error('nostr: no relay')
 	let lastError = null
-	if (!targets.length) throw new Error('nostr: no relay')
-	const attempts = targets.map(target => publishViaSharedRelay(target.relayUrl, event, signal, target.connectTarget)
-		.then(ok => {
-			if (ok) return true
-			lastError = new Error(`nostr: relay rejected publish (${target.relayUrl})`)
-			return false
-		}, error => {
+	const accepted = await Promise.any([...targets].map(async ([relayUrl, connectTarget]) => {
+		let ok = false
+		try {
+			ok = await publishViaSharedRelay(relayUrl, event, signal, connectTarget)
+			if (!ok) lastError = new Error(`nostr: relay rejected publish (${relayUrl})`)
+		}
+		catch (error) {
+			if (error?.message === 'nostr: aborted') throw error
 			lastError = error
-			return false
-		}))
-	// 首个成功的 relay 即结算调用方；其余尝试继续在后台跑（失败已就地吞掉，不会变成 unhandled rejection）。
-	const accepted = await Promise.race(attempts.map((attempt, index) => attempt.then(ok => ok ? index : -1)))
-	if (accepted >= 0) return
-	await Promise.all(attempts)
+		}
+		// 快速失败不掩盖稍后成功的 relay：全部尝试各自结算并更新健康度，任一成功即视为发布成功。
+		if (!recordPublishOutcome(relayUrl, ok, signal)) throw new Error('nostr: relay rejected publish')
+		return relayUrl
+	})).catch(() => null)
+	if (accepted) return
 	throw lastError || new Error('nostr: no relay accepted publish')
 }
 

package/discovery/nostr/relays.mjs

@@ -25,6 +25,7 @@ import {
 	NIP66_REFRESH_MS,
 	POOL_CAP,
 	PROBE_STALE_MS,
+	PUBLISH_FAILURE_COOLDOWN_MS,
 	STALE_PENALTY,
 	WORKING_RELAYS_COUNT,
 } from './constants.mjs'
@@ -40,6 +41,8 @@ const NIP66_REQ_LIMIT = 500
 const MAX_NIP66_PROBES_PER_ROUND = 48
 /** NIP-66 候选 probe 并发批大小（有界，避免同轮瞬时打满连接）。 */
 const NIP66_PROBE_BATCH_SIZE = 8
+/** 规范化后的 NIP-66 引导集：它们先当发现源，只有发布成功过才进监听/发布子集。 */
+const NIP66_BOOTSTRAP_RELAY_URLS = new Set(NIP66_BOOTSTRAP_RELAYS.map(normalizeNostrRelayUrl).filter(Boolean))
 
 /** @typedef {'nip66' | 'public' | 'manual' | 'peer'} RelaySource */
 
@@ -52,6 +55,8 @@ const NIP66_PROBE_BATCH_SIZE = 8
  *   lastSuccess: number,
  *   lastFailure: number,
  *   lastProbe: number,
+ *   lastPublishSuccess: number,
+ *   lastPublishFailure: number,
  *   firstSeen: number,
  *   lastSeen: number,
  *   source: RelaySource,
@@ -388,7 +393,8 @@ export function loadRelayPool() {
  * @returns {RelayPoolEntry | null} 规范化条目或 null
  */
 function toRelayEntry(raw, url) {
-	const rttMs = Number(raw?.rttMs)
+	// 失败作废的 RTT 落盘为 null：`Number(null)` 是 0，直接取数会把「没有可信 RTT」变成「0ms 最快」。
+	const rttMs = raw?.rttMs == null ? null : Number(raw.rttMs)
 	return {
 		url,
 		rttMs: Number.isFinite(rttMs) ? Math.round(rttMs) : null,
@@ -397,6 +403,8 @@ function toRelayEntry(raw, url) {
 		lastSuccess: Number(raw?.lastSuccess) || 0,
 		lastFailure: Number(raw?.lastFailure) || 0,
 		lastProbe: Number(raw?.lastProbe) || 0,
+		lastPublishSuccess: Number(raw?.lastPublishSuccess) || 0,
+		lastPublishFailure: Number(raw?.lastPublishFailure) || 0,
 		firstSeen: Number(raw?.firstSeen) || Date.now(),
 		lastSeen: Number(raw?.lastSeen) || Date.now(),
 		source: SOURCE_PRIORITY[String(raw?.source || '')] !== undefined ? raw.source : 'nip66',
@@ -459,6 +467,8 @@ function seedPublicDefaults() {
 			lastSuccess: 0,
 			lastFailure: 0,
 			lastProbe: 0,
+			lastPublishSuccess: 0,
+			lastPublishFailure: 0,
 			firstSeen: now,
 			lastSeen: now,
 			source: 'public',
@@ -489,6 +499,8 @@ export function upsertRelay(input) {
 		if (incoming.lastSuccess) existing.lastSuccess = incoming.lastSuccess
 		if (incoming.lastFailure) existing.lastFailure = incoming.lastFailure
 		if (incoming.lastProbe) existing.lastProbe = incoming.lastProbe
+		if (incoming.lastPublishSuccess) existing.lastPublishSuccess = incoming.lastPublishSuccess
+		if (incoming.lastPublishFailure) existing.lastPublishFailure = incoming.lastPublishFailure
 		if (incoming.rttMs != null) existing.rttMs = incoming.rttMs
 		if (incoming.nips.length) existing.nips = incoming.nips
 		existing.clearnet = existing.clearnet || incoming.clearnet
@@ -545,13 +557,23 @@ export function recordProbeFailure(url) {
 
 /**
  * 记录一次发布结果（与探测共用统计）。
+ * 成功/失败时间戳必须严格递增：同一毫秒内的并发发布否则无法分出先后，会误判 relay 是否已恢复。
  * @param {string} url relay URL
  * @param {boolean} ok 是否成功
  * @returns {void}
  */
 export function recordPublishResult(url, ok) {
-	if (ok) recordProbeSuccess(url, null)
-	else recordProbeFailure(url)
+	const normalized = normalizeNostrRelayUrl(url)
+	if (!normalized) return
+	const entry = ensureEntry(normalized)
+	if (ok) {
+		entry.lastPublishSuccess = Math.max(Date.now(), entry.lastPublishFailure + 1)
+		recordProbeSuccess(normalized, null)
+	}
+	else {
+		entry.lastPublishFailure = Math.max(Date.now(), entry.lastPublishSuccess + 1)
+		recordProbeFailure(normalized)
+	}
 }
 
 /**
@@ -571,6 +593,8 @@ function ensureEntry(url) {
 		lastSuccess: 0,
 		lastFailure: 0,
 		lastProbe: 0,
+		lastPublishSuccess: 0,
+		lastPublishFailure: 0,
 		firstSeen: now,
 		lastSeen: now,
 		source: 'nip66',
@@ -601,11 +625,13 @@ export function clearStale() {
  */
 export function getWorkingRelays() {
 	const now = Date.now()
-	// 合格项：最近一次尝试成功且没过期，或压根还没探测过的引导项。
+	// 合格项：最近一次尝试成功且没过期，或压根还没探测过的引导项；发布失败在冷却期内一律避开。
 	const eligible = [...poolEntries.values()].filter(entry =>
-		entry.successCount === 0
+		(entry.lastPublishFailure <= entry.lastPublishSuccess
+			|| now - entry.lastPublishFailure >= PUBLISH_FAILURE_COOLDOWN_MS)
+		&& (entry.successCount === 0
 			? entry.lastFailure === 0
-			: !latestAttemptFailed(entry.lastFailure, entry.lastSuccess) && now - entry.lastSuccess <= PROBE_STALE_MS)
+			: !latestAttemptFailed(entry.lastFailure, entry.lastSuccess) && now - entry.lastSuccess <= PROBE_STALE_MS))
 	const sorted = sortByHealth(eligible)
 	const pinned = sorted.filter(isPinned)
 	const rest = sorted.filter(entry => !isPinned(entry))
@@ -613,12 +639,13 @@ export function getWorkingRelays() {
 }
 
 /**
- * @returns {RelayPoolEntry[]} 监听/发布子集（仅含工作集内 public/manual）
+ * @returns {RelayPoolEntry[]} 监听/发布子集（NIP-66 引导 relay 需先成功发布）
  */
 export function getListenRelays() {
 	const working = getWorkingRelays()
 	const pinned = working.filter(isPinned)
-	const rest = working.filter(entry => !isPinned(entry))
+	const rest = working.filter(entry => !isPinned(entry)
+		&& (!NIP66_BOOTSTRAP_RELAY_URLS.has(entry.url) || entry.lastPublishSuccess > 0))
 	return dedupeByUrl([...pinned, ...rest.slice(0, Math.max(0, LISTEN_RELAYS_COUNT - pinned.length))])
 }
 

package/docs/nostr_relay_discovery.md

@@ -18,7 +18,9 @@ Source layout (`discovery/nostr/`):
 
 - `public`/`manual` entries are **pinned**: preferred in `working`/`listen` when eligible and never evicted by `clearStale` or pool-cap. Failed or stale pins remain in the pool for retry, but leave the working/listen sets. Pin count may exceed the nominal caps.
 - `nip66`/`peer` entries are disposable: evicted when stale (`PROBE_STALE_MS`) or when the pool exceeds `POOL_CAP`.
-- A relay leaves the working/listen sets when it is **not eligible**: never probed but already failed, or its latest attempt failed, or its last success is older than `PROBE_STALE_MS`. Untested bootstrap entries stay eligible; exclusion never evicts from the pool, so dead relays keep getting retried.
+- A relay leaves the working/listen sets when it is **not eligible**: never probed but already failed, or its latest attempt failed, or its last success is older than `PROBE_STALE_MS`. Untested bootstrap entries stay eligible for the working set; exclusion never evicts from the pool, so dead relays keep getting retried.
+- A **publish** outcome is tracked separately from probes (`lastPublishSuccess`/`lastPublishFailure`): a rejected publish keeps the relay out of the working set for `PUBLISH_FAILURE_COOLDOWN_MS` (30min) even if a later connectivity probe succeeds, and a later accepted publish clears it — a relay that answers a WebSocket probe but refuses our events must not keep advertising capacity.
+- The `NIP66_BOOTSTRAP_RELAYS` set is discovery-only: those URLs are `nip66` entries and are not publish/listen targets until one of our publishes is accepted (`lastPublishSuccess > 0`). Ordinary NIP-66 discoveries stay eligible for publish testing.
 - Configured `relayUrls` override the automatic listen subset; adverts publish this resolved subscription set as `listenNostrRelays`.
 - Fresh nodes are seeded with `DEFAULT_RELAY_URLS` (`source: 'public'`) so `listenRelays` is never empty at cold start.
 - Persistent connections stay bounded by `workingRelays` (`WORKING_RELAYS_COUNT`, max 32); pins influence selection, not simultaneous connections.
@@ -42,7 +44,7 @@ score       = rtt * (1 + failureRate * FAILURE_WEIGHT)             // FAILURE_WE
 score      *= STALE_PENALTY                                        // ×2 if lastProbe older than PROBE_STALE_MS
 ```
 
-Lower is better. A dead entry (`failureCount > 0` and either no successes or a latest failure) scores with `MAX_RTT_MS`, `failureRate = 1`, and its stale RTT discarded, so it can never outrank a live one. `recordProbeSuccess` / `recordProbeFailure` / `recordPublishResult` share the same counters; attempt timestamps advance monotonically so success/failure ordering survives same-millisecond attempts. Writes to `nodeDir/nostr/relays.json` are **throttled** (2s debounce).
+Lower is better. A dead entry (`failureCount > 0` and either no successes or a latest failure) scores with `MAX_RTT_MS`, `failureRate = 1`, and its stale RTT discarded, so it can never outrank a live one. `recordProbeSuccess` / `recordProbeFailure` / `recordPublishResult` share the same counters; attempt timestamps advance monotonically so success/failure ordering survives same-millisecond attempts. The health score itself does not look at publish outcomes — the publish-failure cooldown above is a separate eligibility gate. Writes to `nodeDir/nostr/relays.json` are **throttled** (2s debounce).
 
 ## Persistence
 
@@ -51,7 +53,7 @@ Lower is better. A dead entry (`failureCount > 0` and either no successes or a l
 ```text
 {
   "updatedAt": 1234567890,
-  "nostrRelays": [{ "url", "rttMs", "successCount", "failureCount", "lastSuccess", "lastFailure", "lastProbe", "firstSeen", "lastSeen", "source", "nips", "clearnet", "monitorCount" }],
+  "nostrRelays": [{ "url", "rttMs", "successCount", "failureCount", "lastSuccess", "lastFailure", "lastProbe", "lastPublishSuccess", "lastPublishFailure", "firstSeen", "lastSeen", "source", "nips", "clearnet", "monitorCount" }],
   "peerRoutes": { "<nodeHash64>": { "listenRelays", "peerPool", "lastGoodNostrRelays", "lastSeen" } }
 }
 ```

package/link/pipe.mjs

@@ -422,6 +422,7 @@ export function createLinkPipe(options) {
 		stats() {
 			return {
 				ready,
+				closed,
 				providerId,
 				level,
 				nodeHash: remoteNodeHash,

package/link/providers/webrtc.mjs

@@ -22,6 +22,7 @@ import { LINK_LEVEL_WEBRTC } from './levels.mjs'
 export const ICE_CANDIDATE_SETTLE_MS = 300
 /** gathering 状态轮询间隔。 */
 const ICE_GATHERING_POLL_MS = 50
+const ANSWER_SIGNAL_RETRY_DELAYS_MS = [200, 500]
 /** 一个候选都没收到时，等这么久就放行让 DTLS/数据通道自行判成败。 */
 export const ICE_GATHERING_STALL_MS = ms('3s')
 
@@ -158,6 +159,32 @@ export async function createWebRtcLink(options) {
 		await Promise.resolve(options.signal.send(message))
 	}
 
+	/**
+	 * 发送 answer 信令：暂时性失败按 [ANSWER_SIGNAL_RETRY_DELAYS_MS] 重试。
+	 * 链路已就绪（重协商）或已被换掉/关闭时不再重试——那时重发只会打到过期的会话。
+	 * @param {object} message 待发送的 answer
+	 * @param {() => boolean} isCurrent 该 answer 是否仍属于当前一级与存活的链路
+	 * @returns {Promise<void>}
+	 */
+	async function sendAnswerSignal(message, isCurrent) {
+		for (let attempt = 0; ; attempt++) {
+			if (!isCurrent()) return
+			try {
+				await sendSignal(message)
+				return
+			}
+			catch (error) {
+				// 过期的 answer（换级/换 pc 或链路已关）：直接放弃，不能再靠失败去拆掉当前活链路。
+				if (!isCurrent()) return
+				if (linkReady) throw error
+				const delayMs = ANSWER_SIGNAL_RETRY_DELAYS_MS[attempt]
+				if (delayMs == null) throw error
+				nodeDebug('p2p:webrtc answer signal retry', { attempt: attempt + 1, reason: formatErrorReason(error) })
+				await new Promise(resolve => setTimeout(resolve, delayMs))
+			}
+		}
+	}
+
 	const createPipe = options.createPipe ?? createLinkPipe
 	const pipe = createPipe({
 		providerId: 'webrtc',
@@ -424,11 +451,12 @@ export async function createWebRtcLink(options) {
 					hasCandidates,
 				})
 				try {
-					await sendSignal({
+					const answerPeerConnection = peerConnection
+					await sendAnswerSignal({
 						type: 'description',
 						rung: rungIndex,
 						description: peerConnection.localDescription?.toJSON?.() ?? peerConnection.localDescription ?? answer,
-					})
+					}, () => peerConnection === answerPeerConnection && rungIndex === remoteRung && !pipe.stats().closed)
 				}
 				catch (error) {
 					// 已认证的数据链路不应被后续信令发送失败关闭。

package/package.json

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