@colyseus/schema 5.0.11 → 5.0.13

package/src/bench_bloat.ts

@@ -1,173 +0,0 @@
-import { Encoder, Schema, type, MapSchema, ArraySchema } from "./index";
-
-// Must be set before constructing any Encoder — static BUFFER_SIZE is
-// read at Encoder construction time. Default 8KB overflows on the first
-// full-state encode (1000 entities), which used to skew measurements 2/3/6
-// by leaving the initial ADD wave half-encoded.
-Encoder.BUFFER_SIZE = 4 * 1024 * 1024;
-
-class Position extends Schema {
-    @type("number") x: number;
-    @type("number") y: number;
-}
-
-class Player extends Schema {
-    @type("string") name: string;
-    @type(Position) position = new Position();
-    @type(["number"]) scores = new ArraySchema<number>();
-}
-
-class State extends Schema {
-    @type({ map: Player }) players = new MapSchema<Player>();
-}
-
-// --- Measure 1: Memory ---
-globalThis.gc?.();
-const heapBefore = process.memoryUsage().heapUsed;
-
-const state = new State();
-const encoder = new Encoder(state);
-
-for (let i = 0; i < 1000; i++) {
-    const p = new Player();
-    p.name = `Player ${i}`;
-    p.position.x = i;
-    p.position.y = i;
-    for (let j = 0; j < 5; j++) p.scores.push(j);
-    state.players.set(`p${i}`, p);
-}
-
-globalThis.gc?.();
-const heapAfter = process.memoryUsage().heapUsed;
-console.log(`Heap delta (1000 entities): ${((heapAfter - heapBefore) / 1024 / 1024).toFixed(2)} MB`);
-
-// Initial encode
-encoder.encode();
-encoder.discardChanges();
-
-// --- Measure 2: Encode tick speed (small mutations) ---
-const iterations = 5000;
-const start = performance.now();
-for (let i = 0; i < iterations; i++) {
-    // Mutate 10 players (small tick)
-    for (let j = 0; j < 10; j++) {
-        const p = state.players.get(`p${j}`);
-        p.position.x++;
-        p.position.y++;
-    }
-    encoder.encode();
-    encoder.discardChanges();
-}
-const elapsed = performance.now() - start;
-console.log(`${iterations} encode ticks (10 mutations each): ${elapsed.toFixed(1)}ms (${(elapsed/iterations).toFixed(4)}ms/tick)`);
-
-// --- Measure 3: Encode tick speed (large mutations) ---
-const iterations2 = 1000;
-const start2 = performance.now();
-for (let i = 0; i < iterations2; i++) {
-    for (let j = 0; j < 100; j++) {
-        const p = state.players.get(`p${j}`);
-        p.position.x++;
-        p.position.y++;
-    }
-    encoder.encode();
-    encoder.discardChanges();
-}
-const elapsed2 = performance.now() - start2;
-console.log(`${iterations2} encode ticks (100 mutations each): ${elapsed2.toFixed(1)}ms (${(elapsed2/iterations2).toFixed(3)}ms/tick)`);
-
-// --- Measure 4: Entity creation speed ---
-const state2 = new State();
-const encoder2 = new Encoder(state2);
-const createStart = performance.now();
-for (let i = 0; i < 5000; i++) {
-    const p = new Player();
-    p.name = `P${i}`;
-    p.position.x = i;
-    p.position.y = i;
-    state2.players.set(`p${i}`, p);
-}
-const createElapsed = performance.now() - createStart;
-console.log(`Create 5000 entities: ${createElapsed.toFixed(1)}ms`);
-
-// --- Measure 5: encodeAll speed ---
-const encoder3 = new Encoder(state2);
-const encodeAllStart = performance.now();
-for (let i = 0; i < 100; i++) {
-    encoder3.encodeAll();
-}
-const encodeAllElapsed = performance.now() - encodeAllStart;
-console.log(`100x encodeAll (5000 entities): ${encodeAllElapsed.toFixed(1)}ms`);
-
-// --- Measure 6: GC pressure (heap growth over many ticks) ---
-globalThis.gc?.();
-const gcBefore = process.memoryUsage().heapUsed;
-for (let i = 0; i < 10000; i++) {
-    const p = state.players.get(`p${i % 100}`);
-    p.position.x++;
-    p.position.y++;
-    if (i % 10 === 0) {
-        encoder.encode();
-        encoder.discardChanges();
-    }
-}
-globalThis.gc?.();
-const gcAfter = process.memoryUsage().heapUsed;
-console.log(`GC pressure (10k mutations, 1k encode ticks): heap delta ${((gcAfter - gcBefore) / 1024).toFixed(1)} KB`);
-
-// --- Measure 7: Entity add/remove churn (exercises Root linked list) ---
-const churnState = new State();
-const churnEncoder = new Encoder(churnState);
-// Pre-populate
-for (let i = 0; i < 100; i++) {
-    const p = new Player();
-    p.name = `P${i}`;
-    p.position.x = i;
-    p.position.y = i;
-    churnState.players.set(`p${i}`, p);
-}
-churnEncoder.encode();
-churnEncoder.discardChanges();
-
-const churnStart = performance.now();
-for (let i = 0; i < 1000; i++) {
-    // Remove and re-add 10 entities
-    for (let j = 0; j < 10; j++) {
-        const key = `p${(i * 10 + j) % 100}`;
-        churnState.players.delete(key);
-    }
-    churnEncoder.encode();
-    churnEncoder.discardChanges();
-    for (let j = 0; j < 10; j++) {
-        const key = `p${(i * 10 + j) % 100}`;
-        const p = new Player();
-        p.name = key;
-        p.position.x = i;
-        p.position.y = j;
-        churnState.players.set(key, p);
-    }
-    churnEncoder.encode();
-    churnEncoder.discardChanges();
-}
-const churnElapsed = performance.now() - churnStart;
-console.log(`1000 entity churn cycles (10 remove+add each): ${churnElapsed.toFixed(1)}ms (${(churnElapsed/1000).toFixed(3)}ms/cycle)`);
-
-// --- Measure 9: Array push/pop churn ---
-class ArrayState extends Schema {
-    @type(["number"]) items = new ArraySchema<number>();
-}
-const arrayState = new ArrayState();
-const arrayEncoder = new Encoder(arrayState);
-for (let i = 0; i < 100; i++) arrayState.items.push(i);
-arrayEncoder.encode();
-arrayEncoder.discardChanges();
-
-const arrayStart = performance.now();
-for (let i = 0; i < 5000; i++) {
-    arrayState.items.push(100 + i);
-    arrayState.items.pop();
-    arrayEncoder.encode();
-    arrayEncoder.discardChanges();
-}
-const arrayElapsed = performance.now() - arrayStart;
-console.log(`5000 array push/pop ticks: ${arrayElapsed.toFixed(1)}ms (${(arrayElapsed/5000).toFixed(4)}ms/tick)`);

