@steve02081504/fount-p2p 0.0.30 → 0.0.32

package/sim/test/sim_model_regressions.test.mjs

@@ -0,0 +1,110 @@
+import { test } from 'node:test'
+
+import { assert, assertEquals } from '../../test/helpers/assert.mjs'
+import {
+	createDiscoveryState,
+	eclipseFillExplore,
+	initObserverDiscovery,
+	takeRoomSlot,
+} from '../discovery.mjs'
+import { integrityDefendsAgainst, observerHasLocalReplica } from '../integrity.mjs'
+import { runSimulation } from '../model.mjs'
+import { createRng } from '../rng.mjs'
+import { resolveScenarios } from '../scenarios.mjs'
+import { createTransportState, takeTransportJoinSlot } from '../transport.mjs'
+import { loadDefaultTunables } from '../tunables_bundle.mjs'
+
+test('reachCollapse does not shrink with observer count', () => {
+	const tunables = loadDefaultTunables()
+	const base = resolveScenarios('spam_eclipse')[0]
+	const small = { ...base, honestCount: 6, attacks: { eclipse: 6 }, rounds: 30 }
+	const large = { ...base, honestCount: 24, attacks: { eclipse: 6 }, rounds: 30 }
+	const snapSmall = runSimulation(small, 5, tunables)
+	const snapLarge = runSimulation(large, 5, tunables)
+	const rSmall = snapSmall.byAttackImpact?.eclipse?.reachCollapse ?? 0
+	const rLarge = snapLarge.byAttackImpact?.eclipse?.reachCollapse ?? 0
+	if (rSmall > 0.02)
+		assert(
+			rLarge >= rSmall * 0.35,
+			`reachCollapse should not scale down with more observers: small=${rSmall} large=${rLarge}`,
+		)
+})
+
+test('newcomers excluded from falsePositiveRate', () => {
+	const tunables = loadDefaultTunables()
+	tunables.social.socialRepHideThreshold = 0.01
+	const withNewcomers = {
+		...resolveScenarios('balanced')[0],
+		honestCount: 8,
+		newcomerCount: 6,
+		attacks: {},
+		rounds: 10,
+	}
+	const withoutNewcomers = { ...withNewcomers, newcomerCount: 0 }
+	const snapWith = runSimulation(withNewcomers, 11, tunables)
+	const snapWithout = runSimulation(withoutNewcomers, 11, tunables)
+	assert(
+		snapWith.falsePositiveRate <= snapWithout.falsePositiveRate,
+		`newcomers inflated falsePositive: with=${snapWith.falsePositiveRate} without=${snapWithout.falsePositiveRate}`,
+	)
+})
+
+test('verifiedForgery is per-observer not global', () => {
+	const attacker = { id: 'm1', attack: 'archive_forger' }
+	const scenario = { honestCount: 10, groupSize: 12, behaviorDist: { archiveSubmitRate: { mean: 0.2 } } }
+	const observerA = { id: 'o1', trustedPeers: ['t1', 't2'] }
+	const observerB = { id: 'o2', trustedPeers: ['t1', 't2'] }
+	const simulationContext = { verifiedForgeryByObserver: new Map([['o1', new Set(['m1'])]]) }
+	assertEquals(integrityDefendsAgainst(attacker, observerA, scenario, simulationContext), true)
+	assertEquals(integrityDefendsAgainst(attacker, observerB, scenario, simulationContext), false)
+	assertEquals(observerHasLocalReplica(observerB, scenario), true)
+})
+
+test('takeRoomSlot enforces maxNonTrusted cap', () => {
+	const state = createDiscoveryState()
+	state.rtcMaxActive = 10
+	const trusted = ['t1', 't2', 't3']
+	initObserverDiscovery(state, 'obs', trusted, ['obs', 't1', 't2', 't3', ...Array.from({ length: 12 }, (_, i) => `p${i}`)], createRng(1), 4)
+	const bucket = state.roomSlotsByObserver.get('obs')
+	assert(bucket)
+	const maxNonTrusted = Math.max(0, state.rtcMaxActive - bucket.trustedReserved.size)
+	let nonTrustedAdded = 0
+	for (let i = 0; i < 20; i++) {
+		if (!takeRoomSlot(state, 'obs', `extra${i}`, 'spam', trusted)) continue
+		if (!bucket.trustedReserved.has(`extra${i}`)) nonTrustedAdded++
+	}
+	assert(nonTrustedAdded <= maxNonTrusted, `non-trusted slots ${nonTrustedAdded} > cap ${maxNonTrusted}`)
+})
+
+test('eclipse cluster mates fill explore together', () => {
+	const state = createDiscoveryState()
+	const rng = createRng(3)
+	const roster = ['obs', 'h1', 'mal1', 'mal2', 'mal3']
+	initObserverDiscovery(state, 'obs', ['h1'], roster, rng, 4)
+	eclipseFillExplore(state, 'obs', 'mal1', ['mal2', 'mal3'], 0.9)
+	const explore = state.exploreByObserver.get('obs')
+	assert(explore?.has('mal2'))
+	assert(explore?.has('mal3'))
+})
+
+test('transport trusted peers reserve slots per observer', () => {
+	const state = createTransportState()
+	state.rtcMaxActive = 8
+	state.maxJoinsPerMin = 200
+	for (const id of ['anchor1', 'anchor2', 'anchor3'])
+		state.trustedPeers.add(id)
+	for (const id of ['anchor1', 'anchor2', 'anchor3'])
+		assertEquals(takeTransportJoinSlot(state, id, 'trusted', 1000), true)
+	const trustedReserved = Math.max(3, Math.floor(state.rtcMaxActive * 0.25))
+	const maxNonTrusted = Math.max(1, state.rtcMaxActive - trustedReserved)
+	let nonTrusted = 0
+	for (let i = 0; i < 20; i++)
+		if (takeTransportJoinSlot(state, `flood${i}`, 'flood-src', 2000 + i)) nonTrusted++
+	assert(nonTrusted <= maxNonTrusted + 1)
+})
+
+test('buildWorld wires per-observer transport with trusted anchors', () => {
+	const snap = runSimulation(resolveScenarios('transport_siege')[0], 2, loadDefaultTunables())
+	assertEquals(typeof snap.joinThrottleEffectiveness, 'number')
+	assert(snap.joinThrottleEffectiveness >= 0 && snap.joinThrottleEffectiveness <= 1)
+})

