@colyseus/schema 4.0.20 → 5.0.1

package/src/bench_init.ts

@@ -0,0 +1,150 @@
+/**
+ * Benchmark: Schema instance initialization throughput.
+ *
+ * Measures how fast schema instances can be created. The main hot path is
+ * Schema.initialize() — which allocates $changes and $values per instance.
+ *
+ * Usage (current branch):
+ *   npx tsx --tsconfig tsconfig.test.json bench_init.ts
+ *
+ * Usage (previous version — run from the sibling checkout):
+ *   cd ../schema && npx tsx --tsconfig tsconfig.test.json ../schema-5.0/bench_init.ts
+ *
+ * The benchmark uses the same schema hierarchy as bench_encode.js so results
+ * are directly comparable.
+ */
+import { Schema, type, ArraySchema, MapSchema, Encoder } from "./index";
+
+class Attribute extends Schema {
+    @type("string") name: string;
+    @type("number") value: number;
+}
+
+class Item extends Schema {
+    @type("number") price: number;
+    @type([Attribute]) attributes = new ArraySchema<Attribute>();
+}
+
+class Position extends Schema {
+    @type("number") x: number;
+    @type("number") y: number;
+}
+
+class Player extends Schema {
+    @type(Position) position = new Position();
+    @type({ map: Item }) items = new MapSchema<Item>();
+}
+
+class State extends Schema {
+    @type({ map: Player }) players = new MapSchema<Player>();
+    @type("string") currentTurn: string;
+}
+
+// ---------------------------------------------------------------------------
+// Warmup — let V8 JIT the constructors
+// ---------------------------------------------------------------------------
+for (let i = 0; i < 500; i++) {
+    const p = new Player();
+    p.position.x = i;
+    const item = new Item();
+    const attr = new Attribute();
+    attr.name = "warmup";
+    attr.value = i;
+    item.attributes.push(attr);
+    p.items.set("w", item);
+}
+
+// ---------------------------------------------------------------------------
+// Benchmark 1: Raw instance creation (no encoder, no parent wiring)
+// ---------------------------------------------------------------------------
+const INSTANCES = 50_000;
+
+globalThis.gc?.();
+const t0 = performance.now();
+const players: Player[] = new Array(INSTANCES);
+for (let i = 0; i < INSTANCES; i++) {
+    players[i] = new Player();
+}
+const t1 = performance.now();
+console.log(`\n--- Raw instance creation (${INSTANCES} Player instances) ---`);
+console.log(`Total: ${(t1 - t0).toFixed(2)} ms`);
+console.log(`Per instance: ${((t1 - t0) / INSTANCES * 1000).toFixed(2)} µs`);
+
+// ---------------------------------------------------------------------------
+// Benchmark 2: Deep hierarchy creation (Player + Position + 10 Items × 5 Attributes)
+// ---------------------------------------------------------------------------
+const DEEP_COUNT = 5_000;
+
+globalThis.gc?.();
+const t2 = performance.now();
+for (let i = 0; i < DEEP_COUNT; i++) {
+    const player = new Player();
+    player.position.x = i;
+    player.position.y = i;
+    for (let j = 0; j < 10; j++) {
+        const item = new Item();
+        item.price = j * 50;
+        for (let k = 0; k < 5; k++) {
+            const attr = new Attribute();
+            attr.name = `Attribute ${k}`;
+            attr.value = k;
+            item.attributes.push(attr);
+        }
+        player.items.set(`item-${j}`, item);
+    }
+}
+const t3 = performance.now();
+const totalInstances = DEEP_COUNT * (1 /* Player */ + 1 /* Position */ + 10 /* Items */ + 50 /* Attributes */);
+console.log(`\n--- Deep hierarchy creation (${DEEP_COUNT} trees, ${totalInstances} total instances) ---`);
+console.log(`Total: ${(t3 - t2).toFixed(2)} ms`);
+console.log(`Per tree: ${((t3 - t2) / DEEP_COUNT * 1000).toFixed(2)} µs`);
+console.log(`Per instance: ${((t3 - t2) / totalInstances * 1000).toFixed(2)} µs`);
+
+// ---------------------------------------------------------------------------
+// Benchmark 3: Full encode cycle (matches bench_encode.js structure)
+// ---------------------------------------------------------------------------
+const state = new State();
+Encoder.BUFFER_SIZE = 4096 * 4096;
+const encoder = new Encoder(state);
+
+const ROUNDS = 50;
+const PLAYERS_PER_ROUND = 50;
+
+globalThis.gc?.();
+let totalMakeChanges = 0;
+let totalEncode = 0;
+
+for (let i = 0; i < ROUNDS; i++) {
+    const mc0 = performance.now();
+    for (let j = 0; j < PLAYERS_PER_ROUND; j++) {
+        const player = new Player();
+        state.players.set(`p-${i}-${j}`, player);
+        player.position.x = (j + 1) * 100;
+        player.position.y = (j + 1) * 100;
+        for (let k = 0; k < 10; k++) {
+            const item = new Item();
+            item.price = (j + 1) * 50;
+            for (let l = 0; l < 5; l++) {
+                const attr = new Attribute();
+                attr.name = `Attribute ${l}`;
+                attr.value = l;
+                item.attributes.push(attr);
+            }
+            player.items.set(`item-${k}`, item);
+        }
+    }
+    const mc1 = performance.now();
+    totalMakeChanges += mc1 - mc0;
+
+    const enc0 = performance.now();
+    encoder.encode();
+    encoder.discardChanges();
+    const enc1 = performance.now();
+    totalEncode += enc1 - enc0;
+}
+
+console.log(`\n--- Encode cycle (${ROUNDS} rounds × ${PLAYERS_PER_ROUND} players) ---`);
+console.log(`Avg make changes: ${(totalMakeChanges / ROUNDS).toFixed(2)} ms`);
+console.log(`Avg encode:       ${(totalEncode / ROUNDS).toFixed(2)} ms`);
+console.log(`Total:            ${(totalMakeChanges + totalEncode).toFixed(2)} ms`);
+console.log(`Encoded size:     ${Array.from(encoder.encodeAll()).length} bytes`);

