@steve02081504/fount-p2p 0.0.30 → 0.0.32

package/sim/optimizer.mjs

@@ -0,0 +1,250 @@
+/**
+ * 参数搜索（随机 + 进化）。
+ */
+import { pastDeadline } from './duration.mjs'
+import { evaluateTunables, minPanelFitness } from './metrics.mjs'
+import { runSimulation } from './model.mjs'
+import { mutateCandidate, randomCandidate } from './space.mjs'
+import { loadDefaultTunables } from './tunables_bundle.mjs'
+
+/**
+ * @typedef {{
+ *   tunables: import('./tunables_bundle.mjs').TunablesBundle,
+ *   result: Awaited<ReturnType<typeof evaluateTunables>>,
+ *   generation: number,
+ * }} CandidateRecord
+ */
+
+/**
+ * @typedef {{
+ *   generation: number,
+ *   generationsRun: number,
+ *   bestFitness: number,
+ *   meanFitness: number,
+ *   elapsedMs: number,
+ *   durationMs: number | null,
+ *   generations: number,
+ *   percent: number,
+ * }} OptimizerProgress
+ */
+
+/**
+ * @typedef {{
+ *   baseline: CandidateRecord,
+ *   best: CandidateRecord,
+ *   history: Array<{ generation: number, bestFitness: number, meanFitness: number }>,
+ *   stoppedBy: 'generations' | 'duration',
+ *   generationsRun: number,
+ *   durationMs: number | null,
+ *   elapsedMs: number,
+ * }} OptimizerResult
+ */
+
+/**
+ * @param {number | null} durationMs 时长上限
+ * @param {number} generations 代数上限
+ * @param {number} generation 当前代
+ * @param {number} elapsedMs 已用毫秒
+ * @param {boolean} timed 是否按时间停止
+ * @returns {number} 0..100 进度百分比
+ */
+export function computeProgressPercent(durationMs, generations, generation, elapsedMs, timed) {
+	let raw
+	if (timed && durationMs != null && durationMs > 0)
+		raw = (elapsedMs / durationMs) * 100
+	else
+		raw = generations > 0 ? (generation / generations) * 100 : 0
+	return Math.max(0, Math.min(100, raw))
+}
+
+/**
+ * @param {CandidateRecord[]} pool 当前种群
+ * @param {CandidateRecord} best 当前最优
+ * @returns {{ pool: CandidateRecord[], best: CandidateRecord, meanFitness: number }} 本代统计
+ */
+function recordGeneration(pool, best) {
+	const meanFitness = pool.reduce((s, c) => s + c.result.fitness, 0) / pool.length
+	return { pool, best, meanFitness }
+}
+
+/**
+ * @param {object} options 选项
+ * @param {import('./scenarios.mjs').SimScenario[]} options.scenarios 场景
+ * @param {number} [options.generations=20] 代数上限（未设 duration 时生效）
+ * @param {number} [options.population=12] 种群
+ * @param {number[]} [options.seeds] 种子
+ * @param {number} [options.seedBase=42] 搜索种子基
+ * @param {import('./metrics.mjs').MetricWeights} [options.weights] 权重
+ * @param {number | null} [options.durationMs] 墙钟时长上限（毫秒）；设则按时间停止
+ * @param {import('./metrics.mjs').EvalOptions} [options.evalOptions] 评估并行选项
+ * @param {(info: OptimizerProgress) => void} [options.onProgress] 进度回调
+ * @returns {Promise<OptimizerResult>} 搜索结论
+ */
+export async function runOptimizer(options) {
+	const {
+		scenarios,
+		generations = 20,
+		population = 12,
+		seeds = [1, 2, 3],
+		seedBase = 42,
+		weights,
+		durationMs = null,
+		evalOptions,
+		onProgress,
+	} = options
+
+	const startedAt = Date.now()
+	const deadline = durationMs != null && durationMs > 0 ? startedAt + durationMs : null
+	const timed = deadline != null
+
+	/**
+	 * @param {number} generation 代数
+	 * @param {number} generationsRun 已完成代数
+	 * @param {number} bestFitness 最优适应度
+	 * @param {number} meanFitness 平均适应度
+	 */
+	function emitProgress(generation, generationsRun, bestFitness, meanFitness) {
+		if (!onProgress) return
+		const elapsedMs = Date.now() - startedAt
+		onProgress({
+			generation,
+			generationsRun,
+			bestFitness,
+			meanFitness,
+			elapsedMs,
+			durationMs,
+			generations,
+			percent: computeProgressPercent(durationMs, generations, generation, elapsedMs, timed),
+		})
+	}
+
+	const baselineTunables = loadDefaultTunables()
+	const baselineResult = await evaluateTunables(scenarios, seeds, baselineTunables, runSimulation, weights, evalOptions)
+	const baseline = { tunables: baselineTunables, result: baselineResult, generation: 0 }
+
+	/** @type {CandidateRecord} */
+	let best = { ...baseline }
+	/** @type {Array<{ generation: number, bestFitness: number, meanFitness: number }>} */
+	const history = []
+
+	/** @type {CandidateRecord[]} */
+	let pool = [{ ...baseline }]
+	for (let i = 1; i < population; i++) {
+		const tunables = randomCandidate(seedBase + i)
+		const result = await evaluateTunables(scenarios, seeds, tunables, runSimulation, weights, evalOptions)
+		const rec = { tunables, result, generation: 0 }
+		pool.push(rec)
+		if (result.fitness > best.result.fitness) best = rec
+	}
+
+	{
+		const snap = recordGeneration(pool, best)
+		history.push({
+			generation: 0,
+			bestFitness: best.result.fitness,
+			meanFitness: snap.meanFitness,
+		})
+		emitProgress(0, 0, best.result.fitness, snap.meanFitness)
+	}
+
+	/** @type {'generations' | 'duration'} */
+	let stoppedBy = timed ? 'duration' : 'generations'
+	let generationsRun = 0
+
+	if (timed && pastDeadline(deadline))
+		return {
+			baseline,
+			best,
+			history,
+			stoppedBy: 'duration',
+			generationsRun: 0,
+			durationMs,
+			elapsedMs: Date.now() - startedAt,
+		}
+
+	let gen = 1
+	while (true) {
+		if (!timed && gen > generations) break
+
+		pool.sort((a, b) => b.result.fitness - a.result.fitness)
+		const elites = pool.slice(0, Math.max(2, Math.floor(population / 4)))
+		/** @type {CandidateRecord[]} */
+		const next = [...elites]
+
+		while (next.length < population) {
+			const parent = elites[next.length % elites.length]
+			const tunables = mutateCandidate(parent.tunables, seedBase + gen * 1000 + next.length)
+			const result = await evaluateTunables(scenarios, seeds, tunables, runSimulation, weights, evalOptions)
+			const rec = { tunables, result, generation: gen }
+			next.push(rec)
+			if (result.fitness > best.result.fitness) best = rec
+		}
+
+		pool = next
+		generationsRun = gen
+		const snap = recordGeneration(pool, best)
+		history.push({
+			generation: gen,
+			bestFitness: best.result.fitness,
+			meanFitness: snap.meanFitness,
+		})
+		emitProgress(gen, generationsRun, best.result.fitness, snap.meanFitness)
+
+		if (timed && pastDeadline(deadline)) {
+			stoppedBy = 'duration'
+			break
+		}
+
+		if (!timed && gen >= generations) {
+			stoppedBy = 'generations'
+			break
+		}
+
+		gen++
+	}
+
+	return {
+		baseline,
+		best,
+		history,
+		stoppedBy,
+		generationsRun,
+		durationMs,
+		elapsedMs: Date.now() - startedAt,
+	}
+}
+
+/**
+ * 写回门槛（防单场景过拟合）：必须在**全场景**总适应度上超过基线 + margin，
+ * 且不得让任何单一场景相对基线明显回退。
+ * @param {Awaited<ReturnType<typeof evaluateTunables>>} baselineEval 全场景基线评估
+ * @param {Awaited<ReturnType<typeof evaluateTunables>>} candidateEval 全场景候选评估
+ * @param {object} [options] 选项
+ * @param {number} [options.margin=0.02] 全场景最小提升
+ * @param {number} [options.regressTol=0.01] 单场景允许的最大回退
+ * @returns {{ ok: boolean, reason: string }} 是否应写回与原因
+ */
+export function shouldApplyResult(baselineEval, candidateEval, options = {}) {
+	const { margin = 0.02, regressTol = 0.01 } = options
+	if (candidateEval.fitness < baselineEval.fitness + margin)
+		return {
+			ok: false,
+			reason: `全场景 fitness ${candidateEval.fitness.toFixed(4)} 未超过基线 ${baselineEval.fitness.toFixed(4)} + margin ${margin}`,
+		}
+	for (const [id, agg] of Object.entries(candidateEval.byScenario)) {
+		const base = baselineEval.byScenario[id]
+		if (base && agg.fitness < base.fitness - regressTol)
+			return {
+				ok: false,
+				reason: `场景 ${id} 回退（${agg.fitness.toFixed(4)} < 基线 ${base.fitness.toFixed(4)} - ${regressTol}）`,
+			}
+	}
+	const baseMin = minPanelFitness(baselineEval.byScenario)
+	const candMin = minPanelFitness(candidateEval.byScenario)
+	if (candMin < baseMin - regressTol)
+		return {
+			ok: false,
+			reason: `面板最差 min ${candMin.toFixed(4)} 低于基线 ${baseMin.toFixed(4)} - ${regressTol}`,
+		}
+	return { ok: true, reason: 'ok' }
+}

