@steve02081504/fount-p2p 0.0.0

package/link/rtc.mjs

@@ -0,0 +1,109 @@
+import process from 'node:process'
+
+import { getSignalingRuntimeConfig } from '../node/instance.mjs'
+import { wrapRtcPeerConnectionForMdns } from '../transport/rtc_mdns_filter.mjs'
+
+/**
+ * 注册进程退出时销毁 libdatachannel 全部原生资源（仅一次）。
+ * libdatachannel 的原生线程在 pc.close() 后仍需时间回收；进程退出时若原生资源未同步销毁，
+ * Windows 上会触发堆损坏（退出码 0xC0000374）。
+ */
+const { cleanup = undefined } = await import('node-datachannel').catch(console.error)
+process.on('exit', () => {
+	try { cleanup?.() } catch { /* already torn down */ }
+})
+
+/**
+ * 加载 node-datachannel polyfill，并按配置包装 RTCPeerConnection。
+ * @returns {Promise<{ RTCPeerConnection: typeof RTCPeerConnection, RTCIceCandidate: typeof RTCIceCandidate }>} RTC 构造器
+ */
+export async function loadNodeRtcPolyfill() {
+	const mod = await import('node-datachannel/polyfill')
+	const { mdnsPolicy } = getSignalingRuntimeConfig()
+	return {
+		RTCPeerConnection: wrapRtcPeerConnectionForMdns(mod.RTCPeerConnection, mod.RTCIceCandidate, mdnsPolicy),
+		RTCIceCandidate: mod.RTCIceCandidate,
+	}
+}
+
+/**
+ * 绑定 ICE candidate 回调，兼容 onicecandidate 与 onIceCandidate.subscribe。
+ * @param {RTCPeerConnection} pc 对等连接
+ * @param {(event: { candidate: RTCIceCandidate | null }) => void} handler candidate 事件处理器
+ * @returns {void}
+ */
+export function attachIceCandidateListener(pc, handler) {
+	pc.onicecandidate = handler
+	pc.onIceCandidate?.subscribe?.(candidate =>
+		handler({ candidate: candidate ?? null })
+	)
+}
+
+/**
+ * 绑定远端 data channel 回调，兼容 ondatachannel 与 onDataChannel.subscribe。
+ * @param {RTCPeerConnection} pc 对等连接
+ * @param {(event: { channel: RTCDataChannel }) => void} handler data channel 事件处理器
+ * @returns {void}
+ */
+export function attachDataChannelListener(pc, handler) {
+	pc.ondatachannel = handler
+	pc.onDataChannel?.subscribe?.(channel => handler({ channel }))
+}
+
+/**
+ * 等待 data channel 进入 open 或 close 状态，超时则 reject。
+ * @param {RTCDataChannel} channel RTC 数据通道
+ * @param {'open' | 'close'} eventName 目标状态事件名
+ * @param {number} timeoutMs 超时毫秒数
+ * @returns {Promise<void>}
+ */
+export function waitForChannelState(channel, eventName, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		if (eventName === 'open' && channel.readyState === 'open') {
+			resolve()
+			return
+		}
+		if (eventName === 'close' && channel.readyState === 'closed') {
+			resolve()
+			return
+		}
+		const timer = setTimeout(() => {
+			cleanup()
+			reject(new Error(`p2p: data channel ${eventName} timeout after ${timeoutMs}ms`))
+		}, timeoutMs)
+		/**
+		 * 通道状态变化处理函数。
+		 * @returns {void}
+		 */
+		const handler = () => {
+			cleanup()
+			resolve()
+		}
+		/**
+		 * 移除监听器并清除超时定时器。
+		 * @returns {void}
+		 */
+		const cleanup = () => {
+			clearTimeout(timer)
+			channel.removeEventListener?.(eventName, handler)
+			if (eventName === 'open' && channel.onopen === handler) channel.onopen = null
+			if (eventName === 'close' && channel.onclose === handler) channel.onclose = null
+		}
+		channel.addEventListener?.(eventName, handler)
+		if (eventName === 'open') channel.onopen = handler
+		if (eventName === 'close') channel.onclose = handler
+	})
+}
+
+/**
+ * 将信令/消息数据统一转为 Uint8Array。
+ * @param {unknown} data 原始数据（字符串、ArrayBuffer、TypedArray 等）
+ * @returns {Uint8Array} 字节视图
+ */
+export function signalDataToBytes(data) {
+	if (data instanceof Uint8Array) return data
+	if (data instanceof ArrayBuffer) return new Uint8Array(data)
+	if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+	if (typeof data === 'string') return new TextEncoder().encode(data)
+	return new TextEncoder().encode(String(data ?? ''))
+}