package/sim/test/slow_drip.test.mjs

@@ -0,0 +1,28 @@
+import { test } from 'node:test'
+
+import { assertEquals } from '../../test/helpers/assert.mjs'
+import { runSimulation } from '../model.mjs'
+import { resolveScenarios } from '../scenarios.mjs'
+import { loadDefaultTunables } from '../tunables_bundle.mjs'
+
+test('slow_drip_spam is deterministic across runs', () => {
+	const scenario = resolveScenarios('slow_drip_spam')[0]
+	const tunables = loadDefaultTunables()
+	const a = runSimulation(scenario, 42, tunables)
+	const b = runSimulation(scenario, 42, tunables)
+	assertEquals(JSON.stringify(a), JSON.stringify(b))
+})
+
+test('slow_drip_spam defends better than disabled penalties', () => {
+	const scenario = resolveScenarios('slow_drip_spam')[0]
+	const defaults = loadDefaultTunables()
+	const disabled = loadDefaultTunables()
+	disabled.reputation.penaltyMessageRate = 0
+	let defaultDefense = 0
+	let disabledDefense = 0
+	for (const seed of [1, 2, 3]) {
+		defaultDefense += runSimulation(scenario, seed, defaults).byAttackDefense?.slow_drip_spammer?.rate ?? 0
+		disabledDefense += runSimulation(scenario, seed, disabled).byAttackDefense?.slow_drip_spammer?.rate ?? 0
+	}
+	assertEquals(defaultDefense / 3 >= disabledDefense / 3, true)
+})

package/sim/test/smoke.test.mjs

