@steve02081504/fount-p2p 0.0.22 → 0.0.24

package/federation/chunk_fetch_pending.mjs

@@ -1,124 +0,0 @@
-import { base64ToBytes } from '../core/bytes_codec.mjs'
-import { verifiedChunkBytes } from '../files/chunk_fetch_verify.mjs'
-
-/** @type {Map<string, { expectedHash: string, timer: ReturnType<typeof setTimeout>, resolve: (v: Uint8Array | null) => void, reject?: (e: Error) => void }>} */
-export const pendingChunkFetches = new Map()
-
-/** 并发 pending chunk fetch 上限。 */
-export const MAX_PENDING_CHUNK_FETCHES = 2048
-
-/**
- * 注册 chunk 拉取等待槽（requestId 或 compositeKey）。
- * @param {string} key 唯一等待键
- * @param {string} expectedHash 期望 64 hex 密文哈希
- * @param {number} timeoutMs 超时毫秒
- * @param {{ rejectOnTimeout?: boolean }} [options] rejectOnTimeout 时 Promise 以 Error 拒绝
- * @returns {{ done: Promise<Uint8Array | null>, cancel: () => void }} 等待 Promise 与取消函数
- */
-export function registerChunkFetchWait(key, expectedHash, timeoutMs, options = {}) {
-	if (!key || pendingChunkFetches.size >= MAX_PENDING_CHUNK_FETCHES)
-		return {
-			done: Promise.resolve(null),
-			/**
-			 * 槽位已满时的空操作取消。
-			 */
-			cancel: () => { },
-		}
-
-	/** @type {(value: Uint8Array | null | Error) => void} */
-	let settle
-	const done = new Promise((resolve, reject) => {
-		/**
-		 * @param {Uint8Array | null | Error} value 块数据或错误
-		 * @returns {void}
-		 */
-		function settleWait(value) {
-			if (value instanceof Error) reject(value)
-			else resolve(value)
-		}
-		settle = settleWait
-	})
-	const timer = setTimeout(() => {
-		pendingChunkFetches.delete(key)
-		if (options.rejectOnTimeout)
-			settle(new Error('chunk fetch timeout'))
-		else
-			settle(null)
-	}, timeoutMs)
-
-	/**
-	 * @param {Uint8Array | null} data 块数据
-	 * @returns {void}
-	 */
-	function finish(data) {
-		clearTimeout(timer)
-		pendingChunkFetches.delete(key)
-		settle(data)
-	}
-
-	/**
-	 * @param {Error | unknown} error 拒绝原因
-	 * @returns {void}
-	 */
-	function rejectWait(error) {
-		finish(error instanceof Error ? error : new Error(String(error)))
-	}
-
-	pendingChunkFetches.set(key, {
-		expectedHash,
-		timer,
-		resolve: finish,
-		reject: rejectWait,
-	})
-
-	return {
-		done,
-		/** 取消等待并以 null settle。 */
-		cancel: () => {
-			clearTimeout(timer)
-			pendingChunkFetches.delete(key)
-			settle(null)
-		},
-	}
-}
-
-/**
- * 按等待键解析入站 chunk 响应（校验哈希后 resolve）。
- * @param {string} key 等待键
- * @param {string} expectedHash 期望哈希
- * @param {Uint8Array | null} bytes 密文块
- * @returns {boolean} 是否命中并完成等待
- */
-export function resolveChunkFetchWait(key, expectedHash, bytes) {
-	const entry = pendingChunkFetches.get(key)
-	if (!entry || entry.expectedHash !== expectedHash) return false
-	const verified = bytes ? verifiedChunkBytes(expectedHash, bytes) : null
-	if (bytes && !verified) return false
-	clearTimeout(entry.timer)
-	pendingChunkFetches.delete(key)
-	entry.resolve(verified)
-	return true
-}
-
-/**
- * 处理 fed_chunk_data / 带 requestId 的响应载荷。
- * @param {object} payload 入站载荷
- * @returns {boolean} 是否命中 pending
- */
-export function resolvePendingChunkFetch(payload) {
-	const requestId = typeof payload?.requestId === 'string' ? payload.requestId : ''
-	if (!requestId) return false
-	const entry = pendingChunkFetches.get(requestId)
-	if (!entry) return false
-	if (typeof payload?.dataBase64 === 'string') {
-		try {
-			return resolveChunkFetchWait(requestId, entry.expectedHash, base64ToBytes(payload.dataBase64))
-		}
-		catch { /* keep waiting */ }
-		return false
-	}
-	clearTimeout(entry.timer)
-	pendingChunkFetches.delete(requestId)
-	entry.resolve(null)
-	return true
-}

package/federation/manifest_fetch_pending.mjs

