@net-mesh/browser 0.42.0 → 0.44.0

package/dist/netcode/codec.js

@@ -0,0 +1,547 @@
+/**
+ * Compact snapshots: a game-supplied entity schema, and the binary snapshot
+ * frame it makes possible (sharded-match plan, slice S0c).
+ *
+ * ```ts
+ * const shipCodec = entityCodec({
+ *   x: quantized(0, 512),          // 16 bits over the arena: ~8 mm
+ *   z: quantized(0, 512),
+ *   yaw: angle(),                  // 8 bits: ~1.4°
+ *   hp: uint(8),
+ * });
+ * hostNetcode({ …, codec: shipCodec });
+ * joinNetcode({ …, codec: shipCodec });
+ * ```
+ *
+ * JSON stays the default and the fallback. A player announces its codec's
+ * fingerprint in its join and ping frames; the host sends binary snapshots
+ * only to a player whose fingerprint matches its own, and JSON to everyone
+ * else — so a mismatched or older peer degrades to JSON, never to garbage.
+ *
+ * **Ids.** On the binary wire an entity is named by a varint index, not its
+ * id string. The host assigns indexes in order of first appearance and
+ * **never reuses one** within its lifetime, so a late or reordered
+ * snapshot cannot name the wrong entity. A snapshot carries an entity's
+ * name the first time it shows that entity to a player; a player that sees
+ * an index it has no name for does not draw that entity and asks again
+ * (`u` frame) — the lossy carrier's repair, with no acknowledgements.
+ *
+ * Every binary snapshot also carries the host's **instance**, a random
+ * 32-bit number drawn when `hostNetcode` starts. A host re-created under
+ * the same label starts its indexes over; a player that sees a new instance
+ * drops every name (and every snapshot) it learnt from the old one, so the
+ * new host's indexes are never read through the old host's names.
+ *
+ * Names are also forgotten: an id no player has been shown for
+ * `NAME_FORGET_MS` (10 s) loses its index, and comes back, if it does,
+ * under a fresh one, named again. Transient ids (projectiles) do not grow
+ * the tables for the whole match.
+ *
+ * **Versions.** The fingerprint covers the binary wire's version as well as
+ * the schema. Frames carrying an instance are version 2; a peer from before
+ * it has another fingerprint for the same schema, so the pair falls back
+ * to JSON instead of refusing each other's frames.
+ *
+ * **Interpolation.** `entityCodec` also supplies an `interpolate` blend
+ * that knows its fields: an `angle()` turns the short way round across
+ * 0 / 2π. `joinNetcode` uses it when it has a codec and no `interpolate`
+ * of its own.
+ *
+ * **What the schema promises.** An entity is a flat object of the schema's
+ * fields and nothing else. Writing an entity with a field the schema does
+ * not have, or a value that is not a finite number (or boolean, for
+ * `bool()`), throws: the host then sends that player JSON for that tick
+ * (counted in `dropped`) rather than silently losing a field.
+ */
+import { lerpAngle, lerpNumbers } from './interpolate.js';
+const finite = (value, field) => {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new TypeError(`field '${field}': expected a finite number, got ${String(value)}`);
+    }
+    return value;
+};
+function checkBits(bits, allowed) {
+    if (!allowed.includes(bits))
+        throw new RangeError(`bits must be one of ${allowed.join(', ')}, got ${String(bits)}`);
+}
+function putUint(view, at, bits, value) {
+    if (bits === 8)
+        view.setUint8(at, value);
+    else if (bits === 16)
+        view.setUint16(at, value);
+    else
+        view.setUint32(at, value);
+}
+function getUint(view, at, bits) {
+    return bits === 8 ? view.getUint8(at) : bits === 16 ? view.getUint16(at) : view.getUint32(at);
+}
+/**
+ * A number in `[min, max]`, quantized to `bits` (8 or 16; default 16).
+ * Values outside the range are clamped — including one a hair past an edge
+ * after rounding, which must not wrap around.
+ */
+export function quantized(min, max, bits = 16) {
+    if (!(Number.isFinite(min) && Number.isFinite(max) && max > min))
+        throw new RangeError('quantized(min, max): max must exceed min');
+    checkBits(bits, [8, 16]);
+    const steps = 2 ** bits - 1;
+    const span = max - min;
+    return {
+        size: bits / 8,
+        spec: `q${bits}(${min},${max})`,
+        quantum: span / steps / 2,
+        write(view, at, value) {
+            const v = finite(value, this.spec);
+            const q = Math.round(((v - min) / span) * steps);
+            putUint(view, at, bits, Math.min(steps, Math.max(0, q)));
+        },
+        read(view, at) {
+            return min + (getUint(view, at, bits) / steps) * span;
+        },
+        near(a, b) {
+            if (typeof a !== 'number' || typeof b !== 'number')
+                return a === b;
+            const clampTo = (v) => Math.min(max, Math.max(min, v));
+            return Math.abs(clampTo(a) - clampTo(b)) <= (2 * span) / steps + 1e-9;
+        },
+    };
+}
+/** An angle in radians, any value, stored as a fraction of a turn in `bits` (default 8). Reads in `[0, 2π)`. */
+export function angle(bits = 8) {
+    checkBits(bits, [8, 16]);
+    const steps = 2 ** bits;
+    const turn = Math.PI * 2;
+    return {
+        size: bits / 8,
+        spec: `a${bits}`,
+        quantum: turn / steps / 2,
+        write(view, at, value) {
+            const v = finite(value, this.spec);
+            const fraction = (((v % turn) + turn) % turn) / turn;
+            putUint(view, at, bits, Math.round(fraction * steps) % steps);
+        },
+        read(view, at) {
+            return (getUint(view, at, bits) / steps) * turn;
+        },
+        near(a, b) {
+            if (typeof a !== 'number' || typeof b !== 'number')
+                return a === b;
+            const d = Math.abs((((a - b) % turn) + turn) % turn);
+            return Math.min(d, turn - d) <= (2 * turn) / steps + 1e-9;
+        },
+        blend: lerpAngle,
+    };
+}
+/** A whole number in `[0, 2^bits)`, exact (default 8 bits). Out of range throws. */
+export function uint(bits = 8) {
+    checkBits(bits, [8, 16, 32]);
+    const max = 2 ** bits - 1;
+    return {
+        size: bits / 8,
+        spec: `u${bits}`,
+        quantum: 0,
+        write(view, at, value) {
+            const v = finite(value, this.spec);
+            if (!Number.isInteger(v) || v < 0 || v > max)
+                throw new RangeError(`field u${bits}: ${String(v)} is not a whole number in [0, ${max}]`);
+            putUint(view, at, bits, v);
+        },
+        read(view, at) {
+            return getUint(view, at, bits);
+        },
+        near: (a, b) => a === b,
+    };
+}
+/** A whole number in `[-2^(bits-1), 2^(bits-1))`, exact (default 16 bits). Out of range throws. */
+export function int(bits = 16) {
+    checkBits(bits, [8, 16, 32]);
+    const low = -(2 ** (bits - 1));
+    const high = 2 ** (bits - 1) - 1;
+    return {
+        size: bits / 8,
+        spec: `i${bits}`,
+        quantum: 0,
+        write(view, at, value) {
+            const v = finite(value, this.spec);
+            if (!Number.isInteger(v) || v < low || v > high)
+                throw new RangeError(`field i${bits}: ${String(v)} is not a whole number in [${low}, ${high}]`);
+            if (bits === 8)
+                view.setInt8(at, v);
+            else if (bits === 16)
+                view.setInt16(at, v);
+            else
+                view.setInt32(at, v);
+        },
+        read(view, at) {
+            return bits === 8 ? view.getInt8(at) : bits === 16 ? view.getInt16(at) : view.getInt32(at);
+        },
+        near: (a, b) => a === b,
+    };
+}
+/** A 32-bit float: ~7 significant digits, no range to choose. A NaN or an infinity read off the wire refuses the frame. */
+export function float32() {
+    return {
+        size: 4,
+        spec: 'f32',
+        quantum: Number.NaN, // relative, not absolute: see Math.fround
+        write(view, at, value) {
+            view.setFloat32(at, finite(value, this.spec));
+        },
+        read(view, at) {
+            const value = view.getFloat32(at);
+            // The writer refuses these, so only a hostile or broken host sends them.
+            if (!Number.isFinite(value))
+                throw new RangeError(`field f32: ${String(value)} is not finite`);
+            return value;
+        },
+        near(a, b) {
+            if (typeof a !== 'number' || typeof b !== 'number')
+                return a === b;
+            return Math.fround(a) === Math.fround(b) || Math.abs(a - b) <= 1e-6 * Math.max(Math.abs(a), Math.abs(b));
+        },
+    };
+}
+/** A boolean, one byte. */
+export function bool() {
+    return {
+        size: 1,
+        spec: 'b',
+        quantum: 0,
+        write(view, at, value) {
+            if (typeof value !== 'boolean')
+                throw new TypeError(`field b: expected a boolean, got ${String(value)}`);
+            view.setUint8(at, value ? 1 : 0);
+        },
+        read(view, at) {
+            return view.getUint8(at) !== 0;
+        },
+        near: (a, b) => a === b,
+    };
+}
+/** FNV-1a of a string, as 8 hex digits. */
+function fnv(text) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i += 1)
+        hash = Math.imul(hash ^ text.charCodeAt(i), 0x01000193);
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+/**
+ * The binary wire's version, part of every fingerprint. 2: snapshots carry
+ * the host's instance. A peer at another version has another fingerprint
+ * for the same schema, so the pair falls back to JSON.
+ */
+const BINARY_WIRE_VERSION = 2;
+/**
+ * An entity codec from a schema: one field codec per property, written in
+ * the schema's key order. The fingerprint covers names, order and specs,
+ * and the binary wire's version.
+ */
+export function entityCodec(fields) {
+    const entries = Object.entries(fields);
+    if (entries.length === 0)
+        throw new RangeError('an entity codec needs at least one field');
+    const names = new Set(entries.map(([name]) => name));
+    const offsets = [];
+    let size = 0;
+    for (const [, field] of entries) {
+        offsets.push(size);
+        size += field.size;
+    }
+    const fingerprint = fnv(`v${BINARY_WIRE_VERSION};${entries.map(([name, field]) => `${name}:${field.spec}`).join(';')}`);
+    const blended = entries.filter(([, field]) => field.blend !== undefined);
+    return {
+        size,
+        fingerprint,
+        write(entity, view, at) {
+            const record = entity;
+            for (const key in record) {
+                if (Object.prototype.hasOwnProperty.call(record, key) && !names.has(key)) {
+                    throw new TypeError(`field '${key}' is not in the codec's schema`);
+                }
+            }
+            entries.forEach(([name, field], i) => {
+                try {
+                    field.write(view, at + offsets[i], record[name]);
+                }
+                catch (error) {
+                    throw new TypeError(`field '${name}': ${error.message}`);
+                }
+            });
+        },
+        read(view, at) {
+            const out = {};
+            entries.forEach(([name, field], i) => {
+                out[name] = field.read(view, at + offsets[i]);
+            });
+            return out;
+        },
+        near(a, b) {
+            const left = a;
+            const right = b;
+            return entries.every(([name, field]) => field.near(left[name], right[name]));
+        },
+        interpolate(from, to, alpha) {
+            const out = lerpNumbers(from, to, alpha);
+            if (blended.length === 0 || out === null || typeof out !== 'object')
+                return out;
+            const left = from;
+            const right = to;
+            const result = out;
+            for (const [name, field] of blended) {
+                const a = left[name];
+                const b = right[name];
+                if (typeof a === 'number' && typeof b === 'number')
+                    result[name] = field.blend(a, b, alpha);
+            }
+            return out;
+        },
+    };
+}
+// ── The binary snapshot frame ──────────────────────────────────────────
+/** First byte of a binary netcode frame. Never `{` (0x7b), so it cannot be JSON. */
+export const BINARY_FRAME_MAGIC = 0xb1;
+/** Kind byte: a snapshot. */
+const KIND_SNAPSHOT = 1;
+/**
+ * Kind byte: a snapshot stamped with an assignment epoch (a varint after
+ * the tick). A kind of its own, so a decoder that predates epochs refuses
+ * the frame rather than reading the epoch as the time.
+ */
+const KIND_SNAPSHOT_EPOCH = 2;
+/**
+ * Kind bytes: the same two, with the host's instance (a 32-bit number,
+ * four bytes) right after the kind byte. Wire version 2.
+ */
+const KIND_SNAPSHOT_INSTANCE = 3;
+const KIND_SNAPSHOT_EPOCH_INSTANCE = 4;
+/** The label's 32-bit FNV-1a: a binary frame's stand-in for the JSON `n`. */
+export function labelHash(label) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < label.length; i += 1)
+        hash = Math.imul(hash ^ label.charCodeAt(i), 0x01000193);
+    return hash >>> 0;
+}
+const utf8 = new TextEncoder();
+const fromUtf8 = new TextDecoder('utf-8', { fatal: true });
+function varintSize(value) {
+    let size = 1;
+    while (value >= 0x80) {
+        value = Math.floor(value / 128);
+        size += 1;
+    }
+    return size;
+}
+function putVarint(bytes, at, value) {
+    while (value >= 0x80) {
+        bytes[at++] = (value % 128) | 0x80;
+        value = Math.floor(value / 128);
+    }
+    bytes[at++] = value;
+    return at;
+}
+/** `[value, next offset]`, or `null` past the end / over 2^53. */
+function getVarint(bytes, at) {
+    let value = 0;
+    let scale = 1;
+    for (let i = 0; i < 8; i += 1) {
+        if (at >= bytes.length)
+            return null;
+        const byte = bytes[at++];
+        value += (byte & 0x7f) * scale;
+        if ((byte & 0x80) === 0)
+            return Number.isSafeInteger(value) ? [value, at] : null;
+        scale *= 128;
+    }
+    return null;
+}
+/** The binary size of one snapshot frame, without building it. */
+export function binarySnapshotSize(frame, names, indexes, entitySize) {
+    let size = 1 + 4 + 1 + varintSize(frame.tick) + 8 + varintSize(frame.ack) + varintSize(frame.iv ?? 0);
+    if (frame.instance !== undefined)
+        size += 4;
+    if (frame.ep !== undefined)
+        size += varintSize(frame.ep);
+    size += varintSize(frame.of ?? 0) + varintSize(frame.c ?? 0);
+    let count = 0;
+    let nameCount = 0;
+    for (const [index, name] of names) {
+        nameCount += 1;
+        size += varintSize(index) + varintSize(name.length) + name.length;
+    }
+    size += varintSize(nameCount);
+    for (const index of indexes) {
+        count += 1;
+        size += varintSize(index) + entitySize;
+    }
+    return size + varintSize(count);
+}
+/**
+ * Build one binary snapshot frame. `names` are UTF-8 ids by index;
+ * `entities` are by index. Throws if the codec refuses an entity.
+ */
+export function encodeBinarySnapshot(label, frame, names, entities, codec) {
+    const instance = frame.instance;
+    if (instance !== undefined && !(Number.isInteger(instance) && instance >= 0 && instance <= 0xffffffff)) {
+        throw new RangeError(`binary snapshot: instance ${String(instance)} is not a 32-bit unsigned integer`);
+    }
+    const size = binarySnapshotSize(frame, names, entities.keys(), codec.size);
+    const bytes = new Uint8Array(size);
+    const view = new DataView(bytes.buffer);
+    bytes[0] = BINARY_FRAME_MAGIC;
+    view.setUint32(1, labelHash(label));
+    let at = 6;
+    if (instance === undefined) {
+        bytes[5] = frame.ep === undefined ? KIND_SNAPSHOT : KIND_SNAPSHOT_EPOCH;
+    }
+    else {
+        bytes[5] = frame.ep === undefined ? KIND_SNAPSHOT_INSTANCE : KIND_SNAPSHOT_EPOCH_INSTANCE;
+        view.setUint32(6, instance);
+        at = 10;
+    }
+    at = putVarint(bytes, at, frame.tick);
+    if (frame.ep !== undefined)
+        at = putVarint(bytes, at, frame.ep);
+    view.setFloat64(at, frame.t);
+    at += 8;
+    at = putVarint(bytes, at, frame.ack);
+    at = putVarint(bytes, at, frame.iv ?? 0);
+    at = putVarint(bytes, at, frame.of ?? 0);
+    at = putVarint(bytes, at, frame.c ?? 0);
+    at = putVarint(bytes, at, names.size);
+    for (const [index, name] of names) {
+        at = putVarint(bytes, at, index);
+        at = putVarint(bytes, at, name.length);
+        bytes.set(name, at);
+        at += name.length;
+    }
+    at = putVarint(bytes, at, entities.size);
+    for (const [index, entity] of entities) {
+        at = putVarint(bytes, at, index);
+        codec.write(entity, view, at);
+        at += codec.size;
+    }
+    if (at !== size)
+        throw new Error(`binary snapshot: wrote ${at} of ${size} bytes`);
+    return bytes;
+}
+/** True if `payload` is a binary netcode frame (of any label). */
+export function isBinaryFrame(payload) {
+    return payload !== undefined && payload.length > 0 && payload[0] === BINARY_FRAME_MAGIC;
+}
+/**
+ * Read a binary snapshot for `label`, or `null` for another label, another
+ * kind, or anything malformed (truncated, trailing bytes, bad chunk fields,
+ * a duplicate index, a name that is not UTF-8, an entity the codec will not
+ * read, such as a NaN `float32()`).
+ */
+export function decodeBinarySnapshot(payload, label, codec) {
+    if (!isBinaryFrame(payload) || payload.length < 6)
+        return null;
+    const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    const kind = payload[5];
+    if (view.getUint32(1) !== labelHash(label))
+        return null;
+    if (kind !== KIND_SNAPSHOT && kind !== KIND_SNAPSHOT_EPOCH && kind !== KIND_SNAPSHOT_INSTANCE && kind !== KIND_SNAPSHOT_EPOCH_INSTANCE) {
+        return null;
+    }
+    let instance;
+    let start = 6;
+    if (kind === KIND_SNAPSHOT_INSTANCE || kind === KIND_SNAPSHOT_EPOCH_INSTANCE) {
+        if (payload.length < 10)
+            return null;
+        instance = view.getUint32(6);
+        start = 10;
+    }
+    const varint = (at) => getVarint(payload, at);
+    let read = varint(start);
+    if (read === null)
+        return null;
+    const [tick] = read;
+    let at = read[1];
+    let ep;
+    if (kind === KIND_SNAPSHOT_EPOCH || kind === KIND_SNAPSHOT_EPOCH_INSTANCE) {
+        read = varint(at);
+        if (read === null)
+            return null;
+        [ep, at] = read;
+    }
+    if (at + 8 > payload.length)
+        return null;
+    const t = view.getFloat64(at);
+    if (!Number.isFinite(t))
+        return null;
+    at += 8;
+    const fields = [];
+    for (let i = 0; i < 4; i += 1) {
+        read = varint(at);
+        if (read === null)
+            return null;
+        fields.push(read[0]);
+        at = read[1];
+    }
+    const [ack, iv, of, c] = fields;
+    if (of !== 0 && (of > 256 || c >= of))
+        return null;
+    if (of === 0 && c !== 0)
+        return null;
+    read = varint(at);
+    if (read === null)
+        return null;
+    const names = new Map();
+    let nameCount = read[0];
+    at = read[1];
+    for (; nameCount > 0; nameCount -= 1) {
+        const index = varint(at);
+        if (index === null)
+            return null;
+        const length = varint(index[1]);
+        if (length === null || length[1] + length[0] > payload.length)
+            return null;
+        let name;
+        try {
+            name = fromUtf8.decode(payload.subarray(length[1], length[1] + length[0]));
+        }
+        catch {
+            return null;
+        }
+        if (names.has(index[0]))
+            return null;
+        names.set(index[0], name);
+        at = length[1] + length[0];
+    }
+    read = varint(at);
+    if (read === null)
+        return null;
+    let count = read[0];
+    at = read[1];
+    const entities = new Map();
+    for (; count > 0; count -= 1) {
+        const index = varint(at);
+        if (index === null || index[1] + codec.size > payload.length || entities.has(index[0]))
+            return null;
+        try {
+            entities.set(index[0], codec.read(view, index[1]));
+        }
+        catch {
+            return null;
+        }
+        at = index[1] + codec.size;
+    }
+    if (at !== payload.length)
+        return null;
+    return {
+        tick,
+        t,
+        ack,
+        ...(iv > 0 ? { iv } : {}),
+        ...(of > 0 ? { c, of } : {}),
+        ...(ep === undefined ? {} : { ep }),
+        ...(instance === undefined ? {} : { instance }),
+        names,
+        entities,
+    };
+}
+/** UTF-8 of an id, for {@link encodeBinarySnapshot}'s names. */
+export function nameBytes(id) {
+    return utf8.encode(id);
+}