package/link/sdp_fingerprint.mjs

@@ -0,0 +1,25 @@
+/**
+ * 将 DTLS fingerprint 规范化为小写 `aa:bb:...` 格式。
+ * @param {unknown} value 原始 fingerprint 字符串
+ * @returns {string | null} 规范化后的 fingerprint，无效时返回 null
+ */
+export function normalizeDtlsFingerprint(value) {
+	const text = String(value ?? '')
+		.trim()
+		.toLowerCase()
+		.replace(/^sha-256\s+/u, '')
+	if (!text) return null
+	const compact = text.replace(/\s+/gu, '')
+	if (!/^([\da-f]{2}:){31}[\da-f]{2}$/u.test(compact)) return null
+	return compact
+}
+
+/**
+ * 从 SDP 文本中提取 SHA-256 DTLS fingerprint。
+ * @param {string} sdp SDP 描述字符串
+ * @returns {string | null} 规范化 fingerprint，未找到时返回 null
+ */
+export function extractDtlsFingerprint(sdp) {
+	const line = String(sdp || '').match(/^a=fingerprint:sha-256\s+([0-9A-Fa-f:]+)$/mu)?.[1]
+	return normalizeDtlsFingerprint(line)
+}

package/mailbox/consumer_registry.mjs

@@ -0,0 +1,71 @@
+/**
+ * Mailbox 投递成功后由 Part 消费 envelope（P2P 不解析 DAG）。
+ */
+
+/** @typedef {(username: string, records: object[]) => Promise<string[]>} MailboxConsumer */
+
+/**
+ * @typedef {{
+ *   handler: MailboxConsumer,
+ * }} MailboxConsumerEntry
+ */
+
+/** @type {Map<string, MailboxConsumerEntry>} */
+const consumers = new Map()
+
+/**
+ * @param {string} app 应用名（与 record.app 匹配）
+ * @param {MailboxConsumer} handler 返回已交付 record id 列表
+ * @returns {void}
+ */
+export function registerMailboxConsumer(app, handler) {
+	consumers.set(String(app), { handler })
+}
+
+/**
+ * @param {string} app 应用名
+ * @returns {void}
+ */
+export function unregisterMailboxConsumer(app) {
+	consumers.delete(String(app))
+}
+
+/**
+ * @param {string} username 副本用户名
+ * @param {object[]} records mailbox 记录
+ * @returns {Promise<string[]>} 所有 consumer 成功交付的 id 并集
+ */
+export async function dispatchMailboxRecordsToConsumers(username, records) {
+	/** @type {Map<string, object[]>} */
+	const grouped = new Map()
+	for (const row of records) {
+		const app = String(row?.app || '')
+		if (!app) continue
+		const bucket = grouped.get(app) || []
+		bucket.push(row)
+		grouped.set(app, bucket)
+	}
+	/** @type {Set<string>} */
+	const delivered = new Set()
+	for (const [app, { handler }] of consumers.entries()) {
+		const scoped = grouped.get(app)
+		if (!scoped?.length) continue
+		try {
+			const ids = await handler(username, scoped)
+			for (const id of ids || []) delivered.add(String(id))
+		}
+		catch (err) {
+			console.error('mailbox: consumer batch failed, retry per record', err)
+			for (const row of scoped)
+				try {
+					const ids = await handler(username, [row])
+					for (const id of ids || []) delivered.add(String(id))
+				}
+				catch (rowErr) {
+					console.error('mailbox: consumer record failed', rowErr)
+				}
+
+		}
+	}
+	return [...delivered]
+}

package/mailbox/deliver_or_store.mjs