@@ -1,88 +0,0 @@
-import { verifySignedPublicManifest } from '../files/public_manifest.mjs'
-
-/** @type {Map<string, { expectedKey: string, timer: ReturnType<typeof setTimeout>, resolve: (v: object | null) => void }>} */
-export const pendingManifestFetches = new Map()
-
-/** 并发 pending manifest fetch 上限。 */
-export const MAX_PENDING_MANIFEST_FETCHES = 512
-
-/**
- * @param {string} ownerEntityHash owner
- * @param {string} logicalPath 路径
- * @returns {string} 期望键
- */
-export function manifestFetchExpectedKey(ownerEntityHash, logicalPath) {
-	return `${String(ownerEntityHash || '').trim().toLowerCase()}\0${String(logicalPath || '').trim().replace(/^\/+/, '')}`
-}
-
-/**
- * @param {string} key requestId
- * @param {string} expectedKey owner+path 复合键
- * @param {number} timeoutMs 超时毫秒
- * @returns {{ done: Promise<object | null>, cancel: () => void }} 等待 Promise 与取消
- */
-export function registerManifestFetchWait(key, expectedKey, timeoutMs) {
-	if (!key || pendingManifestFetches.size >= MAX_PENDING_MANIFEST_FETCHES)
-		return {
-			done: Promise.resolve(null),
-			/**
-			 * 槽位已满时的空操作取消。
-			 */
-			cancel: () => { },
-		}
-
-	/** @type {(value: object | null) => void} */
-	let settle
-	const done = new Promise(resolve => {
-		settle = resolve
-	})
-	const timer = setTimeout(() => {
-		pendingManifestFetches.delete(key)
-		settle(null)
-	}, timeoutMs)
-
-	pendingManifestFetches.set(key, {
-		expectedKey,
-		timer,
-		/**
-		 * @param {object | null} value 验签后的 manifest，超时/取消为 null
-		 */
-		resolve: value => {
-			clearTimeout(timer)
-			pendingManifestFetches.delete(key)
-			settle(value)
-		},
-	})
-
-	return {
-		done,
-		/**
-		 * 取消等待并以 null 结算。
-		 */
-		cancel: () => {
-			clearTimeout(timer)
-			pendingManifestFetches.delete(key)
-			settle(null)
-		},
-	}
-}
-
-/**
- * 处理 fed_manifest_data：验签通过后 resolve pending。
- * @param {object} payload 入站载荷
- * @returns {Promise<boolean>} 是否命中并完成等待
- */
-export async function resolvePendingManifestFetch(payload) {
-	const requestId = String(payload?.requestId || '')
-	if (!requestId) return false
-	const entry = pendingManifestFetches.get(requestId)
-	if (!entry) return false
-
-	const verified = await verifySignedPublicManifest(payload?.manifest)
-	if (!verified) return false
-	const key = manifestFetchExpectedKey(verified.ownerEntityHash, verified.logicalPath)
-	if (key !== entry.expectedKey) return false
-
-	entry.resolve(verified)
-	return true
-}

package/files/chunk_fetch.mjs