package/src/bench_static.ts

@@ -0,0 +1,109 @@
+/**
+ * Benchmark: per-tick encode cost with vs without `.static()` on fields
+ * that are mutated every tick but semantically configure-once.
+ *
+ * Scenario: 1000 entities with 4 "config" fields + 2 "dynamic" fields.
+ * Both variants mutate all 6 fields on all entities every tick. The
+ * `.static()` variant skips change-tracking for the 4 config fields,
+ * so per-tick encode emits and transmits only the 2 dynamic ones.
+ *
+ * Measures (per 1000 ticks of 1000 entities × 6 mutations):
+ *   - encode() wall time
+ *   - encoded tick patch size (bytes)
+ */
+
+import { Encoder, Schema, type, schema, t, MapSchema } from "./index";
+
+const NUM_ENTITIES = 1000;
+const NUM_TICKS = 1000;
+
+// ──────────────────────────────────────────────────────────────────────────
+// Variant A: all fields tracked (no .static())
+// ──────────────────────────────────────────────────────────────────────────
+const EntityA = schema({
+    maxHp: t.uint16(),
+    team: t.uint8(),
+    mapId: t.uint8(),
+    spawnIndex: t.uint16(),
+    hp: t.uint16(),
+    x: t.float32(),
+}, "EntityA");
+const StateA = schema({
+    entities: t.map(EntityA),
+}, "StateA");
+
+// ──────────────────────────────────────────────────────────────────────────
+// Variant B: 4 fields marked `.static()` (sync-once, tick-skip)
+// ──────────────────────────────────────────────────────────────────────────
+const EntityB = schema({
+    maxHp: t.uint16().static(),
+    team: t.uint8().static(),
+    mapId: t.uint8().static(),
+    spawnIndex: t.uint16().static(),
+    hp: t.uint16(),
+    x: t.float32(),
+}, "EntityB");
+const StateB = schema({
+    entities: t.map(EntityB),
+}, "StateB");
+
+function run<T extends Schema, E extends Schema>(
+    label: string,
+    StateCtor: new () => T,
+    EntityCtor: new () => E,
+) {
+    const state = new StateCtor();
+    const entitiesMap = (state as any).entities as MapSchema<E>;
+
+    for (let i = 0; i < NUM_ENTITIES; i++) {
+        const e = new EntityCtor();
+        (e as any).maxHp = 100;
+        (e as any).team = i % 4;
+        (e as any).mapId = 1;
+        (e as any).spawnIndex = i;
+        (e as any).hp = 100;
+        (e as any).x = 0;
+        entitiesMap.set(`e${i}`, e);
+    }
+
+    const encoder = new Encoder(state);
+
+    // Prime: initial encode + discard so tick timings measure steady-state.
+    encoder.encode();
+    encoder.discardChanges();
+
+    let totalBytes = 0;
+    const start = performance.now();
+    for (let tick = 0; tick < NUM_TICKS; tick++) {
+        for (let i = 0; i < NUM_ENTITIES; i++) {
+            const e = entitiesMap.get(`e${i}`);
+            // Mutate all 6 fields. The `.static()` variant will silently
+            // drop the first 4 at tracking time.
+            (e as any).maxHp = 100 + (tick & 15);
+            (e as any).team = i % 4;
+            (e as any).mapId = 1;
+            (e as any).spawnIndex = i;
+            (e as any).hp = 100 - (tick & 31);
+            (e as any).x = tick * 0.1;
+        }
+        const bytes = encoder.encode();
+        totalBytes += bytes.length;
+        encoder.discardChanges();
+    }
+    const elapsed = performance.now() - start;
+
+    console.log(
+        `${label.padEnd(28)} ${elapsed.toFixed(1).padStart(7)} ms total, ` +
+        `${(elapsed / NUM_TICKS).toFixed(3)} ms/tick, ` +
+        `${(totalBytes / NUM_TICKS).toFixed(0)} bytes/tick`
+    );
+}
+
+// Warm up JIT with a short run on each variant before measuring.
+run("warmup-A", StateA as any, EntityA as any);
+run("warmup-B", StateB as any, EntityB as any);
+
+console.log();
+console.log(`--- ${NUM_ENTITIES} entities × ${NUM_TICKS} ticks × 6 mutations ---`);
+run("without .static()", StateA as any, EntityA as any);
+run("with .static() on 4 of 6", StateB as any, EntityB as any);