package/sim/propagation.mjs

@@ -0,0 +1,57 @@
+/**
+ * 信誉信号异步传播（去全知 slash）。
+ */
+
+/**
+ * @typedef {{ targetId: string, senderId: string, claim: number, verified: boolean, birthRound: number, spread: number }} PropagatedSlash
+ */
+
+/**
+ * @returns {{ queue: PropagatedSlash[], delivered: Set<string> }} 传播状态
+ */
+export function createPropagationState() {
+	return { queue: [], delivered: new Set() }
+}
+
+/**
+ * @param {{ queue: PropagatedSlash[] }} state 传播状态
+ * @param {PropagatedSlash} alert slash 警报
+ * @returns {void}
+ */
+export function enqueueSlash(state, alert) {
+	state.queue.push(alert)
+}
+
+/**
+ * @param {object} state 传播状态
+ * @param {number} round 当前回合
+ * @param {(target: string, sender: string, claim: number, verified: boolean) => void} apply 应用到观察者
+ * @param {(senderId: string) => number} trustOf 发送者信任
+ * @param {number} [fanout=0.35] 每跳扩散概率基数
+ * @param {() => number} [rng] 随机源
+ * @returns {number} 本回合送达数
+ */
+export function tickPropagation(state, round, apply, trustOf, fanout = 0.35, rng = () => Math.random()) {
+	let delivered = 0
+	/** @type {PropagatedSlash[]} */
+	const remaining = []
+	for (const alert of state.queue) {
+		const age = round - alert.birthRound
+		if (age < alert.spread) {
+			remaining.push(alert)
+			continue
+		}
+		const key = `${alert.targetId}:${alert.senderId}:${alert.verified}:${alert.claim}`
+		if (state.delivered.has(key)) continue
+		const p = Math.min(0.95, fanout * Math.max(0.05, trustOf(alert.senderId)))
+		if (rng() > p) {
+			remaining.push({ ...alert, spread: alert.spread + 1 })
+			continue
+		}
+		state.delivered.add(key)
+		apply(alert.targetId, alert.senderId, alert.claim, alert.verified)
+		delivered++
+	}
+	state.queue = remaining
+	return delivered
+}