@@ -0,0 +1,52 @@
+import { test } from 'node:test'
+
+import { assertEquals } from '../../test/helpers/assert.mjs'
+import { fitnessFromSnapshot, RATE_METRIC_KEYS } from '../metrics.mjs'
+import { runSimulation } from '../model.mjs'
+import { resolveScenarios } from '../scenarios.mjs'
+import { loadDefaultTunables } from '../tunables_bundle.mjs'
+
+test('p2p sim smoke', () => {
+	const tunables = loadDefaultTunables()
+	const scenario = resolveScenarios('balanced')[0]
+	const snap = runSimulation(scenario, 1, tunables)
+
+	for (const key of RATE_METRIC_KEYS) {
+		assertEquals(typeof snap[key], 'number', key)
+		if (key === 'fanoutCostRatio' || key === 'mailboxCostRatio')
+			assertEquals(snap[key] >= 0, true, key)
+		else
+			assertEquals(snap[key] >= 0 && snap[key] <= 1, true, key)
+	}
+
+	assertEquals(typeof snap.federationReachRate, 'number')
+	assertEquals(snap.federationReachRate >= 0 && snap.federationReachRate <= 1, true)
+
+	assertEquals(typeof snap.malSuppressionRate, 'number')
+	assertEquals(typeof snap.honestPreservationRate, 'number')
+	assertEquals(snap.malSuppressionRate >= 0 && snap.malSuppressionRate <= 1, true)
+	assertEquals(snap.honestPreservationRate >= 0 && snap.honestPreservationRate <= 1, true)
+
+	const fitness = fitnessFromSnapshot(snap)
+	assertEquals(Number.isFinite(fitness), true)
+})
+
+test('usage_mix scenario profiles', () => {
+	const tunables = loadDefaultTunables()
+	const scenario = resolveScenarios('usage_mix')[0]
+	const snap = runSimulation(scenario, 7, tunables)
+	assertEquals(snap.profilePreservationRate > 0, true)
+	assertEquals(snap.relayPreservationRate > 0, true)
+})
+
+test('new endogenous scenarios produce metrics', () => {
+	const tunables = loadDefaultTunables()
+	for (const id of ['churn_storm', 'key_compromise', 'sleeper_turn', 'digest_equivocation', 'eclipse_targeted']) {
+		const scenario = resolveScenarios(id)[0]
+		const snap = runSimulation(scenario, 3, tunables)
+		assertEquals(typeof snap.churnReachRate, 'number', id)
+		assertEquals(typeof snap.compromiseContainmentRate, 'number', id)
+		assertEquals(typeof snap.sleeperReactionRate, 'number', id)
+		assertEquals(typeof snap.equivocationDefenseRate, 'number', id)
+	}
+})

package/sim/test/transport.test.mjs

@@ -0,0 +1,55 @@
+import { test } from 'node:test'
+
+import { assertEquals } from '../../test/helpers/assert.mjs'
+import { runSimulation } from '../model.mjs'
+import { resolveScenarios } from '../scenarios.mjs'
+import {
+	createTransportState,
+	takeTransportJoinSlot,
+	transportHintWeight,
+	transportMetrics,
+} from '../transport.mjs'
+import { loadDefaultTunables } from '../tunables_bundle.mjs'
+
+test('single source can still connect at least one peer', () => {
+	const state = createTransportState()
+	state.rtcMaxActive = 8
+	state.maxJoinsPerMin = 120
+	assertEquals(takeTransportJoinSlot(state, 'peer0', 'solo-source', 1000), true)
+	const sourceCap = Math.max(1, Math.floor(state.rtcMaxActive * 0.25))
+	for (let i = 1; i < sourceCap; i++)
+		assertEquals(takeTransportJoinSlot(state, `peer${i}`, 'solo-source', 1000 + i), true)
+})
+
+test('transport_siege scenario exposes transport metrics', () => {
+	const snap = runSimulation(resolveScenarios('transport_siege')[0], 3, loadDefaultTunables())
+	assertEquals(typeof snap.transportReachRate, 'number')
+	assertEquals(typeof snap.joinThrottleEffectiveness, 'number')
+	assertEquals(snap.transportReachRate >= 0 && snap.transportReachRate <= 1, true)
+})
+
+test('transportMetrics tracks signaling diversity', () => {
+	const state = createTransportState()
+	transportHintWeight(state, 'obs', 'p1', 'tracker')
+	transportHintWeight(state, 'obs', 'p2', 'nostr')
+	const m = transportMetrics(state, 'obs', ['obs', 'p1', 'p2'], () => 0.5)
+	assertEquals(m.reach >= 0 && m.reach <= 1, true)
+	assertEquals(m.diversity > 0, true)
+})
+
+test('transportMetrics throttle uses simulation clock not wall clock', () => {
+	const state = createTransportState()
+	const simStart = Date.now()
+	// 40 回合后 simulationContext.now 比墙钟超前约 2.4M ms，overloadUntil 落在虚拟时间轴上
+	state.overloadUntil = simStart + 2_400_000
+	const atWall = transportMetrics(state, 'obs', ['obs'], () => 0.5)
+	assertEquals(atWall.throttleOk, 0)
+	const atSim = transportMetrics(state, 'obs', ['obs'], () => 0.5, simStart + 2_500_000)
+	assertEquals(atSim.throttleOk, 1)
+})
+
+test('transport_siege join throttle effective after sim decay', () => {
+	const snap = runSimulation(resolveScenarios('transport_siege')[0], 3, loadDefaultTunables())
+	assertEquals(typeof snap.joinThrottleEffectiveness, 'number')
+	assertEquals(snap.joinThrottleEffectiveness >= 0 && snap.joinThrottleEffectiveness <= 1, true)
+})

