@peerbit/pubsub 5.2.11 → 5.3.0

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

@@ -1,10 +1,11 @@
 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 { InMemoryNetwork, InMemorySession, } from "@peerbit/libp2p-test-utils/inmemory-libp2p.js";
-import { int, mulberry32, quantile, runWithConcurrency } from "./sim/bench-utils.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);
@@ -25,6 +26,18 @@ class SimFanoutTree extends FanoutTree {
         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 [];
@@ -56,6 +69,14 @@ export const resolveFanoutTreeSimParams = (input) => {
         : 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),
@@ -64,6 +85,8 @@ export const resolveFanoutTreeSimParams = (input) => {
         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,
@@ -105,12 +128,53 @@ export const resolveFanoutTreeSimParams = (input) => {
             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),
@@ -131,6 +195,8 @@ export const resolveFanoutTreeSimParams = (input) => {
         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),
@@ -142,12 +208,22 @@ export const formatFanoutTreeSimResult = (r) => {
     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
             ? [
@@ -160,13 +236,23 @@ export const formatFanoutTreeSimResult = (r) => {
             : `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 ?? "-"}`,
-        `reparent: disconnect=${r.reparentDisconnectTotal} stale=${r.reparentStaleTotal} kicked=${r.reparentKickedTotal}`,
+        ...(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 ?? "-"}`,
+        `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} trackerFeedbackSent=${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}`,
+        `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
             ? [
@@ -296,7 +382,9 @@ export const runFanoutTreeSim = async (input) => {
                 role: "root",
                 msgRate: params.msgRate,
                 msgSize: params.msgSize,
-                ...(params.maxDataAgeMs > 0 ? { maxDataAgeMs: params.maxDataAgeMs } : {}),
+                ...(params.maxDataAgeMs > 0
+                    ? { maxDataAgeMs: params.maxDataAgeMs }
+                    : {}),
                 uploadLimitBps: params.rootUploadLimitBps,
                 maxChildren: params.rootMaxChildren,
                 bidPerByte: params.bidPerByte,
@@ -317,7 +405,9 @@ export const runFanoutTreeSim = async (input) => {
                     ? { neighborAnnounceIntervalMs: params.neighborAnnounceIntervalMs }
                     : {}),
                 ...(params.neighborMeshRefreshIntervalMs >= 0
-                    ? { neighborMeshRefreshIntervalMs: params.neighborMeshRefreshIntervalMs }
+                    ? {
+                        neighborMeshRefreshIntervalMs: params.neighborMeshRefreshIntervalMs,
+                    }
                     : {}),
                 ...(params.neighborHaveTtlMs >= 0
                     ? { neighborHaveTtlMs: params.neighborHaveTtlMs }
@@ -343,7 +433,8 @@ export const runFanoutTreeSim = async (input) => {
                     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);
+                    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?.();
@@ -355,15 +446,21 @@ export const runFanoutTreeSim = async (input) => {
                     await node.joinChannel(params.topic, rootId, {
                         msgRate: params.msgRate,
                         msgSize: params.msgSize,
-                        ...(params.maxDataAgeMs > 0 ? { maxDataAgeMs: params.maxDataAgeMs } : {}),
+                        ...(params.maxDataAgeMs > 0
+                            ? { maxDataAgeMs: params.maxDataAgeMs }
+                            : {}),
                         uploadLimitBps: isRelay ? params.relayUploadLimitBps : 0,
                         maxChildren: isRelay ? params.relayMaxChildren : 0,
-                        bidPerByte: isRelay ? params.bidPerByteRelay : params.bidPerByteLeaf,
+                        bidPerByte: isRelay
+                            ? params.bidPerByteRelay
+                            : params.bidPerByteLeaf,
                         allowKick: params.allowKick,
                         repair: params.repair,
                         repairWindowMessages: params.repairWindowMessages,
                         ...(params.repairMaxBackfillMessages >= 0
-                            ? { repairMaxBackfillMessages: params.repairMaxBackfillMessages }
+                            ? {
+                                repairMaxBackfillMessages: params.repairMaxBackfillMessages,
+                            }
                             : {}),
                         repairIntervalMs: params.repairIntervalMs,
                         repairMaxPerReq: params.repairMaxPerReq,
@@ -373,10 +470,14 @@ export const runFanoutTreeSim = async (input) => {
                             ? { neighborMeshPeers: params.neighborMeshPeers }
                             : {}),
                         ...(params.neighborAnnounceIntervalMs >= 0
-                            ? { neighborAnnounceIntervalMs: params.neighborAnnounceIntervalMs }
+                            ? {
+                                neighborAnnounceIntervalMs: params.neighborAnnounceIntervalMs,
+                            }
                             : {}),
                         ...(params.neighborMeshRefreshIntervalMs >= 0
-                            ? { neighborMeshRefreshIntervalMs: params.neighborMeshRefreshIntervalMs }
+                            ? {
+                                neighborMeshRefreshIntervalMs: params.neighborMeshRefreshIntervalMs,
+                            }
                             : {}),
                         ...(params.neighborHaveTtlMs >= 0
                             ? { neighborHaveTtlMs: params.neighborHaveTtlMs }
@@ -389,7 +490,9 @@ export const runFanoutTreeSim = async (input) => {
                             : {}),
                     }, {
                         timeoutMs: Math.max(10_000, Math.min(120_000, timeoutMs || 120_000)),
-                        ...(params.maxDataAgeMs > 0 ? { staleAfterMs: params.maxDataAgeMs } : {}),
+                        ...(params.maxDataAgeMs > 0
+                            ? { staleAfterMs: params.maxDataAgeMs }
+                            : {}),
                         ...(params.joinReqTimeoutMs >= 0
                             ? { joinReqTimeoutMs: params.joinReqTimeoutMs }
                             : {}),
@@ -397,8 +500,11 @@ export const runFanoutTreeSim = async (input) => {
                             ? { candidateShuffleTopK: params.candidateShuffleTopK }
                             : {}),
                         candidateScoringMode: params.candidateScoringMode,
+                        ...parentUpgradeRuntimeOptions(params),
                         ...(params.bootstrapEnsureIntervalMs >= 0
-                            ? { bootstrapEnsureIntervalMs: params.bootstrapEnsureIntervalMs }
+                            ? {
+                                bootstrapEnsureIntervalMs: params.bootstrapEnsureIntervalMs,
+                            }
                             : {}),
                         ...(params.trackerQueryIntervalMs >= 0
                             ? { trackerQueryIntervalMs: params.trackerQueryIntervalMs }
@@ -465,7 +571,9 @@ export const runFanoutTreeSim = async (input) => {
                 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 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;
@@ -479,13 +587,17 @@ export const runFanoutTreeSim = async (input) => {
             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;
@@ -493,6 +605,11 @@ export const runFanoutTreeSim = async (input) => {
                     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;
                     }
@@ -504,9 +621,13 @@ export const runFanoutTreeSim = async (input) => {
                 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 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;
+                const treeChildrenMax = childrenCounts.length > 0
+                    ? childrenCounts[childrenCounts.length - 1]
+                    : 0;
                 return {
                     treeMaxLevel,
                     treeLevelP95,
@@ -516,6 +637,7 @@ export const runFanoutTreeSim = async (input) => {
                     treeChildrenMax,
                     treeRootChildren,
                     levelByIndex,
+                    childrenByHash,
                 };
             };
             const formationTree = computeTreeShapeStats();
@@ -557,7 +679,9 @@ export const runFanoutTreeSim = async (input) => {
                 .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 formationUnderlayDistP95 = formationUnderlayDists.length > 0
+                ? quantile(formationUnderlayDists, 0.95)
+                : NaN;
             const formationUnderlayDistMax = formationUnderlayDists.length > 0
                 ? formationUnderlayDists[formationUnderlayDists.length - 1]
                 : NaN;
@@ -565,14 +689,20 @@ export const runFanoutTreeSim = async (input) => {
                 .map((i) => {
                 const overlay = formationTree.levelByIndex[i];
                 const under = underlayDist[i];
-                if (!Number.isFinite(overlay) || !Number.isFinite(under) || under <= 0)
+                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 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
@@ -582,10 +712,16 @@ export const runFanoutTreeSim = async (input) => {
                 formationOrphanPct +
                 formationStretchPenalty;
             const churnController = new AbortController();
-            const churnSignal = anySignal([timeoutSignal, churnController.signal]);
+            const churnSignal = anySignal([
+                timeoutSignal,
+                churnController.signal,
+            ]);
             let churnEvents = 0;
             let churnedPeersTotal = 0;
-            const wantsMaintenance = (params.churnEveryMs > 0 && params.churnDownMs > 0 && params.churnFraction > 0) ||
+            const wantsMaintenance = (params.churnEveryMs > 0 &&
+                params.churnDownMs > 0 &&
+                params.churnFraction > 0) ||
+                params.parentUpgradeIntervalMs > 0 ||
                 params.assertMaxOrphans > 0 ||
                 params.assertMaxOrphanArea > 0 ||
                 params.assertRecoveryP95Ms > 0 ||
@@ -607,20 +743,29 @@ export const runFanoutTreeSim = async (input) => {
             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(Math.max(0, params.messages) / 8);
+            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)
@@ -633,7 +778,7 @@ export const runFanoutTreeSim = async (input) => {
                 const index = hashToIndex.get(localHash);
                 if (index == null)
                     return; // not joined / not tracked
-                if (seq >= params.messages)
+                if (seq >= totalMessages)
                     return;
                 const bits = receivedBits[index];
                 const byteIndex = seq >>> 3;
@@ -646,6 +791,9 @@ export const runFanoutTreeSim = async (input) => {
                 }
                 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;
@@ -661,6 +809,21 @@ export const runFanoutTreeSim = async (input) => {
                         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++) {
@@ -830,18 +993,105 @@ export const runFanoutTreeSim = async (input) => {
                     }));
                 }
             };
+            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);
+                    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 < params.messages; seq++) {
+                for (let seq = 0; seq < firstBatchMessages; seq++) {
                     if (timeoutSignal.aborted) {
                         throw timeoutSignal.reason ?? new Error("fanout-tree-sim aborted");
                     }
@@ -853,17 +1103,58 @@ export const runFanoutTreeSim = async (input) => {
                 }
             }
             finally {
+                if (firstBatchMessages > 0) {
+                    publishActiveMs += Math.max(0, Date.now() - publishStart);
+                }
+                publishActiveParentUpgrade = diffParentUpgradeActivity(collectParentUpgradeActivity(), publishStartParentUpgrade);
                 churnController.abort();
                 await churnPromise;
                 churnSignal.clear?.();
+                await lateRootDuringPublishPromise;
             }
-            const publishDone = Date.now();
+            let publishDone = Date.now();
             // Signal end-of-stream so subscribers can detect tail gaps and repair.
-            if (params.repair && params.messages > 0) {
-                await root.publishEnd(params.topic, rootId, params.messages);
+            if (params.repair && firstBatchMessages > 0) {
+                await root.publishEnd(params.topic, rootId, firstBatchMessages);
             }
             if (params.settleMs > 0) {
-                await delay(params.settleMs, { signal: timeoutSignal });
+                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;
@@ -876,7 +1167,10 @@ export const runFanoutTreeSim = async (input) => {
                 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;
+                    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;
@@ -887,13 +1181,23 @@ export const runFanoutTreeSim = async (input) => {
             const maintReparentsPerMin = maintDurationMin > 0 ? maintReparentsTotal / maintDurationMin : 0;
             const maintOrphanArea = maintOrphanAreaMs / 1_000;
             // Compute delivery
-            const expected = joinedCount * params.messages;
+            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;
@@ -967,6 +1271,11 @@ export const runFanoutTreeSim = async (input) => {
             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)
@@ -979,6 +1288,15 @@ export const runFanoutTreeSim = async (input) => {
                 }
             }
             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;
@@ -993,6 +1311,9 @@ export const runFanoutTreeSim = async (input) => {
             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;
@@ -1012,6 +1333,45 @@ export const runFanoutTreeSim = async (input) => {
             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) {
@@ -1030,6 +1390,60 @@ export const runFanoutTreeSim = async (input) => {
                 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;
@@ -1046,6 +1460,9 @@ export const runFanoutTreeSim = async (input) => {
                 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;
@@ -1057,8 +1474,25 @@ export const runFanoutTreeSim = async (input) => {
                 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 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;
@@ -1068,7 +1502,9 @@ export const runFanoutTreeSim = async (input) => {
                 ? 1
                 : protocolDataPayloadBytesSent / idealPayloadBytes;
             const deliveredPayloadBytes = delivered * Math.max(0, params.msgSize);
-            const controlBpp = deliveredPayloadBytes <= 0 ? 0 : protocolControlBytesSent / deliveredPayloadBytes;
+            const controlBpp = deliveredPayloadBytes <= 0
+                ? 0
+                : protocolControlBytesSent / deliveredPayloadBytes;
             const trackerBpp = deliveredPayloadBytes <= 0
                 ? 0
                 : protocolControlBytesSentTracker / deliveredPayloadBytes;
@@ -1101,13 +1537,25 @@ export const runFanoutTreeSim = async (input) => {
                 formationStretchP95,
                 formationStretchMax,
                 formationScore,
-                publishMs: publishDone - publishStart,
+                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),
@@ -1125,6 +1573,53 @@ export const runFanoutTreeSim = async (input) => {
                 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,
@@ -1135,6 +1630,8 @@ export const runFanoutTreeSim = async (input) => {
                 maxUploadBps,
                 maxUploadFracPct,
                 maxUploadNode,
+                rootUploadBps,
+                rootUploadFracPct,
                 streamQueuedBytesTotal,
                 streamQueuedBytesMax,
                 streamQueuedBytesP95,
@@ -1176,6 +1673,9 @@ export const runFanoutTreeSim = async (input) => {
                 protocolRepairReqSent,
                 protocolFetchReqSent,
                 protocolIHaveSent,
+                protocolTrackerAnnounceSent,
+                protocolTrackerQuerySent,
+                protocolTrackerReplySent,
                 protocolTrackerFeedbackSent,
                 protocolCacheHitsServed,
                 protocolHoleFillsFromNeighbor,
@@ -1207,7 +1707,9 @@ export const runFanoutTreeSim = async (input) => {
                 timeoutSignal.addEventListener("abort", onAbort, { once: true });
             })
             : undefined;
-        const result = abortPromise ? await Promise.race([run(), abortPromise]) : await run();
+        const result = abortPromise
+            ? await Promise.race([run(), abortPromise])
+            : await run();
         if (profileEnabled && profileCpuStart) {
             try {
                 profileEld?.disable();