package/sim/report.mjs

@@ -0,0 +1,176 @@
+/**
+ * 挖矿结果报告（写入 gitignore 目录）。
+ */
+import { mkdir, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { snapshotMetricRows } from './metrics.mjs'
+import { formatVulnerabilityMarkdown } from './vulnerability.mjs'
+
+const SIM_DIR = path.dirname(fileURLToPath(import.meta.url))
+
+/** gitignore 下的报告输出目录 */
+export const RESULTS_DIR = path.join(SIM_DIR, 'results')
+
+/**
+ * @param {Array<{ generation: number, bestFitness: number, meanFitness: number }>} history 完整历史
+ * @param {number} [maxRows=60] 最大行数
+ * @returns {Array<{ generation: number, bestFitness: number, meanFitness: number, note?: string }>} 下采样历史
+ */
+export function downsampleHistory(history, maxRows = 60) {
+	if (!history?.length || history.length <= maxRows) return history ?? []
+
+	/** @type {Array<{ generation: number, bestFitness: number, meanFitness: number, note?: string }>} */
+	const out = []
+	let lastBest = -Infinity
+	const stride = Math.ceil(history.length / maxRows)
+
+	for (let i = 0; i < history.length; i++) {
+		const row = history[i]
+		const improved = row.bestFitness > lastBest + 1e-6
+		const sampled = i % stride === 0 || i === history.length - 1
+		if (improved || sampled) {
+			out.push({ ...row, note: improved && !sampled ? 'best↑' : undefined })
+			if (improved) lastBest = row.bestFitness
+		}
+	}
+
+	if (out.length && out[0].generation !== history[0].generation)
+		out.unshift({ ...history[0] })
+
+	const last = history[history.length - 1]
+	if (out[out.length - 1]?.generation !== last.generation)
+		out.push({ ...last })
+
+	if (out.length <= maxRows) return out
+
+	const first = out[0]
+	const tail = out[out.length - 1]
+	const middle = out.slice(1, -1)
+	const midStride = Math.max(1, Math.ceil(middle.length / Math.max(1, maxRows - 2)))
+	const sampledMiddle = middle.filter((_, i) => i % midStride === 0)
+	return [first, ...sampledMiddle, tail].slice(0, maxRows)
+}
+
+/**
+ * @param {object} payload 报告内容
+ * @param {string} [tag] 文件名标签
+ * @returns {Promise<{ jsonPath: string, mdPath: string }>} 写入路径
+ */
+export async function writeReport(payload, tag = 'latest') {
+	await mkdir(RESULTS_DIR, { recursive: true })
+	const stamp = new Date().toISOString().replace(/[.:]/g, '-')
+	const base = `${tag}-${stamp}`
+	const jsonPath = path.join(RESULTS_DIR, `${base}.json`)
+	const mdPath = path.join(RESULTS_DIR, `${base}.md`)
+
+	const reportPayload = {
+		...payload,
+		historyFull: payload.history,
+		history: downsampleHistory(payload.history),
+	}
+
+	await writeFile(jsonPath, `${JSON.stringify(reportPayload, null, 2)}\n`, 'utf8')
+	await writeFile(mdPath, formatMarkdown(reportPayload), 'utf8')
+	return { jsonPath, mdPath }
+}
+
+/**
+ * @param {object} payload 报告载荷
+ * @returns {string} Markdown 正文
+ */
+function formatMarkdown(payload) {
+	const lines = [
+		'# P2P 参数挖矿报告',
+		'',
+		`生成时间: ${payload.generatedAt || new Date().toISOString()}`,
+		'',
+	]
+
+	if (payload.durationMs != null) {
+		const elapsed = Number(payload.elapsedMs)
+		const limit = Number(payload.durationMs)
+		lines.push(
+			`运行时长: ${Number.isFinite(elapsed) ? (elapsed / 1000).toFixed(1) : '—'}s / ${Number.isFinite(limit) ? (limit / 1000).toFixed(1) : '—'}s`,
+			`停止原因: ${payload.stoppedBy || '—'}（完成 ${payload.generationsRun ?? '—'} 代）`,
+			'',
+		)
+	}
+
+	lines.push(
+		'## 适应度',
+		'',
+		'| 指标 | 基线 | 最优 |',
+		'| --- | ---: | ---: |',
+		`| fitness | ${fmt(payload.baseline?.result?.fitness)} | ${fmt(payload.best?.result?.fitness)} |`,
+		`| mean | ${fmt(payload.baseline?.result?.mean)} | ${fmt(payload.best?.result?.mean)} |`,
+		`| min | ${fmt(payload.baseline?.result?.min)} | ${fmt(payload.best?.result?.min)} |`,
+		'',
+	)
+
+	const baselineSnap = payload.baseline?.result?.byScenario
+		? Object.values(payload.baseline.result.byScenario)[0]?.snapshots?.[0]
+		: null
+	const bestSnap = payload.best?.result?.byScenario
+		? Object.values(payload.best.result.byScenario)[0]?.snapshots?.[0]
+		: null
+
+	if (baselineSnap && bestSnap) {
+		lines.push('## 评测维度', '', '| 维度 | 基线 | 最优 |', '| --- | ---: | ---: |')
+		for (const row of snapshotMetricRows(baselineSnap, bestSnap))
+			lines.push(`| ${row.key} | ${fmt(row.baseline)} | ${fmt(row.best)} |`)
+		lines.push('')
+	}
+
+	if (payload.apply?.applied)
+		lines.push('## 已应用', '', '最优参数已写回各模块 JSON。', '')
+	else if (payload.apply)
+		lines.push('## 未应用', '', String(payload.apply.reason || '未达提升门槛'), '')
+
+	if (payload.bestRed?.attackGenome)
+		lines.push(
+			'## 红队（攻击基因）',
+			'',
+			'| 指标 | 值 |',
+			'| --- | --- |',
+			`| 最大伤害 | ${fmt(-(payload.bestRed.result?.fitness ?? 0))} |`,
+			`| 名人堂规模 | ${payload.attackHof?.length ?? 0} |`,
+			'',
+		)
+
+
+	const history = payload.history ?? []
+	const historyFull = payload.historyFull ?? history
+	if (history.length) {
+		const folded = historyFull.length > history.length
+			? `（由 ${historyFull.length} 代下采样至 ${history.length} 行）`
+			: ''
+		lines.push('## 收敛', '', `| generation | bestFitness | meanFitness | note |${folded}`, '| ---: | ---: | ---: | --- |')
+		for (const row of history) {
+			const note = row.note ?? ''
+			lines.push(`| ${row.generation} | ${fmt(row.bestFitness)} | ${fmt(row.meanFitness)} | ${note} |`)
+		}
+		lines.push('')
+	}
+
+	if (payload.best?.result?.byScenario) {
+		lines.push('## 分场景', '')
+		for (const [id, agg] of Object.entries(payload.best.result.byScenario))
+			lines.push(`- **${id}**: fitness=${fmt(agg.fitness)}, mean=${fmt(agg.mean)}, min=${fmt(agg.min)}`)
+		lines.push('')
+	}
+
+	if (payload.vulnerability)
+		lines.push(...formatVulnerabilityMarkdown(payload.vulnerability))
+
+	return `${lines.join('\n')}\n`
+}
+
+/**
+ * @param {number | undefined} n 数值
+ * @returns {string} 格式化字符串
+ */
+function fmt(n) {
+	return Number.isFinite(n) ? n.toFixed(4) : '—'
+}

package/sim/reputation_social.tunables.json

@@ -0,0 +1,6 @@
+{
+	"socialRepHideThreshold": 0,
+	"socialBlockDecayFraction": 0.02,
+	"followedBlockSelfTrustPenalty": 0.12,
+	"followedBlockPenalty": 0.06
+}

package/sim/rng.mjs

@@ -0,0 +1,62 @@
+/**
+ * 确定性 PRNG（mulberry32）。
+ */
+
+/**
+ * @param {number} seed 种子
+ * @returns {() => number} [0, 1) 均匀随机函数
+ */
+export function createRng(seed) {
+	let state = seed >>> 0
+	return () => {
+		state = (state + 0x6D2B79F5) >>> 0
+		let t = Math.imul(state ^ (state >>> 15), 1 | state)
+		t ^= t + Math.imul(t ^ (t >>> 7), 61 | t)
+		return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+	}
+}
+
+/**
+ * @param {() => number} rng 随机源
+ * @param {number} min 下界（含）
+ * @param {number} max 上界（不含）
+ * @returns {number} [min, max) 整数
+ */
+export function randInt(rng, min, max) {
+	return Math.floor(rng() * (max - min)) + min
+}
+
+/**
+ * @param {() => number} rng 随机源
+ * @param {readonly T[]} items 候选数组
+ * @returns {T} 随机元素
+ * @template T
+ */
+export function pickOne(rng, items) {
+	return items[Math.floor(rng() * items.length)]
+}
+
+/**
+ * @param {() => number} rng 随机源
+ * @param {readonly T[]} items 候选数组
+ * @param {number} k 抽取个数
+ * @returns {T[]} 不重复随机子集
+ * @template T
+ */
+export function pickMany(rng, items, k) {
+	const copy = [...items]
+	const out = []
+	while (copy.length && out.length < k) {
+		const i = Math.floor(rng() * copy.length)
+		out.push(copy.splice(i, 1)[0])
+	}
+	return out
+}
+
+/**
+ * @param {number} index 序号
+ * @returns {string} 64 位十六进制 伪 nodeHash
+ */
+export function fakeNodeHash(index) {
+	return index.toString(16).padStart(64, '0')
+}