package/sim/test/tunables_apply.test.mjs

@@ -0,0 +1,64 @@
+import { test } from 'node:test'
+
+import { assert, assertEquals } from '../../test/helpers/assert.mjs'
+import { resolveArchiveQuorumPeerMin, resolveArchiveQuorumPeerStrictMin } from '../../trust_graph/resolve.mjs'
+import { applyTunablesBundle, prepareBundleForApply } from '../apply.mjs'
+import { normalizeBundle, PARAM_SPACE, randomCandidate, sanitizeArchiveQuorum } from '../space.mjs'
+import { loadDefaultTunables } from '../tunables_bundle.mjs'
+
+test('normalizeBundle keeps every PARAM_SPACE value in its semantic domain', () => {
+	for (let seed = 1; seed <= 40; seed++) {
+		const bundle = normalizeBundle(randomCandidate(seed))
+		for (const spec of PARAM_SPACE) {
+			const v = bundle[spec.module][spec.key]
+			const label = `${spec.module}.${spec.key} seed ${seed}`
+			assertEquals(Number.isFinite(v), true, label)
+			if (spec.kind === 'count') assertEquals(Number.isInteger(v) && v >= 1, true, label)
+			if (spec.kind === 'pos') assertEquals(v > 0, true, label)
+			if (spec.kind === 'unit') assertEquals(v > 0 && v < 1, true, label)
+			if (spec.kind === 'score') assertEquals(v > -1 && v < 1, true, label)
+		}
+	}
+})
+
+test('prepareBundleForApply preserves fractional tunables', () => {
+	const bundle = randomCandidate(7)
+	bundle.reputation.penaltyUnknownWant = 0.22
+	bundle.reputation.slashDefaultClaim = 0.2
+	bundle.social.socialRepHideThreshold = -0.4
+	bundle.reputation.collusionDelta = 0.62
+
+	const ready = prepareBundleForApply(bundle)
+	assertEquals(ready.reputation.penaltyUnknownWant, 0.22)
+	assertEquals(ready.reputation.slashDefaultClaim, 0.2)
+	assertEquals(ready.social.socialRepHideThreshold, -0.4)
+	assertEquals(ready.reputation.collusionDelta, 0.62)
+})
+
+test('prepareBundleForApply does not zero non-space reputation keys', () => {
+	const bundle = randomCandidate(11)
+	const ready = prepareBundleForApply(bundle)
+	assertEquals(ready.reputation.slashDefaultClaim > 0, true)
+	assertEquals(ready.reputation.slashUnverifiedDefaultClaim > 0, true)
+	assertEquals(ready.reputation.chunkStoreRepBump > 0, true)
+})
+
+test('applyTunablesBundle requires socialTunablesPath', async () => {
+	await assert.rejects(
+		() => applyTunablesBundle(loadDefaultTunables(), {}),
+		/socialTunablesPath required/u,
+	)
+})
+
+test('prepareBundleForApply enforces strict>=base quorum rule', () => {
+	const bundle = randomCandidate(3)
+	bundle.archive.archiveQuorumPeerMinRatio = 0.8
+	bundle.archive.archiveQuorumPeerStrictMinRatio = 0.1
+	sanitizeArchiveQuorum(bundle)
+	const refN = 8
+	assertEquals(
+		resolveArchiveQuorumPeerStrictMin(refN, bundle.archive)
+		>= resolveArchiveQuorumPeerMin(refN, bundle.archive),
+		true,
+	)
+})