package/src/bench_churn.ts

@@ -1,121 +0,0 @@
-/**
- * Benchmark: entity churn (spawn → despawn → respawn) with and without the
- * native SchemaPool. Existing benches (bench_encode/bench_bloat) are
- * monotonic-growth and never return instances to a pool, so they can't show
- * pooling ROI — this one models the ECS/projectile/bot workload the pool
- * targets.
- *
- * Usage:  npx tsx --tsconfig tsconfig.test.json src/bench_churn.ts
- */
-import v8 from "node:v8";
-import vm from "node:vm";
-import { Schema, type, MapSchema, Encoder, createPool, type SchemaPool } from "./index";
-
-// gc() handle (works under the tsx CLI, where `node --expose-gc` doesn't reach
-// the forked child).
-v8.setFlagsFromString("--expose-gc");
-const gc = (globalThis.gc as undefined | (() => void)) ?? (vm.runInNewContext("gc") as () => void);
-
-class Vector extends Schema {
-    @type("number") x: number = 0;
-    @type("number") y: number = 0;
-    @type("number") z: number = 0;
-}
-// A nested entity: Entity + 2 child Vectors = 3 Schema instances per spawn,
-// matching the miniplex profiling scenario.
-class Entity extends Schema {
-    @type("string") name: string = "";
-    @type(Vector) position = new Vector();
-    @type(Vector) velocity = new Vector();
-}
-class State extends Schema {
-    @type({ map: Entity }) entities = new MapSchema<Entity>();
-}
-
-Encoder.BUFFER_SIZE = 4096 * 4096;
-
-const N = 2_000;     // entities alive per tick
-const TICKS = 200;   // churn cycles
-const WARMUP = 10;
-const INSTANCES_PER_ENTITY = 3; // Entity + position + velocity
-const spawns = N * TICKS;
-
-const heap = () => {
-    gc?.();
-    gc?.();
-    return process.memoryUsage().heapUsed;
-};
-
-function runChurn(usePool: boolean) {
-    const state = new State();
-    const encoder = new Encoder(state);
-    encoder.encode();
-    encoder.discardChanges();
-
-    const pool: SchemaPool<Entity> | undefined = usePool ? createPool(Entity, { preallocate: N }) : undefined;
-    const live: Entity[] = new Array(N);
-
-    const spawnTick = (timeConstruct: boolean): number => {
-        // CONSTRUCTION phase (the differentiator): new vs acquire
-        const c0 = performance.now();
-        for (let i = 0; i < N; i++) {
-            live[i] = pool ? pool.acquire() : new Entity();
-        }
-        const c1 = performance.now();
-
-        // init + attach + encode
-        for (let i = 0; i < N; i++) {
-            const e = live[i];
-            e.name = "e" + i;
-            e.position.x = i; e.position.y = i; e.position.z = i;
-            e.velocity.x = 1;
-            state.entities.set(String(i), e);
-        }
-        encoder.encode();
-        encoder.discardChanges();
-
-        // despawn + release
-        for (let i = 0; i < N; i++) state.entities.delete(String(i));
-        encoder.encode();
-        encoder.discardChanges();
-        if (pool) for (let i = 0; i < N; i++) pool.release(live[i]);
-
-        return timeConstruct ? c1 - c0 : 0;
-    };
-
-    for (let t = 0; t < WARMUP; t++) spawnTick(false);
-
-    const before = heap();
-    let constructMs = 0;
-    const t0 = performance.now();
-    for (let t = 0; t < TICKS; t++) constructMs += spawnTick(true);
-    const t1 = performance.now();
-    const after = heap();
-
-    return {
-        cycleMs: t1 - t0,
-        constructMs,
-        constructNsPerEntity: (constructMs * 1e6) / spawns,
-        heapDelta: after - before,
-        poolSize: pool?.size ?? 0
-    };
-}
-
-console.log(`\nEntity churn benchmark — ${N} entities × ${TICKS} ticks = ${spawns.toLocaleString("en-US")} spawns`);
-console.log(`(each entity = ${INSTANCES_PER_ENTITY} Schema instances; gc=${gc ? "on" : "off"})\n`);
-
-const noPool = runChurn(false);
-const pooled = runChurn(true);
-
-const row = (label: string, r: ReturnType<typeof runChurn>) => {
-    console.log(`${label.padEnd(14)} construct: ${r.constructMs.toFixed(1).padStart(8)} ms  ` +
-        `${r.constructNsPerEntity.toFixed(0).padStart(6)} ns/entity   ` +
-        `full cycle: ${r.cycleMs.toFixed(1).padStart(8)} ms   ` +
-        `heapΔ: ${(r.heapDelta / 1024 / 1024).toFixed(1).padStart(7)} MB`);
-};
-
-row("new Entity()", noPool);
-row("pool.acquire()", pooled);
-console.log(`\nConstruction speedup: ${(noPool.constructNsPerEntity / pooled.constructNsPerEntity).toFixed(1)}x faster` +
-    `   (full-cycle: ${(noPool.cycleMs / pooled.cycleMs).toFixed(2)}x — diluted by identical encode/decode cost)`);
-console.log(`Pool retained ${pooled.poolSize} instances after the run.\n`);