@@ -0,0 +1,190 @@
+import { normalizeHex64 } from '../core/hexIds.mjs'
+import { getNodeTransportSettings, getNodeHash } from '../node/identity.mjs'
+import { deliverToUserRoomPeers, ensureUserRoom } from '../transport/user_room.mjs'
+import { DEFAULT_TRUST_GRAPH_OWNER, requireTrustGraphProvider } from '../trust_graph/registry.mjs'
+
+import { allowMailboxRelayForTier } from './importance.mjs'
+import { takeIncomingMailboxPutSlot } from './rate.mjs'
+import { resolveMailboxRoutingForPeerCount } from './settings.mjs'
+import {
+	isDeliverableMailboxRecord,
+	isMailboxRecordWithinSizeLimit,
+	mailboxEnvelopeId,
+	mailboxTierFromHop,
+	normalizeMailboxHop,
+	relayHopAfterWireIngress,
+	storeMailboxRecord,
+	getMailboxRecords,
+} from './store.mjs'
+
+/**
+ * @param {string} username 副本用户名
+ * @param {string} peerId Trystero 对端 id
+ * @returns {Promise<string | null>} 已验证的 remote nodeHash
+ */
+async function resolveRemoteNodeHashForPeer(username, peerId) {
+	if (!peerId) return null
+	const slot = await ensureUserRoom({ replicaUsername: username })
+	const entry = slot?.getRoster()?.find(row => row.peerId === peerId)
+	const remote = entry?.remoteNodeHash?.trim().toLowerCase()
+	return remote || null
+}
+
+/**
+ * @param {object} record 入站 record
+ * @returns {Promise<number>} 本节点应存储的 hop
+ */
+async function resolveRelayHopForIngress(record) {
+	let id
+	try {
+		id = mailboxEnvelopeId(record.envelope)
+	}
+	catch {
+		return relayHopAfterWireIngress(record.hop)
+	}
+	const existing = (await getMailboxRecords([id]))[0]
+	return relayHopAfterWireIngress(record.hop, existing?.hop)
+}
+
+/**
+ * @param {string} username 副本用户名
+ * @returns {Promise<{ maxHop: number, relayFanoutTrusted: number, relayFanoutNormal: number, wantFanout: number, batterySaver: boolean }>} 按在线 peer 数缩放的路由
+ */
+async function resolveRouting(username) {
+	const { batterySaver, mailbox } = getNodeTransportSettings()
+	const slot = await ensureUserRoom({ replicaUsername: username })
+	const peerCount = slot?.getRoster()?.length ?? 0
+	return resolveMailboxRoutingForPeerCount(peerCount, mailbox, batterySaver)
+}
+
+/**
+ * @param {string} username 副本用户名（trust graph 投递上下文）
+ * @param {object} opts 投递选项
+ * @returns {Promise<{ stored: boolean, delivered: boolean, relayed: number }>} 存转结果
+ */
+export async function deliverOrStoreMailboxPut(username, opts) {
+	const routing = await resolveRouting(username)
+	const toPubKeyHash = normalizeHex64(opts.toPubKeyHash)
+	if (!toPubKeyHash) return { stored: false, delivered: false, relayed: 0 }
+	const hop = normalizeMailboxHop(opts.hop)
+	if (hop >= routing.maxHop) return { stored: false, delivered: false, relayed: 0 }
+	const tier = mailboxTierFromHop(hop)
+	const nodeHash = getNodeHash()
+	const record = {
+		...opts.record,
+		toPubKeyHash,
+		hop,
+		tier,
+		fromNodeHash: opts.record?.fromNodeHash || nodeHash,
+	}
+	const stored = await storeMailboxRecord(record)
+	const toNodeHash = opts.toNodeHash?.trim().toLowerCase()
+	const delivered = toNodeHash && isMailboxRecordWithinSizeLimit(record)
+		? await requireTrustGraphProvider(DEFAULT_TRUST_GRAPH_OWNER).sendToNode(username, toNodeHash, 'mailbox_put', { nodeHash, record })
+		: false
+
+	let relayed = 0
+	const relayFanout = tier === 'trusted' ? routing.relayFanoutTrusted : routing.relayFanoutNormal
+	if (stored && hop < routing.maxHop && allowMailboxRelayForTier(tier))
+		relayed = await deliverToUserRoomPeers(username, 'mailbox_put', { record }, null, relayFanout)
+
+	return { stored, delivered, relayed }
+}
+
+/**
+ * @param {string} username 副本用户名
+ * @param {string} toPubKeyHash 收件人
+ * @param {object} record 待发 record
+ * @param {string} [toNodeHash] 已知在线节点时直投
+ * @returns {Promise<{ stored: boolean, delivered: boolean, relayed: number }>} 存转结果
+ */
+export async function publishMailboxRecord(username, toPubKeyHash, record, toNodeHash = '') {
+	return deliverOrStoreMailboxPut(username, {
+		toPubKeyHash,
+		toNodeHash: toNodeHash || undefined,
+		record: { ...record, toPubKeyHash },
+		hop: 0,
+	})
+}
+
+/**
+ * @param {{ replicaUsername?: string }} ctx 入站上下文
+ * @param {object} put 入站 mailbox_put
+ * @param {string} [peerId] Trystero 对端 id（有则校验 nodeHash 绑定）
+ * @returns {Promise<void>}
+ */
+export async function ingestMailboxPut(ctx, 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()
+	if (!username) return
+	if (peerId) {
+		const remote = await resolveRemoteNodeHashForPeer(username, peerId)
+		if (!remote || remote !== fromNode) return
+	}
+	const routing = await resolveRouting(username)
+	const relayHop = await resolveRelayHopForIngress(record)
+	if (relayHop >= routing.maxHop) return
+	await deliverOrStoreMailboxPut(username, {
+		toPubKeyHash: record.toPubKeyHash,
+		record: {
+			...record,
+			fromNodeHash: fromNode,
+		},
+		hop: relayHop,
+	})
+}
+
+/**
+ * @param {object} want mailbox_want 载荷
+ * @param {(payload: unknown, peerId: string) => void} sendGive mailbox_give 发送回调
+ * @param {string} peerId 请求方 peer
+ * @returns {Promise<void>}
+ */
+export async function respondMailboxWant(want, sendGive, peerId) {
+	const { getMailboxRecords, takeMailboxForRecipient } = await import('./store.mjs')
+	const recipient = normalizeHex64(want.toPubKeyHash)
+	if (!recipient) return
+	const ids = Array.isArray(want.ids) ? want.ids : []
+	const rows = (ids.length
+		? await getMailboxRecords(ids)
+		: await takeMailboxForRecipient(recipient)
+	).filter(row => row.toPubKeyHash === recipient && isDeliverableMailboxRecord(row))
+	if (!rows.length) return
+	sendGive({ toPubKeyHash: recipient, records: rows.slice(0, 32) }, peerId)
+}
+
+/**
+ * @param {{ replicaUsername?: string }} ctx 入站上下文
+ * @param {object} give mailbox_give 载荷
+ * @returns {Promise<number>} 投递给消费者的记录数
+ */
+export async function ingestMailboxGive(ctx, give) {
+	const records = (give.records || []).filter(isDeliverableMailboxRecord)
+	if (!records.length) return 0
+	const username = String(ctx?.replicaUsername || '').trim()
+	if (!username) return 0
+	const { dispatchMailboxRecordsToConsumers } = await import('./consumer_registry.mjs')
+	const { deleteMailboxRecords } = await import('./store.mjs')
+	const delivered = await dispatchMailboxRecordsToConsumers(username, records)
+	if (delivered.length) await deleteMailboxRecords(delivered)
+	return delivered.length
+}
+
+/**
+ * @param {string} username 副本用户名
+ * @param {string} toPubKeyHash 本机收件人 pubKeyHash
+ * @returns {Promise<void>}
+ */
+export async function requestMailboxFromNetwork(username, toPubKeyHash) {
+	const routing = await resolveRouting(username)
+	const { listMailboxIdsForRecipient } = await import('./store.mjs')
+	const recipient = normalizeHex64(toPubKeyHash)
+	if (!recipient) return
+	await deliverToUserRoomPeers(username, 'mailbox_want', {
+		toPubKeyHash: recipient,
+		ids: (await listMailboxIdsForRecipient(recipient)).slice(0, 64),
+	}, null, routing.wantFanout)
+}