package/sim/test/tunables_param_space.test.mjs

@@ -0,0 +1,74 @@
+import { test } from 'node:test'
+
+import { assertEquals } from '../../test/helpers/assert.mjs'
+import { resolveArchiveQuorumPeerMin, resolveArchiveQuorumPeerStrictMin } from '../../trust_graph/resolve.mjs'
+import { createRng } from '../rng.mjs'
+import {
+	normalizeParam,
+	PARAM_SPACE,
+	quantize,
+	randomCandidate,
+	sampleParam,
+	sanitizeArchiveQuorum,
+} from '../space.mjs'
+import { loadDefaultTunables } from '../tunables_bundle.mjs'
+
+test('quantize removes float tails', () => {
+	assertEquals(quantize(0.060000000000000005, 6), 0.06)
+	assertEquals(quantize(0.8400000000000001, 6), 0.84)
+	assertEquals(String(quantize(0.034999999999999996, 6)).includes('999'), false)
+})
+
+test('quantize default preserves fractional values', () => {
+	assertEquals(quantize(0.22), 0.22)
+	assertEquals(quantize(-0.4), -0.4)
+	assertEquals(quantize(0.62), 0.62)
+})
+
+test('sampleParam stays inside each semantic domain', () => {
+	const rng = createRng(99)
+	const base = loadDefaultTunables()
+	for (const spec of PARAM_SPACE)
+		for (let i = 0; i < 50; i++) {
+			const v = sampleParam(rng, spec, base[spec.module][spec.key])
+			const label = `${spec.module}.${spec.key}`
+			assertEquals(Number.isFinite(v), true, label)
+			switch (spec.kind) {
+				case 'count':
+					assertEquals(Number.isInteger(v) && v >= 1, true, label)
+					break
+				case 'pos':
+					assertEquals(v > 0, true, label)
+					break
+				case 'unit':
+					assertEquals(v > 0 && v < 1, true, label)
+					break
+				case 'score':
+					assertEquals(v > -1 && v < 1, true, label)
+					break
+				default:
+					break
+			}
+		}
+})
+
+test('normalizeParam repairs out-of-domain values without a tuning box', () => {
+	assertEquals(normalizeParam(-5, { module: 'reputation', key: 'penaltyUnknownWant', kind: 'pos' }) > 0, true)
+	assertEquals(normalizeParam(3.4, { module: 'reputation', key: 'slashVerifiedMultiplier', kind: 'unit' }) < 1, true)
+	assertEquals(normalizeParam(2.7, { module: 'mailbox', key: 'maxHop', kind: 'count' }), 3)
+	assertEquals(normalizeParam(9, { module: 'social', key: 'socialRepHideThreshold', kind: 'score' }) < 1, true)
+})
+
+test('randomCandidate archive quorum ordering', () => {
+	for (let seed = 1; seed <= 30; seed++) {
+		const bundle = randomCandidate(seed)
+		sanitizeArchiveQuorum(bundle)
+		const refN = 8
+		assertEquals(
+			resolveArchiveQuorumPeerStrictMin(refN, bundle.archive)
+			>= resolveArchiveQuorumPeerMin(refN, bundle.archive),
+			true,
+			`seed ${seed}`,
+		)
+	}
+})

package/sim/test/vulnerability.test.mjs