package/dist/netcode/host.d.ts

@@ -17,6 +17,7 @@
  * ```
  */
 import { type Frame, type NetcodeTransport, type Now } from './wire.js';
+import { type EntityCodec } from './codec.js';
 /** One input as `step` receives it. */
 export interface TickInput<I> {
     readonly seq: number;
@@ -85,6 +86,30 @@ export interface HostNetcodeOptions<E, I> {
     readonly playerTimeoutMs?: number;
     /** `false` to drive ticks yourself with {@link HostNetcode.tick}. Default `true`. */
     readonly autoTick?: boolean;
+    /**
+     * Compact snapshots (`codec.ts`): players whose `joinNetcode` has a codec
+     * with the same fingerprint receive binary snapshots; everyone else JSON.
+     * An entity the codec refuses sends that player JSON for that tick
+     * (`dropped['codec-write-failed']`).
+     */
+    readonly codec?: EntityCodec<E>;
+    /**
+     * Sharded matches (`joinShards`): the assignment epoch this host is at,
+     * read every tick. Each snapshot carries it (`ep`), so a player draws
+     * this host's entities only at the epoch it has installed; an input
+     * frame stamped with another epoch is dropped (`dropped['stale-epoch']`).
+     * An input frame with no epoch is applied, as from any plain player.
+     */
+    epoch?(): number;
+    /**
+     * Sharded matches: whether this host still holds its lease (`leaseWatch`
+     * in `assignment.ts`), asked every tick. While `false` the host neither
+     * simulates nor sends — a host cut off from the lobby must stop before
+     * the lobby gives its entities to another — and inputs that arrive are
+     * dropped (`dropped['lease-lost']`), not saved for later. Clock pings are
+     * still answered.
+     */
+    live?(): boolean;
     readonly now?: Now;
 }
 /** The running host. */
@@ -101,6 +126,38 @@ export interface HostNetcode<E> {
      * never further back than `maxRewindMs` before now.
      */
     rewind(seen: number): Rewound<E>;
+    /**
+     * Stop taking `peer`'s inputs, and say how far they were applied: the
+     * half of a planned move (sharded matches, S5) that pairs with the
+     * entity's frozen state. Call it between ticks — the state you freeze in
+     * the same synchronous turn then contains exactly inputs `1..lastApplied`.
+     * Later inputs from `peer` are dropped unapplied and unacknowledged
+     * (`dropped['released']`), so the player keeps them for the new owner.
+     */
+    releasePlayer(peer: string): {
+        readonly lastApplied: number;
+    };
+    /**
+     * Take `peer`'s inputs from `lastApplied + 1` on: the other half of a
+     * planned move. Inputs at or below it — already in the state the entity
+     * arrived with — are never applied here.
+     *
+     * The boundary holds until the player arrives, however late: a player
+     * that times out (`playerTimeoutMs`) before its first frame, or that
+     * `authorize` refuses for now, keeps it for when it is admitted (the
+     * refusal is counted in `dropped['adopt-unauthorized']`).
+     *
+     * `{ resume: true }` is the crash-recovery form (S6), for an entity
+     * restored from an observation with no boundary to hand over: the first
+     * input frame from `peer` sets the boundary at its newest input and none
+     * of it is applied. The player's pending inputs are dropped (they were
+     * made against a state that was rolled back) and it carries on from there.
+     */
+    adoptPlayer(peer: string, from: {
+        readonly lastApplied: number;
+    } | {
+        readonly resume: true;
+    }): void;
     /** Frames dropped and why. */
     readonly dropped: Readonly<Record<string, number>>;
     /** The last error a send or stream open raised, for diagnosis; `null` if none. */
@@ -113,6 +170,6 @@ export interface HostNetcode<E> {
  * {@link MAX_SNAPSHOT_CHUNKS}; past that the chunks are sent over-size and
  * ride as fragments).
  */
-export declare function snapshotFrames<E>(label: string, tick: number, time: number, ack: number, entities: Readonly<Record<string, E>>, maxBytes: number, interestVersion?: number): Frame<E, never>[];
+export declare function snapshotFrames<E>(label: string, tick: number, time: number, ack: number, entities: Readonly<Record<string, E>>, maxBytes: number, interestVersion?: number, epoch?: number): Frame<E, never>[];
 /** Start the authoritative netcode host. */
 export declare function hostNetcode<E, I>(options: HostNetcodeOptions<E, I>): HostNetcode<E>;