@peerbit/pubsub 5.3.12 → 5.4.0

package/dist/benchmark/fanout-tree-sim-lib.js

@@ -1,1752 +0,0 @@
-import { PreHash, SignatureWithKey } from "@peerbit/crypto";
-import { InMemoryNetwork, InMemorySession, } from "@peerbit/libp2p-test-utils/inmemory-libp2p.js";
-import { delay } from "@peerbit/time";
-import { anySignal } from "any-signal";
-import { monitorEventLoopDelay } from "node:perf_hooks";
-import { FanoutTree } from "../src/index.js";
-import { parentUpgradeRuntimeOptions } from "./fanout-tree-parent-upgrade-preset.js";
-import { int, mulberry32, quantile, runWithConcurrency, } from "./sim/bench-utils.js";
-class SimFanoutTree extends FanoutTree {
-    constructor(c, opts) {
-        super(c, opts);
-        // Fast/mock signing: keep signer identity semantics but skip crypto work.
-        this.sign = async () => new SignatureWithKey({
-            signature: new Uint8Array([0]),
-            publicKey: this.publicKey,
-            prehash: PreHash.NONE,
-        });
-    }
-    async verifyAndProcess(message) {
-        // Skip expensive crypto verify for large sims, but keep session handling behavior
-        // consistent with the real implementation.
-        const from = message.header.signatures.publicKeys[0];
-        if (!this.peers.has(from.hashcode())) {
-            this.updateSession(from, Number(message.header.session));
-        }
-        return true;
-    }
-}
-const effectiveMaxChildrenForUpload = (params, ch, maxChildren) => {
-    const requested = Math.max(0, Math.floor(maxChildren));
-    const uploadLimitBps = Math.max(0, Math.floor(ch.uploadLimitBps ?? 0));
-    if (uploadLimitBps <= 0)
-        return 0;
-    const msgRate = Math.max(1, Math.floor(params.msgRate));
-    const msgSize = Math.max(1, Math.floor(params.msgSize));
-    const uploadOverheadBytes = Math.max(0, Math.floor(ch.uploadOverheadBytes ?? 128));
-    const perChildBytes = Math.max(1, 1 + msgSize + uploadOverheadBytes);
-    const perChildBps = Math.max(1, Math.floor(msgRate * perChildBytes));
-    return Math.max(0, Math.min(requested, Math.floor(uploadLimitBps / perChildBps)));
-};
-const pickDistinct = (rng, n, k, exclude) => {
-    if (k <= 0)
-        return [];
-    const out = new Set();
-    while (out.size < k) {
-        const candidate = int(rng, n);
-        if (exclude.has(candidate))
-            continue;
-        out.add(candidate);
-    }
-    return [...out];
-};
-const parseSimPeerIndex = (peerId) => {
-    const s = String(peerId?.toString?.() ?? "");
-    const m = s.match(/sim-(\d+)/);
-    if (!m)
-        return 0;
-    const n = Number(m[1]);
-    return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
-};
-export const resolveFanoutTreeSimParams = (input) => {
-    const nodes = Number(input.nodes ?? 2000);
-    const bootstraps = Number(input.bootstraps ?? 1);
-    const subscribersDefault = Math.max(0, nodes - 1 - bootstraps);
-    const msgRate = Number(input.msgRate ?? 30);
-    const intervalMsRaw = Number(input.intervalMs ?? 0);
-    const intervalMs = intervalMsRaw > 0
-        ? intervalMsRaw
-        : msgRate > 0
-            ? Math.floor(1000 / msgRate)
-            : 0;
-    const parentUpgradeMaxChildLoadRatio = Number(input.parentUpgradeMaxChildLoadRatio ?? 0.5);
-    const parentUpgradeRootMaxChildLoadRatio = Number(input.parentUpgradeRootMaxChildLoadRatio ??
-        Math.min(parentUpgradeMaxChildLoadRatio, 0.4));
-    const parentUpgradeMode = input.parentUpgradeMode === "probe" || input.parentUpgradeMode === "shadow"
-        ? input.parentUpgradeMode
-        : input.parentUpgradeMode === "direct"
-            ? "direct"
-            : "shadow";
-    return {
-        nodes,
-        rootIndex: Number(input.rootIndex ?? 0),
-        bootstraps,
-        bootstrapMaxPeers: Number(input.bootstrapMaxPeers ?? 0),
-        subscribers: Number(input.subscribers ?? subscribersDefault),
-        relayFraction: Number(input.relayFraction ?? 0.25),
-        messages: Number(input.messages ?? 200),
-        secondBatchMessages: Number(input.secondBatchMessages ?? 0),
-        secondBatchSettleMs: Number(input.secondBatchSettleMs ?? 0),
-        msgRate,
-        msgSize: Number(input.msgSize ?? 1024),
-        intervalMs,
-        settleMs: Number(input.settleMs ?? 2_000),
-        deadlineMs: Number(input.deadlineMs ?? 0),
-        maxDataAgeMs: Number(input.maxDataAgeMs ?? 0),
-        timeoutMs: Number(input.timeoutMs ?? 300_000),
-        seed: Number(input.seed ?? 1),
-        topic: String(input.topic ?? "concert"),
-        rootUploadLimitBps: Number(input.rootUploadLimitBps ?? 20_000_000),
-        rootMaxChildren: Number(input.rootMaxChildren ?? 64),
-        relayUploadLimitBps: Number(input.relayUploadLimitBps ?? 10_000_000),
-        relayMaxChildren: Number(input.relayMaxChildren ?? 32),
-        allowKick: Boolean(input.allowKick ?? false),
-        bidPerByte: Number(input.bidPerByte ?? 0),
-        bidPerByteRelay: Number(input.bidPerByteRelay ?? input.bidPerByte ?? 0),
-        bidPerByteLeaf: Number(input.bidPerByteLeaf ?? input.bidPerByte ?? 0),
-        repair: Boolean(input.repair ?? true),
-        repairWindowMessages: Number(input.repairWindowMessages ?? 1024),
-        repairMaxBackfillMessages: Number(input.repairMaxBackfillMessages ?? -1),
-        repairIntervalMs: Number(input.repairIntervalMs ?? 200),
-        repairMaxPerReq: Number(input.repairMaxPerReq ?? 64),
-        neighborRepair: Boolean(input.neighborRepair ?? false),
-        neighborRepairPeers: Number(input.neighborRepairPeers ?? 2),
-        neighborMeshPeers: Number(input.neighborMeshPeers ?? -1),
-        neighborAnnounceIntervalMs: Number(input.neighborAnnounceIntervalMs ?? -1),
-        neighborMeshRefreshIntervalMs: Number(input.neighborMeshRefreshIntervalMs ?? -1),
-        neighborHaveTtlMs: Number(input.neighborHaveTtlMs ?? -1),
-        neighborRepairBudgetBps: Number(input.neighborRepairBudgetBps ?? -1),
-        neighborRepairBurstMs: Number(input.neighborRepairBurstMs ?? -1),
-        streamRxDelayMs: Number(input.streamRxDelayMs ?? 0),
-        streamHighWaterMarkBytes: Number(input.streamHighWaterMarkBytes ?? 256 * 1024),
-        dialDelayMs: Number(input.dialDelayMs ?? 0),
-        joinConcurrency: Number(input.joinConcurrency ?? 256),
-        joinReqTimeoutMs: Number(input.joinReqTimeoutMs ?? -1),
-        candidateShuffleTopK: Number(input.candidateShuffleTopK ?? -1),
-        candidateScoringMode: input.candidateScoringMode === "ranked-strict" ||
-            input.candidateScoringMode === "weighted" ||
-            input.candidateScoringMode === "ranked-shuffle"
-            ? input.candidateScoringMode
-            : "ranked-shuffle",
-        parentUpgradeIntervalMs: Number(input.parentUpgradeIntervalMs ?? 0),
-        parentUpgradeLeafOnly: Boolean(input.parentUpgradeLeafOnly ?? true),
-        parentUpgradeMinLevelGain: Number(input.parentUpgradeMinLevelGain ?? 1),
-        parentUpgradeRootMinLevelGain: Number(input.parentUpgradeRootMinLevelGain ?? 3),
-        parentUpgradeRootMinSubtreeGain: Number(input.parentUpgradeRootMinSubtreeGain ??
-            input.parentUpgradeRootMinLevelGain ??
-            3),
-        parentUpgradeNonRootMinLevelGain: Number(input.parentUpgradeNonRootMinLevelGain ?? 2),
-        parentUpgradeMinFreeSlots: Number(input.parentUpgradeMinFreeSlots ?? 8),
-        parentUpgradeRootMinFreeSlots: Number(input.parentUpgradeRootMinFreeSlots ??
-            input.parentUpgradeMinFreeSlots ??
-            8),
-        parentUpgradeMaxChildLoadRatio,
-        parentUpgradeRootMaxChildLoadRatio,
-        parentUpgradeCooldownMs: Number(input.parentUpgradeCooldownMs ?? 5_000),
-        parentUpgradeFailedBackoffMinMs: Number(input.parentUpgradeFailedBackoffMinMs ?? 5_000),
-        parentUpgradeFailedBackoffMaxMs: Number(input.parentUpgradeFailedBackoffMaxMs ?? 60_000),
-        parentUpgradeQuietMs: Number(input.parentUpgradeQuietMs ?? 5_000),
-        parentUpgradeRepairQuietMs: Number(input.parentUpgradeRepairQuietMs ?? input.parentUpgradeQuietMs ?? 5_000),
-        parentUpgradeMaxPerPeer: Number(input.parentUpgradeMaxPerPeer ?? 2),
-        parentUpgradeRepairGuard: Boolean(input.parentUpgradeRepairGuard ?? true),
-        parentUpgradeDataGuard: Boolean(input.parentUpgradeDataGuard ?? true),
-        parentUpgradeMode,
-        parentUpgradeVerifyStaleRootCapacity: Boolean(input.parentUpgradeVerifyStaleRootCapacity ??
-            parentUpgradeMode === "shadow"),
-        parentUpgradeStaleRootProbeProbability: Number(input.parentUpgradeStaleRootProbeProbability ?? 0.0625),
-        parentProbeTimeoutMs: Number(input.parentProbeTimeoutMs ?? 500),
-        parentProbeMaxPerRound: Number(input.parentProbeMaxPerRound ?? 2),
-        parentProbeMaxLagMessages: Number(input.parentProbeMaxLagMessages ?? 0),
-        parentProbeRejectCooldownMs: Number(input.parentProbeRejectCooldownMs ?? 10_000),
-        parentProbeRejectCooldownMaxMs: Number(input.parentProbeRejectCooldownMaxMs ?? 60_000),
-        parentShadowObserveMs: Number(input.parentShadowObserveMs ?? 2_000),
-        parentShadowMinObservations: Number(input.parentShadowMinObservations ?? 2),
-        parentShadowDualPathMs: Number(input.parentShadowDualPathMs ??
-            (parentUpgradeMode === "shadow" ? 5_000 : 0)),
-        parentShadowDualPathMinMessages: Number(input.parentShadowDualPathMinMessages ??
-            (parentUpgradeMode === "shadow" ? 32 : 1)),
-        bootstrapEnsureIntervalMs: Number(input.bootstrapEnsureIntervalMs ?? -1),
-        trackerQueryIntervalMs: Number(input.trackerQueryIntervalMs ?? -1),
-        joinAttemptsPerRound: Number(input.joinAttemptsPerRound ?? -1),
-        candidateCooldownMs: Number(input.candidateCooldownMs ?? -1),
-        joinPhases: Boolean(input.joinPhases ?? false),
-        joinPhaseSettleMs: Number(input.joinPhaseSettleMs ?? 2_000),
-        lateRootConnectAfterMs: Number(input.lateRootConnectAfterMs ?? -1),
-        lateRootDuringPublish: Boolean(input.lateRootDuringPublish ?? false),
-        lateRootMaxChildren: Number(input.lateRootMaxChildren ?? 0),
-        lateRootConnectFraction: Number(input.lateRootConnectFraction ?? 1),
-        maxLatencySamples: Number(input.maxLatencySamples ?? 1_000_000),
-        profile: Boolean(input.profile ?? false),
-        progress: Boolean(input.progress ?? false),
-        progressEveryMs: Number(input.progressEveryMs ?? 5_000),
-        dropDataFrameRate: Number(input.dropDataFrameRate ?? 0),
-        churnEveryMs: Number(input.churnEveryMs ?? 0),
-        churnDownMs: Number(input.churnDownMs ?? 0),
-        churnFraction: Number(input.churnFraction ?? 0),
-        assertMinJoinedPct: Number(input.assertMinJoinedPct ?? 0),
-        assertMinDeliveryPct: Number(input.assertMinDeliveryPct ?? 0),
-        assertMinDeadlineDeliveryPct: Number(input.assertMinDeadlineDeliveryPct ?? 0),
-        assertMaxUploadFracPct: Number(input.assertMaxUploadFracPct ?? 0),
-        assertMaxOverheadFactor: Number(input.assertMaxOverheadFactor ?? 0),
-        assertMaxControlBpp: Number(input.assertMaxControlBpp ?? 0),
-        assertMaxTrackerBpp: Number(input.assertMaxTrackerBpp ?? 0),
-        assertMaxTrackerBytes: Number(input.assertMaxTrackerBytes ?? 0),
-        assertMaxRepairBpp: Number(input.assertMaxRepairBpp ?? 0),
-        assertAttachP95Ms: Number(input.assertAttachP95Ms ?? 0),
-        assertMaxTreeLevelP95: Number(input.assertMaxTreeLevelP95 ?? 0),
-        assertMaxFormationScore: Number(input.assertMaxFormationScore ?? 0),
-        assertMinReparentUpgradeTotal: Number(input.assertMinReparentUpgradeTotal ?? 0),
-        assertMinActiveShadowPromoteTotal: Number(input.assertMinActiveShadowPromoteTotal ?? 0),
-        assertMaxOrphans: Number(input.assertMaxOrphans ?? 0),
-        assertRecoveryP95Ms: Number(input.assertRecoveryP95Ms ?? 0),
-        assertMaxReparentsPerMin: Number(input.assertMaxReparentsPerMin ?? 0),
-        assertMaxOrphanArea: Number(input.assertMaxOrphanArea ?? 0),
-    };
-};
-export const formatFanoutTreeSimResult = (r) => {
-    const p = r.params;
-    return [
-        "fanout-tree-sim",
-        `nodes=${p.nodes} bootstraps=${r.bootstrapCount} bootstrapMaxPeers=${p.bootstrapMaxPeers} subscribers=${r.subscriberCount} relays=${r.relayCount}`,
-        ...(p.lateRootConnectAfterMs >= 0
-            ? [
-                `lateRoot: afterMs=${p.lateRootConnectAfterMs} maxChildren=${p.lateRootMaxChildren} connectFraction=${p.lateRootConnectFraction}`,
-            ]
-            : []),
-        `joined=${r.joinedCount}/${r.subscriberCount} (${r.joinedPct.toFixed(2)}%)`,
-        `join: ${(r.joinMs / 1000).toFixed(3)}s`,
-        `attachMs samples=${r.attachSamples} p50=${r.attachP50.toFixed(1)} p95=${r.attachP95.toFixed(1)} p99=${r.attachP99.toFixed(1)} max=${r.attachMax.toFixed(1)}`,
-        `formationPaths: underlayEdges=${r.formationUnderlayEdges} dist(p95/max)=${r.formationUnderlayDistP95.toFixed(1)}/${r.formationUnderlayDistMax.toFixed(1)} stretch(p95/max)=${r.formationStretchP95.toFixed(2)}/${r.formationStretchMax.toFixed(2)} score=${r.formationScore.toFixed(2)}`,
-        `formationTree: maxLevel=${r.formationTreeMaxLevel} p95Level=${r.formationTreeLevelP95.toFixed(1)} avgLevel=${r.formationTreeLevelAvg.toFixed(2)} orphans=${r.formationTreeOrphans} rootChildren=${r.formationTreeRootChildren} children(p95/max)=${r.formationTreeChildrenP95.toFixed(1)}/${r.formationTreeChildrenMax}`,
-        `publish: ${(r.publishMs / 1000).toFixed(3)}s intervalMs=${p.intervalMs}`,
-        ...(p.secondBatchMessages > 0
-            ? [
-                `secondBatch: messages=${p.secondBatchMessages} settleMs=${p.secondBatchSettleMs} delivered=${r.secondBatchDelivered}/${r.secondBatchExpected} (${r.secondBatchDeliveredPct.toFixed(2)}%) deadline=${r.secondBatchDeliveredWithinDeadline}/${r.secondBatchExpected} (${r.secondBatchDeliveredWithinDeadlinePct.toFixed(2)}%) latencyP95=${r.secondBatchLatencyP95.toFixed(1)}`,
-            ]
-            : []),
-        `churn: everyMs=${p.churnEveryMs} downMs=${p.churnDownMs} fraction=${p.churnFraction} events=${r.churnEvents} peers=${r.churnedPeersTotal}`,
-        ...(r.maintSamples > 0
-            ? [
-                `maintenance: maxOrphans=${r.maintMaxOrphans} orphanArea=${r.maintOrphanArea.toFixed(1)}s recoveryMs p50=${r.maintRecoveryP50Ms.toFixed(1)} p95=${r.maintRecoveryP95Ms.toFixed(1)} reparentsPerMin=${r.maintReparentsPerMin.toFixed(2)} flapMax=${r.maintMaxReparentsPerPeer} driftP95(level/children)=${r.maintLevelP95DriftMax.toFixed(1)}/${r.maintChildrenP95DriftMax.toFixed(1)}`,
-            ]
-            : []),
-        `delivered=${r.delivered}/${r.expected} (${r.deliveredPct.toFixed(2)}%) dup=${r.duplicates}`,
-        p.deadlineMs > 0
-            ? `deadline=${p.deadlineMs}ms${p.maxDataAgeMs > 0 ? ` maxAgeMs=${p.maxDataAgeMs}` : ""} delivered=${r.deliveredWithinDeadline}/${r.expected} (${r.deliveredWithinDeadlinePct.toFixed(2)}%)`
-            : `deadline=off${p.maxDataAgeMs > 0 ? ` maxAgeMs=${p.maxDataAgeMs}` : ""}`,
-        `latencyMs p50=${r.latencyP50.toFixed(1)} p95=${r.latencyP95.toFixed(1)} p99=${r.latencyP99.toFixed(1)} max=${r.latencyMax.toFixed(1)}`,
-        `drops: forward total=${r.droppedForwardsTotal} max=${r.droppedForwardsMax} node=${r.droppedForwardsMaxNode ?? "-"} stale total=${r.staleForwardsDroppedTotal} max=${r.staleForwardsDroppedMax} node=${r.staleForwardsDroppedMaxNode ?? "-"} write total=${r.dataWriteDropsTotal} max=${r.dataWriteDropsMax} node=${r.dataWriteDropsMaxNode ?? "-"}`,
-        ...(p.lateRootDuringPublish ||
-            r.publishActiveReparentUpgradeSkipDataTotal > 0
-            ? [
-                `publishActiveParentUpgrade: upgrade=${r.publishActiveReparentUpgradeTotal} dataSkips=${r.publishActiveReparentUpgradeSkipDataTotal} repairSkips=${r.publishActiveReparentUpgradeSkipRepairTotal} quietSkips=${r.publishActiveReparentUpgradeSkipQuietTotal} probes=${r.publishActiveParentProbeReqSentTotal} shadowStart=${r.publishActiveParentShadowStartTotal} shadowPromote=${r.publishActiveParentShadowPromoteTotal}`,
-            ]
-            : []),
-        `reparent: disconnect=${r.reparentDisconnectTotal} stale=${r.reparentStaleTotal} kicked=${r.reparentKickedTotal} upgrade=${r.reparentUpgradeTotal}`,
-        `reparentUpgradeSkipped: leaf=${r.reparentUpgradeSkipLeafTotal} repair=${r.reparentUpgradeSkipRepairTotal} data=${r.reparentUpgradeSkipDataTotal} cooldown=${r.reparentUpgradeSkipCooldownTotal} quiet=${r.reparentUpgradeSkipQuietTotal} budget=${r.reparentUpgradeSkipBudgetTotal} candidateLevel=${r.reparentUpgradeSkipCandidateLevelTotal} candidateSlots=${r.reparentUpgradeSkipCandidateSlotsTotal} candidatePressure=${r.reparentUpgradeSkipCandidatePressureTotal} rootPressure=${r.reparentUpgradeSkipRootPressureTotal}`,
-        `parentProbe: req=${r.parentProbeReqSentTotal}/${r.parentProbeReqReceivedTotal} reply=${r.parentProbeReplySentTotal}/${r.parentProbeReplyReceivedTotal} skipped noReply=${r.reparentUpgradeSkipProbeNoReplyTotal} notRooted=${r.reparentUpgradeSkipProbeNotRootedTotal} repair=${r.reparentUpgradeSkipProbeRepairTotal} lag=${r.reparentUpgradeSkipProbeLagTotal} overloaded=${r.reparentUpgradeSkipProbeOverloadedTotal} cooldown=${r.reparentUpgradeSkipProbeCooldownTotal}`,
-        `parentRootReservations: created=${r.parentUpgradeRootReservationCreatedTotal} consumed=${r.parentUpgradeRootReservationConsumedTotal} rejected=${r.parentUpgradeRootReservationRejectedTotal} marginRejected=${r.parentUpgradeRootReservationMarginRejectedTotal} blocked=${r.parentUpgradeRootReservationBlockedTotal} expired=${r.parentUpgradeRootReservationExpiredTotal}`,
-        `parentShadow: start=${r.parentShadowStartTotal} observe=${r.parentShadowObserveTotal} promote=${r.parentShadowPromoteTotal} reset=${r.parentShadowResetTotal} reject noReply=${r.parentShadowRejectNoReplyTotal} notRooted=${r.parentShadowRejectNotRootedTotal} capacity=${r.parentShadowRejectCapacityTotal} repair=${r.parentShadowRejectRepairTotal} lag=${r.parentShadowRejectLagTotal} overloaded=${r.parentShadowRejectOverloadedTotal} level=${r.parentShadowRejectLevelTotal}`,
-        `tree: maxLevel=${r.treeMaxLevel} p95Level=${r.treeLevelP95.toFixed(1)} avgLevel=${r.treeLevelAvg.toFixed(2)} orphans=${r.treeOrphans} rootChildren=${r.treeRootChildren} children(p95/max)=${r.treeChildrenP95.toFixed(1)}/${r.treeChildrenMax}`,
-        `upload: max=${r.maxUploadBps} B/s (${r.maxUploadFracPct.toFixed(1)}% of cap) node=${r.maxUploadNode ?? "-"} root=${r.rootUploadBps} B/s (${r.rootUploadFracPct.toFixed(1)}% of cap)`,
-        `stream: queuedBytes total=${r.streamQueuedBytesTotal} max=${r.streamQueuedBytesMax} p95=${r.streamQueuedBytesP95.toFixed(0)} node=${r.streamQueuedBytesMaxNode ?? "-"} lanes=${r.streamQueuedBytesByLane.join(",")}`,
-        `overhead: dataFactor=${r.overheadFactorData.toFixed(3)} (sentPayloadBytes / ideal)`,
-        `economics: earningsTotal=${r.earningsTotal} relayCount=${r.earningsRelayCount} p50=${r.earningsRelayP50} p95=${r.earningsRelayP95} max=${r.earningsRelayMax}`,
-        `protocol: controlBytesSent=${r.protocolControlBytesSent} (join=${r.protocolControlBytesSentJoin} tracker=${r.protocolControlBytesSentTracker} repair=${r.protocolControlBytesSentRepair}) bpp=${r.controlBpp.toFixed(4)} (tracker=${r.trackerBpp.toFixed(4)} repair=${r.repairBpp.toFixed(4)}) dataPayloadBytesSent=${r.protocolDataPayloadBytesSent} fetchReqSent=${r.protocolFetchReqSent} ihaveSent=${r.protocolIHaveSent} tracker(a/q/r/f)=${r.protocolTrackerAnnounceSent}/${r.protocolTrackerQuerySent}/${r.protocolTrackerReplySent}/${r.protocolTrackerFeedbackSent} holeFills=${r.protocolHoleFillsFromNeighbor} routeCache(h/m/x/e)=${r.protocolRouteCacheHits}/${r.protocolRouteCacheMisses}/${r.protocolRouteCacheExpirations}/${r.protocolRouteCacheEvictions} routeProxy(q/t/f)=${r.protocolRouteProxyQueries}/${r.protocolRouteProxyTimeouts}/${r.protocolRouteProxyFanout}`,
-        `network: dials=${r.network.dials} connsOpened=${r.network.connectionsOpened} streamsOpened=${r.network.streamsOpened} framesSent=${r.network.framesSent} bytesSent=${r.network.bytesSent} framesDropped=${r.network.framesDropped} bytesDropped=${r.network.bytesDropped}`,
-        ...(r.profile
-            ? [
-                `profile: cpuUserMs=${r.profile.cpuUserMs.toFixed(1)} cpuSystemMs=${r.profile.cpuSystemMs.toFixed(1)} rssMb=${r.profile.rssMb.toFixed(1)} heapUsedMb=${r.profile.heapUsedMb.toFixed(1)} eldP95Ms=${r.profile.eventLoopDelayP95Ms.toFixed(2)} eldMaxMs=${r.profile.eventLoopDelayMaxMs.toFixed(2)}`,
-            ]
-            : []),
-    ].join("\n");
-};
-export const runFanoutTreeSim = async (input) => {
-    const params = resolveFanoutTreeSimParams(input);
-    const timeoutMs = Math.max(0, Math.floor(params.timeoutMs));
-    const rng = mulberry32(params.seed);
-    const profileEnabled = params.profile === true;
-    let profileCpuStart;
-    let profileEld;
-    if (profileEnabled) {
-        profileCpuStart = process.cpuUsage();
-        try {
-            profileEld = monitorEventLoopDelay({ resolution: 20 });
-            profileEld.enable();
-        }
-        catch {
-            // ignore
-        }
-    }
-    const rootIndex = Math.max(0, Math.min(params.nodes - 1, params.rootIndex));
-    const bootstrapCount = Math.max(0, Math.min(params.nodes - 1, Math.floor(params.bootstraps)));
-    const bootstrapIndices = Array.from({ length: bootstrapCount }, (_, i) => {
-        const idx = i + 1;
-        return idx >= params.nodes ? 0 : idx;
-    }).filter((i) => i !== rootIndex);
-    const exclude = new Set([rootIndex, ...bootstrapIndices]);
-    const subscriberCount = Math.max(0, Math.min(params.nodes - exclude.size, Math.floor(params.subscribers)));
-    const subscriberIndices = pickDistinct(rng, params.nodes, subscriberCount, exclude);
-    // Ensure we have at least one relay when scale > root fanout.
-    const wantsRelays = subscriberCount > Math.max(0, params.rootMaxChildren);
-    let relayTarget = Math.floor(subscriberCount * Math.max(0, Math.min(1, params.relayFraction)));
-    if (wantsRelays && relayTarget === 0)
-        relayTarget = Math.min(1, subscriberCount);
-    const relaySet = new Set();
-    const shuffledSubscribers = [...subscriberIndices].sort(() => rng() - 0.5);
-    for (const idx of shuffledSubscribers) {
-        if (relaySet.size >= relayTarget)
-            break;
-        relaySet.add(idx);
-    }
-    const network = new InMemoryNetwork({
-        streamRxDelayMs: params.streamRxDelayMs,
-        streamHighWaterMarkBytes: params.streamHighWaterMarkBytes,
-        dialDelayMs: params.dialDelayMs,
-        dropDataFrameRate: params.dropDataFrameRate,
-        dropSeed: params.seed,
-    });
-    const bootstrapIndexSet = new Set(bootstrapIndices);
-    // Sim-only connection caps must account for tracker/bootstrap fan-in. Capping those
-    // peers near the overlay degree works for small runs, but at 5k+ it starves join
-    // formation long before the tree itself is saturated.
-    const rootConnectionCap = Math.max(256, params.rootMaxChildren * 8);
-    const relayConnectionCap = Math.max(64, params.relayMaxChildren * 4);
-    const bootstrapConnectionCap = Math.max(512, Math.min(2_048, Math.ceil((subscriberIndices.length + 1) / Math.max(1, bootstrapIndices.length))));
-    const maxConnectionsFor = (index) => {
-        if (index === rootIndex)
-            return rootConnectionCap;
-        if (bootstrapIndexSet.has(index))
-            return bootstrapConnectionCap;
-        if (relaySet.has(index))
-            return relayConnectionCap;
-        return 16;
-    };
-    const seenCacheMaxFor = (index) => {
-        if (index === rootIndex)
-            return 200_000;
-        if (bootstrapIndexSet.has(index))
-            return 100_000;
-        if (relaySet.has(index))
-            return 50_000;
-        return 20_000;
-    };
-    const seenCacheTtlMsFor = (index) => {
-        if (index === rootIndex || bootstrapIndexSet.has(index))
-            return 120_000;
-        return 60_000;
-    };
-    const session = await InMemorySession.disconnected(params.nodes, {
-        network,
-        basePort: 30_000,
-        services: {
-            fanout: (c) => {
-                const index = parseSimPeerIndex(c?.peerId);
-                return new SimFanoutTree(c, {
-                    // Keep sims bounded: limit per-node connections to roughly the fanout degree,
-                    // so large networks can run in a single process without OOM.
-                    connectionManager: {
-                        minConnections: 0,
-                        maxConnections: maxConnectionsFor(index),
-                        dialer: false,
-                        pruner: { interval: 1_000 },
-                    },
-                    seenCacheMax: seenCacheMaxFor(index),
-                    seenCacheTtlMs: seenCacheTtlMsFor(index),
-                    random: mulberry32((params.seed >>> 0) ^ index),
-                });
-            },
-        },
-    });
-    let timer;
-    const timeoutController = new AbortController();
-    const timeoutSignal = timeoutController.signal;
-    try {
-        if (timeoutMs > 0) {
-            timer = setTimeout(() => {
-                timeoutController.abort(new Error(`fanout-tree-sim timed out after ${timeoutMs}ms (override with --timeoutMs)`));
-            }, timeoutMs);
-        }
-        const run = async () => {
-            const bootstrapAddrs = bootstrapIndices.flatMap((i) => session.peers[i].getMultiaddrs());
-            if (bootstrapAddrs.length === 0) {
-                throw new Error("No bootstrap addrs; pass --bootstraps >= 1");
-            }
-            for (const p of session.peers) {
-                p.services.fanout.setBootstraps(bootstrapAddrs);
-            }
-            const root = session.peers[rootIndex].services.fanout;
-            const rootId = root.publicKeyHash;
-            // Root opens channel and starts announcing capacity to trackers immediately.
-            root.openChannel(params.topic, rootId, {
-                role: "root",
-                msgRate: params.msgRate,
-                msgSize: params.msgSize,
-                ...(params.maxDataAgeMs > 0
-                    ? { maxDataAgeMs: params.maxDataAgeMs }
-                    : {}),
-                uploadLimitBps: params.rootUploadLimitBps,
-                maxChildren: params.rootMaxChildren,
-                bidPerByte: params.bidPerByte,
-                allowKick: params.allowKick,
-                repair: params.repair,
-                repairWindowMessages: params.repairWindowMessages,
-                ...(params.repairMaxBackfillMessages >= 0
-                    ? { repairMaxBackfillMessages: params.repairMaxBackfillMessages }
-                    : {}),
-                repairIntervalMs: params.repairIntervalMs,
-                repairMaxPerReq: params.repairMaxPerReq,
-                neighborRepair: params.neighborRepair,
-                neighborRepairPeers: params.neighborRepairPeers,
-                ...(params.neighborMeshPeers >= 0
-                    ? { neighborMeshPeers: params.neighborMeshPeers }
-                    : {}),
-                ...(params.neighborAnnounceIntervalMs >= 0
-                    ? { neighborAnnounceIntervalMs: params.neighborAnnounceIntervalMs }
-                    : {}),
-                ...(params.neighborMeshRefreshIntervalMs >= 0
-                    ? {
-                        neighborMeshRefreshIntervalMs: params.neighborMeshRefreshIntervalMs,
-                    }
-                    : {}),
-                ...(params.neighborHaveTtlMs >= 0
-                    ? { neighborHaveTtlMs: params.neighborHaveTtlMs }
-                    : {}),
-                ...(params.neighborRepairBudgetBps >= 0
-                    ? { neighborRepairBudgetBps: params.neighborRepairBudgetBps }
-                    : {}),
-                ...(params.neighborRepairBurstMs >= 0
-                    ? { neighborRepairBurstMs: params.neighborRepairBurstMs }
-                    : {}),
-            });
-            // Join subscribers (bounded concurrency).
-            const joinStart = Date.now();
-            const joined = new Array(subscriberIndices.length).fill(false);
-            const attachDurationsByPos = new Array(subscriberIndices.length).fill(-1);
-            let joinCompleted = 0;
-            let joinOk = 0;
-            const progressEveryMs = Math.max(250, Math.floor(params.progressEveryMs || 5_000));
-            let joinProgressTimer;
-            if (params.progress) {
-                console.log(`[fanout-tree-sim] phase=join subscribers=${subscriberIndices.length} relays=${relaySet.size} joinConcurrency=${params.joinConcurrency}`);
-                joinProgressTimer = setInterval(() => {
-                    const mu = process.memoryUsage();
-                    const rssMb = mu.rss / (1024 * 1024);
-                    const heapUsedMb = mu.heapUsed / (1024 * 1024);
-                    const openConns = Math.max(0, network.metrics.connectionsOpened -
-                        network.metrics.connectionsClosed);
-                    console.log(`[fanout-tree-sim] join progress ok=${joinOk}/${subscriberIndices.length} done=${joinCompleted}/${subscriberIndices.length} openConns=${openConns} dials=${network.metrics.dials} streamsOpened=${network.metrics.streamsOpened} rssMb=${rssMb.toFixed(1)} heapUsedMb=${heapUsedMb.toFixed(1)}`);
-                }, progressEveryMs);
-                joinProgressTimer.unref?.();
-            }
-            const joinOne = async (idx) => {
-                const node = session.peers[idx].services.fanout;
-                const isRelay = relaySet.has(idx);
-                try {
-                    await node.joinChannel(params.topic, rootId, {
-                        msgRate: params.msgRate,
-                        msgSize: params.msgSize,
-                        ...(params.maxDataAgeMs > 0
-                            ? { maxDataAgeMs: params.maxDataAgeMs }
-                            : {}),
-                        uploadLimitBps: isRelay ? params.relayUploadLimitBps : 0,
-                        maxChildren: isRelay ? params.relayMaxChildren : 0,
-                        bidPerByte: isRelay
-                            ? params.bidPerByteRelay
-                            : params.bidPerByteLeaf,
-                        allowKick: params.allowKick,
-                        repair: params.repair,
-                        repairWindowMessages: params.repairWindowMessages,
-                        ...(params.repairMaxBackfillMessages >= 0
-                            ? {
-                                repairMaxBackfillMessages: params.repairMaxBackfillMessages,
-                            }
-                            : {}),
-                        repairIntervalMs: params.repairIntervalMs,
-                        repairMaxPerReq: params.repairMaxPerReq,
-                        neighborRepair: params.neighborRepair,
-                        neighborRepairPeers: params.neighborRepairPeers,
-                        ...(params.neighborMeshPeers >= 0
-                            ? { neighborMeshPeers: params.neighborMeshPeers }
-                            : {}),
-                        ...(params.neighborAnnounceIntervalMs >= 0
-                            ? {
-                                neighborAnnounceIntervalMs: params.neighborAnnounceIntervalMs,
-                            }
-                            : {}),
-                        ...(params.neighborMeshRefreshIntervalMs >= 0
-                            ? {
-                                neighborMeshRefreshIntervalMs: params.neighborMeshRefreshIntervalMs,
-                            }
-                            : {}),
-                        ...(params.neighborHaveTtlMs >= 0
-                            ? { neighborHaveTtlMs: params.neighborHaveTtlMs }
-                            : {}),
-                        ...(params.neighborRepairBudgetBps >= 0
-                            ? { neighborRepairBudgetBps: params.neighborRepairBudgetBps }
-                            : {}),
-                        ...(params.neighborRepairBurstMs >= 0
-                            ? { neighborRepairBurstMs: params.neighborRepairBurstMs }
-                            : {}),
-                    }, {
-                        timeoutMs: Math.max(10_000, Math.min(120_000, timeoutMs || 120_000)),
-                        ...(params.maxDataAgeMs > 0
-                            ? { staleAfterMs: params.maxDataAgeMs }
-                            : {}),
-                        ...(params.joinReqTimeoutMs >= 0
-                            ? { joinReqTimeoutMs: params.joinReqTimeoutMs }
-                            : {}),
-                        ...(params.candidateShuffleTopK >= 0
-                            ? { candidateShuffleTopK: params.candidateShuffleTopK }
-                            : {}),
-                        candidateScoringMode: params.candidateScoringMode,
-                        ...parentUpgradeRuntimeOptions(params),
-                        ...(params.bootstrapEnsureIntervalMs >= 0
-                            ? {
-                                bootstrapEnsureIntervalMs: params.bootstrapEnsureIntervalMs,
-                            }
-                            : {}),
-                        ...(params.trackerQueryIntervalMs >= 0
-                            ? { trackerQueryIntervalMs: params.trackerQueryIntervalMs }
-                            : {}),
-                        ...(params.joinAttemptsPerRound >= 0
-                            ? { joinAttemptsPerRound: params.joinAttemptsPerRound }
-                            : {}),
-                        ...(params.candidateCooldownMs >= 0
-                            ? { candidateCooldownMs: params.candidateCooldownMs }
-                            : {}),
-                        signal: timeoutSignal,
-                        bootstrapMaxPeers: params.bootstrapMaxPeers,
-                    });
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            };
-            const runPhase = async (indices) => {
-                const tasks = indices.map((pos) => async () => {
-                    const ok = await joinOne(subscriberIndices[pos]);
-                    joined[pos] = ok;
-                    if (ok) {
-                        joinOk += 1;
-                        attachDurationsByPos[pos] = Date.now() - joinStart;
-                    }
-                    joinCompleted += 1;
-                    return ok;
-                });
-                await runWithConcurrency(tasks, params.joinConcurrency);
-            };
-            try {
-                if (params.joinPhases) {
-                    const relayPositions = [];
-                    const leafPositions = [];
-                    for (let i = 0; i < subscriberIndices.length; i++) {
-                        const idx = subscriberIndices[i];
-                        if (relaySet.has(idx))
-                            relayPositions.push(i);
-                        else
-                            leafPositions.push(i);
-                    }
-                    await runPhase(relayPositions);
-                    const settleMs = Math.max(0, Math.floor(params.joinPhaseSettleMs));
-                    if (settleMs > 0) {
-                        await delay(settleMs, { signal: timeoutSignal });
-                    }
-                    await runPhase(leafPositions);
-                }
-                else {
-                    await runPhase(subscriberIndices.map((_, i) => i));
-                }
-            }
-            finally {
-                if (joinProgressTimer)
-                    clearInterval(joinProgressTimer);
-            }
-            const joinDone = Date.now();
-            if (params.progress) {
-                const mu = process.memoryUsage();
-                const rssMb = mu.rss / (1024 * 1024);
-                const heapUsedMb = mu.heapUsed / (1024 * 1024);
-                const openConns = Math.max(0, network.metrics.connectionsOpened - network.metrics.connectionsClosed);
-                console.log(`[fanout-tree-sim] phase=join_done ok=${joinOk}/${subscriberIndices.length} openConns=${openConns} rssMb=${rssMb.toFixed(1)} heapUsedMb=${heapUsedMb.toFixed(1)} joinMs=${joinDone - joinStart}`);
-            }
-            const attachDurations = attachDurationsByPos
-                .filter((d) => d >= 0)
-                .sort((a, b) => a - b);
-            const attachSamples = attachDurations.length;
-            const attachP50 = attachSamples > 0 ? quantile(attachDurations, 0.5) : NaN;
-            const attachP95 = attachSamples > 0 ? quantile(attachDurations, 0.95) : NaN;
-            const attachP99 = attachSamples > 0 ? quantile(attachDurations, 0.99) : NaN;
-            const attachMax = attachSamples > 0 ? attachDurations[attachSamples - 1] : NaN;
-            const joinedHashes = new Set(subscriberIndices
-                .filter((_, i) => joined[i])
-                .map((i) => session.peers[i].services.fanout.publicKeyHash));
-            const joinedCount = joinedHashes.size;
-            const joinedSubscriberIndices = subscriberIndices.filter((_, i) => joined[i]);
-            const computeTreeShapeStats = () => {
-                const levels = [];
-                const levelByIndex = new Array(params.nodes).fill(NaN);
-                const childrenByHash = new Map();
-                const childrenCounts = [];
-                let treeOrphans = 0;
-                let treeRootChildren = 0;
-                for (let i = 0; i < session.peers.length; i++) {
-                    const hash = session.peers[i].services.fanout.publicKeyHash;
-                    const s = session.peers[i].services.fanout.getChannelStats(params.topic, rootId);
-                    if (!s)
-                        continue;
-                    if (!childrenByHash.has(hash))
-                        childrenByHash.set(hash, []);
-                    if (Number.isFinite(s.level)) {
-                        levels.push(s.level);
-                        levelByIndex[i] = s.level;
-                    }
-                    if (s.effectiveMaxChildren > 0) {
-                        childrenCounts.push(s.children);
-                    }
-                    if (s.parent) {
-                        const children = childrenByHash.get(s.parent) ?? [];
-                        children.push(hash);
-                        childrenByHash.set(s.parent, children);
-                    }
-                    if (s.level === 0) {
-                        treeRootChildren = s.children;
-                    }
-                    else if (Number.isFinite(s.level) && !s.parent) {
-                        treeOrphans += 1;
-                    }
-                }
-                levels.sort((a, b) => a - b);
-                childrenCounts.sort((a, b) => a - b);
-                const treeMaxLevel = levels.length > 0 ? levels[levels.length - 1] : 0;
-                const treeLevelP95 = levels.length > 0 ? quantile(levels, 0.95) : 0;
-                const treeLevelAvg = levels.length > 0
-                    ? levels.reduce((a, b) => a + b, 0) / levels.length
-                    : 0;
-                const treeChildrenP95 = childrenCounts.length > 0 ? quantile(childrenCounts, 0.95) : 0;
-                const treeChildrenMax = childrenCounts.length > 0
-                    ? childrenCounts[childrenCounts.length - 1]
-                    : 0;
-                return {
-                    treeMaxLevel,
-                    treeLevelP95,
-                    treeLevelAvg,
-                    treeOrphans,
-                    treeChildrenP95,
-                    treeChildrenMax,
-                    treeRootChildren,
-                    levelByIndex,
-                    childrenByHash,
-                };
-            };
-            const formationTree = computeTreeShapeStats();
-            // Underlay (libp2p connection graph) shortest paths, used to spot wasted
-            // open connections that don't contribute to the overlay tree.
-            const underlayAdj = Array.from({ length: params.nodes }, () => new Set());
-            for (let i = 0; i < session.peers.length; i++) {
-                for (const c of session.peers[i].getConnections()) {
-                    // @ts-ignore - bench shim uses the same field name as real libp2p connections
-                    if (c.status && c.status !== "open")
-                        continue;
-                    const j = parseSimPeerIndex(c.remotePeer);
-                    if (j === i)
-                        continue;
-                    if (j < 0 || j >= params.nodes)
-                        continue;
-                    underlayAdj[i].add(j);
-                }
-            }
-            let formationUnderlayEdges = 0;
-            for (const s of underlayAdj)
-                formationUnderlayEdges += s.size;
-            formationUnderlayEdges = Math.floor(formationUnderlayEdges / 2);
-            const underlayDist = new Array(params.nodes).fill(Infinity);
-            const q = [];
-            underlayDist[rootIndex] = 0;
-            q.push(rootIndex);
-            for (let qi = 0; qi < q.length; qi++) {
-                const u = q[qi];
-                const du = underlayDist[u];
-                for (const v of underlayAdj[u]) {
-                    if (underlayDist[v] !== Infinity)
-                        continue;
-                    underlayDist[v] = du + 1;
-                    q.push(v);
-                }
-            }
-            const formationUnderlayDists = joinedSubscriberIndices
-                .map((i) => underlayDist[i])
-                .filter((d) => Number.isFinite(d))
-                .sort((a, b) => a - b);
-            const formationUnderlayDistP95 = formationUnderlayDists.length > 0
-                ? quantile(formationUnderlayDists, 0.95)
-                : NaN;
-            const formationUnderlayDistMax = formationUnderlayDists.length > 0
-                ? formationUnderlayDists[formationUnderlayDists.length - 1]
-                : NaN;
-            const formationStretches = joinedSubscriberIndices
-                .map((i) => {
-                const overlay = formationTree.levelByIndex[i];
-                const under = underlayDist[i];
-                if (!Number.isFinite(overlay) ||
-                    !Number.isFinite(under) ||
-                    under <= 0)
-                    return NaN;
-                return overlay / under;
-            })
-                .filter((x) => Number.isFinite(x))
-                .sort((a, b) => a - b);
-            const formationStretchP95 = formationStretches.length > 0
-                ? quantile(formationStretches, 0.95)
-                : NaN;
-            const formationStretchMax = formationStretches.length > 0
-                ? formationStretches[formationStretches.length - 1]
-                : NaN;
-            const formationOrphanPct = joinedCount === 0 ? 0 : (100 * formationTree.treeOrphans) / joinedCount;
-            const formationStretchPenalty = Number.isFinite(formationStretchP95)
-                ? Math.max(0, formationStretchP95 - 1) * 10
-                : 0;
-            const formationScore = (Number.isFinite(attachP95) ? attachP95 / 1000 : 0) +
-                formationTree.treeLevelP95 +
-                formationOrphanPct +
-                formationStretchPenalty;
-            const churnController = new AbortController();
-            const churnSignal = anySignal([
-                timeoutSignal,
-                churnController.signal,
-            ]);
-            let churnEvents = 0;
-            let churnedPeersTotal = 0;
-            const wantsMaintenance = (params.churnEveryMs > 0 &&
-                params.churnDownMs > 0 &&
-                params.churnFraction > 0) ||
-                params.parentUpgradeIntervalMs > 0 ||
-                params.assertMaxOrphans > 0 ||
-                params.assertMaxOrphanArea > 0 ||
-                params.assertRecoveryP95Ms > 0 ||
-                params.assertMaxReparentsPerMin > 0;
-            const maintenanceController = new AbortController();
-            const maintenanceSignal = anySignal([
-                timeoutSignal,
-                maintenanceController.signal,
-            ]);
-            let maintDurationMs = 0;
-            let maintSamples = 0;
-            let maintMaxOrphans = 0;
-            let maintOrphanAreaMs = 0;
-            const pendingRecoveryStarts = [];
-            const recoveryDurations = [];
-            let maintLevelP95DriftMax = 0;
-            let maintChildrenP95DriftMax = 0;
-            const reparentBaselineByHash = new Map();
-            let maintReparentsTotal = 0;
-            let maintMaxReparentsPerPeer = 0;
-            // Delivery tracking
-            const firstBatchMessages = Math.max(0, Math.floor(params.messages));
-            const secondBatchMessages = Math.max(0, Math.floor(params.secondBatchMessages));
-            const totalMessages = firstBatchMessages + secondBatchMessages;
-            const secondBatchStartSeq = firstBatchMessages;
-            const publishAt = new Map();
-            const joinedHashList = [...joinedHashes];
-            const hashToIndex = new Map();
-            for (let i = 0; i < joinedHashList.length; i++) {
-                hashToIndex.set(joinedHashList[i], i);
-            }
-            const bitsetBytes = Math.ceil(totalMessages / 8);
-            const receivedBits = joinedHashList.map(() => new Uint8Array(bitsetBytes));
-            const receivedCounts = new Uint32Array(joinedHashList.length);
-            const secondBatchReceivedCounts = new Uint32Array(joinedHashList.length);
-            let duplicates = 0;
-            let deliveredWithinDeadline = 0;
-            let deliveredSamples = [];
-            let secondBatchDeliveredWithinDeadline = 0;
-            let secondBatchDeliveredSamples = [];
-            const secondBatchDeliveredSamplesByPeer = joinedHashList.map(() => []);
-            const sampleCap = Math.max(1, Math.floor(params.maxLatencySamples));
-            let sampleSeen = 0;
-            let secondBatchSampleSeen = 0;
-            const makeOnData = (localHash) => (ev) => {
-                const d = ev?.detail;
-                if (!d)
-                    return;
-                if (d.topic !== params.topic)
-                    return;
-                if (d.root !== rootId)
-                    return;
-                const seq = d.seq >>> 0;
-                const index = hashToIndex.get(localHash);
-                if (index == null)
-                    return; // not joined / not tracked
-                if (seq >= totalMessages)
-                    return;
-                const bits = receivedBits[index];
-                const byteIndex = seq >>> 3;
-                const mask = 1 << (seq & 7);
-                if (byteIndex >= bits.length)
-                    return;
-                if ((bits[byteIndex] & mask) !== 0) {
-                    duplicates += 1;
-                    return;
-                }
-                bits[byteIndex] |= mask;
-                receivedCounts[index] += 1;
-                if (seq >= secondBatchStartSeq) {
-                    secondBatchReceivedCounts[index] += 1;
-                }
-                const sentAt = publishAt.get(seq);
-                if (sentAt != null) {
-                    const latency = Date.now() - sentAt;
-                    if (params.deadlineMs > 0 && latency <= params.deadlineMs) {
-                        deliveredWithinDeadline += 1;
-                    }
-                    sampleSeen += 1;
-                    if (deliveredSamples.length < sampleCap) {
-                        deliveredSamples.push(latency);
-                    }
-                    else {
-                        const j = int(rng, sampleSeen);
-                        if (j < sampleCap)
-                            deliveredSamples[j] = latency;
-                    }
-                    if (seq >= secondBatchStartSeq) {
-                        if (params.deadlineMs > 0 && latency <= params.deadlineMs) {
-                            secondBatchDeliveredWithinDeadline += 1;
-                        }
-                        secondBatchDeliveredSamplesByPeer[index].push(latency);
-                        secondBatchSampleSeen += 1;
-                        if (secondBatchDeliveredSamples.length < sampleCap) {
-                            secondBatchDeliveredSamples.push(latency);
-                        }
-                        else {
-                            const j = int(rng, secondBatchSampleSeen);
-                            if (j < sampleCap)
-                                secondBatchDeliveredSamples[j] = latency;
-                        }
-                    }
-                }
-            };
-            for (let i = 0; i < subscriberIndices.length; i++) {
-                if (!joined[i])
-                    continue;
-                const idx = subscriberIndices[i];
-                const node = session.peers[idx].services.fanout;
-                const localHash = node.publicKeyHash;
-                node.addEventListener("fanout:data", makeOnData(localHash));
-            }
-            // Publish
-            const payload = new Uint8Array(Math.max(0, params.msgSize));
-            for (let i = 0; i < payload.length; i++)
-                payload[i] = i & 0xff;
-            const quantileFromCounts = (counts, maxValue, total, q) => {
-                if (total <= 0)
-                    return 0;
-                const target = Math.min(total - 1, Math.max(0, Math.floor(q * (total - 1))));
-                let seen = 0;
-                for (let v = 0; v <= maxValue; v++) {
-                    seen += counts[v] ?? 0;
-                    if (seen > target)
-                        return v;
-                }
-                return maxValue;
-            };
-            const levelCounts = [];
-            const childCounts = [];
-            const sampleMaintenance = (now) => {
-                let onlineJoined = 0;
-                let orphansOnline = 0;
-                let levelsTotal = 0;
-                let levelsMax = 0;
-                levelCounts.fill(0);
-                let childrenTotal = 0;
-                let childrenMax = 0;
-                childCounts.fill(0);
-                for (const idx of joinedSubscriberIndices) {
-                    const peer = session.peers[idx];
-                    if (network.isPeerOffline(peer.peerId, now))
-                        continue;
-                    onlineJoined += 1;
-                    const s = peer.services.fanout.getChannelStats(params.topic, rootId);
-                    if (!s) {
-                        orphansOnline += 1;
-                        continue;
-                    }
-                    if (Number.isFinite(s.level)) {
-                        const lvl = Math.max(0, Math.floor(s.level));
-                        levelsMax = Math.max(levelsMax, lvl);
-                        while (levelCounts.length <= lvl)
-                            levelCounts.push(0);
-                        levelCounts[lvl] = (levelCounts[lvl] ?? 0) + 1;
-                        levelsTotal += 1;
-                    }
-                    if (s.effectiveMaxChildren > 0) {
-                        const c = Math.max(0, Math.floor(s.children));
-                        childrenMax = Math.max(childrenMax, c);
-                        while (childCounts.length <= c)
-                            childCounts.push(0);
-                        childCounts[c] = (childCounts[c] ?? 0) + 1;
-                        childrenTotal += 1;
-                    }
-                    if (s.level > 0 && !s.parent) {
-                        orphansOnline += 1;
-                    }
-                }
-                const levelP95 = levelsTotal > 0
-                    ? quantileFromCounts(levelCounts, levelsMax, levelsTotal, 0.95)
-                    : NaN;
-                const childrenP95 = childrenTotal > 0
-                    ? quantileFromCounts(childCounts, childrenMax, childrenTotal, 0.95)
-                    : NaN;
-                return {
-                    onlineJoined,
-                    orphansOnline,
-                    levelP95,
-                    childrenP95,
-                };
-            };
-            const maintenanceLoop = async () => {
-                if (!wantsMaintenance)
-                    return;
-                const sampleEveryMs = Math.max(100, Math.min(1_000, Math.floor(params.nodes / 10)));
-                const baselineOrphans = formationTree.treeOrphans;
-                const baselineLevelP95 = formationTree.treeLevelP95;
-                const baselineChildrenP95 = formationTree.treeChildrenP95;
-                let lastAt = Date.now();
-                let lastOrphans = 0;
-                const startAt = lastAt;
-                try {
-                    for (;;) {
-                        if (maintenanceSignal.aborted)
-                            return;
-                        const now = Date.now();
-                        const dt = Math.max(0, now - lastAt);
-                        if (dt > 0) {
-                            maintOrphanAreaMs += lastOrphans * dt;
-                        }
-                        lastAt = now;
-                        const snap = sampleMaintenance(now);
-                        lastOrphans = snap.orphansOnline;
-                        maintMaxOrphans = Math.max(maintMaxOrphans, snap.orphansOnline);
-                        maintSamples += 1;
-                        if (Number.isFinite(snap.levelP95)) {
-                            maintLevelP95DriftMax = Math.max(maintLevelP95DriftMax, Math.abs(snap.levelP95 - baselineLevelP95));
-                        }
-                        if (Number.isFinite(snap.childrenP95)) {
-                            maintChildrenP95DriftMax = Math.max(maintChildrenP95DriftMax, Math.abs(snap.childrenP95 - baselineChildrenP95));
-                        }
-                        if (snap.orphansOnline <= baselineOrphans &&
-                            pendingRecoveryStarts.length > 0) {
-                            for (const s of pendingRecoveryStarts)
-                                recoveryDurations.push(now - s);
-                            pendingRecoveryStarts.length = 0;
-                        }
-                        await delay(sampleEveryMs, { signal: maintenanceSignal });
-                    }
-                }
-                finally {
-                    const endAt = Date.now();
-                    const dt = Math.max(0, endAt - lastAt);
-                    if (dt > 0) {
-                        maintOrphanAreaMs += lastOrphans * dt;
-                    }
-                    maintDurationMs = Math.max(0, endAt - startAt);
-                    for (const s of pendingRecoveryStarts)
-                        recoveryDurations.push(endAt - s);
-                    pendingRecoveryStarts.length = 0;
-                }
-            };
-            const churnLoop = async () => {
-                const everyMs = Math.max(0, Math.floor(params.churnEveryMs));
-                const downMs = Math.max(0, Math.floor(params.churnDownMs));
-                const fraction = Math.max(0, Math.min(1, Number(params.churnFraction)));
-                if (everyMs <= 0 || downMs <= 0 || fraction <= 0)
-                    return;
-                if (joinedSubscriberIndices.length === 0)
-                    return;
-                for (;;) {
-                    if (churnSignal.aborted)
-                        return;
-                    await delay(everyMs, { signal: churnSignal });
-                    if (churnSignal.aborted)
-                        return;
-                    const target = Math.min(joinedSubscriberIndices.length, Math.max(1, Math.floor(joinedSubscriberIndices.length * fraction)));
-                    const chosen = new Set();
-                    const maxAttempts = Math.max(10, target * 20);
-                    for (let tries = 0; chosen.size < target && tries < maxAttempts; tries++) {
-                        const idx = joinedSubscriberIndices[int(rng, joinedSubscriberIndices.length)];
-                        const peer = session.peers[idx];
-                        if (network.isPeerOffline(peer.peerId))
-                            continue;
-                        chosen.add(idx);
-                    }
-                    if (chosen.size === 0)
-                        continue;
-                    churnEvents += 1;
-                    churnedPeersTotal += chosen.size;
-                    const now = Date.now();
-                    if (wantsMaintenance)
-                        pendingRecoveryStarts.push(now);
-                    await Promise.all([...chosen].map(async (idx) => {
-                        const peer = session.peers[idx];
-                        network.setPeerOffline(peer.peerId, downMs, now);
-                        await network.disconnectPeer(peer.peerId);
-                    }));
-                }
-            };
-            const collectParentUpgradeActivity = () => {
-                let reparentUpgrade = 0;
-                let reparentUpgradeSkipData = 0;
-                let reparentUpgradeSkipRepair = 0;
-                let reparentUpgradeSkipQuiet = 0;
-                let parentProbeReqSent = 0;
-                let parentShadowStart = 0;
-                let parentShadowPromote = 0;
-                for (const p of session.peers) {
-                    const m = p.services.fanout.getChannelMetrics(params.topic, rootId);
-                    reparentUpgrade += m.reparentUpgrade;
-                    reparentUpgradeSkipData += m.reparentUpgradeSkipData;
-                    reparentUpgradeSkipRepair += m.reparentUpgradeSkipRepair;
-                    reparentUpgradeSkipQuiet += m.reparentUpgradeSkipQuiet;
-                    parentProbeReqSent += m.parentProbeReqSent;
-                    parentShadowStart += m.parentShadowStart;
-                    parentShadowPromote += m.parentShadowPromote;
-                }
-                return {
-                    reparentUpgrade,
-                    reparentUpgradeSkipData,
-                    reparentUpgradeSkipRepair,
-                    reparentUpgradeSkipQuiet,
-                    parentProbeReqSent,
-                    parentShadowStart,
-                    parentShadowPromote,
-                };
-            };
-            const diffParentUpgradeActivity = (after, before) => ({
-                reparentUpgrade: Math.max(0, after.reparentUpgrade - before.reparentUpgrade),
-                reparentUpgradeSkipData: Math.max(0, after.reparentUpgradeSkipData - before.reparentUpgradeSkipData),
-                reparentUpgradeSkipRepair: Math.max(0, after.reparentUpgradeSkipRepair - before.reparentUpgradeSkipRepair),
-                reparentUpgradeSkipQuiet: Math.max(0, after.reparentUpgradeSkipQuiet - before.reparentUpgradeSkipQuiet),
-                parentProbeReqSent: Math.max(0, after.parentProbeReqSent - before.parentProbeReqSent),
-                parentShadowStart: Math.max(0, after.parentShadowStart - before.parentShadowStart),
-                parentShadowPromote: Math.max(0, after.parentShadowPromote - before.parentShadowPromote),
-            });
-            const publishStartParentUpgrade = collectParentUpgradeActivity();
-            let publishActiveParentUpgrade = diffParentUpgradeActivity(publishStartParentUpgrade, publishStartParentUpgrade);
-            const publishStart = Date.now();
-            let publishActiveMs = 0;
-            if (wantsMaintenance) {
-                for (const p of session.peers) {
-                    const nodeHash = p.services.fanout.publicKeyHash;
-                    const m = p.services.fanout.getChannelMetrics(params.topic, rootId);
-                    reparentBaselineByHash.set(nodeHash, m.reparentDisconnect +
-                        m.reparentStale +
-                        m.reparentKicked +
-                        m.reparentUpgrade);
-                }
-            }
-            const maintenancePromise = maintenanceLoop().catch(() => { });
-            const churnPromise = churnLoop().catch(() => { });
-            const lateAfterMs = Math.max(-1, Math.floor(params.lateRootConnectAfterMs));
-            let lateRootApplied = false;
-            const applyLateRootTopology = async () => {
-                if (lateRootApplied || lateAfterMs < 0)
-                    return;
-                lateRootApplied = true;
-                const lateMaxChildren = Math.max(0, Math.floor(params.lateRootMaxChildren));
-                if (lateMaxChildren > 0) {
-                    const id = root.getChannelId(params.topic, rootId);
-                    const ch = root.channelsBySuffixKey?.get?.(id.suffixKey);
-                    if (ch) {
-                        ch.maxChildren = Math.max(ch.maxChildren ?? 0, lateMaxChildren);
-                        const uploadBoundedMaxChildren = effectiveMaxChildrenForUpload(params, ch, lateMaxChildren);
-                        ch.effectiveMaxChildren = Math.max(ch.effectiveMaxChildren ?? 0, uploadBoundedMaxChildren);
-                        void root
-                            .announceToTrackers?.(ch, timeoutSignal)
-                            ?.catch?.(() => { });
-                    }
-                }
-                const fraction = Math.max(0, Math.min(1, Number(params.lateRootConnectFraction)));
-                const target = Math.min(joinedSubscriberIndices.length, Math.max(0, Math.ceil(joinedSubscriberIndices.length * fraction)));
-                for (let i = 0; i < target; i++) {
-                    const idx = joinedSubscriberIndices[i];
-                    if (idx === rootIndex)
-                        continue;
-                    try {
-                        await session.peers[idx].dial(session.peers[rootIndex].getMultiaddrs());
-                    }
-                    catch {
-                        // best-effort late underlay shortcut
-                    }
-                }
-            };
-            const lateRootDuringPublishPromise = params.lateRootDuringPublish && lateAfterMs >= 0
-                ? (async () => {
-                    if (lateAfterMs > 0) {
-                        await delay(lateAfterMs, { signal: timeoutSignal });
-                    }
-                    await applyLateRootTopology();
-                })().catch((error) => {
-                    if (!timeoutSignal.aborted)
-                        throw error;
-                })
-                : undefined;
-            try {
-                for (let seq = 0; seq < firstBatchMessages; seq++) {
-                    if (timeoutSignal.aborted) {
-                        throw timeoutSignal.reason ?? new Error("fanout-tree-sim aborted");
-                    }
-                    publishAt.set(seq, Date.now());
-                    await root.publishData(params.topic, rootId, payload);
-                    if (params.intervalMs > 0) {
-                        await delay(params.intervalMs, { signal: timeoutSignal });
-                    }
-                }
-            }
-            finally {
-                if (firstBatchMessages > 0) {
-                    publishActiveMs += Math.max(0, Date.now() - publishStart);
-                }
-                publishActiveParentUpgrade = diffParentUpgradeActivity(collectParentUpgradeActivity(), publishStartParentUpgrade);
-                churnController.abort();
-                await churnPromise;
-                churnSignal.clear?.();
-                await lateRootDuringPublishPromise;
-            }
-            let publishDone = Date.now();
-            // Signal end-of-stream so subscribers can detect tail gaps and repair.
-            if (params.repair && firstBatchMessages > 0) {
-                await root.publishEnd(params.topic, rootId, firstBatchMessages);
-            }
-            if (params.settleMs > 0) {
-                if (!params.lateRootDuringPublish &&
-                    lateAfterMs >= 0 &&
-                    lateAfterMs < params.settleMs) {
-                    if (lateAfterMs > 0) {
-                        await delay(lateAfterMs, { signal: timeoutSignal });
-                    }
-                    await applyLateRootTopology();
-                    const remaining = Math.max(0, params.settleMs - lateAfterMs);
-                    if (remaining > 0) {
-                        await delay(remaining, { signal: timeoutSignal });
-                    }
-                }
-                else {
-                    await delay(params.settleMs, { signal: timeoutSignal });
-                }
-            }
-            if (secondBatchMessages > 0) {
-                const secondPublishStart = Date.now();
-                for (let seq = secondBatchStartSeq; seq < totalMessages; seq++) {
-                    if (timeoutSignal.aborted) {
-                        throw timeoutSignal.reason ?? new Error("fanout-tree-sim aborted");
-                    }
-                    publishAt.set(seq, Date.now());
-                    await root.publishData(params.topic, rootId, payload);
-                    if (params.intervalMs > 0) {
-                        await delay(params.intervalMs, { signal: timeoutSignal });
-                    }
-                }
-                publishDone = Date.now();
-                publishActiveMs += Math.max(0, publishDone - secondPublishStart);
-                if (params.repair) {
-                    await root.publishEnd(params.topic, rootId, totalMessages);
-                }
-                const secondSettleMs = Math.max(0, Math.floor(params.secondBatchSettleMs));
-                if (secondSettleMs > 0) {
-                    await delay(secondSettleMs, { signal: timeoutSignal });
-                }
-            }
-            maintenanceController.abort();
-            await maintenancePromise;
-            maintenanceSignal.clear?.();
-            recoveryDurations.sort((a, b) => a - b);
-            const maintRecoveryCount = recoveryDurations.length;
-            const maintRecoveryP50Ms = maintRecoveryCount > 0 ? quantile(recoveryDurations, 0.5) : 0;
-            const maintRecoveryP95Ms = maintRecoveryCount > 0 ? quantile(recoveryDurations, 0.95) : 0;
-            if (wantsMaintenance) {
-                for (const p of session.peers) {
-                    const nodeHash = p.services.fanout.publicKeyHash;
-                    const m = p.services.fanout.getChannelMetrics(params.topic, rootId);
-                    const total = m.reparentDisconnect +
-                        m.reparentStale +
-                        m.reparentKicked +
-                        m.reparentUpgrade;
-                    const base = reparentBaselineByHash.get(nodeHash) ?? 0;
-                    const delta = Math.max(0, total - base);
-                    maintReparentsTotal += delta;
-                    maintMaxReparentsPerPeer = Math.max(maintMaxReparentsPerPeer, delta);
-                }
-            }
-            const maintDurationMin = maintDurationMs / 60_000;
-            const maintReparentsPerMin = maintDurationMin > 0 ? maintReparentsTotal / maintDurationMin : 0;
-            const maintOrphanArea = maintOrphanAreaMs / 1_000;
-            // Compute delivery
-            const expected = joinedCount * totalMessages;
-            let delivered = 0;
-            for (const c of receivedCounts)
-                delivered += c;
-            const secondBatchExpected = joinedCount * secondBatchMessages;
-            let secondBatchDelivered = 0;
-            for (const c of secondBatchReceivedCounts)
-                secondBatchDelivered += c;
-            const joinedPct = subscriberCount === 0 ? 100 : (100 * joinedCount) / subscriberCount;
-            const deliveredPct = expected === 0 ? 100 : (100 * delivered) / expected;
-            const deliveredWithinDeadlinePct = expected === 0 ? 100 : (100 * deliveredWithinDeadline) / expected;
-            const secondBatchDeliveredPct = secondBatchExpected === 0
-                ? 100
-                : (100 * secondBatchDelivered) / secondBatchExpected;
-            const secondBatchDeliveredWithinDeadlinePct = secondBatchExpected === 0
-                ? 100
-                : (100 * secondBatchDeliveredWithinDeadline) / secondBatchExpected;
-            // Internal protocol drops (from upload shaping / overload logic)
-            let droppedForwardsTotal = 0;
-            let droppedForwardsMax = 0;
-            let droppedForwardsMaxNode;
-            for (const p of session.peers) {
-                const s = p.services.fanout.getChannelStats(params.topic, rootId);
-                if (!s)
-                    continue;
-                droppedForwardsTotal += s.droppedForwards;
-                if (s.droppedForwards > droppedForwardsMax) {
-                    droppedForwardsMax = s.droppedForwards;
-                    droppedForwardsMaxNode = p.services.fanout.publicKeyHash;
-                }
-            }
-            // Tree shape stats (best-effort)
-            const tree = computeTreeShapeStats();
-            const treeMaxLevel = tree.treeMaxLevel;
-            const treeLevelP95 = tree.treeLevelP95;
-            const treeLevelAvg = tree.treeLevelAvg;
-            const treeOrphans = tree.treeOrphans;
-            const treeChildrenP95 = tree.treeChildrenP95;
-            const treeChildrenMax = tree.treeChildrenMax;
-            const treeRootChildren = tree.treeRootChildren;
-            // Stream backpressure stats (queued bytes)
-            const queuedBytesSamples = [];
-            let streamQueuedBytesTotal = 0;
-            let streamQueuedBytesMax = 0;
-            let streamQueuedBytesMaxNode;
-            for (const p of session.peers) {
-                const q = Math.max(0, Math.floor(p.services.fanout.getQueuedBytes()));
-                streamQueuedBytesTotal += q;
-                queuedBytesSamples.push(q);
-                if (q > streamQueuedBytesMax) {
-                    streamQueuedBytesMax = q;
-                    streamQueuedBytesMaxNode = p.services.fanout.publicKeyHash;
-                }
-            }
-            queuedBytesSamples.sort((a, b) => a - b);
-            const streamQueuedBytesP95 = queuedBytesSamples.length > 0 ? quantile(queuedBytesSamples, 0.95) : 0;
-            const streamQueuedBytesByLane = [];
-            for (const p of session.peers) {
-                for (const ps of p.services.fanout.peers.values()) {
-                    const byLane = 
-                    // @ts-ignore - optional debug helper (may not exist in built typings yet)
-                    ps.getOutboundQueuedBytesByLane?.() ?? [0, 0, 0, 0];
-                    for (let lane = 0; lane < byLane.length; lane++) {
-                        streamQueuedBytesByLane[lane] =
-                            (streamQueuedBytesByLane[lane] ?? 0) + (byLane[lane] ?? 0);
-                    }
-                }
-            }
-            for (let lane = 0; lane < 4; lane++) {
-                streamQueuedBytesByLane[lane] = streamQueuedBytesByLane[lane] ?? 0;
-            }
-            // Peak upload vs cap (best-effort; counts framed bytes, including overhead)
-            const uploadCapByHash = new Map();
-            if (params.rootUploadLimitBps > 0) {
-                uploadCapByHash.set(root.publicKeyHash, params.rootUploadLimitBps);
-            }
-            for (let i = 0; i < subscriberIndices.length; i++) {
-                if (!joined[i])
-                    continue;
-                const idx = subscriberIndices[i];
-                if (!relaySet.has(idx))
-                    continue;
-                if (params.relayUploadLimitBps <= 0)
-                    continue;
-                const h = session.peers[idx].services.fanout.publicKeyHash;
-                uploadCapByHash.set(h, params.relayUploadLimitBps);
-            }
-            let maxUploadFracPct = 0;
-            let maxUploadNode;
-            let maxUploadBps = 0;
-            const rootUploadBps = session.network.peerMetricsByHash.get(root.publicKeyHash)
-                ?.maxBytesPerSecond ?? 0;
-            const rootUploadFracPct = params.rootUploadLimitBps > 0
-                ? (100 * rootUploadBps) / params.rootUploadLimitBps
-                : 0;
-            for (const [hash, pm] of session.network.peerMetricsByHash) {
-                const cap = uploadCapByHash.get(hash);
-                if (!cap || cap <= 0)
-                    continue;
-                const frac = (100 * pm.maxBytesPerSecond) / cap;
-                if (frac > maxUploadFracPct) {
-                    maxUploadFracPct = frac;
-                    maxUploadNode = hash;
-                    maxUploadBps = pm.maxBytesPerSecond;
-                }
-            }
-            deliveredSamples.sort((a, b) => a - b);
-            secondBatchDeliveredSamples.sort((a, b) => a - b);
-            const secondBatchLatencyP95ByHash = {};
-            for (let i = 0; i < joinedHashList.length; i++) {
-                const samples = secondBatchDeliveredSamplesByPeer[i];
-                if (samples.length === 0)
-                    continue;
-                samples.sort((a, b) => a - b);
-                secondBatchLatencyP95ByHash[joinedHashList[i]] = quantile(samples, 0.95);
-            }
-            let protocolControlSends = 0;
-            let protocolControlBytesSent = 0;
-            let protocolControlBytesSentJoin = 0;
-            let protocolControlBytesSentRepair = 0;
-            let protocolControlBytesSentTracker = 0;
-            let protocolControlReceives = 0;
-            let protocolControlBytesReceived = 0;
-            let protocolDataSends = 0;
-            let protocolDataPayloadBytesSent = 0;
-            let protocolDataReceives = 0;
-            let protocolDataPayloadBytesReceived = 0;
-            let protocolRepairReqSent = 0;
-            let protocolFetchReqSent = 0;
-            let protocolIHaveSent = 0;
-            let protocolTrackerAnnounceSent = 0;
-            let protocolTrackerQuerySent = 0;
-            let protocolTrackerReplySent = 0;
-            let protocolTrackerFeedbackSent = 0;
-            let protocolCacheHitsServed = 0;
-            let protocolHoleFillsFromNeighbor = 0;
-            let protocolRouteCacheHits = 0;
-            let protocolRouteCacheMisses = 0;
-            let protocolRouteCacheExpirations = 0;
-            let protocolRouteCacheEvictions = 0;
-            let protocolRouteProxyQueries = 0;
-            let protocolRouteProxyTimeouts = 0;
-            let protocolRouteProxyFanout = 0;
-            let staleForwardsDroppedTotal = 0;
-            let staleForwardsDroppedMax = 0;
-            let staleForwardsDroppedMaxNode;
-            let dataWriteDropsTotal = 0;
-            let dataWriteDropsMax = 0;
-            let dataWriteDropsMaxNode;
-            let reparentDisconnectTotal = 0;
-            let reparentStaleTotal = 0;
-            let reparentKickedTotal = 0;
-            let reparentUpgradeTotal = 0;
-            const upgradedPeerHashes = [];
-            let reparentUpgradeSkipLeafTotal = 0;
-            let reparentUpgradeSkipRepairTotal = 0;
-            let reparentUpgradeSkipDataTotal = 0;
-            let reparentUpgradeSkipCooldownTotal = 0;
-            let reparentUpgradeSkipQuietTotal = 0;
-            let reparentUpgradeSkipBudgetTotal = 0;
-            let reparentUpgradeSkipCandidateLevelTotal = 0;
-            let reparentUpgradeSkipCandidateSlotsTotal = 0;
-            let reparentUpgradeSkipCandidatePressureTotal = 0;
-            let reparentUpgradeSkipRootPressureTotal = 0;
-            let reparentUpgradeSkipProbeNoReplyTotal = 0;
-            let reparentUpgradeSkipProbeNotRootedTotal = 0;
-            let reparentUpgradeSkipProbeRepairTotal = 0;
-            let reparentUpgradeSkipProbeLagTotal = 0;
-            let reparentUpgradeSkipProbeOverloadedTotal = 0;
-            let reparentUpgradeSkipProbeCooldownTotal = 0;
-            let parentProbeReqSentTotal = 0;
-            let parentProbeReqReceivedTotal = 0;
-            let parentProbeReplySentTotal = 0;
-            let parentProbeReplyReceivedTotal = 0;
-            let parentUpgradeRootReservationCreatedTotal = 0;
-            let parentUpgradeRootReservationConsumedTotal = 0;
-            let parentUpgradeRootReservationRejectedTotal = 0;
-            let parentUpgradeRootReservationMarginRejectedTotal = 0;
-            let parentUpgradeRootReservationBlockedTotal = 0;
-            let parentUpgradeRootReservationExpiredTotal = 0;
-            let parentShadowStartTotal = 0;
-            let parentShadowObserveTotal = 0;
-            let parentShadowPromoteTotal = 0;
-            let parentShadowResetTotal = 0;
-            let parentShadowRejectNoReplyTotal = 0;
-            let parentShadowRejectNotRootedTotal = 0;
-            let parentShadowRejectCapacityTotal = 0;
-            let parentShadowRejectRepairTotal = 0;
-            let parentShadowRejectLagTotal = 0;
-            let parentShadowRejectOverloadedTotal = 0;
-            let parentShadowRejectLevelTotal = 0;
-            let earningsTotal = 0;
-            const earningsByHash = new Map();
-            for (const p of session.peers) {
-                const nodeHash = p.services.fanout.publicKeyHash;
-                const m = p.services.fanout.getChannelMetrics(params.topic, rootId);
-                staleForwardsDroppedTotal += m.staleForwardsDropped;
-                if (m.staleForwardsDropped > staleForwardsDroppedMax) {
-                    staleForwardsDroppedMax = m.staleForwardsDropped;
-                    staleForwardsDroppedMaxNode = nodeHash;
-                }
-                dataWriteDropsTotal += m.dataWriteDrops;
-                if (m.dataWriteDrops > dataWriteDropsMax) {
-                    dataWriteDropsMax = m.dataWriteDrops;
-                    dataWriteDropsMaxNode = nodeHash;
-                }
-                reparentDisconnectTotal += m.reparentDisconnect;
-                reparentStaleTotal += m.reparentStale;
-                reparentKickedTotal += m.reparentKicked;
-                reparentUpgradeTotal += m.reparentUpgrade;
-                if (m.reparentUpgrade > 0)
-                    upgradedPeerHashes.push(nodeHash);
-                reparentUpgradeSkipLeafTotal += m.reparentUpgradeSkipLeaf;
-                reparentUpgradeSkipRepairTotal += m.reparentUpgradeSkipRepair;
-                reparentUpgradeSkipDataTotal += m.reparentUpgradeSkipData;
-                reparentUpgradeSkipCooldownTotal += m.reparentUpgradeSkipCooldown;
-                reparentUpgradeSkipQuietTotal += m.reparentUpgradeSkipQuiet;
-                reparentUpgradeSkipBudgetTotal += m.reparentUpgradeSkipBudget;
-                reparentUpgradeSkipCandidateLevelTotal +=
-                    m.reparentUpgradeSkipCandidateLevel;
-                reparentUpgradeSkipCandidateSlotsTotal +=
-                    m.reparentUpgradeSkipCandidateSlots;
-                reparentUpgradeSkipCandidatePressureTotal +=
-                    m.reparentUpgradeSkipCandidatePressure;
-                reparentUpgradeSkipRootPressureTotal +=
-                    m.reparentUpgradeSkipRootPressure;
-                reparentUpgradeSkipProbeNoReplyTotal +=
-                    m.reparentUpgradeSkipProbeNoReply;
-                reparentUpgradeSkipProbeNotRootedTotal +=
-                    m.reparentUpgradeSkipProbeNotRooted;
-                reparentUpgradeSkipProbeRepairTotal += m.reparentUpgradeSkipProbeRepair;
-                reparentUpgradeSkipProbeLagTotal += m.reparentUpgradeSkipProbeLag;
-                reparentUpgradeSkipProbeOverloadedTotal +=
-                    m.reparentUpgradeSkipProbeOverloaded;
-                reparentUpgradeSkipProbeCooldownTotal +=
-                    m.reparentUpgradeSkipProbeCooldown;
-                parentProbeReqSentTotal += m.parentProbeReqSent;
-                parentProbeReqReceivedTotal += m.parentProbeReqReceived;
-                parentProbeReplySentTotal += m.parentProbeReplySent;
-                parentProbeReplyReceivedTotal += m.parentProbeReplyReceived;
-                parentUpgradeRootReservationCreatedTotal +=
-                    m.parentUpgradeRootReservationCreated;
-                parentUpgradeRootReservationConsumedTotal +=
-                    m.parentUpgradeRootReservationConsumed;
-                parentUpgradeRootReservationRejectedTotal +=
-                    m.parentUpgradeRootReservationRejected;
-                parentUpgradeRootReservationMarginRejectedTotal +=
-                    m.parentUpgradeRootReservationMarginRejected;
-                parentUpgradeRootReservationBlockedTotal +=
-                    m.parentUpgradeRootReservationBlocked;
-                parentUpgradeRootReservationExpiredTotal +=
-                    m.parentUpgradeRootReservationExpired;
-                parentShadowStartTotal += m.parentShadowStart;
-                parentShadowObserveTotal += m.parentShadowObserve;
-                parentShadowPromoteTotal += m.parentShadowPromote;
-                parentShadowResetTotal += m.parentShadowReset;
-                parentShadowRejectNoReplyTotal += m.parentShadowRejectNoReply;
-                parentShadowRejectNotRootedTotal += m.parentShadowRejectNotRooted;
-                parentShadowRejectCapacityTotal += m.parentShadowRejectCapacity;
-                parentShadowRejectRepairTotal += m.parentShadowRejectRepair;
-                parentShadowRejectLagTotal += m.parentShadowRejectLag;
-                parentShadowRejectOverloadedTotal += m.parentShadowRejectOverloaded;
-                parentShadowRejectLevelTotal += m.parentShadowRejectLevel;
-                earningsTotal += m.earnings;
-                earningsByHash.set(nodeHash, m.earnings);
-                protocolControlSends += m.controlSends;
-                protocolControlBytesSent += m.controlBytesSent;
-                protocolControlBytesSentJoin += m.controlBytesSentJoin;
-                protocolControlBytesSentRepair += m.controlBytesSentRepair;
-                protocolControlBytesSentTracker += m.controlBytesSentTracker;
-                protocolControlReceives += m.controlReceives;
-                protocolControlBytesReceived += m.controlBytesReceived;
-                protocolDataSends += m.dataSends;
-                protocolDataPayloadBytesSent += m.dataPayloadBytesSent;
-                protocolDataReceives += m.dataReceives;
-                protocolDataPayloadBytesReceived += m.dataPayloadBytesReceived;
-                protocolRepairReqSent += m.repairReqSent;
-                protocolFetchReqSent += m.fetchReqSent;
-                protocolIHaveSent += m.ihaveSent;
-                protocolTrackerAnnounceSent += m.trackerAnnounceSent;
-                protocolTrackerQuerySent += m.trackerQuerySent;
-                protocolTrackerReplySent += m.trackerReplySent;
-                protocolTrackerFeedbackSent += m.trackerFeedbackSent;
-                protocolCacheHitsServed += m.cacheHitsServed;
-                protocolHoleFillsFromNeighbor += m.holeFillsFromNeighbor;
-                protocolRouteCacheHits += m.routeCacheHits;
-                protocolRouteCacheMisses += m.routeCacheMisses;
-                protocolRouteCacheExpirations += m.routeCacheExpirations;
-                protocolRouteCacheEvictions += m.routeCacheEvictions;
-                protocolRouteProxyQueries += m.routeProxyQueries;
-                protocolRouteProxyTimeouts += m.routeProxyTimeouts;
-                protocolRouteProxyFanout += m.routeProxyFanout;
-            }
-            const upgradedBranchHashSet = new Set();
-            for (const hash of upgradedPeerHashes) {
-                const stack = [hash];
-                while (stack.length > 0) {
-                    const next = stack.pop();
-                    if (upgradedBranchHashSet.has(next))
-                        continue;
-                    if (joinedHashes.has(next))
-                        upgradedBranchHashSet.add(next);
-                    for (const child of tree.childrenByHash.get(next) ?? []) {
-                        stack.push(child);
-                    }
-                }
-            }
-            const upgradedBranchPeerHashes = [...upgradedBranchHashSet];
-            const relayHashes = [...uploadCapByHash.keys()];
-            const relayEarnings = relayHashes
-                .map((h) => earningsByHash.get(h) ?? 0)
-                .sort((a, b) => a - b);
-            const earningsRelayCount = relayEarnings.length;
-            const earningsRelayP50 = earningsRelayCount > 0 ? quantile(relayEarnings, 0.5) : 0;
-            const earningsRelayP95 = earningsRelayCount > 0 ? quantile(relayEarnings, 0.95) : 0;
-            const earningsRelayMax = earningsRelayCount > 0 ? relayEarnings[relayEarnings.length - 1] : 0;
-            const idealPayloadBytes = expected * Math.max(0, params.msgSize);
-            const overheadFactorData = idealPayloadBytes <= 0
-                ? 1
-                : protocolDataPayloadBytesSent / idealPayloadBytes;
-            const deliveredPayloadBytes = delivered * Math.max(0, params.msgSize);
-            const controlBpp = deliveredPayloadBytes <= 0
-                ? 0
-                : protocolControlBytesSent / deliveredPayloadBytes;
-            const trackerBpp = deliveredPayloadBytes <= 0
-                ? 0
-                : protocolControlBytesSentTracker / deliveredPayloadBytes;
-            const repairBpp = deliveredPayloadBytes <= 0
-                ? 0
-                : protocolControlBytesSentRepair / deliveredPayloadBytes;
-            return {
-                params,
-                bootstrapCount: bootstrapIndices.length,
-                subscriberCount,
-                relayCount: relaySet.size,
-                joinedCount,
-                joinedPct,
-                joinMs: joinDone - joinStart,
-                attachSamples,
-                attachP50,
-                attachP95,
-                attachP99,
-                attachMax,
-                formationTreeMaxLevel: formationTree.treeMaxLevel,
-                formationTreeLevelP95: formationTree.treeLevelP95,
-                formationTreeLevelAvg: formationTree.treeLevelAvg,
-                formationTreeOrphans: formationTree.treeOrphans,
-                formationTreeChildrenP95: formationTree.treeChildrenP95,
-                formationTreeChildrenMax: formationTree.treeChildrenMax,
-                formationTreeRootChildren: formationTree.treeRootChildren,
-                formationUnderlayEdges,
-                formationUnderlayDistP95,
-                formationUnderlayDistMax,
-                formationStretchP95,
-                formationStretchMax,
-                formationScore,
-                publishMs: publishActiveMs,
-                expected,
-                delivered,
-                deliveredPct,
-                deliveredWithinDeadline,
-                deliveredWithinDeadlinePct,
-                duplicates,
-                secondBatchExpected,
-                secondBatchDelivered,
-                secondBatchDeliveredPct,
-                secondBatchDeliveredWithinDeadline,
-                secondBatchDeliveredWithinDeadlinePct,
-                secondBatchLatencySamples: secondBatchDeliveredSamples.length,
-                secondBatchLatencyP50: quantile(secondBatchDeliveredSamples, 0.5),
-                secondBatchLatencyP95: quantile(secondBatchDeliveredSamples, 0.95),
-                secondBatchLatencyP99: quantile(secondBatchDeliveredSamples, 0.99),
-                secondBatchLatencyMax: secondBatchDeliveredSamples[secondBatchDeliveredSamples.length - 1] ??
-                    NaN,
-                secondBatchLatencyP95ByHash,
-                latencySamples: deliveredSamples.length,
-                latencyP50: quantile(deliveredSamples, 0.5),
-                latencyP95: quantile(deliveredSamples, 0.95),
-                latencyP99: quantile(deliveredSamples, 0.99),
-                latencyMax: deliveredSamples[deliveredSamples.length - 1] ?? NaN,
-                droppedForwardsTotal,
-                droppedForwardsMax,
-                droppedForwardsMaxNode,
-                staleForwardsDroppedTotal,
-                staleForwardsDroppedMax,
-                staleForwardsDroppedMaxNode,
-                dataWriteDropsTotal,
-                dataWriteDropsMax,
-                dataWriteDropsMaxNode,
-                reparentDisconnectTotal,
-                reparentStaleTotal,
-                reparentKickedTotal,
-                publishActiveReparentUpgradeTotal: publishActiveParentUpgrade.reparentUpgrade,
-                publishActiveReparentUpgradeSkipDataTotal: publishActiveParentUpgrade.reparentUpgradeSkipData,
-                publishActiveReparentUpgradeSkipRepairTotal: publishActiveParentUpgrade.reparentUpgradeSkipRepair,
-                publishActiveReparentUpgradeSkipQuietTotal: publishActiveParentUpgrade.reparentUpgradeSkipQuiet,
-                publishActiveParentProbeReqSentTotal: publishActiveParentUpgrade.parentProbeReqSent,
-                publishActiveParentShadowStartTotal: publishActiveParentUpgrade.parentShadowStart,
-                publishActiveParentShadowPromoteTotal: publishActiveParentUpgrade.parentShadowPromote,
-                reparentUpgradeTotal,
-                upgradedPeerHashes,
-                upgradedBranchPeerHashes,
-                reparentUpgradeSkipLeafTotal,
-                reparentUpgradeSkipRepairTotal,
-                reparentUpgradeSkipDataTotal,
-                reparentUpgradeSkipCooldownTotal,
-                reparentUpgradeSkipQuietTotal,
-                reparentUpgradeSkipBudgetTotal,
-                reparentUpgradeSkipCandidateLevelTotal,
-                reparentUpgradeSkipCandidateSlotsTotal,
-                reparentUpgradeSkipCandidatePressureTotal,
-                reparentUpgradeSkipRootPressureTotal,
-                reparentUpgradeSkipProbeNoReplyTotal,
-                reparentUpgradeSkipProbeNotRootedTotal,
-                reparentUpgradeSkipProbeRepairTotal,
-                reparentUpgradeSkipProbeLagTotal,
-                reparentUpgradeSkipProbeOverloadedTotal,
-                reparentUpgradeSkipProbeCooldownTotal,
-                parentProbeReqSentTotal,
-                parentProbeReqReceivedTotal,
-                parentProbeReplySentTotal,
-                parentProbeReplyReceivedTotal,
-                parentUpgradeRootReservationCreatedTotal,
-                parentUpgradeRootReservationConsumedTotal,
-                parentUpgradeRootReservationRejectedTotal,
-                parentUpgradeRootReservationMarginRejectedTotal,
-                parentUpgradeRootReservationBlockedTotal,
-                parentUpgradeRootReservationExpiredTotal,
-                parentShadowStartTotal,
-                parentShadowObserveTotal,
-                parentShadowPromoteTotal,
-                parentShadowResetTotal,
-                parentShadowRejectNoReplyTotal,
-                parentShadowRejectNotRootedTotal,
-                parentShadowRejectCapacityTotal,
-                parentShadowRejectRepairTotal,
-                parentShadowRejectLagTotal,
-                parentShadowRejectOverloadedTotal,
-                parentShadowRejectLevelTotal,
-                treeMaxLevel,
-                treeLevelP95,
-                treeLevelAvg,
-                treeOrphans,
-                treeChildrenP95,
-                treeChildrenMax,
-                treeRootChildren,
-                maxUploadBps,
-                maxUploadFracPct,
-                maxUploadNode,
-                rootUploadBps,
-                rootUploadFracPct,
-                streamQueuedBytesTotal,
-                streamQueuedBytesMax,
-                streamQueuedBytesP95,
-                streamQueuedBytesMaxNode,
-                streamQueuedBytesByLane,
-                churnEvents,
-                churnedPeersTotal,
-                maintDurationMs,
-                maintSamples,
-                maintMaxOrphans,
-                maintOrphanArea,
-                maintRecoveryCount,
-                maintRecoveryP50Ms,
-                maintRecoveryP95Ms,
-                maintReparentsPerMin,
-                maintMaxReparentsPerPeer,
-                maintLevelP95DriftMax,
-                maintChildrenP95DriftMax,
-                overheadFactorData,
-                controlBpp,
-                trackerBpp,
-                repairBpp,
-                earningsTotal,
-                earningsRelayCount,
-                earningsRelayP50,
-                earningsRelayP95,
-                earningsRelayMax,
-                protocolControlSends,
-                protocolControlBytesSent,
-                protocolControlBytesSentJoin,
-                protocolControlBytesSentRepair,
-                protocolControlBytesSentTracker,
-                protocolControlReceives,
-                protocolControlBytesReceived,
-                protocolDataSends,
-                protocolDataPayloadBytesSent,
-                protocolDataReceives,
-                protocolDataPayloadBytesReceived,
-                protocolRepairReqSent,
-                protocolFetchReqSent,
-                protocolIHaveSent,
-                protocolTrackerAnnounceSent,
-                protocolTrackerQuerySent,
-                protocolTrackerReplySent,
-                protocolTrackerFeedbackSent,
-                protocolCacheHitsServed,
-                protocolHoleFillsFromNeighbor,
-                protocolRouteCacheHits,
-                protocolRouteCacheMisses,
-                protocolRouteCacheExpirations,
-                protocolRouteCacheEvictions,
-                protocolRouteProxyQueries,
-                protocolRouteProxyTimeouts,
-                protocolRouteProxyFanout,
-                network: session.network.metrics,
-            };
-        };
-        const abortPromise = timeoutMs > 0
-            ? new Promise((_, reject) => {
-                const onAbort = () => {
-                    timeoutSignal.removeEventListener("abort", onAbort);
-                    const reason = timeoutSignal.reason;
-                    reject(reason instanceof Error
-                        ? reason
-                        : new Error(typeof reason === "string"
-                            ? reason
-                            : "fanout-tree-sim aborted"));
-                };
-                if (timeoutSignal.aborted) {
-                    onAbort();
-                    return;
-                }
-                timeoutSignal.addEventListener("abort", onAbort, { once: true });
-            })
-            : undefined;
-        const result = abortPromise
-            ? await Promise.race([run(), abortPromise])
-            : await run();
-        if (profileEnabled && profileCpuStart) {
-            try {
-                profileEld?.disable();
-            }
-            catch {
-                // ignore
-            }
-            const cpu = process.cpuUsage(profileCpuStart);
-            const mem = process.memoryUsage();
-            const p95 = profileEld ? profileEld.percentile(95) / 1e6 : 0;
-            const max = profileEld ? profileEld.max / 1e6 : 0;
-            result.profile = {
-                cpuUserMs: cpu.user / 1_000,
-                cpuSystemMs: cpu.system / 1_000,
-                rssMb: mem.rss / 1e6,
-                heapUsedMb: mem.heapUsed / 1e6,
-                eventLoopDelayP95Ms: p95,
-                eventLoopDelayMaxMs: max,
-            };
-        }
-        return result;
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-        try {
-            profileEld?.disable();
-        }
-        catch {
-            // ignore
-        }
-        try {
-            await session.stop();
-        }
-        catch {
-            // ignore teardown aborts in the shim
-        }
-    }
-};
-//# sourceMappingURL=fanout-tree-sim-lib.js.map