@@ -0,0 +1,127 @@
+import { test } from 'node:test'
+
+import { assert, assertEquals } from '../../test/helpers/assert.mjs'
+import { evaluateTunables } from '../metrics.mjs'
+import { runSimulation } from '../model.mjs'
+import { resolveScenarios } from '../scenarios.mjs'
+import { shutdownSimPool } from '../sim_pool.mjs'
+import { loadDefaultTunables } from '../tunables_bundle.mjs'
+import {
+	analyzeVulnerabilities,
+	ATTACK_PROFILES,
+	classifyDefenseSeverity,
+	formatVulnerabilityConsole,
+	formatVulnerabilityMarkdown,
+} from '../vulnerability.mjs'
+
+test('classifyDefenseSeverity bands', () => {
+	assertEquals(classifyDefenseSeverity(0.1).severity, '群级瘫痪')
+	assertEquals(classifyDefenseSeverity(0.35).severity, '群级接管')
+	assertEquals(classifyDefenseSeverity(0.5).severity, '明显薄弱')
+	assertEquals(classifyDefenseSeverity(0.7).severity, '尚可')
+	assertEquals(classifyDefenseSeverity(0.9).severity, '较稳')
+})
+
+test('snapshot includes byAttackDefense and byAttackImpact', () => {
+	const tunables = loadDefaultTunables()
+	const scenario = resolveScenarios('balanced')[0]
+	const snap = runSimulation(scenario, 1, tunables)
+	assert.ok(snap.byAttackDefense)
+	assert.ok(snap.byAttackImpact)
+	assertEquals(typeof snap.byAttackDefense.sybil?.rate, 'number')
+	assertEquals(snap.byAttackDefense.sybil.rate >= 0 && snap.byAttackDefense.sybil.rate <= 1, true)
+})
+
+test('gain-type with low topK harm avoids 群级瘫痪 despite zero suppression', () => {
+	/**
+	 * 构造测试快照。
+	 * @type {import('../metrics.mjs').SimSnapshot}
+	 */
+	const snap = {
+		malSuppressionRate: 0,
+		honestPreservationRate: 1,
+		falsePositiveRate: 0,
+		fanoutReachRate: 1,
+		federationReachRate: 1,
+		fanoutCostRatio: 0,
+		collusionCollapseRate: 1,
+		relayPreservationRate: 1,
+		profilePreservationRate: 1,
+		quietHonestPreservationRate: 1,
+		sybilContainmentRate: 1,
+		archiveDefenseRate: 1,
+		mailboxReachRate: 1,
+		mailboxCostRatio: 0,
+		archiveQuorumAccuracy: 1,
+		churnReachRate: 1,
+		compromiseContainmentRate: 1,
+		sleeperReactionRate: 1,
+		equivocationDefenseRate: 1,
+		observerCount: 1,
+		maliciousCount: 1,
+		honestCount: 1,
+		groupSize: 8,
+		byAttackDefense: { relay_farmer: { rate: 0, defended: 0, total: 3 } },
+		byAttackImpact: { relay_farmer: { topKCapture: 0.08, reachCollapse: 0.05 } },
+	}
+	const defense = ATTACK_PROFILES.relay_farmer.defense(snap, 'relay_farmer')
+	assertEquals(classifyDefenseSeverity(defense).severity !== '群级瘫痪', true)
+})
+
+test('collusion defense counts per-node suppression when ring avg stays positive', () => {
+	/**
+	 * 构造测试快照。
+	 * @type {import('../metrics.mjs').SimSnapshot}
+	 */
+	const snap = {
+		malSuppressionRate: 1,
+		honestPreservationRate: 1,
+		falsePositiveRate: 0,
+		fanoutReachRate: 1,
+		federationReachRate: 1,
+		fanoutCostRatio: 0,
+		collusionCollapseRate: 0,
+		relayPreservationRate: 1,
+		profilePreservationRate: 1,
+		quietHonestPreservationRate: 1,
+		sybilContainmentRate: 1,
+		archiveDefenseRate: 1,
+		mailboxReachRate: 1,
+		mailboxCostRatio: 0,
+		archiveQuorumAccuracy: 1,
+		churnReachRate: 1,
+		compromiseContainmentRate: 1,
+		sleeperReactionRate: 1,
+		equivocationDefenseRate: 1,
+		observerCount: 1,
+		maliciousCount: 4,
+		honestCount: 10,
+		groupSize: 8,
+		byAttackDefense: { collusion: { rate: 1, defended: 4, total: 4 } },
+		byAttackImpact: { collusion: { topKCapture: 0, reachCollapse: 0 } },
+	}
+	const defense = ATTACK_PROFILES.collusion.defense(snap, 'collusion')
+	assertEquals(defense, 1)
+	assertEquals(classifyDefenseSeverity(defense).severity, '较稳')
+})
+
+test('analyzeVulnerabilities ranks attacks', async () => {
+	const tunables = loadDefaultTunables()
+	const scenarios = resolveScenarios('all')
+	const evalResult = await evaluateTunables(scenarios, [1, 2], tunables, runSimulation)
+	const analysis = analyzeVulnerabilities(scenarios, evalResult)
+
+	assert.ok(analysis.weakest)
+	assertEquals(analysis.ranked.length >= 1, true)
+	assertEquals(analysis.ranked[0].attack, analysis.weakest.attack)
+	assertEquals(typeof analysis.weakest.severity, 'string')
+	assertEquals(typeof analysis.weakest.impact, 'string')
+
+	const md = formatVulnerabilityMarkdown(analysis).join('\n')
+	assertEquals(md.includes('防御薄弱点'), true)
+	assertEquals(md.includes(analysis.weakest.label), true)
+
+	const consoleLines = formatVulnerabilityConsole(analysis)
+	assertEquals(consoleLines.some(l => l.includes('最弱:')), true)
+	shutdownSimPool()
+})

