@steve02081504/fount-p2p 0.0.40 → 0.0.42

package/AGENTS.md

@@ -24,6 +24,8 @@ Detail docs: [transports](docs/transports.md) · [mesh](docs/mesh.md) · [signal
 | `crypto/crypto.mjs` | Node + browser | `@noble/hashes` + `@noble/curves` only — never `node:crypto` |
 | `crypto/key.mjs` / `crypto/channel.mjs`, disk I/O, LAN/BT, `ws`, CLI / `startNode` | Node (+ Deno bridge) | Do not load the whole package via esm.sh in the browser |
 
+**Browser pages reusing package code:** pages import browser-safe package modules (`core/*`, `crypto/crypto.mjs`, `discovery/nostr/constants|_math|_verify|_monitor`) from esm.sh; their bare `@noble/*` deps resolve via an injected importmap. The frontend static test server (`test/frontend/census_page.test.mjs`) serves the whole package root (offline), injects an importmap into served HTML (`https://esm.sh/@steve02081504/fount-p2p/` → local package root, `@noble/` → `https://esm.sh/@noble/`), and runs the page live against a fake relay (`test/helpers/fake_relay.mjs` with `store`), injecting its `ws://` URL via `?relay=` — no demo mode. Page code stays a thin shell — pass display fn + optional relays; logic lives in the package (`discovery/nostr/census_monitor.mjs`).
+
 Deno / native / BT: [runtime.md](docs/runtime.md).
 
 ## Conventions
@@ -39,7 +41,7 @@ Deno / native / BT: [runtime.md](docs/runtime.md).
 
 ## Tests / tools
 
-- `npm test` — pure + integration (Node; `--test-force-exit`)
+- `npm test` — pure + integration + frontend (Node; `--test-force-exit`)
 - `npm run test:live` — live link / LAN smoke
 - `npm run test:fount` — cross-repo Deno bridge (`test/fount/`); see [runtime.md](docs/runtime.md)
 - `npm run test:sim` — tunables co-evolution (dev-only; [sim/AGENTS.md](sim/AGENTS.md))
@@ -73,7 +75,7 @@ Deno / native / BT: [runtime.md](docs/runtime.md).
 
 | File | Directory |
 |---|---|
-| `tunables.json` | `reputation/`, `trust_graph/`, `mailbox/`, `governance/`, `dag/` |
+| `tunables.json` | `transport/`, `infra/`, `reputation/`, `trust_graph/`, `mailbox/`, `governance/`, `dag/` |
 | `part_query.tunables.json` | `schemas/` |
 
 Sim harness: `sim/tunables_bundle.mjs` (dev-only). See [sim/AGENTS.md](sim/AGENTS.md).

package/discovery/nostr/census.mjs

@@ -15,45 +15,33 @@
  */
 import { Buffer } from 'node:buffer'
 
-import { isHex64, isSignatureHex128 } from '../../core/hexIds.mjs'
-import { keyPairFromSeed, pubKeyHash, sign, verify } from '../../crypto/crypto.mjs'
+import { isHex64 } from '../../core/hexIds.mjs'
+import { keyPairFromSeed, pubKeyHash, sign } from '../../crypto/crypto.mjs'
 import { ensureNodeSeed, getNodeHash } from '../../node/identity.mjs'
 import { getP2PFeatures, isNodeInitialized } from '../../node/instance.mjs'
 import { nodeDebug } from '../../node/log.mjs'
 
 import {
-	CENSUS_MIN_P,
+	CENSUS_TAG_FOUNT,
+	CENSUS_TAG_X,
+	NOSTR_CENSUS_KIND,
+} from './constants.mjs'
+import {
 	CENSUS_TARGET_EVENTS,
 	estimatePopulation,
 	nextInclusionProbability,
 } from './census_math.mjs'
+import { CENSUS_TTL_MS, buildCensusMessage, verifyCensusBytes } from './census_verify.mjs'
 import { resolveRelayConnectTarget } from './relays.mjs'
 
-/** Nostr census 事件 kind（每节点每窗口至多一条，按 nodeHash 去重）。 */
-export const NOSTR_CENSUS_KIND = 30789
-
-/** census 订阅/发布标签：`t=fount` + `x=census`（subscribeNostrKind 以 rendezvousKey/tagX 匹配）。 */
-const CENSUS_TAG_FOUNT = 'fount'
-const CENSUS_TAG_X = 'census'
+/** census 订阅标签数组（发布用）。 */
 const CENSUS_TAGS = [['t', CENSUS_TAG_FOUNT], ['x', CENSUS_TAG_X]]
 
-/** 事件/窗口存活时间（与 advert TTL 一致）。 */
-const CENSUS_TTL_MS = 10 * 60_000
 /** 发布/统计周期。 */
 const CENSUS_INTERVAL_MS = 10 * 60_000
 /** 冷启动初始包含概率。 */
 const CENSUS_INITIAL_P = 0.5
 
-/**
- * @param {number} ts 时间戳（毫秒）
- * @param {string} nodeHash 64 hex 节点 hash
- * @param {number} p 包含概率
- * @returns {Buffer} 待签名消息
- */
-function buildCensusMessage(ts, nodeHash, p) {
-	return Buffer.from(`fount-census\0${ts}\0${nodeHash}\0${p}`, 'utf8')
-}
-
 /**
  * 用指定 seed 身份构建签名 census 包（nodeHash 由 seed 派生）。
  * 供工具与测试构造任意身份的 peer 包。
@@ -75,47 +63,6 @@ export async function buildCensusPacketFromSeed(seedHex, { p, ts = Date.now() })
 	}
 }
 
-/**
- * 校验 census 包（Untrusted ingress）：canonicalize + 验签 + 时间窗 + p 范围。
- * @param {unknown} packet 原始 census 包
- * @param {number} [now=Date.now()] 当前时间（毫秒）
- * @param {number} [ttlMs=CENSUS_TTL_MS] 允许的时间窗
- * @returns {Promise<{ nodeHash: string, p: number, ts: number } | null>} 校验通过返回 nodeHash/p/ts，否则 null
- */
-export async function verifyCensusPacket(packet, now = Date.now(), ttlMs = CENSUS_TTL_MS) {
-	const nodeHash = isHex64(packet?.nodeHash)
-	const nodePubKey = isHex64(packet?.nodePubKey)
-	const sig = isSignatureHex128(packet?.sig)
-	const ts = Number(packet?.ts)
-	const p = Number(packet?.p)
-	if (!nodeHash || !nodePubKey || !sig || !Number.isFinite(ts)) return null
-	if (Math.abs(now - ts) > ttlMs) return null
-	if (!Number.isFinite(p) || p < CENSUS_MIN_P || p > 1) return null
-	try {
-		if (pubKeyHash(Buffer.from(nodePubKey, 'hex')) !== nodeHash) return null
-	}
-	catch {
-		return null
-	}
-	return await verify(Buffer.from(sig, 'hex'), buildCensusMessage(ts, nodeHash, p), Buffer.from(nodePubKey, 'hex')) ? { nodeHash, p, ts } : null
-}
-
-/**
- * 解 base64 content 字节并校验 census 包。
- * @param {Uint8Array} bytes content 解码字节
- * @param {number} [now=Date.now()] 当前时间（毫秒）
- * @param {number} [ttlMs=CENSUS_TTL_MS] 允许的时间窗
- * @returns {Promise<{ nodeHash: string, p: number, ts: number } | null>} 校验通过结果或 null
- */
-export async function verifyCensusBytes(bytes, now = Date.now(), ttlMs = CENSUS_TTL_MS) {
-	try {
-		return await verifyCensusPacket(JSON.parse(Buffer.from(bytes).toString('utf8')), now, ttlMs)
-	}
-	catch {
-		return null
-	}
-}
-
 /** 窗口事件：nodeHash → { p, at }（模块级，与 visibleByHash 同模式）。 */
 const censusEvents = new Map()
 

package/discovery/nostr/census_monitor.mjs

@@ -0,0 +1,403 @@
+/**
+ * 浏览器端人口统计监控器（无 Node 依赖；WebSocket + Ed25519 验签）。
+ *
+ * 供 pages 等纯前端消费：`createPopulationMonitor({ onUpdate, relays, signal })`。
+ * 开始监听即自动：
+ * 1. 连接全部默认（或传入）relay，订阅 census 事件（kind 30789，t=fount / x=census）；
+ * 2. 经 NIP-66（kind 30166）发现更多 relay 并加入监听（断开自动指数退避重连）；
+ * 3. 每轮刷新取人口估计最大的 relay 作为显示源，把
+ *    `{ estimate, sampleSize, eventsInWindow, relayUrl, relays }` 快照传给 onUpdate。
+ */
+import { base64ToBytes } from '../../core/bytes_codec.mjs'
+
+import {
+	CENSUS_TAG_FOUNT,
+	CENSUS_TAG_X,
+	DEFAULT_RELAY_URLS,
+	NIP66_BOOTSTRAP_RELAYS,
+	NOSTR_CENSUS_KIND,
+} from './constants.mjs'
+import { estimatePopulation } from './census_math.mjs'
+import { CENSUS_TTL_MS, verifyCensusBytes } from './census_verify.mjs'
+
+/** NIP-66 relay 注册 kind。 */
+const NIP66_KIND = 30166
+/** NIP-66 发现周期。 */
+const NIP66_REFRESH_MS = 30 * 60_000
+/** 单次 NIP-66 REQ 上限。 */
+const NIP66_REQ_LIMIT = 300
+/** 监控 relay 数上限（防 socket 爆炸）。 */
+const MAX_MONITOR_RELAYS = 32
+/** relay 帧 content 最大长度（超出直接丢弃，避免先 Base64 解码再被拒）。 */
+const MAX_FRAME_BYTES = 16 * 1024
+/** 并发验签任务上限；达上限时多余帧直接丢弃。 */
+const MAX_INFLIGHT_VERIFICATIONS = 8
+/** 单次连接超时。 */
+const CONNECT_TIMEOUT_MS = 10_000
+/** 断线重连指数退避：初始延迟与上限。 */
+const RECONNECT_BASE_MS = 1_000
+const RECONNECT_MAX_MS = 30_000
+/** 事件入库后刷新防抖。 */
+const REFRESH_DEBOUNCE_MS = 300
+/** 无事件时周期刷新默认间隔（也用于 TTL 逐出）。 */
+const DEFAULT_REFRESH_MS = 5_000
+
+/**
+ * 规范化 Nostr relay URL（浏览器端轻量版）：仅 ws/wss，小写 host，去默认端口与尾部斜杠。
+ * @param {unknown} raw 原始 URL
+ * @returns {string | null} 规范化字符串，无效返回 null
+ */
+function normalizeRelayUrl(raw) {
+	const value = String(raw || '').trim()
+	if (!value) return null
+	let url
+	try { url = new URL(value) } catch { return null }
+	if (url.protocol !== 'wss:' && url.protocol !== 'ws:') return null
+	if (!url.hostname) return null
+	url.hostname = url.hostname.toLowerCase()
+	if (url.port && ((url.protocol === 'wss:' && url.port === '443') || (url.protocol === 'ws:' && url.port === '80')))
+		url.port = ''
+	const path = url.pathname.replace(/\/+$/, '') || '/'
+	url.pathname = path
+	return url.toString().replace(/\/$/, '')
+}
+
+/**
+ * @typedef {{
+ *   url: string,
+ *   ws: WebSocket | null,
+ *   subId: string,
+ *   events: Map<string, { p: number, at: number }>,
+ *   inflight: number,
+ *   reconnectDelayMs: number,
+ *   reconnectTimer: ReturnType<typeof setTimeout> | null,
+ * }} RelaySession
+ */
+
+/**
+ * 创建人口统计监控器：立即连接并监听，返回 `{ stop }` 控制句柄。
+ * @param {{
+ *   onUpdate: (snapshot: { estimate: number, sampleSize: number, eventsInWindow: number, relayUrl: string, relays: number }) => void,
+ *   relays?: string[],
+ *   signal?: AbortSignal,
+ *   refreshMs?: number,
+ *   discover?: boolean,
+ *   nip66Bootstrap?: string[],
+ * }} options 选项
+ * @returns {{ stop: () => void }} 停止函数
+ */
+export function createPopulationMonitor(options = {}) {
+	const {
+		onUpdate,
+		relays,
+		signal,
+		refreshMs = DEFAULT_REFRESH_MS,
+		discover = true,
+		nip66Bootstrap = NIP66_BOOTSTRAP_RELAYS,
+	} = options
+	if (typeof onUpdate !== 'function')
+		throw new Error('p2p: population monitor requires onUpdate callback')
+	/** @type {string[]} */
+	const relayUrls = []
+	for (const raw of relays && relays.length ? relays : DEFAULT_RELAY_URLS) {
+		const url = normalizeRelayUrl(raw)
+		if (url && !relayUrls.includes(url)) relayUrls.push(url)
+	}
+	if (!relayUrls.length)
+		throw new Error('p2p: population monitor requires at least one relay url')
+
+	let stopped = false
+	/** @type {Map<string, RelaySession>} */
+	const sessions = new Map()
+	/** @type {ReturnType<typeof setInterval> | null} */
+	let refreshTimer = null
+	/** @type {ReturnType<typeof setTimeout> | null} */
+	let refreshDebounce = null
+	/** @type {ReturnType<typeof setInterval> | null} */
+	let discoveryTimer = null
+
+	/**
+	 * @param {string} url relay URL
+	 * @returns {RelaySession} 新会话
+	 */
+	function createSession(url) {
+		return {
+			url,
+			ws: null,
+			subId: '',
+			events: new Map(),
+			inflight: 0,
+			reconnectDelayMs: RECONNECT_BASE_MS,
+			reconnectTimer: null,
+		}
+	}
+
+	/**
+	 * 连接会话（含指数退避重连调度）。
+	 * @param {RelaySession} session 会话
+	 * @returns {void}
+	 */
+	function connectSession(session) {
+		if (stopped || session.ws) return
+		const ws = new WebSocket(session.url)
+		session.ws = ws
+		const connectTimer = setTimeout(() => { try { ws.close() } catch { /* ignore */ } }, CONNECT_TIMEOUT_MS)
+		/**
+		 * WebSocket 已连接：订阅 census 事件。
+		 * @returns {void}
+		 */
+		const onOpen = () => {
+			if (session.ws !== ws) return
+			clearTimeout(connectTimer)
+			session.reconnectDelayMs = RECONNECT_BASE_MS
+			session.subId = 'census-' + Math.random().toString(36).slice(2)
+			ws.send(JSON.stringify(['REQ', session.subId, {
+				kinds: [NOSTR_CENSUS_KIND],
+				'#t': [CENSUS_TAG_FOUNT],
+				'#x': [CENSUS_TAG_X],
+			}]))
+		}
+		/**
+		 * @param {MessageEvent} event WebSocket 消息事件
+		 * @returns {void}
+		 */
+		const onMessage = event => {
+			if (session.ws !== ws) return
+			handleRelayMessage(session, event.data)
+		}
+		/**
+		 * 连接关闭：清会话并调度重连。
+		 * @returns {void}
+		 */
+		const onClose = () => {
+			clearTimeout(connectTimer)
+			if (session.ws !== ws) return
+			session.ws = null
+			scheduleReconnect(session)
+		}
+		ws.addEventListener('open', onOpen)
+		ws.addEventListener('message', onMessage)
+		ws.addEventListener('close', onClose)
+		ws.addEventListener('error', () => { /* close follows error */ })
+	}
+
+	/**
+	 * 指数退避调度重连（去重保护）。
+	 * @param {RelaySession} session 会话
+	 * @returns {void}
+	 */
+	function scheduleReconnect(session) {
+		if (stopped || session.reconnectTimer) return
+		session.reconnectTimer = setTimeout(() => {
+			session.reconnectTimer = null
+			connectSession(session)
+		}, session.reconnectDelayMs)
+		session.reconnectDelayMs = Math.min(session.reconnectDelayMs * 2, RECONNECT_MAX_MS)
+	}
+
+	/**
+	 * 处理单条 relay 消息：验签 census 帧并入库。
+	 * @param {RelaySession} session 会话
+	 * @param {unknown} data 消息数据
+	 * @returns {void}
+	 */
+	function handleRelayMessage(session, data) {
+		if (session.inflight >= MAX_INFLIGHT_VERIFICATIONS) return
+		if (typeof data !== 'string' || data.length > MAX_FRAME_BYTES) return
+		let parsed
+		try { parsed = JSON.parse(data) } catch { return }
+		if (parsed?.[0] !== 'EVENT' || parsed[1] !== session.subId) return
+		if (parsed[2]?.kind !== NOSTR_CENSUS_KIND) return
+		const content = parsed[2]?.content
+		if (typeof content !== 'string' || content.length > MAX_FRAME_BYTES) return
+		session.inflight++
+		void (async () => {
+			try {
+				const verified = await verifyCensusBytes(base64ToBytes(content))
+				if (!verified) return
+				const existing = session.events.get(verified.nodeHash)
+				if (existing && verified.ts < existing.at) return
+				session.events.set(verified.nodeHash, { p: verified.p, at: verified.ts })
+				scheduleRefresh()
+			}
+			catch { /* ignore malformed */ }
+			finally { session.inflight-- }
+		})()
+	}
+
+	/**
+	 * 会话快照（逐出过期事件后 HT 估计）。
+	 * @param {RelaySession} session 会话
+	 * @returns {{ estimate: number, sampleSize: number, eventsInWindow: number }} 快照
+	 */
+	function sessionSnapshot(session) {
+		const now = Date.now()
+		const events = []
+		for (const [hash, event] of session.events)
+			if (now - event.at > CENSUS_TTL_MS) session.events.delete(hash)
+			else events.push(event)
+		const { estimate, sampleSize } = estimatePopulation(events)
+		return { estimate, sampleSize, eventsInWindow: events.length }
+	}
+
+	/**
+	 * 取人口估计最大的 relay 作为显示源，回调 onUpdate。
+	 * @returns {void}
+	 */
+	function refresh() {
+		let best = null
+		for (const session of sessions.values()) {
+			const snapshot = sessionSnapshot(session)
+			if (!best || snapshot.estimate > best.snapshot.estimate)
+				best = { url: session.url, snapshot }
+		}
+		const chosen = best || { url: relayUrls[0], snapshot: { estimate: 0, sampleSize: 0, eventsInWindow: 0 } }
+		onUpdate({
+			...chosen.snapshot,
+			relayUrl: chosen.url,
+			relays: sessions.size,
+		})
+	}
+
+	/**
+	 * 防抖调度刷新。
+	 * @returns {void}
+	 */
+	function scheduleRefresh() {
+		if (refreshDebounce || stopped) return
+		refreshDebounce = setTimeout(() => {
+			refreshDebounce = null
+			refresh()
+		}, REFRESH_DEBOUNCE_MS)
+	}
+
+	/**
+	 * 单轮 NIP-66 发现：从引导集 + 现有会话拉 kind 30166 候选，加入监听（有界）。
+	 * @returns {Promise<void>}
+	 */
+	async function runDiscovery() {
+		/** @type {string[]} */
+		const candidates = []
+		/** @type {string[]} */
+		const sources = []
+		for (const url of [...nip66Bootstrap, ...sessions.keys()])
+			if (!sources.includes(url)) sources.push(url)
+		await Promise.allSettled(sources.map(url => collectNip66Candidates(url, candidate => {
+			if (!candidates.includes(candidate)) candidates.push(candidate)
+		})))
+		for (const url of candidates) {
+			if (stopped || sessions.size >= MAX_MONITOR_RELAYS) break
+			if (sessions.has(url)) continue
+			const session = createSession(url)
+			sessions.set(url, session)
+			connectSession(session)
+		}
+	}
+
+	/**
+	 * 从单个中继收集 NIP-66 候选（d tag，wss）。
+	 * @param {string} relayUrl 发现源中继
+	 * @param {(candidate: string) => void} onCandidate 候选回调
+	 * @returns {Promise<void>}
+	 */
+	function collectNip66Candidates(relayUrl, onCandidate) {
+		return new Promise(resolve => {
+			let ws
+			let settled = false
+			/** @type {ReturnType<typeof setTimeout> | null} */
+			let quietTimer = null
+			/**
+			 * @returns {void}
+			 */
+			const finish = () => {
+				if (settled) return
+				settled = true
+				clearTimeout(timer)
+				if (quietTimer) clearTimeout(quietTimer)
+				try { ws?.close() } catch { /* ignore */ }
+				resolve()
+			}
+			/** 收到候选后 500ms 无新候选即结束（兼容不响应 EOSE 的中继）。 */
+			const armQuiet = () => {
+				if (quietTimer) clearTimeout(quietTimer)
+				quietTimer = setTimeout(finish, 500)
+			}
+			const timer = setTimeout(finish, CONNECT_TIMEOUT_MS)
+			try { ws = new WebSocket(relayUrl) } catch { finish(); return }
+			/**
+			 * @param {MessageEvent} event WebSocket 消息事件
+			 * @returns {void}
+			 */
+			const onMessage = event => {
+				if (typeof event.data !== 'string') return
+				let parsed
+				try { parsed = JSON.parse(event.data) } catch { return }
+				if (parsed?.[0] === 'EOSE') { finish(); return }
+				if (parsed?.[0] !== 'EVENT' || parsed[2]?.kind !== NIP66_KIND) return
+				const d = (parsed[2]?.tags || []).find(tag => tag?.[0] === 'd')?.[1]
+				const url = normalizeRelayUrl(d)
+				if (url) {
+					onCandidate(url)
+					armQuiet()
+				}
+			}
+			ws.addEventListener('open', () => {
+				const subId = 'nip66-' + Math.random().toString(36).slice(2)
+				ws.send(JSON.stringify(['REQ', subId, { kinds: [NIP66_KIND, 10166], limit: NIP66_REQ_LIMIT }]))
+			})
+			ws.addEventListener('message', onMessage)
+			ws.addEventListener('close', finish)
+			ws.addEventListener('error', () => { /* close follows error */ })
+		})
+	}
+
+	/**
+	 * 启动周期 NIP-66 发现。
+	 * @returns {void}
+	 */
+	function startDiscovery() {
+		void runDiscovery().catch(() => { })
+		discoveryTimer = setInterval(() => { void runDiscovery().catch(() => { }) }, NIP66_REFRESH_MS)
+		discoveryTimer.unref?.()
+	}
+
+	/**
+	 * 停止监控：关闭全部连接与定时器。
+	 * @returns {void}
+	 */
+	function stop() {
+		if (stopped) return
+		stopped = true
+		signal?.removeEventListener('abort', stop)
+		if (refreshTimer) clearInterval(refreshTimer)
+		refreshTimer = null
+		if (refreshDebounce) clearTimeout(refreshDebounce)
+		refreshDebounce = null
+		if (discoveryTimer) clearInterval(discoveryTimer)
+		discoveryTimer = null
+		for (const session of sessions.values()) {
+			if (session.reconnectTimer) clearTimeout(session.reconnectTimer)
+			session.reconnectTimer = null
+			try { session.ws?.close() } catch { /* ignore */ }
+			session.ws = null
+		}
+		sessions.clear()
+	}
+
+	for (const url of relayUrls) {
+		const session = createSession(url)
+		sessions.set(url, session)
+		connectSession(session)
+	}
+	if (discover) startDiscovery()
+	refresh()
+	if (refreshMs > 0) {
+		refreshTimer = setInterval(refresh, refreshMs)
+		refreshTimer.unref?.()
+	}
+	if (signal) {
+		if (signal.aborted) { stop(); return { stop } }
+		signal.addEventListener('abort', stop, { once: true })
+	}
+	return { stop }
+}

package/discovery/nostr/census_verify.mjs

@@ -0,0 +1,65 @@
+/**
+ * census 包验签（Untrusted ingress；Node 与浏览器共用，无 Node 依赖）。
+ *
+ * 签名体：{ nodeHash, nodePubKey, ts, p, sig }，消息 `fount-census\0ts\0nodeHash\0p`，
+ * 用节点身份（Ed25519）签名，nodeHash = sha256(nodePubKey)。
+ */
+import { hexToBytes } from '../../core/bytes_codec.mjs'
+import { isHex64, isSignatureHex128 } from '../../core/hexIds.mjs'
+import { pubKeyHash, verify } from '../../crypto/crypto.mjs'
+
+import { CENSUS_MIN_P } from './census_math.mjs'
+
+/** 事件/窗口存活时间（与 advert TTL 一致）。 */
+export const CENSUS_TTL_MS = 10 * 60_000
+
+/**
+ * @param {number} ts 时间戳（毫秒）
+ * @param {string} nodeHash 64 hex 节点 hash
+ * @param {number} p 包含概率
+ * @returns {Uint8Array} 待签名消息
+ */
+export function buildCensusMessage(ts, nodeHash, p) {
+	return new TextEncoder().encode(`fount-census\0${ts}\0${nodeHash}\0${p}`)
+}
+
+/**
+ * 校验 census 包（Untrusted ingress）：canonicalize + 验签 + 时间窗 + p 范围。
+ * @param {unknown} packet 原始 census 包
+ * @param {number} [now=Date.now()] 当前时间（毫秒）
+ * @param {number} [ttlMs=CENSUS_TTL_MS] 允许的时间窗
+ * @returns {Promise<{ nodeHash: string, p: number, ts: number } | null>} 校验通过返回 nodeHash/p/ts，否则 null
+ */
+export async function verifyCensusPacket(packet, now = Date.now(), ttlMs = CENSUS_TTL_MS) {
+	const nodeHash = isHex64(packet?.nodeHash)
+	const nodePubKey = isHex64(packet?.nodePubKey)
+	const sig = isSignatureHex128(packet?.sig)
+	const ts = Number(packet?.ts)
+	const p = Number(packet?.p)
+	if (!nodeHash || !nodePubKey || !sig || !Number.isFinite(ts)) return null
+	if (Math.abs(now - ts) > ttlMs) return null
+	if (!Number.isFinite(p) || p < CENSUS_MIN_P || p > 1) return null
+	try {
+		if (pubKeyHash(hexToBytes(nodePubKey)) !== nodeHash) return null
+	}
+	catch {
+		return null
+	}
+	return await verify(hexToBytes(sig), buildCensusMessage(ts, nodeHash, p), hexToBytes(nodePubKey)) ? { nodeHash, p, ts } : null
+}
+
+/**
+ * 解 base64 content 字节并校验 census 包。
+ * @param {Uint8Array} bytes content 解码字节
+ * @param {number} [now=Date.now()] 当前时间（毫秒）
+ * @param {number} [ttlMs=CENSUS_TTL_MS] 允许的时间窗
+ * @returns {Promise<{ nodeHash: string, p: number, ts: number } | null>} 校验通过结果或 null
+ */
+export async function verifyCensusBytes(bytes, now = Date.now(), ttlMs = CENSUS_TTL_MS) {
+	try {
+		return await verifyCensusPacket(JSON.parse(new TextDecoder().decode(bytes)), now, ttlMs)
+	}
+	catch {
+		return null
+	}
+}

package/discovery/nostr/constants.mjs

@@ -41,3 +41,20 @@ export const NIP66_BOOTSTRAP_RELAYS = [
 	'wss://relaypag.es',
 	'wss://monitorlizard.nostr1.com',
 ]
+
+/** 默认公共中继（source='public'，永不淘汰；浏览器端人口统计监控亦以此为默认监听集）。 */
+export const DEFAULT_RELAY_URLS = [
+	'wss://relay.nostr.com',
+	'wss://nos.lol',
+	'wss://nostr.bitcoiner.social',
+	'wss://nostr.mom',
+	'wss://relay.snort.social',
+	'wss://relay.primal.net',
+]
+
+/** Nostr census 事件 kind（每节点每窗口至多一条，按 nodeHash 去重）。 */
+export const NOSTR_CENSUS_KIND = 30789
+
+/** census 订阅/发布标签：`t=fount` + `x=census`（subscribeNostrKind 以 rendezvousKey/tagX 匹配）。 */
+export const CENSUS_TAG_FOUNT = 'fount'
+export const CENSUS_TAG_X = 'census'

package/discovery/nostr/index.mjs

@@ -18,9 +18,9 @@ import {
 } from '../internal/signal_crypto.mjs'
 import { noteDiscoveryPeerClue } from '../peer_clue.mjs'
 
+import { DEFAULT_RELAY_URLS } from './constants.mjs'
 import { createNostrCensus } from './census.mjs'
 import {
-	DEFAULT_RELAY_URLS,
 	getListenRelays,
 	getPeerRoute,
 	getPoolByUrl,

package/discovery/nostr/relays.mjs

@@ -15,6 +15,7 @@ import {
 } from '../../node/storage.mjs'
 
 import {
+	DEFAULT_RELAY_URLS,
 	DEFAULT_RTT_MS,
 	FAILURE_WEIGHT,
 	LAST_GOOD_RELAYS_MAX,
@@ -29,13 +30,6 @@ import {
 } from './constants.mjs'
 import { connectRelay, dedupeRelayUrls, pinnedLookup } from './session.mjs'
 
-/** 默认公共中继（source='public'，永不淘汰）。 */
-export const DEFAULT_RELAY_URLS = [
-	'wss://relay.damus.io',
-	'wss://nos.lol',
-	'wss://relay.primal.net',
-]
-
 /** 持久化写盘节流延迟。 */
 const FLUSH_DELAY_MS = 2_000
 /** probe 单次连接超时。 */

package/docs/evfs.md

@@ -40,6 +40,12 @@ Concurrency: `putChunk` / `putChunkFromStream` / `deleteChunk` / the GC delete p
 
 Outer caller timeouts must **not** abort the in-flight work — background fill continues after the caller gives up.
 
+## `fetchChunk` / public-file chunk reads
+
+- `fetchChunk` accepts the same `fanoutTargets` as `fetchManifest`. With targets it fanouts `fed_chunk_get` **only** to that node set; without targets it falls back to node-scope fanout. Same `username`+chunk hash+mode (`targeted`/`public`) is deduped in-flight.
+- `readPublicFile` / `readManifestPlaintext` forward `options.fanoutTargets` to both the manifest fetch and the chunk fetch, so a cross-node public read can pull profile/avatar content straight from the owner node instead of depending on the node-scope fanout.
+- The public (non-targeted) fanout does **not** block the request window on dialing the whole peer pool: already-linked / group-room-reachable peers are sent immediately, and unreachable peers are dialed in the background and re-sent once linked. (`ensureLinkToNode` no longer gates the send.)
+
 ## Non-public (ACL-gated) manifests
 
 - `file-master-key-wrap` / `vault-wrap` / `identity-wrap` manifests carry no author signature, so the remote-acquisition trust boundary is **not** a signature — it is the **fanout target set** plus the **serving node's authorization**.

package/files/chunk/fetch.mjs

@@ -26,10 +26,14 @@ const chunkInflight = createInflightTable({
  *   ciphertextHash: string,
  *   ownerEntityHash?: string,
  *   groupId?: string,
+ *   fanoutTargets?: string[],
  * }} FetchChunkContext
  */
 
 /**
+ * 拉取密文块。默认走 node-scope public 语义；
+ * 传入 `fanoutTargets` 时只向目标集 fanout（public 文件定向拉取，如 profile/avatar 直接向 owner 节点取块）。
+ * 同 username+hash+模式（含规范化目标集）in-flight 去重；本地已缓存块直接返回。
  * @param {FetchChunkContext} context 上下文
  * @returns {Promise<Uint8Array | null>} 密文块
  */
@@ -50,7 +54,7 @@ export async function fetchChunk(context) {
 
 	const shared = beginFedFanoutFetch({
 		inflight: chunkInflight,
-		inflightKey: `${username}\0${hash}`,
+		inflightKeyBase: `${username}\0${hash}`,
 		username,
 		action: 'fed_chunk_get',
 		/**
@@ -69,6 +73,7 @@ export async function fetchChunk(context) {
 			chunkHash: hash,
 			ownerEntityHash: context.ownerEntityHash,
 		}),
+		fanoutTargets: context.fanoutTargets,
 	})
 	if (!shared) return null
 

package/files/evfs.mjs

@@ -32,7 +32,7 @@ function transferKeyDependenciesForReplica(replicaUsername, manifest) {
 /**
  * @param {string} username 拉取身份
  * @param {import('./manifest/normalize.mjs').FileManifest} manifest 清单
- * @param {{ fetchChunk?: Function }} [options] miss 拉取
+ * @param {{ fetchChunk?: Function, fanoutTargets?: string[] }} [options] miss 拉取
  * @returns {Promise<boolean>} 全部 part 是否已就位
  */
 async function ensureManifestPartsLocal(username, manifest, options = {}) {
@@ -43,6 +43,7 @@ async function ensureManifestPartsLocal(username, manifest, options = {}) {
 			ciphertextHash: part.hash,
 			ownerEntityHash: manifest.ownerEntityHash,
 			groupId: manifest.transferKeyDescriptor.groupId,
+			fanoutTargets: options.fanoutTargets,
 		})
 		if (!fetchedChunk) return false
 		await putChunk(part.hash, fetchedChunk)
@@ -94,7 +95,7 @@ export async function storeManifestParts(manifest, partBytes) {
 /**
  * @param {string} replicaUsername 副本用户名
  * @param {import('./manifest/normalize.mjs').FileManifest} manifest 清单
- * @param {{ username?: string, fetchChunk?: Function }} [options] miss 拉取
+ * @param {{ username?: string, fetchChunk?: Function, fanoutTargets?: string[] }} [options] miss 拉取
  * @returns {Promise<Buffer | null>} 明文内容
  */
 export async function readManifestPlaintext(replicaUsername, manifest, options = {}) {
@@ -118,7 +119,7 @@ export async function readManifestPlaintext(replicaUsername, manifest, options =
 /**
  * @param {string} replicaUsername 副本用户名
  * @param {import('./manifest/normalize.mjs').FileManifest} manifest 清单
- * @param {{ username?: string, fetchChunk?: Function }} [options] miss 拉取
+ * @param {{ username?: string, fetchChunk?: Function, fanoutTargets?: string[] }} [options] miss 拉取
  * @returns {Promise<import('node:stream').Readable | null>} 明文流
  */
 export async function readManifestPlaintextStream(replicaUsername, manifest, options = {}) {
@@ -229,10 +230,11 @@ export async function putFileManifestFromStream(parameters) {
 
 /**
  * 读取实体公开文件：本地 miss 时经网络取回签名 manifest，chunk miss 走既有 fetchChunk。
+ * 传入 `fanoutTargets` 时 manifest 与 chunk 拉取均定向到目标集（public 文件跨节点直取 owner 节点，避免 node-scope 大扇出）。
  * @param {string} replicaUsername 副本用户名
  * @param {string} entityHash owner entityHash
  * @param {string} logicalPath EVFS 逻辑路径
- * @param {{ username?: string, fetchChunk?: Function, revalidate?: boolean }} [options] miss 拉取；`revalidate` 强制阻塞等待 fanout 择新
+ * @param {{ username?: string, fetchChunk?: Function, revalidate?: boolean, fanoutTargets?: string[] }} [options] miss 拉取；`revalidate` 强制阻塞等待 fanout 择新
  * @returns {Promise<Buffer | null>} 明文或 null
  */
 export async function readPublicFile(replicaUsername, entityHash, logicalPath, options = {}) {
@@ -243,6 +245,7 @@ export async function readPublicFile(replicaUsername, entityHash, logicalPath, o
 		logicalPath,
 		cache: true,
 		revalidate: options.revalidate === true,
+		fanoutTargets: options.fanoutTargets,
 	})
 	if (!manifest) return null
 	return readManifestPlaintext(replicaUsername, manifest, options)

package/files/fed/fetch_shared.mjs

@@ -1,14 +1,15 @@
 import { randomUUID } from 'node:crypto'
 
 import { resolveNodeHash } from '../chunk/provider_registry.mjs'
-import { fanoutFedFetch } from '../fetch_fanout.mjs'
+import { canonicalizeFanoutTargets, fanoutFedFetch } from '../fetch_fanout.mjs'
 
 /**
  * inflight + pending wait + fanout 共用骨架。
+ * 规范化目标集并拼入 inflight key：`fanoutTargets` 为数组（含空）即定向模式，undefined 为 node-scope public 模式。
  * @template T
  * @param {{
  *   inflight: { acquire: (key: string, start: () => { done: Promise<T | null>, cancel: () => void }) => Promise<T | null> | null },
- *   inflightKey: string,
+ *   inflightKeyBase: string,
  *   username: string,
  *   action: string,
  *   registerWait: (requestId: string) => { done: Promise<T | null>, cancel: () => void },
@@ -19,20 +20,23 @@ import { fanoutFedFetch } from '../fetch_fanout.mjs'
  */
 export function beginFedFanoutFetch({
 	inflight,
-	inflightKey,
+	inflightKeyBase,
 	username,
 	action,
 	registerWait,
 	buildPayload,
 	fanoutTargets,
 }) {
+	const targeted = Array.isArray(fanoutTargets)
+	const canonicalTargets = targeted ? canonicalizeFanoutTargets(fanoutTargets) : undefined
+	const inflightKey = `${inflightKeyBase}\0${targeted ? 'targeted' : 'public'}` + (canonicalTargets?.length ? `\0${canonicalTargets.join('\0')}` : '')
 	return inflight.acquire(inflightKey, () => {
 		const requestId = randomUUID()
 		const wait = registerWait(requestId)
 		void (async () => {
 			try {
 				const { nodeHash } = await resolveNodeHash(username)
-				await fanoutFedFetch(username, action, buildPayload(requestId, nodeHash), fanoutTargets)
+				await fanoutFedFetch(username, action, buildPayload(requestId, nodeHash), canonicalTargets)
 			}
 			catch { /* pending wait 超时/cancel 负责 settle */ }
 		})()

package/files/fetch_fanout.mjs

@@ -32,6 +32,7 @@ export function canonicalizeFanoutTargets(targets) {
 /**
  * 全局 miss 请求扇出：先向已知 peer 定向发送，再 trust-graph top-K fanout。
  * 已直连 / follow hint peer 可能不在 trust-graph top-K（非成员 emoji CAS / Social 预览路径），故先定向发送。
+ * 拨号不阻塞请求窗口：已直连 peer 立即经现有链路投递，未直连 peer 先经群房间/overlay 尝试并后台拨号补发。
  * @param {string} username 用户
  * @param {string} action wire action 名
  * @param {object} payload 请求载荷
@@ -52,8 +53,20 @@ export async function fanoutFedFetch(username, action, payload, fanoutTargets) {
 
 	const graph = await trustGraph.buildMergedGraph(username)
 	const peerTargets = fetchPeerTargets()
-	await Promise.all(peerTargets.map(nodeHash => ensureLinkToNode(nodeHash).catch(() => null)))
-	for (const nodeHash of peerTargets)
-		void trustGraph.sendToNode(username, nodeHash, action, payload, graph)
+	// 已直连 peer 立即经现有链路投递；其余 peer 后台并行：先经群房间/overlay 尝试投递，同时拨号，拨通且首投失败再补发。
+	// 全程不阻塞请求窗口（大 peer 池下 await 全量拨号会超窗口）。
+	const linked = new Set(listLinks().map(({ nodeHash }) => nodeHash))
+	for (const nodeHash of peerTargets) {
+		if (linked.has(nodeHash)) {
+			void trustGraph.sendToNode(username, nodeHash, action, payload, graph)
+			continue
+		}
+		const dialed = ensureLinkToNode(nodeHash).catch(() => null)
+		void trustGraph.sendToNode(username, nodeHash, action, payload, graph).then(async sent => {
+			if (sent) return
+			const link = await dialed
+			if (link) await trustGraph.sendToNode(username, nodeHash, action, payload, graph)
+		})
+	}
 	await trustGraph.fanoutToTopNodes(username, action, payload, FEDERATION_CHUNK_FETCH_FANOUT_K)
 }

package/files/manifest/fetch.mjs

@@ -54,7 +54,7 @@ export async function fetchManifest(context) {
 	const localPromise = loadFileManifest(ownerEntityHash, logicalPath)
 	const shared = beginFedFanoutFetch({
 		inflight: manifestInflight,
-		inflightKey: `${username}\0${expectedKey}\0${targeted ? 'targeted' : 'public'}` + (fanoutTargets?.length ? `\0${fanoutTargets.join('\0')}` : ''),
+		inflightKeyBase: `${username}\0${expectedKey}`,
 		username,
 		action: 'fed_manifest_get',
 		/**

package/infra/service.mjs

@@ -1,4 +1,3 @@
-
 import { isNodeInitialized } from '../node/instance.mjs'
 import { setOverlayRateGate, clearOverlayRateGate } from '../overlay/index.mjs'
 import { getLinkRegistry } from '../transport/link_registry.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@steve02081504/fount-p2p",
-	"version": "0.0.40",
+	"version": "0.0.42",
 	"description": "fount federation P2P layer — link, trust graph, mailbox, DAG, EVFS.",
 	"keywords": [
 		"network",
@@ -84,7 +84,7 @@
 	"optionalDependencies": {
 		"@stoprocent/bleno": "latest",
 		"@stoprocent/noble": "latest",
-		"node-datachannel": "0.33.0"
+		"node-datachannel": "latest"
 	},
 	"allowScripts": {
 		"node-datachannel": true

package/pages/index.html

@@ -17,7 +17,7 @@
 </head>
 <body>
 	<h1>fount 节点人口统计</h1>
-	<p>基于 Nostr census 事件（kind 30789，<code>t=fount</code> / <code>x=census</code>）的采样估计。本页为独立前端实现，仅做展示：在线节点数 = <code>Σ(1/p)</code>（Horvitz–Thompson 估计）。</p>
+	<p>基于 Nostr census 事件（kind 30789，<code>t=fount</code> / <code>x=census</code>）的采样估计。监听逻辑由包内 <code>census_monitor</code> 封装：自动监听默认/传入 relay 并经 NIP-66 发现更多，取人口最大的 relay 作为显示源。在线节点数 = <code>Σ(1/p)</code>（Horvitz–Thompson 估计）。</p>
 	<label>
 		<input type="checkbox" id="toggle" checked>
 		人口统计（census）
@@ -30,7 +30,7 @@
 	<div class="card">
 		<div>采样事件数 <span id="sample-size">0</span> · 窗口内事件 <span id="window-events">0</span></div>
 	</div>
-	<footer id="footer" style="opacity:.6;font-size:.85rem"></footer>
-	<script type="module" src="./app.mjs"></script>
+	<footer id="footer" style="opacity:.6;font-size:.85rem">通过 URL 参数 ?relay=wss://... 指定中继；缺省监听默认 relay。</footer>
+	<script type="module" src="./index.mjs"></script>
 </body>
 </html>

package/pages/index.mjs

@@ -0,0 +1,62 @@
+/**
+ * fount 人口统计前端（薄壳，逻辑由包内 `census_monitor` 封装）。
+ * - `createPopulationMonitor` 自动监听全部默认（或传入）relay、经 NIP-66 发现更多，
+ *   并取人口估计最大的 relay 作为显示源，把 `{ estimate, sampleSize, eventsInWindow, relayUrl, relays }`
+ *   快照连同 relay 地址传给 onUpdate。
+ * - 页面只负责：导入监控器、传显示函数与可选 relay 地址。
+ */
+import { createPopulationMonitor } from 'https://esm.sh/@steve02081504/fount-p2p/discovery/nostr/census_monitor.mjs'
+
+const statusEl = document.querySelector('#status')
+const toggleEl = document.querySelector('#toggle')
+
+const params = new URLSearchParams(location.search)
+const relayUrl = params.get('relay')
+
+/** @type {{ stop: () => void } | null} */
+let monitor = null
+
+/**
+ * @param {{ estimate: number, sampleSize: number, eventsInWindow: number }} snapshot 快照
+ * @returns {void}
+ */
+function render(snapshot) {
+	document.querySelector('#estimate').textContent = snapshot.estimate.toLocaleString('zh-CN', { maximumFractionDigits: 1 })
+	document.querySelector('#sample-size').textContent = String(snapshot.sampleSize)
+	document.querySelector('#window-events').textContent = String(snapshot.eventsInWindow)
+}
+
+/** @returns {void} 启动 live 监控（默认/传入 relay 全交给库） */
+function startLive() {
+	if (monitor) return
+	try {
+		monitor = createPopulationMonitor({
+			relays: relayUrl ? [relayUrl] : undefined,
+			onUpdate: snapshot => {
+				render(snapshot)
+				statusEl.textContent = `监听 ${snapshot.relayUrl}（census，共 ${snapshot.relays} 个 relay）`
+			},
+		})
+	}
+	catch (error) {
+		statusEl.textContent = `中继配置无效：${String(error?.message || error)}`
+	}
+}
+
+/** @returns {void} 停止监控 */
+function stopLive() {
+	monitor?.stop()
+	monitor = null
+}
+
+toggleEl.addEventListener('change', () => {
+	if (!toggleEl.checked) {
+		stopLive()
+		render({ estimate: 0, sampleSize: 0, eventsInWindow: 0 })
+		statusEl.textContent = '已关闭'
+		return
+	}
+	startLive()
+})
+
+if (toggleEl.checked) startLive()

package/pages/app.mjs

@@ -1,172 +0,0 @@
-/**
- * fount 人口统计前端（独立实现，不依赖包内代码）。
- * - 浏览器原生 WebSocket 订阅 Nostr 中继 kind=30789 / #t=fount / #x=census。
- * - 本地用 @noble 验签（懒加载，仅 live 模式需要）。
- * - 在线节点数估计 = Σ(1/p)（HT）。
- * - `?demo=1`（或无 relay 参数）进入演示模式：喂入 20 条 p=0.1 的样本 → 估计 200。
- */
-const CENSUS_KIND = 30789
-const CENSUS_TTL_MS = 10 * 60_000
-const CENSUS_SUB_ID = 'census'
-const CENSUS_MIN_P = 0.001
-/** relay 帧 content 最大长度（超出直接丢弃，避免先 Base64 解码再被拒）。 */
-const MAX_FRAME_BYTES = 16 * 1024
-/** 并发验签任务上限；达上限时多余帧直接丢弃。 */
-const MAX_INFLIGHT_VERIFICATIONS = 8
-
-const statusEl = document.querySelector('#status')
-const toggleEl = document.querySelector('#toggle')
-
-const params = new URLSearchParams(location.search)
-const relayUrl = params.get('relay')
-const demoMode = params.get('demo') === '1' || !relayUrl
-
-/** @type {Map<string, { p: number, at: number }>} */
-const events = new Map()
-let webSocket = null
-let enabled = true
-let inflightVerifications = 0
-
-/**
- * HT 估计；遍历时逐出过期事件，避免窗口 Map 持续增长。
- * @returns {{ estimate: number, sampleSize: number }} 估计与采样数
- */
-function estimatePopulation() {
-	let total = 0
-	let sampleSize = 0
-	const now = Date.now()
-	for (const [hash, { p, at }] of events) {
-		if (!Number.isFinite(at) || now - at > CENSUS_TTL_MS) { events.delete(hash); continue }
-		total += 1 / p
-		sampleSize++
-	}
-	return { estimate: total, sampleSize }
-}
-
-let noblePromise = null
-/** @returns {Promise<[object, object]>} noble 模块 */
-function loadNoble() {
-	return noblePromise ||= Promise.all([
-		import('https://esm.sh/@noble/curves@1/ed25519.js'),
-		import('https://esm.sh/@noble/hashes@1/sha2.js'),
-	])
-}
-
-/**
- * 校验 census 包：nodeHash=sha256(nodePubKey) 且 Ed25519 签名匹配 `fount-census\0ts\0nodeHash\0p`。
- * @param {object} packet 原始包
- * @returns {Promise<{ nodeHash: string, p: number, ts: number } | null>} 验签结果
- */
-async function verifyCensusPacket(packet) {
-	const nodeHash = /^[\da-f]{64}$/u.test(String(packet?.nodeHash ?? '')) ? packet.nodeHash : null
-	const nodePubKey = /^[\da-f]{64}$/u.test(String(packet?.nodePubKey ?? '')) ? packet.nodePubKey : null
-	const sig = /^[\da-f]{128}$/u.test(String(packet?.sig ?? '')) ? packet.sig : null
-	const ts = Number(packet?.ts)
-	const p = Number(packet?.p)
-	if (!nodeHash || !nodePubKey || !sig || !Number.isFinite(ts)) return null
-	if (Math.abs(Date.now() - ts) > CENSUS_TTL_MS) return null
-	if (!Number.isFinite(p) || p < CENSUS_MIN_P || p > 1) return null
-	const [{ ed25519 }, { sha256 }] = await loadNoble()
-	const pubBytes = new Uint8Array(nodePubKey.match(/.{2}/gu).map(hex => parseInt(hex, 16)))
-	if ([...sha256(pubBytes)].map(byte => byte.toString(16).padStart(2, '0')).join('') !== nodeHash) return null
-	const ok = ed25519.verify(
-		new Uint8Array(sig.match(/.{2}/gu).map(hex => parseInt(hex, 16))),
-		new TextEncoder().encode(`fount-census\0${ts}\0${nodeHash}\0${p}`),
-		pubBytes,
-	)
-	return ok ? { nodeHash, p, ts } : null
-}
-
-/** @param {{ nodeHash: string, p: number, ts: number }} verified 已验签 census 包 @returns {void} */
-function ingest(verified) {
-	const existing = events.get(verified.nodeHash)
-	if (existing && verified.ts < existing.at) return
-	events.set(verified.nodeHash, { p: verified.p, at: verified.ts })
-	render()
-}
-
-/** @returns {void} 渲染人口估计 */
-function render() {
-	const { estimate, sampleSize } = estimatePopulation()
-	document.querySelector('#estimate').textContent = estimate.toLocaleString('zh-CN', { maximumFractionDigits: 1 })
-	document.querySelector('#sample-size').textContent = String(sampleSize)
-	document.querySelector('#window-events').textContent = String(events.size)
-}
-
-/** @returns {void} 注入演示数据 */
-function seedDemo() {
-	events.clear()
-	for (let index = 0; index < 20; index++)
-		events.set((index + 1).toString(16).padStart(2, '0').repeat(32), { p: 0.1, at: Date.now() })
-	statusEl.textContent = '演示模式：20 条 p=0.1 样本（HT 估计 = 200）'
-	document.querySelector('#footer').textContent = '演示模式样本为虚构数据；添加 ?relay=wss://... 进入 live 模式。'
-}
-
-/** @returns {void} 连接中继并订阅 */
-function connectRelay() {
-	if (webSocket) {
-		try { webSocket.close() } catch { /* ignore */ }
-		webSocket = null
-	}
-	if (!relayUrl || !enabled) return
-	statusEl.textContent = `连接 ${relayUrl} …`
-	const connection = new WebSocket(relayUrl)
-	webSocket = connection
-	/** WebSocket 已连接后发送 REQ 订阅 census 事件。 */
-	connection.onopen = () => {
-		if (connection !== webSocket || !enabled) return
-		connection.send(JSON.stringify(['REQ', CENSUS_SUB_ID, { kinds: [CENSUS_KIND], '#t': ['fount'], '#x': ['census'] }]))
-		statusEl.textContent = `监听 ${relayUrl}（kind ${CENSUS_KIND}）`
-	}
-	/**
-	 * @param {MessageEvent} rawMessage 中继消息事件
-	 * @returns {void}
-	 */
-	connection.onmessage = rawMessage => {
-		if (connection !== webSocket || !enabled) return
-		if (inflightVerifications >= MAX_INFLIGHT_VERIFICATIONS) return
-		if (typeof rawMessage.data !== 'string' || rawMessage.data.length > MAX_FRAME_BYTES) return
-		let parsed
-		try { parsed = JSON.parse(String(rawMessage.data)) } catch { return }
-		if (parsed?.[0] !== 'EVENT' || parsed[1] !== CENSUS_SUB_ID) return
-		if (parsed[2]?.kind !== CENSUS_KIND) return
-		const content = parsed[2]?.content
-		if (typeof content !== 'string' || content.length > MAX_FRAME_BYTES) return
-		inflightVerifications++
-		void (async () => {
-			try {
-				const verified = await verifyCensusPacket(JSON.parse(atob(content)))
-				if (connection !== webSocket || !enabled) return
-				if (verified) ingest(verified)
-			}
-			catch { /* ignore malformed */ }
-			finally { inflightVerifications-- }
-		})()
-	}
-	/** WebSocket 关闭时更新状态为已断开。 */
-	connection.onclose = () => {
-		if (connection !== webSocket || !enabled) return
-		statusEl.textContent = '已断开'
-	}
-	/** WebSocket 出错时提示中继连接失败。 */
-	connection.onerror = () => {
-		if (connection !== webSocket || !enabled) return
-		statusEl.textContent = '中继连接失败'
-	}
-}
-
-toggleEl.addEventListener('change', () => {
-	enabled = toggleEl.checked
-	if (!enabled) {
-		events.clear()
-		if (webSocket) { try { webSocket.close() } catch { /* ignore */ } webSocket = null }
-		statusEl.textContent = '已关闭'
-	}
-	else if (demoMode) seedDemo()
-	else connectRelay()
-	render()
-})
-
-if (demoMode) seedDemo()
-else connectRelay()
-render()