package/src/bench_decode.ts

@@ -1,221 +0,0 @@
-import { Encoder, Decoder, Schema, type, MapSchema, ArraySchema } from "./index";
-
-class Position extends Schema {
-    @type("number") x: number;
-    @type("number") y: number;
-}
-
-class Player extends Schema {
-    @type("string") name: string;
-    @type(Position) position = new Position();
-    @type(["number"]) scores = new ArraySchema<number>();
-}
-
-class State extends Schema {
-    @type({ map: Player }) players = new MapSchema<Player>();
-}
-
-function freshDecoder() {
-    return new Decoder(new State());
-}
-
-function clone(bytes: Uint8Array) {
-    return bytes.slice();
-}
-
-Encoder.BUFFER_SIZE = 4096 * 4096;
-
-// --- Build a server state with N entities ---
-const state = new State();
-const encoder = new Encoder(state);
-
-const N = 1000;
-for (let i = 0; i < N; i++) {
-    const p = new Player();
-    p.name = `Player ${i}`;
-    p.position.x = i;
-    p.position.y = i;
-    for (let j = 0; j < 5; j++) p.scores.push(j);
-    state.players.set(`p${i}`, p);
-}
-
-// --- Measure 1: Initial bootstrap decode (encodeAll on a fresh client) ---
-{
-    const bootstrapBytes = clone(encoder.encodeAll());
-    encoder.discardChanges();
-
-    const iterations = 200;
-    const start = performance.now();
-    for (let i = 0; i < iterations; i++) {
-        const decoder = freshDecoder();
-        decoder.decode(bootstrapBytes);
-    }
-    const elapsed = performance.now() - start;
-    console.log(
-        `Bootstrap decode (${N} entities) x${iterations}: ${elapsed.toFixed(1)}ms ` +
-        `(${(elapsed / iterations).toFixed(3)}ms/run, ${bootstrapBytes.length} bytes)`
-    );
-}
-
-// --- Measure 2: Steady-state small-tick decode (10 players per tick) ---
-{
-    const decoder = freshDecoder();
-    decoder.decode(clone(encoder.encodeAll()));
-    encoder.discardChanges();
-
-    const ticks = 5000;
-    // Pre-produce the byte frames so we measure decode only.
-    const frames: Uint8Array[] = new Array(ticks);
-    for (let i = 0; i < ticks; i++) {
-        for (let j = 0; j < 10; j++) {
-            const p = state.players.get(`p${j}`)!;
-            p.position.x++;
-            p.position.y++;
-        }
-        frames[i] = clone(encoder.encode());
-        encoder.discardChanges();
-    }
-
-    const start = performance.now();
-    for (let i = 0; i < ticks; i++) decoder.decode(frames[i]);
-    const elapsed = performance.now() - start;
-    const totalBytes = frames.reduce((s, f) => s + f.length, 0);
-    console.log(
-        `Small-tick decode (10 mutations/tick) x${ticks}: ${elapsed.toFixed(1)}ms ` +
-        `(${(elapsed / ticks).toFixed(4)}ms/tick, avg ${(totalBytes / ticks).toFixed(1)} bytes/tick)`
-    );
-}
-
-// --- Measure 3: Steady-state large-tick decode (100 players per tick) ---
-{
-    const decoder = freshDecoder();
-    decoder.decode(clone(encoder.encodeAll()));
-    encoder.discardChanges();
-
-    const ticks = 1000;
-    const frames: Uint8Array[] = new Array(ticks);
-    for (let i = 0; i < ticks; i++) {
-        for (let j = 0; j < 100; j++) {
-            const p = state.players.get(`p${j}`)!;
-            p.position.x++;
-            p.position.y++;
-        }
-        frames[i] = clone(encoder.encode());
-        encoder.discardChanges();
-    }
-
-    const start = performance.now();
-    for (let i = 0; i < ticks; i++) decoder.decode(frames[i]);
-    const elapsed = performance.now() - start;
-    const totalBytes = frames.reduce((s, f) => s + f.length, 0);
-    console.log(
-        `Large-tick decode (100 mutations/tick) x${ticks}: ${elapsed.toFixed(1)}ms ` +
-        `(${(elapsed / ticks).toFixed(3)}ms/tick, avg ${(totalBytes / ticks).toFixed(1)} bytes/tick)`
-    );
-}
-
-// --- Measure 4: Add/remove churn decode ---
-{
-    const churnState = new State();
-    const churnEncoder = new Encoder(churnState);
-    for (let i = 0; i < 100; i++) {
-        const p = new Player();
-        p.name = `P${i}`;
-        p.position.x = i;
-        p.position.y = i;
-        churnState.players.set(`p${i}`, p);
-    }
-
-    const decoder = new Decoder(new State());
-    decoder.decode(clone(churnEncoder.encodeAll()));
-    churnEncoder.discardChanges();
-
-    const cycles = 1000;
-    const frames: Uint8Array[] = [];
-    for (let i = 0; i < cycles; i++) {
-        for (let j = 0; j < 10; j++) {
-            const key = `p${(i * 10 + j) % 100}`;
-            churnState.players.delete(key);
-        }
-        frames.push(clone(churnEncoder.encode()));
-        churnEncoder.discardChanges();
-        for (let j = 0; j < 10; j++) {
-            const key = `p${(i * 10 + j) % 100}`;
-            const p = new Player();
-            p.name = key;
-            p.position.x = i;
-            p.position.y = j;
-            churnState.players.set(key, p);
-        }
-        frames.push(clone(churnEncoder.encode()));
-        churnEncoder.discardChanges();
-    }
-
-    const start = performance.now();
-    for (let i = 0; i < frames.length; i++) decoder.decode(frames[i]);
-    const elapsed = performance.now() - start;
-    console.log(
-        `Churn decode (${cycles} cycles, 10 remove+add each, ${frames.length} frames): ` +
-        `${elapsed.toFixed(1)}ms (${(elapsed / cycles).toFixed(3)}ms/cycle)`
-    );
-}
-
-// --- Measure 5: Array push/pop churn decode ---
-{
-    class ArrayState extends Schema {
-        @type(["number"]) items = new ArraySchema<number>();
-    }
-    const arrayState = new ArrayState();
-    const arrayEncoder = new Encoder(arrayState);
-    for (let i = 0; i < 100; i++) arrayState.items.push(i);
-
-    const decoder = new Decoder(new ArrayState());
-    decoder.decode(clone(arrayEncoder.encodeAll()));
-    arrayEncoder.discardChanges();
-
-    const ticks = 5000;
-    const frames: Uint8Array[] = new Array(ticks);
-    for (let i = 0; i < ticks; i++) {
-        arrayState.items.push(100 + i);
-        arrayState.items.pop();
-        frames[i] = clone(arrayEncoder.encode());
-        arrayEncoder.discardChanges();
-    }
-
-    const start = performance.now();
-    for (let i = 0; i < ticks; i++) decoder.decode(frames[i]);
-    const elapsed = performance.now() - start;
-    console.log(
-        `Array push/pop decode x${ticks}: ${elapsed.toFixed(1)}ms ` +
-        `(${(elapsed / ticks).toFixed(4)}ms/tick)`
-    );
-}
-
-// --- Measure 6: Heavy mutation per tick (every player + array items) ---
-{
-    const decoder = freshDecoder();
-    decoder.decode(clone(encoder.encodeAll()));
-    encoder.discardChanges();
-
-    const ticks = 200;
-    const frames: Uint8Array[] = new Array(ticks);
-    for (let i = 0; i < ticks; i++) {
-        for (let j = 0; j < N; j++) {
-            const p = state.players.get(`p${j}`)!;
-            p.position.x++;
-            p.position.y++;
-            p.scores[0] = i;
-        }
-        frames[i] = clone(encoder.encode());
-        encoder.discardChanges();
-    }
-
-    const start = performance.now();
-    for (let i = 0; i < ticks; i++) decoder.decode(frames[i]);
-    const elapsed = performance.now() - start;
-    const totalBytes = frames.reduce((s, f) => s + f.length, 0);
-    console.log(
-        `Heavy-tick decode (${N} players touched) x${ticks}: ${elapsed.toFixed(1)}ms ` +
-        `(${(elapsed / ticks).toFixed(3)}ms/tick, avg ${(totalBytes / ticks).toFixed(0)} bytes/tick)`
-    );
-}