package/sim/transport.mjs

@@ -0,0 +1,135 @@
+/**
+ * 传输/信令层子模型：RTC 连接预算 + 信令源多样性（软加成，不强制多来源）。
+ * 预算默认值直接派生自真实 rtc_connection_budget.mjs，避免与生产代码人肉脱钩。
+ */
+import { MAX_SOURCE_SLOT_FRACTION, resolveRtcBudgetLimits } from '../transport/rtc_connection_budget.mjs'
+
+import { buildRankedNeighborAdj } from './graph_adj.mjs'
+
+/** 默认注册的信令/发现源（对齐真实 link_registry：lan + nostr + bt） */
+export const DEFAULT_SIGNALING_SOURCES = Object.freeze(['lan', 'nostr', 'bt'])
+
+/**
+ * @returns {object} 传输状态
+ */
+export function createTransportState() {
+	const limits = resolveRtcBudgetLimits()
+	return {
+		rtcMaxActive: limits.maxActive,
+		maxJoinsPerMin: limits.maxJoinsPerMin,
+		overloadCooldownMs: limits.overloadCooldownMs,
+		trustedReserveFraction: limits.trustedReserveFraction,
+		minTrustedReserved: limits.minTrustedReserved,
+		sourceSlotFraction: MAX_SOURCE_SLOT_FRACTION,
+		overloadUntil: 0,
+		joinTimestamps: [],
+		active: new Set(),
+		sourceByPeer: new Map(),
+		trustedPeers: new Set(),
+		hintsByObserver: new Map(),
+		signalingSources: [...DEFAULT_SIGNALING_SOURCES],
+	}
+}
+
+/**
+ * @param {ReturnType<typeof createTransportState>} state 传输状态
+ * @param {string} observerId 观察者
+ * @param {string} peerId 对端
+ * @param {string} sourceId 信令/发现来源
+ * @param {number} [weight=0.1] 基础权重
+ * @returns {number} 有效权重（多来源软加成，单来源仍可连接）
+ */
+export function transportHintWeight(state, observerId, peerId, sourceId, weight = 0.1) {
+	let bucket = state.hintsByObserver.get(observerId)
+	if (!bucket) {
+		bucket = new Map()
+		state.hintsByObserver.set(observerId, bucket)
+	}
+	let row = bucket.get(peerId)
+	if (!row) {
+		row = { sources: new Set(), weight: 0, trusted: state.trustedPeers.has(peerId) }
+		bucket.set(peerId, row)
+	}
+	row.sources.add(String(sourceId || 'peer'))
+	const multiBoost = row.sources.size >= 2 ? 1.2 : 1
+	row.weight = Math.max(row.weight, weight * multiBoost)
+	return row.weight
+}
+
+/**
+ * @param {ReturnType<typeof createTransportState>} state 传输状态
+ * @param {string} peerId 对端
+ * @param {string} sourceId 来源
+ * @param {number} now 当前时间
+ * @returns {boolean} 是否占槽成功
+ */
+export function takeTransportJoinSlot(state, peerId, sourceId, now = Date.now()) {
+	const cooldown = state.overloadCooldownMs ?? 15_000
+	if (now < state.overloadUntil) return false
+	state.joinTimestamps = state.joinTimestamps.filter(t => now - t < 60_000)
+	if (state.joinTimestamps.length >= state.maxJoinsPerMin) {
+		state.overloadUntil = now + cooldown
+		return false
+	}
+	if (peerId && state.active.has(peerId)) return true
+	const isTrusted = peerId && state.trustedPeers.has(peerId)
+	const trustedReserved = Math.max(state.minTrustedReserved ?? 3, Math.floor(state.rtcMaxActive * (state.trustedReserveFraction ?? 0.25)))
+	const maxNonTrusted = Math.max(1, state.rtcMaxActive - trustedReserved)
+	const nonTrusted = [...state.active].filter(id => !state.trustedPeers.has(id)).length
+	if (!isTrusted) {
+		const sameSource = [...state.sourceByPeer.values()].filter(s => s === sourceId).length
+		const sourceCap = Math.max(1, Math.floor(state.rtcMaxActive * (state.sourceSlotFraction ?? 0.25)))
+		if (sameSource >= sourceCap) return false
+		if (nonTrusted >= maxNonTrusted && state.active.size >= state.rtcMaxActive) {
+			state.overloadUntil = now + cooldown
+			return false
+		}
+	}
+	if (state.active.size >= state.rtcMaxActive && !isTrusted) {
+		state.overloadUntil = now + cooldown
+		return false
+	}
+	state.joinTimestamps.push(now)
+	if (peerId) {
+		state.active.add(peerId)
+		state.sourceByPeer.set(peerId, String(sourceId || 'peer'))
+	}
+	return true
+}
+
+/**
+ * @param {ReturnType<typeof createTransportState>} state 传输状态
+ * @param {string} observerId 观察者
+ * @param {string[]} friendlyIds 友善节点
+ * @param {(id: string) => number} scoreOf 信誉分
+ * @param {number} [now=Date.now()] 当前时间（仿真须传 simulationContext.now，与 takeTransportJoinSlot 同一时钟）
+ * @returns {{ reach: number, diversity: number, throttleOk: number }} 传输指标
+ */
+export function transportMetrics(state, observerId, friendlyIds, scoreOf, now = Date.now()) {
+	const bucket = state.hintsByObserver.get(observerId) ?? new Map()
+	const adj = buildRankedNeighborAdj(friendlyIds, scoreOf, 6)
+	const visited = new Set([observerId])
+	let frontier = [observerId]
+	for (let hop = 0; hop < 4 && frontier.length; hop++) {
+		const next = []
+		for (const id of frontier)
+			for (const peer of adj.get(id) ?? []) {
+				if (visited.has(peer)) continue
+				visited.add(peer)
+				next.push(peer)
+			}
+		frontier = next
+	}
+	const target = friendlyIds.filter(id => id !== observerId)
+	const reach = target.length ? [...visited].filter(id => target.includes(id)).length / target.length : 0
+	let diversitySum = 0
+	let diversityN = 0
+	for (const [peerId, row] of bucket) {
+		if (!target.includes(peerId)) continue
+		diversitySum += Math.min(1, row.sources.size / Math.max(1, state.signalingSources.length))
+		diversityN++
+	}
+	const diversity = diversityN ? diversitySum / diversityN : 1
+	const throttleOk = state.overloadUntil > now ? 0 : 1
+	return { reach, diversity, throttleOk }
+}