@@ -1,99 +0,0 @@
-import { randomUUID } from 'node:crypto'
-
-import { bytesToBase64 } from '../core/bytes_codec.mjs'
-import {
-	MAX_PENDING_CHUNK_FETCHES,
-	registerChunkFetchWait,
-} from '../federation/chunk_fetch_pending.mjs'
-import { ms } from '../utils/duration.mjs'
-import { createInflightTable } from '../utils/inflight_table.mjs'
-
-import { verifiedChunkBytes } from './chunk_fetch_verify.mjs'
-import { fetchFederationChunk, resolveNodeHash } from './chunk_provider_registry.mjs'
-import { getChunk, hasChunk, putChunk } from './chunk_store.mjs'
-import { fanoutFedFetch } from './fetch_fanout.mjs'
-
-const DEFAULT_CHUNK_FETCH_TIMEOUT_MS = ms('8s')
-
-/** 同 username+hash 共享一次 fanout；队满只丢已超基础超时的队首。 */
-const chunkInflight = createInflightTable({
-	maxSize: MAX_PENDING_CHUNK_FETCHES,
-	baseTimeoutMs: DEFAULT_CHUNK_FETCH_TIMEOUT_MS,
-})
-
-/**
- * @typedef {{
- *   username: string,
- *   ciphertextHash: string,
- *   ownerEntityHash?: string,
- *   groupId?: string,
- * }} FetchChunkContext
- */
-
-/**
- * @param {FetchChunkContext} context 上下文
- * @returns {Promise<Uint8Array | null>} 密文块
- */
-export async function fetchChunk(context) {
-	const hash = String(context.ciphertextHash || '').trim().toLowerCase()
-	const { username } = context
-	if (!hash || !username) return null
-
-	if (await hasChunk(hash))
-		return new Uint8Array(await getChunk(hash))
-
-	if (context.groupId) {
-		const u8 = await fetchFederationChunk(username, context.groupId, hash)
-		const verified = verifiedChunkBytes(hash, u8)
-		if (verified) {
-			await putChunk(hash, verified)
-			return verified
-		}
-	}
-
-	const inflightKey = `${username}\0${hash}`
-	const shared = chunkInflight.acquire(inflightKey, () => {
-		const requestId = randomUUID()
-		const wait = registerChunkFetchWait(requestId, hash, DEFAULT_CHUNK_FETCH_TIMEOUT_MS)
-		void (async () => {
-			try {
-				const { nodeHash } = await resolveNodeHash(username)
-				await fanoutFedFetch(username, 'fed_chunk_get', {
-					requestId,
-					nodeHash,
-					chunkHash: hash,
-					ownerEntityHash: context.ownerEntityHash,
-				})
-			}
-			catch { /* pending wait 超时/cancel 负责 settle */ }
-		})()
-		return { done: wait.done, cancel: wait.cancel }
-	})
-	if (!shared) return null
-
-	const result = await shared
-	const verified = verifiedChunkBytes(hash, result)
-	if (verified) {
-		await putChunk(hash, verified)
-		return verified
-	}
-
-	return null
-}
-
-/**
- * 若本机有 chunk 则响应 fed_chunk_get。
- * @param {string} username 用户
- * @param {object} payload 请求
- * @param {(response: object, peerId: string) => void} sendResponse 发送
- * @param {string} peerId 对端
- * @returns {Promise<void>}
- */
-export async function handleIncomingChunkGet(username, payload, sendResponse, peerId) {
-	const hash = String(payload?.chunkHash || '').trim().toLowerCase()
-	if (!hash) return
-	if (!await hasChunk(hash)) return
-	const chunkBytes = await getChunk(hash)
-	if (!chunkBytes?.length) return
-	sendResponse({ requestId: payload.requestId, dataBase64: bytesToBase64(chunkBytes) }, peerId)
-}

package/files/chunk_responder.mjs