package/src/bench_decode_mem.ts

@@ -1,165 +0,0 @@
-import { PerformanceObserver, constants } from "node:perf_hooks";
-import { Encoder, Decoder, Schema, type, MapSchema, ArraySchema } from "./index";
-
-class Position extends Schema {
-    @type("number") x: number;
-    @type("number") y: number;
-}
-
-class Player extends Schema {
-    @type("string") name: string;
-    @type(Position) position = new Position();
-    @type(["number"]) scores = new ArraySchema<number>();
-}
-
-class State extends Schema {
-    @type({ map: Player }) players = new MapSchema<Player>();
-}
-
-if (!globalThis.gc) {
-    console.error("Run with --expose-gc: npx tsx --expose-gc ...");
-    process.exit(1);
-}
-
-Encoder.BUFFER_SIZE = 4096 * 4096;
-
-// --- GC observer ---
-const gcStats = { count: 0, totalMs: 0, majorMs: 0, minorMs: 0 };
-const gcObserver = new PerformanceObserver((list) => {
-    for (const e of list.getEntries() as any) {
-        gcStats.count++;
-        gcStats.totalMs += e.duration;
-        if (e.detail?.kind === constants.NODE_PERFORMANCE_GC_MAJOR) gcStats.majorMs += e.duration;
-        else gcStats.minorMs += e.duration;
-    }
-});
-gcObserver.observe({ entryTypes: ["gc"], buffered: false });
-
-function resetGc() { gcStats.count = 0; gcStats.totalMs = 0; gcStats.majorMs = 0; gcStats.minorMs = 0; }
-function snapshotGc() { return { ...gcStats }; }
-function heap() {
-    globalThis.gc!();
-    globalThis.gc!();
-    return process.memoryUsage().heapUsed;
-}
-function mb(n: number) { return (n / 1024 / 1024).toFixed(2); }
-function kb(n: number) { return (n / 1024).toFixed(1); }
-
-// --- Build an encoder-side state once ---
-const state = new State();
-const encoder = new Encoder(state);
-const N = 1000;
-for (let i = 0; i < N; i++) {
-    const p = new Player();
-    p.name = `Player ${i}`;
-    p.position.x = i;
-    p.position.y = i;
-    for (let j = 0; j < 5; j++) p.scores.push(j);
-    state.players.set(`p${i}`, p);
-}
-const bootstrapBytes = encoder.encodeAll().slice();
-encoder.discardChanges();
-
-// Pre-produce steady-state frames (outside the timed region).
-const heavyFrames: Uint8Array[] = [];
-const HEAVY_TICKS = 200;
-for (let i = 0; i < HEAVY_TICKS; i++) {
-    for (let j = 0; j < N; j++) {
-        const p = state.players.get(`p${j}`)!;
-        p.position.x++;
-        p.position.y++;
-        p.scores[0] = i;
-    }
-    heavyFrames.push(encoder.encode().slice());
-    encoder.discardChanges();
-}
-
-type Stats = {
-    decoderHeapKb: number;
-    steadyHeapDeltaKb: number;
-    steadyGcCount: number;
-    steadyGcMs: number;
-    bootstrapMs: number;
-    heavyMs: number;
-};
-
-function run(): Stats {
-    const baseHeap = heap();
-
-    const decoder = new Decoder(new State());
-    const tBoot0 = performance.now();
-    decoder.decode(bootstrapBytes);
-    const bootstrapMs = performance.now() - tBoot0;
-
-    const decoderHeap = heap() - baseHeap;
-
-    resetGc();
-    const beforeSteady = process.memoryUsage().heapUsed;
-    const tHeavy0 = performance.now();
-    for (let i = 0; i < HEAVY_TICKS; i++) decoder.decode(heavyFrames[i]);
-    const heavyMs = performance.now() - tHeavy0;
-    const afterSteady = process.memoryUsage().heapUsed;
-    const gcSnap = snapshotGc();
-
-    return {
-        decoderHeapKb: decoderHeap / 1024,
-        steadyHeapDeltaKb: (afterSteady - beforeSteady) / 1024,
-        steadyGcCount: gcSnap.count,
-        steadyGcMs: gcSnap.totalMs,
-        bootstrapMs,
-        heavyMs,
-    };
-}
-
-// Warm (JIT seeding), discard result
-run();
-
-// Best-of-3 to get stable numbers
-let best: Stats | undefined;
-for (let i = 0; i < 3; i++) {
-    const s = run();
-    if (!best || s.heavyMs < best.heavyMs) best = s;
-}
-
-console.log("\n=== decoder memory + GC (best of 3) ===");
-console.log(
-    `bootstrap ${best!.bootstrapMs.toFixed(1)}ms | ` +
-    `heavy ${HEAVY_TICKS}t ${best!.heavyMs.toFixed(1)}ms (${(best!.heavyMs / HEAVY_TICKS).toFixed(3)}ms/tick) | ` +
-    `heap(decoder state, ${N} entities) ${kb(best!.decoderHeapKb * 1024)} KB | ` +
-    `heap-growth/steady ${kb(best!.steadyHeapDeltaKb * 1024)} KB | ` +
-    `GCs ${best!.steadyGcCount} (${best!.steadyGcMs.toFixed(1)}ms)`
-);
-
-// --- Multi-client scenario: 100 fresh decoders, each bootstrapped on the same bytes.
-// Answers "how much heap does N simultaneous clients cost?".
-function multiClient(numClients: number) {
-    const baseHeap = heap();
-    resetGc();
-    const decoders: Decoder[] = [];
-    const t0 = performance.now();
-    for (let i = 0; i < numClients; i++) {
-        const d = new Decoder(new State());
-        d.decode(bootstrapBytes);
-        decoders.push(d);
-    }
-    const elapsed = performance.now() - t0;
-    const gcSnap = snapshotGc();
-    const heapAfter = heap();
-    return {
-        decoders, // keep alive so GC can't reclaim during measurement
-        totalHeapKb: (heapAfter - baseHeap) / 1024,
-        elapsedMs: elapsed,
-        gcCount: gcSnap.count,
-        gcMs: gcSnap.totalMs,
-    };
-}
-
-console.log(`\n=== multi-client bootstrap (100 decoders, ${N} entities each) ===`);
-const mc = multiClient(100);
-console.log(
-    `${mc.elapsedMs.toFixed(0)}ms | ` +
-    `heap ${mb(mc.totalHeapKb * 1024)} MB | ` +
-    `GCs ${mc.gcCount} (${mc.gcMs.toFixed(1)}ms)`
-);
-
-gcObserver.disconnect();