package/src/bench_stream.ts

@@ -0,0 +1,295 @@
+/**
+ * bench_stream.ts — RTS-style ECS workload over StreamSchema.
+ *
+ * Simulates a room with many units, each built from several polymorphic
+ * components (Hp, Team, Position, Velocity). Exercises:
+ *   - Encode throughput of a large initial spawn spread across ticks
+ *     (priority-batched per-view vs broadcast).
+ *   - Steady-state per-tick mutation cost (hp damage + position move).
+ *   - Memory footprint.
+ *
+ * Run: npx tsx --tsconfig tsconfig.test.json --expose-gc src/bench_stream.ts
+ */
+import {
+    Encoder,
+    Schema,
+    type,
+    ArraySchema,
+    StreamSchema,
+    StateView,
+} from "./index";
+
+// Pre-size the shared buffer so the steady-state loops don't print
+// overflow-warning noise mid-measurement.
+Encoder.BUFFER_SIZE = 256 * 1024;
+
+// ─── Schema ───────────────────────────────────────────────────────────
+
+class Vec3 extends Schema {
+    @type("number") x: number = 0;
+    @type("number") y: number = 0;
+    @type("number") z: number = 0;
+}
+
+class Component extends Schema {
+    @type("string") kind: string = "";
+}
+
+class Hp extends Component {
+    @type("uint16") current: number = 100;
+    @type("uint16") max: number = 100;
+}
+
+class Team extends Component {
+    @type("uint8") teamId: number = 0;
+    @type("uint32") color: number = 0xffffff;
+}
+
+class Position extends Component {
+    @type(Vec3) value: Vec3 = new Vec3();
+}
+
+class Velocity extends Component {
+    @type(Vec3) value: Vec3 = new Vec3();
+}
+
+class Unit extends Schema {
+    @type("string") name: string = "";
+    @type([Component]) components = new ArraySchema<Component>();
+}
+
+class State extends Schema {
+    @type({ stream: Unit }) units = new StreamSchema<Unit>();
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+function mkUnit(i: number): Unit {
+    const u = new Unit().assign({ name: `U${i}` });
+    const hp = new Hp().assign({ kind: "hp", current: 100, max: 100 });
+    const team = new Team().assign({ kind: "team", teamId: i % 2, color: 0xff0000 });
+    const pos = new Position().assign({ kind: "position" });
+    pos.value.assign({ x: i, y: 0, z: i * 2 });
+    const vel = new Velocity().assign({ kind: "velocity" });
+    vel.value.assign({ x: 1, y: 0, z: 1 });
+    u.components.push(hp);
+    u.components.push(team);
+    u.components.push(pos);
+    u.components.push(vel);
+    return u;
+}
+
+function ms(fn: () => void): number {
+    const t = performance.now();
+    fn();
+    return performance.now() - t;
+}
+
+function sum(arr: number[]): number {
+    let s = 0;
+    for (const v of arr) s += v;
+    return s;
+}
+
+// ─── 1. Memory footprint ──────────────────────────────────────────────
+
+const UNIT_COUNT = 1000;
+
+globalThis.gc?.();
+const heapBefore = process.memoryUsage().heapUsed;
+
+const state = new State();
+const encoder = new Encoder(state);
+
+for (let i = 0; i < UNIT_COUNT; i++) {
+    state.units.add(mkUnit(i));
+}
+
+globalThis.gc?.();
+const heapAfter = process.memoryUsage().heapUsed;
+console.log(`Heap for ${UNIT_COUNT} units × 4 components: ${((heapAfter - heapBefore) / 1024 / 1024).toFixed(2)} MB`);
+
+// ─── 2. Broadcast-mode encoding (no views) ────────────────────────────
+// maxPerTick drains units in batches. Measure bytes + time per tick
+// until the backlog is fully drained.
+
+{
+    const s = new State();
+    s.units.maxPerTick = 50;
+    const enc = new Encoder(s);
+
+    // Spawn all units in one "tick" (worst case for backlog).
+    for (let i = 0; i < UNIT_COUNT; i++) {
+        s.units.add(mkUnit(i));
+    }
+
+    // Bootstrap full state snapshot.
+    enc.encodeAll();
+    enc.discardChanges();
+
+    const tickTimes: number[] = [];
+    const tickBytes: number[] = [];
+    let tick = 0;
+    while (
+        ((s.units as any)._stream?.broadcastPending.size ?? 0) > 0 ||
+        ((s.units as any)._stream?.broadcastDeletes.size ?? 0) > 0
+    ) {
+        tick++;
+        const t = performance.now();
+        const bytes = enc.encode();
+        tickTimes.push(performance.now() - t);
+        tickBytes.push(bytes.length);
+        enc.discardChanges();
+        if (tick > 1000) throw new Error("drain did not converge");
+    }
+    console.log(
+        `Broadcast drain: ${tick} ticks @ maxPerTick=50, total=${sum(tickBytes)} bytes, ` +
+        `avg=${(sum(tickTimes) / tick).toFixed(3)}ms/tick`,
+    );
+}
+
+// ─── 3. View-mode encoding (1 client) ─────────────────────────────────
+// Same workload but with a StateView. Exercises the priority pass +
+// per-view pending state.
+
+{
+    const s = new State();
+    s.units.maxPerTick = 50;
+    const enc = new Encoder(s);
+
+    // Instance-level priority override (same sort path exercised).
+    s.units.priority = (_view: any, el: Unit) => {
+        const pos = el.components[2] as Position;
+        return -(pos?.value?.x ?? 0);
+    };
+
+    // Create view BEFORE adding units so stream.add doesn't seed
+    // broadcast pending (view mode = no auto-seed, explicit subscribe).
+    const view = new StateView();
+    view.add(s);
+
+    for (let i = 0; i < UNIT_COUNT; i++) {
+        const u = mkUnit(i);
+        s.units.add(u);
+        view.add(u);
+    }
+
+    // Bootstrap.
+    const bootIt = { offset: 0 };
+    enc.encodeAll(bootIt);
+    const bootShared = bootIt.offset;
+    enc.encodeAllView(view, bootShared, bootIt);
+    enc.discardChanges();
+
+    const tickTimes: number[] = [];
+    const tickBytes: number[] = [];
+    let tick = 0;
+    while (true) {
+        const pending = (s.units as any)._stream?.pendingByView.get(view.id);
+        if (!pending || pending.size === 0) break;
+        tick++;
+        const t = performance.now();
+        const it = { offset: 0 };
+        enc.encode(it);
+        const sharedOffset = it.offset;
+        const bytes = enc.encodeView(view, sharedOffset, it);
+        tickTimes.push(performance.now() - t);
+        tickBytes.push(bytes.length);
+        enc.discardChanges();
+        if (tick > 1000) throw new Error("drain did not converge");
+    }
+    console.log(
+        `View drain: ${tick} ticks @ maxPerTick=50 w/ priority sort, total=${sum(tickBytes)} bytes, ` +
+        `avg=${(sum(tickTimes) / tick).toFixed(3)}ms/tick`,
+    );
+}
+
+// ─── 4. Steady-state mutations ────────────────────────────────────────
+// After the backlog is drained, simulate 60Hz gameplay: every unit's
+// hp.current and position.value.x mutate each tick.
+
+{
+    const s = new State();
+    s.units.maxPerTick = Number.MAX_SAFE_INTEGER; // drain everything immediately
+    const enc = new Encoder(s);
+
+    const units: Unit[] = [];
+    for (let i = 0; i < UNIT_COUNT; i++) {
+        const u = mkUnit(i);
+        units.push(u);
+        s.units.add(u);
+    }
+
+    // Bootstrap — drain the whole backlog in one tick.
+    enc.encodeAll();
+    enc.encode();
+    enc.discardChanges();
+
+    const iterations = 200;
+    const mutateAndEncode = ms(() => {
+        for (let it = 0; it < iterations; it++) {
+            for (const u of units) {
+                const hp = u.components[0] as Hp;
+                const pos = u.components[2] as Position;
+                hp.current = Math.max(0, hp.current - 1);
+                pos.value.x++;
+            }
+            enc.encode();
+            enc.discardChanges();
+        }
+    });
+    console.log(
+        `Steady-state mutations (${iterations} ticks × ${UNIT_COUNT} units × 2 fields): ` +
+        `${mutateAndEncode.toFixed(1)}ms total, ${(mutateAndEncode / iterations).toFixed(3)}ms/tick`,
+    );
+}
+
+// ─── 5. View-mode steady state (1 client w/ per-view priority) ────────
+
+{
+    const s = new State();
+    s.units.maxPerTick = Number.MAX_SAFE_INTEGER;
+    const enc = new Encoder(s);
+
+    // View must exist before units so stream.add doesn't seed broadcast.
+    const view = new StateView();
+    view.add(s);
+
+    const units: Unit[] = [];
+    for (let i = 0; i < UNIT_COUNT; i++) {
+        const u = mkUnit(i);
+        units.push(u);
+        s.units.add(u);
+        view.add(u);
+    }
+
+    const bootIt = { offset: 0 };
+    enc.encodeAll(bootIt);
+    const bootShared = bootIt.offset;
+    enc.encodeAllView(view, bootShared, bootIt);
+    // Drain pending.
+    const drainIt = { offset: 0 };
+    enc.encode(drainIt);
+    enc.encodeView(view, drainIt.offset, drainIt);
+    enc.discardChanges();
+
+    const iterations = 200;
+    const mutateAndEncode = ms(() => {
+        for (let it = 0; it < iterations; it++) {
+            for (const u of units) {
+                const hp = u.components[0] as Hp;
+                const pos = u.components[2] as Position;
+                hp.current = Math.max(0, hp.current - 1);
+                pos.value.x++;
+            }
+            const tickIt = { offset: 0 };
+            enc.encode(tickIt);
+            enc.encodeView(view, tickIt.offset, tickIt);
+            enc.discardChanges();
+        }
+    });
+    console.log(
+        `View steady-state (${iterations} ticks × ${UNIT_COUNT} units × 2 fields, 1 client): ` +
+        `${mutateAndEncode.toFixed(1)}ms total, ${(mutateAndEncode / iterations).toFixed(3)}ms/tick`,
+    );
+}

package/src/bench_view_cmp.ts

@@ -0,0 +1,142 @@
+/**
+ * bench_view_cmp.ts — StateView-path counterpart to bench_bloat.ts.
+ *
+ * Same entity layout (1000 players × Position × 5 scores) but with N
+ * StateViews subscribing to a @view-tagged secret field on each player.
+ * Measures per-tick encode throughput under view-filtered fanout.
+ *
+ * Run: npx tsx --tsconfig tsconfig.test.json --expose-gc src/bench_view_cmp.ts
+ */
+import { Encoder, Schema, type, view, MapSchema, ArraySchema, StateView } from "./index";
+
+class Position extends Schema {
+    @type("number") x: number = 0;
+    @type("number") y: number = 0;
+}
+
+class Player extends Schema {
+    @type("string") name: string = "";
+    @type(Position) position = new Position();
+    @type(["number"]) scores = new ArraySchema<number>();
+    @view() @type("uint32") secret: number = 0;
+}
+
+class State extends Schema {
+    @type({ map: Player }) players = new MapSchema<Player>();
+}
+
+const N_PLAYERS = 1000;
+const N_CLIENTS = 10;
+
+// ─── Setup ─────────────────────────────────────────────────────────────
+
+globalThis.gc?.();
+const heapBefore = process.memoryUsage().heapUsed;
+
+const state = new State();
+const encoder = new Encoder(state);
+Encoder.BUFFER_SIZE = 256 * 1024;
+
+for (let i = 0; i < N_PLAYERS; i++) {
+    const p = new Player();
+    p.name = `P${i}`;
+    p.position.x = i;
+    p.position.y = i;
+    for (let j = 0; j < 5; j++) p.scores.push(j);
+    p.secret = i;
+    state.players.set(`p${i}`, p);
+}
+
+globalThis.gc?.();
+const heapAfter = process.memoryUsage().heapUsed;
+console.log(`Heap (${N_PLAYERS} players): ${((heapAfter - heapBefore) / 1024 / 1024).toFixed(2)} MB`);
+
+// Subscribe N clients, each to every player.
+const views: StateView[] = [];
+for (let c = 0; c < N_CLIENTS; c++) {
+    const v = new StateView();
+    for (let i = 0; i < N_PLAYERS; i++) {
+        v.add(state.players.get(`p${i}`)!);
+    }
+    views.push(v);
+}
+
+// Bootstrap full encode.
+encoder.encodeAll();
+for (const v of views) {
+    const it = { offset: 0 };
+    encoder.encodeAll(it);
+    encoder.encodeAllView(v, it.offset, it);
+}
+encoder.discardChanges();
+
+// ─── 1. 10-mutation ticks ──────────────────────────────────────────────
+
+{
+    const iterations = 2000;
+    const start = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        for (let j = 0; j < 10; j++) {
+            const p = state.players.get(`p${j}`)!;
+            p.position.x++;
+            p.position.y++;
+        }
+        const it = { offset: 0 };
+        encoder.encode(it);
+        const sharedOffset = it.offset;
+        for (const v of views) encoder.encodeView(v, sharedOffset, it);
+        encoder.discardChanges();
+    }
+    const elapsed = performance.now() - start;
+    console.log(
+        `${iterations} ticks × (10 mutations, shared + ${N_CLIENTS} views): ` +
+        `${elapsed.toFixed(1)}ms total (${(elapsed / iterations).toFixed(4)}ms/tick)`,
+    );
+}
+
+// ─── 2. 100-mutation ticks ─────────────────────────────────────────────
+
+{
+    const iterations = 500;
+    const start = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        for (let j = 0; j < 100; j++) {
+            const p = state.players.get(`p${j}`)!;
+            p.position.x++;
+            p.position.y++;
+        }
+        const it = { offset: 0 };
+        encoder.encode(it);
+        const sharedOffset = it.offset;
+        for (const v of views) encoder.encodeView(v, sharedOffset, it);
+        encoder.discardChanges();
+    }
+    const elapsed = performance.now() - start;
+    console.log(
+        `${iterations} ticks × (100 mutations, shared + ${N_CLIENTS} views): ` +
+        `${elapsed.toFixed(1)}ms total (${(elapsed / iterations).toFixed(3)}ms/tick)`,
+    );
+}
+
+// ─── 3. View-tagged field mutations (exercises per-view filtering) ─────
+
+{
+    const iterations = 500;
+    const start = performance.now();
+    for (let i = 0; i < iterations; i++) {
+        for (let j = 0; j < 100; j++) {
+            const p = state.players.get(`p${j}`)!;
+            p.secret = (p.secret + 1) >>> 0;
+        }
+        const it = { offset: 0 };
+        encoder.encode(it);
+        const sharedOffset = it.offset;
+        for (const v of views) encoder.encodeView(v, sharedOffset, it);
+        encoder.discardChanges();
+    }
+    const elapsed = performance.now() - start;
+    console.log(
+        `${iterations} ticks × (100 @view-field mutations, shared + ${N_CLIENTS} views): ` +
+        `${elapsed.toFixed(1)}ms total (${(elapsed / iterations).toFixed(3)}ms/tick)`,
+    );
+}