@steve02081504/fount-p2p 0.0.44 → 0.0.48

package/AGENTS.md

@@ -3,7 +3,7 @@
 ## Package layers (`@steve02081504/fount-p2p`)
 
 | Layer | Directory | Role |
-|---|---|---|
+| --- | --- | --- |
 | L0 | `core/` | IDs, logical entity, canonical JSON, bytes |
 | L1 | `crypto/`, `wire/`, `schemas/` | Crypto, wire ingress, canonical validation |
 | L2 | `node/` | `initNode`, identity, entity store, denylist, reputation, storage plugins |
@@ -19,18 +19,19 @@ Detail docs: [transports](docs/transports.md) · [mesh](docs/mesh.md) · [signal
 ### Runtime: isomorphic vs Node
 
 | Surface | Runtime | Notes |
-|---|---|---|
+| --- | --- | --- |
 | `core/*` | Node + browser | No `node:*` builtins |
 | `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`).
+**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 monorepo root (offline) — the page lives in `pages/`, the package in `js/` — injects an importmap into served HTML (`https://esm.sh/@steve02081504/fount-p2p/` → local `js/` 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
 
 - Prefer shared helpers under `utils/`, `core/`, `wire/subscribe`, `wire/adapter` — do not reimplement LRU/TTL/inflight/atomic-fs/shuffle.
+- **JSONL read-modify-write:** do it inside `withAsyncMutex(jsonlMutexKey(path))`. `rewriteJsonlKeeping` / `appendJsonlSynced` / `writeJsonlSynced` take that per-file mutex themselves and are **not reentrant** — never call them while already holding the same key (use lock-free `writeJsonl` / `writeJsonlLines` instead). Rewrites preserve the original raw line (a `sanitize` passed to `rewriteJsonlKeeping` / `readJsonlEntries` only affects the value handed to the predicate) and skip the rename when nothing is dropped.
 - **No pure-forward aliases:** do not add `fooText`/`fooAlias` that only `return foo(sameArgs)` when the callee already accepts those types (e.g. never wrap `sha256Hex` as `sha256TextHex`). Domain names must add logic or type narrowing, not just rename.
 - **Heterogeneous backends:** normalize at the load boundary (e.g. `link/rtc/ice_local_hostname.mjs` wraps W3C RTC backends); call sites speak one contract.
 - **File naming:** parent directory is scope — short child names. Tunables default `<dir>/tunables.json` (exception: `schemas/part_query.tunables.json`). Subpath `package.json` exports mirror filenames.
@@ -46,12 +47,24 @@ Deno / native / BT: [runtime.md](docs/runtime.md).
 - `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))
+- `npm run test:checks` — the three static-health suites below only
+- `npm run check:text_lf:fix` — rewrite line-ending violations (the suites themselves never write)
 - `node scripts/check-imports.mjs` — relative import check
 - `node scripts/find-unused-exports.mjs` — dead-export scan (`--fount <path>` optional)
 - Assertions: `test/helpers/assert.mjs`
 - Fixed-seed identity: `test/helpers/identity.mjs`
 - Mock discovery: `test/helpers/mock_discovery.mjs`
 
+## Static checks (`scripts/checks/`, ported from fount's check standard)
+
+| Check | Enforces |
+| --- | --- |
+| `text_lf` | Every UTF-8 text file (fatal decode, no NUL / C0 control byte; empty files exempt) uses LF, ends with exactly one LF (single-line `.svg` instead ends with none), and does not start with LF (leading UTF-8 BOM skipped). Binary files such as `gradle-wrapper.jar` are skipped. Scanner: `scripts/checks/text_lf.mjs`; `npm run check:text_lf:fix` writes the fix |
+| `jsdoc_no_english` | JSDoc summaries are Chinese (CJK required; a pure-English summary or a missing summary fails); multi-line blocks put a line break right after `/**` and before `*/`. Tag-only blocks (`@param` / `@typedef` …) are fine, empty `/** */` stubs are not. Scanner: `scripts/checks/jsdoc_no_english.mjs` |
+| `agents_md_english` | Every `AGENTS.md` and each `.md` reachable through its local links is English (no CJK) and its links resolve; a non-`AGENTS.md` doc in that closure must live under a `docs/` directory. Scanner: `scripts/checks/agents_md_english.mjs` |
+
+The scanners run from `js/test/pure/*.test.mjs` (repo-wide scope: they walk up to the monorepo root, so `kotlin/AGENTS.md` and the root docs are covered too). Docs language is unified to English — write agent docs and `.md` in the AGENTS.md closure in English.
+
 ## Hard rules
 
 ### Trust / ingress
@@ -76,7 +89,7 @@ Deno / native / BT: [runtime.md](docs/runtime.md).
 ## Tunables JSON
 
 | File | Directory |
-|---|---|
+| --- | --- |
 | `tunables.json` | `transport/`, `infra/`, `reputation/`, `trust_graph/`, `mailbox/`, `governance/`, `dag/` |
 | `part_query.tunables.json` | `schemas/` |
 

package/dag/storage.mjs

@@ -1,7 +1,7 @@
 import { Buffer } from 'node:buffer'
 import { createReadStream, createWriteStream } from 'node:fs'
-import { appendFile, mkdir, open, readFile, writeFile } from 'node:fs/promises'
-import { dirname } from 'node:path'
+import { appendFile, mkdir, open, unlink, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
 import { createInterface } from 'node:readline'
 import { Readable } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
@@ -29,26 +29,52 @@ function parseJsonlLine(line, sanitize) {
 }
 
 /**
- * 读取 JSONL 文件并解析为对象数组；缺失或读失败时返回空数组。
+ * 逐行读取 JSONL 原始行（不解析、不净化）。文件缺失（ENOENT）视为空流，
+ * 兼容 cleanup 竞态：群目录被删后台仍在尾巴上读它；其他读错误抛出。
+ * @param {string} filePath 文件路径
+ * @returns {AsyncGenerator<string>} 原始行（readline 已去掉行尾换行）
+ */
+async function* readJsonlRawLines(filePath) {
+	const input = createReadStream(filePath, { encoding: 'utf8' })
+	// stream 内部异步 open 失败会触发 'error' 事件；提前订阅避免 unhandled error，
+	// 真实错误仍由下方 for-await 抛出，由本函数统一收口。
+	input.on('error', () => { })
+	const lines = createInterface({ input, crlfDelay: Infinity })
+	try {
+		for await (const line of lines) yield line
+	}
+	catch (error) {
+		if (error?.code !== 'ENOENT') throw error
+	}
+}
+
+/**
+ * 读取 JSONL 为 `{ row, raw }` 列表，保留原始行以便无损写回。
+ * 空行/解析失败/净化抛错的行跳过；文件缺失（ENOENT）返回空数组，其他读错误抛出。
+ * @param {string} filePath 文件路径
+ * @param {{ sanitize?: (row: object) => object }} [options] 行净化
+ * @returns {Promise<Array<{ row: object, raw: string }>>} 行条目列表
+ */
+export async function readJsonlEntries(filePath, options = {}) {
+	const sanitize = options.sanitize ?? (row => row)
+	/** @type {Array<{ row: object, raw: string }>} */
+	const entries = []
+	for await (const raw of readJsonlRawLines(filePath)) {
+		const row = parseJsonlLine(raw, sanitize)
+		if (row != null) entries.push({ row, raw })
+	}
+	return entries
+}
+
+/**
+ * 读取 JSONL 文件并解析为对象数组；缺失（ENOENT）返回空数组，其他读错误抛出。
  * @param {string} filePath 文件系统路径
  * @param {{ sanitize?: (row: object) => object }} [options] 可选净化函数
  * @returns {Promise<object[]>} 各行解析后的对象列表
  */
 export async function readJsonl(filePath, options = {}) {
-	try {
-		const text = await readFile(filePath, 'utf8')
-		const sanitize = options.sanitize ?? (row => row)
-		/** @type {object[]} */
-		const rows = []
-		for (const line of text.split('\n')) {
-			const row = parseJsonlLine(line, sanitize)
-			if (row) rows.push(row)
-		}
-		return rows
-	}
-	catch {
-		return []
-	}
+	const entries = await readJsonlEntries(filePath, options)
+	return entries.map(entry => entry.row).filter(Boolean)
 }
 
 /**
@@ -60,69 +86,93 @@ export async function readJsonl(filePath, options = {}) {
  */
 export async function* readJsonlStream(filePath, options = {}) {
 	const sanitize = options.sanitize ?? (row => row)
-	const input = createReadStream(filePath, { encoding: 'utf8' })
-	// stream 内部异步 open 失败会触发 'error' 事件；提前订阅避免 unhandled error，
-	// 真实错误仍由下方 for-await 抛出，被外层 try/catch 收口。
-	input.on('error', () => { })
-	const lines = createInterface({ input, crlfDelay: Infinity })
-	try {
-		for await (const line of lines) {
-			const row = parseJsonlLine(line, sanitize)
-			if (row) yield row
-		}
-	}
-	catch (error) {
-		if (error?.code !== 'ENOENT') throw error
+	for await (const line of readJsonlRawLines(filePath)) {
+		const row = parseJsonlLine(line, sanitize)
+		if (row) yield row
 	}
 }
 
 /**
- * 流式过滤重写 JSONL：保留 `keep(row)===true` 的行。
+ * 流式过滤重写 JSONL：保留 `keep(row)===true` 的行，写回的是原始行字节，
+ * `sanitize` 只影响传给 `keep` 的值。
+ *
+ * 在 `jsonlMutexKey(filePath)` 互斥锁内执行；调用方不得已持有同一文件的锁（不可重入）。
  * @param {string} filePath 目标路径
- * @param {(row: object) => boolean} keep 保留谓词
+ * @param {(row: object) => boolean | Promise<boolean>} keep 保留谓词（可异步）
  * @param {{ sanitize?: (row: object) => object }} [options] 读行净化
  * @returns {Promise<{ kept: number, dropped: number }>} 统计
  */
 export async function rewriteJsonlKeeping(filePath, keep, options = {}) {
-	const dir = dirname(filePath)
-	await mkdir(dir, { recursive: true })
+	return withAsyncMutex(jsonlMutexKey(filePath), () => rewriteJsonlKeepingUnlocked(filePath, keep, options))
+}
+
+/**
+ * `rewriteJsonlKeeping` 的无锁实现，调用方须已持有该文件互斥锁。
+ * @param {string} filePath 目标路径
+ * @param {(row: object) => boolean | Promise<boolean>} keep 保留谓词（可异步）
+ * @param {{ sanitize?: (row: object) => object }} [options] 读行净化
+ * @returns {Promise<{ kept: number, dropped: number }>} 统计
+ */
+async function rewriteJsonlKeepingUnlocked(filePath, keep, options = {}) {
+	const sanitize = options.sanitize ?? (row => row)
 	const temporaryPath = atomicTemporaryPath(filePath)
-	/** @type {object[]} */
+	let tempCreated = false
+	/** @type {string[]} */
 	const buffer = []
 	let kept = 0
 	let dropped = 0
-	/** @returns {Promise<void>} */
+	/** @returns {Promise<void>} 将缓冲区原始行写入临时文件 */
 	const flush = async () => {
 		if (!buffer.length) return
-		let block = ''
-		for (const row of buffer)
-			block += `${JSON.stringify(row)}\n`
+		const block = buffer.map(line => `${line}\n`).join('')
 		await appendFile(temporaryPath, block, 'utf8')
+		tempCreated = true
 		buffer.length = 0
 	}
 	try {
-		for await (const row of readJsonlStream(filePath, options))
-			if (keep(row)) {
-				buffer.push(row)
+		for await (const raw of readJsonlRawLines(filePath)) {
+			if (!raw.trim()) continue
+			const row = parseJsonlLine(raw, sanitize)
+			if (row == null) {
+				dropped++
+				continue
+			}
+			if (await keep(row)) {
+				buffer.push(raw)
 				kept++
-				if (buffer.length >= WRITE_JSONL_CHUNK_LINES)
-					await flush()
+				if (buffer.length >= WRITE_JSONL_CHUNK_LINES) await flush()
 			}
 			else dropped++
+		}
 		await flush()
-	}
-	catch { /* source missing */ }
-	if (kept > 0 || dropped > 0)
+		if (dropped === 0) {
+			if (tempCreated) await unlink(temporaryPath).catch(() => { })
+			return { kept, dropped }
+		}
+		await mkdir(dirname(filePath), { recursive: true })
+		if (!tempCreated) {
+			await writeFile(temporaryPath, '', 'utf8')
+			tempCreated = true
+		}
+		const fileHandle = await open(temporaryPath, 'r+')
+		try {
+			await fileHandle.sync()
+		}
+		finally {
+			await fileHandle.close()
+		}
 		await finalizeAtomicRename(temporaryPath, filePath)
-	else
-		try { await writeFile(filePath, '', 'utf8') }
-		catch { /* ok */ }
-
-	return { kept, dropped }
+		return { kept, dropped }
+	}
+	catch (error) {
+		if (tempCreated) await unlink(temporaryPath).catch(() => { })
+		throw error
+	}
 }
 
 /**
- * 读取 JSONL 末行事件的 `id`（DAG tip）；空文件为 null。
+ * 读取 JSONL 末条可解析事件的 `id`（DAG tip）；从文件尾部最多读 1 MiB，
+ * 跳过撕裂/坏行后取最后一个非空且 `id` 非 null 的行；空文件或缺失为 null。
  * @param {string} filePath 文件路径
  * @returns {Promise<string | null>} tip event id
  */
@@ -132,14 +182,20 @@ export async function readJsonlTipId(filePath) {
 		try {
 			const { size } = await fh.stat()
 			if (!size) return null
-			const chunk = Math.min(size, 65_536)
+			const chunk = Math.min(size, 1_048_576)
 			const buffer = Buffer.alloc(chunk)
 			await fh.read(buffer, 0, chunk, size - chunk)
-			const lines = buffer.toString('utf8').split('\n').filter(Boolean)
-			const last = lines[lines.length - 1]
-			if (!last) return null
-			const row = JSON.parse(last)
-			return row?.id != null ? String(row.id) : null
+			const lines = buffer.toString('utf8').split('\n')
+			for (let index = lines.length - 1; index >= 0; index--) {
+				const line = lines[index].trim()
+				if (!line) continue
+				try {
+					const row = JSON.parse(line)
+					if (row && typeof row === 'object' && row.id != null) return String(row.id)
+				}
+				catch { /* 撕裂/坏行：继续向前找 */ }
+			}
+			return null
 		}
 		finally {
 			await fh.close()
@@ -151,30 +207,50 @@ export async function readJsonlTipId(filePath) {
 }
 
 /**
- * 流式重写 JSONL（临时文件 + rename），避免大数组 join 的内存峰值。
+ * 流式写入原始 JSONL 行（临时文件 + fsync + rename），每行自动补 `\n`。
+ * 不取锁——调用方需自行持有 `jsonlMutexKey(filePath)`。
  * @param {string} filePath 目标路径
- * @param {object[]} records 行对象列表
+ * @param {Iterable<string>} lines 原始行（不含换行）
  * @returns {Promise<void>}
  */
-export async function writeJsonl(filePath, records) {
+export async function writeJsonlLines(filePath, lines) {
 	const dir = dirname(filePath)
 	await mkdir(dir, { recursive: true })
 	const temporaryPath = atomicTemporaryPath(filePath)
-	/** @returns {Generator<string>} JSONL 行 */
-	function* lines() {
-		for (const rec of records)
-			yield `${JSON.stringify(rec)}\n`
+	/** @returns {Generator<string>} 带换行的行 */
+	function* withEol() {
+		for (const line of lines)
+			yield `${line}\n`
+	}
+	await pipeline(Readable.from(withEol()), createWriteStream(temporaryPath, { encoding: 'utf8' }))
+	const fileHandle = await open(temporaryPath, 'r+')
+	try {
+		await fileHandle.sync()
+	}
+	finally {
+		await fileHandle.close()
 	}
-	await pipeline(Readable.from(lines()), createWriteStream(temporaryPath, { encoding: 'utf8' }))
 	await finalizeAtomicRename(temporaryPath, filePath)
 }
 
+/**
+ * 流式重写 JSONL（临时文件 + fsync + rename），避免大数组 join 的内存峰值。
+ * 不取锁——`mailbox/store.mjs` 等调用方在自己的 `jsonlMutexKey` 锁内调用；
+ * 需要锁时用 `writeJsonlSynced`。
+ * @param {string} filePath 目标路径
+ * @param {object[]} records 行对象列表
+ * @returns {Promise<void>}
+ */
+export async function writeJsonl(filePath, records) {
+	return writeJsonlLines(filePath, records.map(record => JSON.stringify(record)))
+}
+
 /**
  * @param {string} filePath JSONL 路径
- * @returns {string} 进程内互斥键
+ * @returns {string} 进程内互斥键（路径已规范化为绝对路径）
  */
 export function jsonlMutexKey(filePath) {
-	return `jsonl:${filePath}`
+	return `jsonl:${resolve(filePath)}`
 }
 
 /**
@@ -188,21 +264,23 @@ export async function writeJsonlSynced(filePath, records) {
 }
 
 /**
- * 追加一行 JSONL 并 `fsync`。
+ * 追加一行 JSONL 并 `fsync`；与 rewrite 共用同一 per-file 互斥锁。
  * @param {string} filePath 目标路径
  * @param {object} record 记录对象
  * @returns {Promise<void>}
  */
 export async function appendJsonlSynced(filePath, record) {
-	await mkdir(dirname(filePath), { recursive: true })
-	const fh = await open(filePath, 'a')
-	try {
-		await fh.appendFile(`${JSON.stringify(record)}\n`, 'utf8')
-		await fh.sync()
-	}
-	finally {
-		await fh.close()
-	}
+	return withAsyncMutex(jsonlMutexKey(filePath), async () => {
+		await mkdir(dirname(filePath), { recursive: true })
+		const fh = await open(filePath, 'a')
+		try {
+			await fh.appendFile(`${JSON.stringify(record)}\n`, 'utf8')
+			await fh.sync()
+		}
+		finally {
+			await fh.close()
+		}
+	})
 }
 
 /**

package/discovery/nostr/census.mjs

@@ -21,17 +21,17 @@ import { ensureNodeSeed, getNodeHash } from '../../node/identity.mjs'
 import { getP2PFeatures, isNodeInitialized } from '../../node/instance.mjs'
 import { nodeDebug } from '../../node/log.mjs'
 
-import {
-	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 {
+	CENSUS_TAG_FOUNT,
+	CENSUS_TAG_X,
+	NOSTR_CENSUS_KIND,
+} from './constants.mjs'
 import { resolveRelayConnectTarget } from './relays.mjs'
 
 /** census 订阅标签数组（发布用）。 */

package/discovery/nostr/census_monitor.mjs

@@ -10,6 +10,8 @@
  */
 import { base64ToBytes } from '../../core/bytes_codec.mjs'
 
+import { estimatePopulation } from './census_math.mjs'
+import { CENSUS_TTL_MS, verifyCensusBytes } from './census_verify.mjs'
 import {
 	CENSUS_TAG_FOUNT,
 	CENSUS_TAG_X,
@@ -17,8 +19,6 @@ import {
 	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

package/discovery/nostr/constants.mjs

@@ -57,4 +57,5 @@ export const NOSTR_CENSUS_KIND = 30789
 
 /** census 订阅/发布标签：`t=fount` + `x=census`（subscribeNostrKind 以 rendezvousKey/tagX 匹配）。 */
 export const CENSUS_TAG_FOUNT = 'fount'
+/** census 标签 `x` 的取值（`t=fount` + `x=census` 共同标识 census 事件）。 */
 export const CENSUS_TAG_X = 'census'

package/discovery/nostr/index.mjs

@@ -18,8 +18,8 @@ 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 } from './constants.mjs'
 import {
 	getListenRelays,
 	getPeerRoute,
@@ -203,7 +203,8 @@ async function signNostrEvent(kind, tags, content, secretKey) {
 }
 
 /**
- * 全量发布到给定 relay（任一成功即返回）。
+ * 全量发布到给定 relay：任一成功即返回，其余 relay 的发布留在后台自行结算。
+ * 每个 relay 尝试都有界（连接超时 / OK 超时 / 入队等待上限），故后台不会永久悬挂。
  * @param {string[]} relayUrls 中继 URL 列表
  * @param {object} event 待发布事件
  * @param {AbortSignal} [signal] 取消信号
@@ -212,19 +213,30 @@ 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')
-	let published = false
-	let lastError = null
-	await Promise.allSettled(urls.map(async relayUrl => {
+	const targets = (await Promise.all(urls.map(async relayUrl => {
 		try {
-			const connectTarget = await resolveRelayConnectTarget(relayUrl)
-			if (!connectTarget) return
-			if (await publishViaSharedRelay(relayUrl, event, signal, connectTarget)) published = true
+			return { relayUrl, connectTarget: await resolveRelayConnectTarget(relayUrl) }
 		}
-		catch (error) {
-			lastError = error
+		catch {
+			return { relayUrl, connectTarget: null }
 		}
-	}))
-	if (!published) throw lastError || new Error('nostr: no relay accepted publish')
+	}))).filter(target => target.connectTarget)
+	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 => {
+			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)
+	throw lastError || new Error('nostr: no relay accepted publish')
 }
 
 /**