package/mailbox/importance.mjs

@@ -0,0 +1,72 @@
+/**
+ * Mailbox 重要性分层与评分（纯函数）。
+ */
+
+/** @typedef {'trusted' | 'normal' | 'quarantine'} MailboxTier */
+
+const TIER_ORDER = { quarantine: 0, normal: 1, trusted: 2 }
+
+/**
+ * @param {number} score 信誉分
+ * @returns {MailboxTier} 分层
+ */
+export function mailboxTierFromScore(score) {
+	const numericScore = Number(score)
+	if (!Number.isFinite(numericScore)) return 'quarantine'
+	if (numericScore >= 0.45) return 'trusted'
+	if (numericScore >= 0.12) return 'normal'
+	return 'quarantine'
+}
+
+/**
+ * @param {object} opts 参数
+ * @param {number} [opts.senderScore] 发件方信誉
+ * @param {number} [opts.recipientScore] 收件方关系信誉（可选）
+ * @param {boolean} [opts.knownMember] 是否本地已知成员/节点
+ * @param {number} [opts.hop] 转发跳数
+ * @returns {{ tier: MailboxTier, score: number }} 分层与分数
+ */
+export function scoreMailboxImportance(opts = {}) {
+	const sender = Number(opts.senderScore ?? 0)
+	const recipient = Number(opts.recipientScore ?? sender)
+	const known = !!opts.knownMember
+	const hop = Math.max(0, Number(opts.hop) || 0)
+	let score = sender * 0.65 + recipient * 0.35
+	if (known) score += 0.15
+	score -= hop * 0.08
+	if (score < 0) score = 0
+	if (score > 1) score = 1
+	return { tier: mailboxTierFromScore(score), score }
+}
+
+/**
+ * 按 tier 与 storedAt 排序（低 tier 先淘汰）。
+ * @param {object[]} rows 记录
+ * @returns {object[]} 排序后
+ */
+export function sortMailboxForRetention(rows) {
+	return [...rows].sort((a, b) => {
+		const ta = TIER_ORDER[a.tier || 'normal'] ?? 1
+		const tb = TIER_ORDER[b.tier || 'normal'] ?? 1
+		if (ta !== tb) return ta - tb
+		return (a.storedAt || 0) - (b.storedAt || 0)
+	})
+}
+
+/**
+ * @param {MailboxTier} tier 分层
+ * @returns {number} 默认 TTL 毫秒
+ */
+export function defaultTtlMsForTier(tier) {
+	if (tier === 'trusted') return 30 * 24 * 3600 * 1000
+	if (tier === 'normal') return 7 * 24 * 3600 * 1000
+	return 24 * 3600 * 1000
+}
+
+/**
+ * @param {MailboxTier} tier 分层
+ * @returns {boolean} 是否允许继续转发
+ */
+export function allowMailboxRelayForTier(tier) {
+	return tier !== 'quarantine'
+}