@@ -1,142 +0,0 @@
-import { resolvePendingChunkFetch } from '../federation/chunk_fetch_pending.mjs'
-import { resolvePendingManifestFetch } from '../federation/manifest_fetch_pending.mjs'
-
-import { handleIncomingChunkGet } from './chunk_fetch.mjs'
-import { handleIncomingManifestGet } from './manifest_fetch.mjs'
-
-/**
- * @param {string} username 副本用户名 用户名
- * @param {object} data 入站 fed_chunk_get
- * @param {string} peerId 对端 id
- * @param {(resp: object, peerId: string) => void} sendChunkData 发送 fed_chunk_data
- * @returns {Promise<void>}
- */
-export async function handleFedChunkGetIngress(username, data, peerId, sendChunkData) {
-	await handleIncomingChunkGet(username, data, sendChunkData, peerId)
-}
-
-/**
- * @param {object} data 入站 fed_chunk_data（含 requestId 时 resolve pending fetch）
- * @returns {void}
- */
-export function handleFedChunkDataIngress(data) {
-	resolvePendingChunkFetch(data)
-}
-
-/**
- * @param {string} username 副本用户名
- * @param {object} data 入站 fed_manifest_get
- * @param {string} peerId 对端 id
- * @param {(resp: object, peerId: string) => void} sendManifestData 发送 fed_manifest_data
- * @returns {Promise<void>}
- */
-export async function handleFedManifestGetIngress(username, data, peerId, sendManifestData) {
-	await handleIncomingManifestGet(username, data, sendManifestData, peerId)
-}
-
-/**
- * @param {object} data 入站 fed_manifest_data
- * @returns {Promise<void>}
- */
-export async function handleFedManifestDataIngress(data) {
-	await resolvePendingManifestFetch(data)
-}
-
-/**
- * node scope user-room wire：注册 fed_chunk_* + fed_manifest_*。
- * @param {string | (() => string)} usernameOrGetter 副本用户名或 live getter
- * @param {{ on: (name: string, handler: (payload: unknown, peerId: string) => void) => (() => void) | void, send: (name: string, payload: unknown, peerId: string | null) => void }} wire action 表
- * @returns {() => void} 取消挂载的 dispose
- */
-export function attachNodeScopeFedChunkResponder(usernameOrGetter, wire) {
-	const resolveUsername = typeof usernameOrGetter === 'function'
-		? usernameOrGetter
-		: () => usernameOrGetter
-	const offs = [
-		wire.on('fed_chunk_get', (data, peerId) => {
-			void handleFedChunkGetIngress(resolveUsername(), data, peerId, (resp, pid) => {
-				try { wire.send('fed_chunk_data', resp, pid) }
-				catch { /* disconnected */ }
-			})
-		}),
-		wire.on('fed_chunk_data', handleFedChunkDataIngress),
-		wire.on('fed_manifest_get', (data, peerId) => {
-			void handleFedManifestGetIngress(resolveUsername(), data, peerId, (resp, pid) => {
-				try { wire.send('fed_manifest_data', resp, pid) }
-				catch { /* disconnected */ }
-			})
-		}),
-		wire.on('fed_manifest_data', data => {
-			void handleFedManifestDataIngress(data)
-		}),
-	]
-	return () => {
-		for (const off of offs)
-			try { off?.() } catch { /* ignore */ }
-	}
-}
-
-/**
- * Trystero room：注册带 requestId 的 fed_chunk_* + fed_manifest_*（TrustGraph 全局 miss）。
- * @param {string} username 用户
- * @param {object} room Trystero room
- * @param {{ enqueue: (prio: number, cleanup: () => void) => void }} [fedOut] 出站队列
- * @param {(roomKey: string, action: string, rtcLimits: object) => boolean} [guardGet] RTC 负载守卫
- * @param {object} [rtcLimits] RTC 限额
- * @param {string} [roomKey] 房间键
- * @returns {void}
- */
-export function attachTrustGraphFedChunkResponder(username, room, fedOut, guardGet, rtcLimits = {}, roomKey = '') {
-	const [sendChunkData, getChunkData] = room.makeAction('fed_chunk_data')
-	const [, getChunkGet] = room.makeAction('fed_chunk_get')
-	const [sendManifestData, getManifestData] = room.makeAction('fed_manifest_data')
-	const [, getManifestGet] = room.makeAction('fed_manifest_get')
-
-	getChunkGet((data, peerId) => {
-		if (guardGet && !guardGet(roomKey, 'fed_chunk_get', rtcLimits)) return
-		void (async () => {
-			if (!data || typeof data !== 'object') return
-			if (!String(data.requestId || '')) return
-			await handleFedChunkGetIngress(username, data, peerId, (resp, pid) => {
-				/**
-				 * 发送 fed_chunk_data 响应（可经 fedOut 限速队列）。
-				 */
-				const send = () => {
-					try { sendChunkData(resp, pid) }
-					catch { /* peer gone — normal */ }
-				}
-				if (fedOut) fedOut.enqueue(6, send)
-				else send()
-			})
-		})().catch(() => { /* peer/handler race — normal degrade */ })
-	})
-
-	getChunkData(data => {
-		if (!data || typeof data !== 'object' || !data.requestId) return
-		handleFedChunkDataIngress(data)
-	})
-
-	getManifestGet((data, peerId) => {
-		if (guardGet && !guardGet(roomKey, 'fed_manifest_get', rtcLimits)) return
-		void (async () => {
-			if (!data || typeof data !== 'object') return
-			if (!String(data.requestId || '')) return
-			await handleFedManifestGetIngress(username, data, peerId, (resp, pid) => {
-				/**
-				 * 发送 fed_manifest_data 响应（可经 fedOut 限速队列）。
-				 */
-				const send = () => {
-					try { sendManifestData(resp, pid) }
-					catch { /* peer gone — normal */ }
-				}
-				if (fedOut) fedOut.enqueue(6, send)
-				else send()
-			})
-		})().catch(() => { /* peer/handler race — normal degrade */ })
-	})
-
-	getManifestData(data => {
-		if (!data || typeof data !== 'object' || !data.requestId) return
-		void handleFedManifestDataIngress(data)
-	})
-}

package/transport/advert_ingest.mjs

@@ -1,17 +0,0 @@
-import { noteAdvertPeerHints } from '../discovery/advert_peer_hints.mjs'
-
-/**
- * 解密并验签 advert（`ingestEncryptedAdvert` 别名）。不写 peer hints；写入需 `applyAdvertPeerHints`。Untrusted ingress。
- */
-export { ingestEncryptedAdvert as ingestSignedAdvert } from '../discovery/adverts.mjs'
-
-/**
- * 将已验签 advert 的 peer hints 写入本地（apply 侧；与 `ingestSignedAdvert` 分离）。
- * @param {string} verifiedNodeHash 已验签 nodeHash
- * @param {object} body advert body
- * @param {object} [meta] 元数据
- * @returns {void}
- */
-export function applyAdvertPeerHints(verifiedNodeHash, body, meta) {
-	noteAdvertPeerHints(verifiedNodeHash, body, meta)
-}