package/mailbox/parse.mjs

@@ -0,0 +1,73 @@
+import { assertHex64 } from '../core/hexIds.mjs'
+import {
+	assertMailboxPubKeyHash,
+	assertMailboxRecordShape,
+} from '../schemas/mailbox.mjs'
+import { isPlainObject } from '../wire/ingress.mjs'
+
+/**
+ * @typedef {import('../schemas/mailbox.mjs').MailboxWireErr} MailboxParseErr
+ * @typedef {{ ok: true, value: object }} MailboxParseOk
+ * @typedef {MailboxParseOk | MailboxParseErr} MailboxParseResult
+ */
+
+/**
+ * @param {unknown} payload 载荷
+ * @returns {MailboxParseResult} 解析结果
+ */
+export function parseMailboxPut(payload) {
+	if (!isPlainObject(payload))
+		return { ok: false, code: 'invalid_payload', field: 'payload' }
+	if (!isPlainObject(payload.record))
+		return { ok: false, code: 'required', field: 'record' }
+	const shape = assertMailboxRecordShape(payload.record)
+	if (!shape.ok) return shape
+	if (payload.nodeHash != null)
+		try {
+			assertHex64(payload.nodeHash, 'mailbox_put.nodeHash')
+		}
+		catch {
+			return { ok: false, code: 'invalid_hex64', field: 'nodeHash' }
+		}
+
+	return { ok: true, value: payload }
+}
+
+/**
+ * @param {unknown} payload 载荷
+ * @returns {MailboxParseResult} 解析结果
+ */
+export function parseMailboxWant(payload) {
+	if (!isPlainObject(payload))
+		return { ok: false, code: 'invalid_payload', field: 'payload' }
+	const pubKey = assertMailboxPubKeyHash(payload.toPubKeyHash)
+	if (!pubKey.ok)
+		return { ok: false, code: pubKey.code, field: 'toPubKeyHash' }
+	return { ok: true, value: { ...payload, toPubKeyHash: pubKey.value } }
+}
+
+/**
+ * @param {unknown} payload 载荷
+ * @returns {MailboxParseResult} 解析结果
+ */
+export function parseMailboxGive(payload) {
+	if (!isPlainObject(payload))
+		return { ok: false, code: 'invalid_payload', field: 'payload' }
+	if (!Array.isArray(payload.records))
+		return { ok: false, code: 'required', field: 'records' }
+	/** @type {object[]} */
+	const records = []
+	for (let i = 0; i < payload.records.length; i++) {
+		const record = payload.records[i]
+		const shape = assertMailboxRecordShape(record)
+		if (!shape.ok)
+			return { ok: false, code: shape.code, field: `records[${i}].${shape.field}` }
+		if (!record.envelope || typeof record.envelope !== 'object')
+			return { ok: false, code: 'required', field: `records[${i}].envelope` }
+		const app = String(record.app || '').trim()
+		if (!app)
+			return { ok: false, code: 'required', field: `records[${i}].app` }
+		records.push(record)
+	}
+	return { ok: true, value: { ...payload, records } }
+}

package/mailbox/prune.mjs

@@ -0,0 +1,106 @@
+/**
+ * Mailbox 公平淘汰（纯函数，供 store 与单测复用）。
+ */
+import { normalizeHex64 } from '../core/hexIds.mjs'
+
+/** 单收件人×发送者桶：条数上限 */
+export const MAX_BUCKET_ENTRIES = 10
+/** 单收件人×发送者桶：字节上限 */
+export const MAX_BUCKET_BYTES = 2 * 1024 * 1024
+/**
+ * 单用户 mailbox 全局条数上限。
+ * @type {number}
+ */
+export const MAX_MAILBOX_ENTRIES = 500
+/**
+ * 单用户 mailbox 全局字节上限。
+ * @type {number}
+ */
+export const MAX_MAILBOX_BYTES = 50 * 1024 * 1024
+
+/**
+ * @param {object} record 记录
+ * @returns {number} JSON 序列化字节量
+ */
+export function mailboxRecordBytes(record) {
+	return JSON.stringify(record).length
+}
+
+/**
+ * @param {object} record 记录
+ * @returns {string} 公平淘汰桶键
+ */
+export function mailboxBucketKey(record) {
+	const to = normalizeHex64(record.toPubKeyHash) || ''
+	const from = record.fromNodeHash?.trim().toLowerCase()
+		|| record.envelope?.sender?.trim().toLowerCase()
+		|| 'unknown'
+	return `${to}\0${from}`
+}
+
+/**
+ * @param {object[]} rows 记录列表
+ * @returns {object[]} 按桶修剪后
+ */
+export function pruneMailboxBuckets(rows) {
+	/** @type {Map<string, object[]>} */
+	const buckets = new Map()
+	for (const record of rows) {
+		const key = mailboxBucketKey(record)
+		const list = buckets.get(key) || []
+		list.push(record)
+		buckets.set(key, list)
+	}
+	/** @type {object[]} */
+	const out = []
+	for (const list of buckets.values()) {
+		const bucket = [...list].sort((a, b) => a.storedAt - b.storedAt)
+		let bytes = bucket.reduce((sum, record) => sum + mailboxRecordBytes(record), 0)
+		while (bucket.length > MAX_BUCKET_ENTRIES || bytes > MAX_BUCKET_BYTES) {
+			if (!bucket.length) break
+			const removed = bucket.shift()
+			bytes -= mailboxRecordBytes(removed)
+		}
+		out.push(...bucket)
+	}
+	return out
+}
+
+/**
+ * @param {object[]} rows 已按桶修剪后的记录
+ * @returns {object[]} 全局限额内
+ */
+export function pruneMailboxGlobalFair(rows) {
+	let kept = [...rows].sort((a, b) => a.storedAt - b.storedAt)
+	let totalBytes = kept.reduce((sum, record) => sum + mailboxRecordBytes(record), 0)
+
+	while ((kept.length > MAX_MAILBOX_ENTRIES || totalBytes > MAX_MAILBOX_BYTES) && kept.length > 1) {
+		/** @type {Map<string, object[]>} */
+		const buckets = new Map()
+		for (const record of kept) {
+			const key = mailboxBucketKey(record)
+			const list = buckets.get(key) || []
+			list.push(record)
+			buckets.set(key, list)
+		}
+		let victimKey = ''
+		let victimScore = -1
+		for (const [key, list] of buckets) {
+			const score = list.length * 1_000_000 + list.reduce((s, r) => s + mailboxRecordBytes(r), 0)
+			if (score > victimScore) {
+				victimScore = score
+				victimKey = key
+			}
+		}
+		const victimList = buckets.get(victimKey) || []
+		if (!victimList.length) break
+		victimList.sort((a, b) => a.storedAt - b.storedAt)
+		const dropId = victimList[0].id
+		kept = kept.filter(record => record.id !== dropId)
+		totalBytes = kept.reduce((sum, record) => sum + mailboxRecordBytes(record), 0)
+	}
+
+	if (kept.length > MAX_MAILBOX_ENTRIES)
+		kept = kept.slice(-MAX_MAILBOX_ENTRIES)
+	return kept
+}