@net-mesh/browser 0.37.0

package/dist/net_leaf_bg.wasm.d.ts

@@ -0,0 +1,137 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_leafnode_free: (a: number, b: number) => void;
+export const __wbg_leafstream_free: (a: number, b: number) => void;
+export const __wbg_meshsession_free: (a: number, b: number) => void;
+export const __wbg_orgbytestreamhandle_free: (a: number, b: number) => void;
+export const __wbg_orgduplexcallhandle_free: (a: number, b: number) => void;
+export const __wbg_orgrequeststreamhandle_free: (a: number, b: number) => void;
+export const __wbg_orgresponsesinkhandle_free: (a: number, b: number) => void;
+export const __wbg_orgservehandle_free: (a: number, b: number) => void;
+export const __wbg_orguploadcallhandle_free: (a: number, b: number) => void;
+export const __wbg_proxystream_free: (a: number, b: number) => void;
+export const leafnode_anchor_id_hex: (a: number, b: number) => void;
+export const leafnode_announce: (a: number, b: number, c: number) => number;
+export const leafnode_apply_org_revocation_bundle: (a: number, b: number, c: number, d: number) => void;
+export const leafnode_arm_network_retry: (a: number, b: number) => void;
+export const leafnode_call: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const leafnode_call_org: (a: number, b: number, c: number, d: number, e: number) => number;
+export const leafnode_call_org_client_stream: (a: number, b: number, c: number, d: number) => number;
+export const leafnode_call_org_duplex: (a: number, b: number, c: number, d: number) => number;
+export const leafnode_call_org_streaming: (a: number, b: number, c: number, d: number, e: number) => number;
+export const leafnode_close: (a: number) => void;
+export const leafnode_connect: (a: number) => number;
+export const leafnode_counters_json: (a: number, b: number) => void;
+export const leafnode_effective_ice_servers: (a: number, b: number) => void;
+export const leafnode_effective_stream_options: (a: number, b: number) => void;
+export const leafnode_enroll: (a: number) => number;
+export const leafnode_is_enrolled: (a: number) => number;
+export const leafnode_listener_count: (a: number) => number;
+export const leafnode_maxEventBytes: () => number;
+export const leafnode_node_id_hex: (a: number, b: number) => void;
+export const leafnode_on_event: (a: number, b: number, c: number) => void;
+export const leafnode_open_stream: (a: number, b: number, c: number) => void;
+export const leafnode_origin_hash_hex: (a: number, b: number) => void;
+export const leafnode_peer_accept_offer: (a: number, b: number, c: number) => number;
+export const leafnode_peer_candidate: (a: number, b: number, c: number) => number;
+export const leafnode_peer_candidate_in: (a: number, b: number, c: number, d: number, e: number) => number;
+export const leafnode_peer_direct_dialog: (a: number, b: number, c: number, d: number) => void;
+export const leafnode_peer_handshake: (a: number, b: number, c: number) => number;
+export const leafnode_peer_handshake_in: (a: number, b: number, c: number, d: number, e: number) => number;
+export const leafnode_peer_offer: (a: number, b: number, c: number) => number;
+export const leafnode_publish: (a: number, b: number, c: number, d: number) => number;
+export const leafnode_query: (a: number, b: number, c: number) => number;
+export const leafnode_remove_listener: (a: number, b: number, c: number) => number;
+export const leafnode_retire: (a: number, b: bigint) => number;
+export const leafnode_retry_report: (a: number, b: number) => void;
+export const leafnode_rtc_stats_json: (a: number, b: number) => void;
+export const leafnode_serve_org: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const leafnode_serve_org_client_stream: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const leafnode_serve_org_duplex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const leafnode_serve_org_streaming: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const leafnode_signal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+export const leafnode_subscribe: (a: number, b: number, c: number) => number;
+export const leafnode_unsubscribe: (a: number, b: number, c: number) => number;
+export const leafstream_close: (a: number) => void;
+export const leafstream_incarnation: (a: number, b: number) => void;
+export const leafstream_is_reliable: (a: number) => number;
+export const leafstream_on_message: (a: number, b: number, c: number) => void;
+export const leafstream_peer_node_hex: (a: number, b: number) => void;
+export const leafstream_remove_listener: (a: number, b: number, c: number) => number;
+export const leafstream_send: (a: number, b: number, c: number) => void;
+export const leafstream_stream_id_hex: (a: number, b: number) => void;
+export const meshsession_announce: (a: number, b: number, c: number) => number;
+export const meshsession_call: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const meshsession_call_org: (a: number, b: number, c: number, d: number, e: number) => number;
+export const meshsession_call_org_client_stream: (a: number, b: number, c: number, d: number) => number;
+export const meshsession_call_org_duplex: (a: number, b: number, c: number, d: number) => number;
+export const meshsession_call_org_streaming: (a: number, b: number, c: number, d: number, e: number) => number;
+export const meshsession_close: (a: number) => void;
+export const meshsession_counters_json: (a: number) => number;
+export const meshsession_enroll: (a: number) => number;
+export const meshsession_fingerprint: (a: number, b: number) => void;
+export const meshsession_generation: (a: number, b: number) => void;
+export const meshsession_interruption_ms: (a: number, b: number) => void;
+export const meshsession_is_enrolled: (a: number) => number;
+export const meshsession_node_id_hex: (a: number, b: number) => void;
+export const meshsession_on_event: (a: number, b: number) => void;
+export const meshsession_open: (a: number) => number;
+export const meshsession_open_stream: (a: number, b: number) => number;
+export const meshsession_peer_accept_offer: (a: number, b: number, c: number) => number;
+export const meshsession_peer_candidate: (a: number, b: number, c: number, d: number, e: number) => number;
+export const meshsession_peer_direct_dialog: (a: number, b: number, c: number) => number;
+export const meshsession_peer_handshake: (a: number, b: number, c: number, d: number, e: number) => number;
+export const meshsession_peer_offer: (a: number, b: number, c: number) => number;
+export const meshsession_publish: (a: number, b: number, c: number, d: number) => number;
+export const meshsession_query: (a: number, b: number, c: number) => number;
+export const meshsession_role: (a: number, b: number) => void;
+export const meshsession_scope: (a: number, b: number) => void;
+export const meshsession_serve_org: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const meshsession_serve_org_client_stream: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const meshsession_serve_org_duplex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const meshsession_serve_org_streaming: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const meshsession_signal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+export const meshsession_subscribe: (a: number, b: number, c: number) => number;
+export const meshsession_unsubscribe: (a: number, b: number, c: number) => number;
+export const orgbytestreamhandle_cancel: (a: number) => void;
+export const orgbytestreamhandle_next: (a: number) => number;
+export const orgduplexcallhandle_cancel: (a: number) => void;
+export const orgduplexcallhandle_finish_sending: (a: number) => number;
+export const orgduplexcallhandle_send: (a: number, b: number) => number;
+export const orgduplexcallhandle_stream: (a: number) => number;
+export const orgrequeststreamhandle_next: (a: number) => number;
+export const orgrequeststreamhandle_retired: (a: number) => number;
+export const orgresponsesinkhandle_close: (a: number) => number;
+export const orgresponsesinkhandle_retired: (a: number) => number;
+export const orgresponsesinkhandle_send: (a: number, b: number) => number;
+export const orgservehandle_close: (a: number) => void;
+export const orgservehandle_service: (a: number, b: number) => void;
+export const orguploadcallhandle_cancel: (a: number) => void;
+export const orguploadcallhandle_finish: (a: number) => number;
+export const orguploadcallhandle_send: (a: number, b: number) => number;
+export const proxystream_close: (a: number) => void;
+export const proxystream_generation: (a: number, b: number) => void;
+export const proxystream_incarnation: (a: number, b: number) => void;
+export const proxystream_is_reliable: (a: number) => number;
+export const proxystream_on_message: (a: number, b: number) => void;
+export const proxystream_peer_node_hex: (a: number, b: number) => void;
+export const proxystream_send: (a: number, b: number) => number;
+export const proxystream_stream_id_hex: (a: number, b: number) => void;
+export const start: () => void;
+export const __wasm_bindgen_func_elem_6504: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_6506: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_2355: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_2356: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2356_112: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2356_113: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2356_114: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2356_115: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2356_116: (a: number, b: number, c: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_export4: (a: number, b: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export5: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/dist/netcode/client.d.ts

@@ -0,0 +1,102 @@
+/**
+ * `joinNetcode` — a player's side of netcode model 2: clock sync with the
+ * host, **snapshot interpolation** for everyone else, **local prediction
+ * with reconciliation** for yourself.
+ *
+ * ```ts
+ * const net = joinNetcode({
+ *   transport: node,
+ *   host: lobbyHostId,
+ *   label: 'my-game.movement',
+ *   local: { id: node.nodeIdHex()!, predict: (ship, input) => move(ship, input) },
+ * });
+ * onKey(input => net.input(input));        // applied locally at once, sent to the host
+ * renderLoop(() => draw(net.view()));      // remote ships interpolated, yours predicted
+ * ```
+ */
+import { type ClockEstimate } from './clock.js';
+import { type Interpolator } from './interpolate.js';
+import { type NetcodeTransport, type Now } from './wire.js';
+/** Your own entity, predicted locally. */
+export interface LocalEntity<E, I> {
+    /** Its id in the host's snapshots (usually your node id). */
+    readonly id: string;
+    /** Apply one input to a state — the same rule the host applies. */
+    predict(state: E, input: I): E;
+}
+/** {@link joinNetcode}'s argument. */
+export interface JoinNetcodeOptions<E, I> {
+    readonly transport: NetcodeTransport;
+    /** The host's node id, 16 hex. */
+    readonly host: string;
+    /** The same label the host uses. */
+    readonly label: string;
+    /** How far behind the host clock remote entities render. Default 100 ms
+     * — at least two snapshot intervals, so one lost snapshot does not
+     * stall them. */
+    readonly interpolationDelayMs?: number;
+    /** Blend two states of an entity. Default {@link lerpNumbers}. */
+    readonly interpolate?: Interpolator<E>;
+    /**
+     * When the newest snapshot is older than the render time (a late or lost
+     * snapshot), carry remote entities on along their last motion for at most
+     * this long, ms, instead of freezing them. Default 0: hold. Extrapolation
+     * guesses; a wrong guess is corrected by the next snapshot, visibly. Your
+     * `interpolate`, if you supply one, is then called with `alpha > 1`.
+     */
+    readonly extrapolateMs?: number;
+    /** Predict and reconcile this entity. Omit for a spectator. */
+    readonly local?: LocalEntity<E, I>;
+    /** Unacknowledged inputs repeated in each input frame. Default 8. */
+    readonly inputRedundancy?: number;
+    /** Clock pings per second. Default 4. */
+    readonly pingRate?: number;
+    /**
+     * The interest keys to receive (the host's `interest` keys entities; an
+     * entity keyed `null` always arrives). Omit to receive everything the host
+     * shows you. Change it with {@link NetcodeClient.setInterest}.
+     */
+    readonly interest?: readonly string[];
+    /**
+     * How long a correction takes to show, ms. Default 100; `0` snaps.
+     *
+     * When reconciliation moves your entity, the view blends from where it
+     * was drawn to where the host says it is, instead of jumping. Inputs
+     * keep applying to both during the blend, so it never lags your
+     * controls; it only closes the gap.
+     */
+    readonly correctionSmoothingMs?: number;
+    readonly now?: Now;
+}
+/** What {@link NetcodeClient.stats} reports. */
+export interface NetcodeStats {
+    readonly clock: ClockEstimate | null;
+    readonly snapshots: number;
+    /** Snapshots that arrived after a newer one. */
+    readonly lateSnapshots: number;
+    /** Inputs sent and not yet acknowledged by the host. */
+    readonly pendingInputs: number;
+    /** Times reconciliation moved the local entity away from its prediction. */
+    readonly corrections: number;
+    /** Chunked snapshots finished with chunks missing (their entities carried over). */
+    readonly partialSnapshots: number;
+}
+/** The running client. */
+export interface NetcodeClient<E, I> {
+    /** Apply `input` locally now (prediction) and send it to the host. */
+    input(data: I): void;
+    /** The world to draw now: remote entities interpolated, yours predicted. */
+    view(): Readonly<Record<string, E>>;
+    /**
+     * Receive only entities under these interest keys from now on. Entities
+     * that leave the set disappear from later snapshots, and so from `view()`.
+     * Throws `RangeError` over 256 keys or for a key over 64 characters.
+     */
+    setInterest(keys: readonly string[]): void;
+    /** The host clock, as estimated. `null` before the first pong. */
+    hostNow(): number | null;
+    stats(): NetcodeStats;
+    close(): void;
+}
+/** Join a host's netcode. */
+export declare function joinNetcode<E, I>(options: JoinNetcodeOptions<E, I>): NetcodeClient<E, I>;

package/dist/netcode/client.js

@@ -0,0 +1,296 @@
+/**
+ * `joinNetcode` — a player's side of netcode model 2: clock sync with the
+ * host, **snapshot interpolation** for everyone else, **local prediction
+ * with reconciliation** for yourself.
+ *
+ * ```ts
+ * const net = joinNetcode({
+ *   transport: node,
+ *   host: lobbyHostId,
+ *   label: 'my-game.movement',
+ *   local: { id: node.nodeIdHex()!, predict: (ship, input) => move(ship, input) },
+ * });
+ * onKey(input => net.input(input));        // applied locally at once, sent to the host
+ * renderLoop(() => draw(net.view()));      // remote ships interpolated, yours predicted
+ * ```
+ */
+import { ClockEstimator } from './clock.js';
+import { lerpNumbers, SnapshotBuffer } from './interpolate.js';
+import { MAX_NETCODE_INTEREST_KEYS, MAX_NETCODE_INTEREST_KEY_LENGTH, chunkOf, defaultNow, decodeFrame, encodeFrame, eventPeer, peerHex, } from './wire.js';
+/** Join a host's netcode. */
+export function joinNetcode(options) {
+    const now = options.now ?? defaultNow;
+    const host = peerHex(options.host);
+    if (host === null)
+        throw new TypeError(`host is not a node id: ${JSON.stringify(options.host)}`);
+    const label = options.label;
+    const delay = options.interpolationDelayMs ?? 100;
+    const blend = options.interpolate ?? lerpNumbers;
+    const redundancy = Math.max(1, options.inputRedundancy ?? 8);
+    const clock = new ClockEstimator();
+    const snapshots = new SnapshotBuffer();
+    let stream = null;
+    let closed = false;
+    let seq = 0;
+    let pending = [];
+    let predicted = null;
+    // A correction being blended in: the stale prediction (still advanced
+    // by every input, so it keeps pace with the controls) and when it began.
+    let correcting = null;
+    const smoothing = Math.max(0, options.correctionSmoothingMs ?? 100);
+    /** The local entity as drawn now, and ends a finished blend. */
+    const drawnLocal = () => {
+        if (predicted === null || correcting === null)
+            return predicted;
+        const alpha = smoothing === 0 ? 1 : (now() - correcting.at) / smoothing;
+        if (alpha >= 1) {
+            correcting = null;
+            return predicted;
+        }
+        return blend(correcting.from, predicted, Math.max(0, alpha));
+    };
+    let snapshotsSeen = 0;
+    // The interest set: what was asked, its version, and the newest version a
+    // snapshot has echoed (the `w` frame repeats until they meet).
+    let interest = null;
+    let interestVersion = 0;
+    let interestAcked = 0;
+    const checkInterest = (keys) => {
+        if (keys.length > MAX_NETCODE_INTEREST_KEYS) {
+            throw new RangeError(`at most ${MAX_NETCODE_INTEREST_KEYS} interest keys, got ${keys.length}`);
+        }
+        for (const key of keys) {
+            if (typeof key !== 'string' || key.length > MAX_NETCODE_INTEREST_KEY_LENGTH) {
+                throw new RangeError(`an interest key is a string of at most ${MAX_NETCODE_INTEREST_KEY_LENGTH} characters`);
+            }
+        }
+        return [...keys];
+    };
+    if (options.interest !== undefined) {
+        interest = checkInterest(options.interest);
+        interestVersion = 1;
+    }
+    const sendInterest = () => {
+        if (interest !== null && interestAcked < interestVersion) {
+            send({ n: label, k: 'w', v: interestVersion, w: interest });
+        }
+    };
+    // Chunked snapshots being assembled, by tick; the newest tick accepted;
+    // snapshots finished with chunks missing.
+    const assemblies = new Map();
+    let newestTick = null;
+    let partialSnapshots = 0;
+    let corrections = 0;
+    let joined = false;
+    const offset = () => clock.estimate()?.offsetMs ?? null;
+    const hostNow = () => {
+        const o = offset();
+        return o === null ? null : now() + o;
+    };
+    let opening = null;
+    const open = () => {
+        opening ??= (async () => {
+            await options.transport.connectPeer?.(host).catch(() => { });
+            const opened = await options.transport.openStream({ reliability: 'fireAndForget', peer: host, label, lossy: true });
+            if (closed) {
+                opened.close();
+                return;
+            }
+            stream = opened;
+        })()
+            .catch(() => { })
+            .finally(() => {
+            opening = null;
+        });
+        return opening;
+    };
+    // A failed send retires the stream: the session under it may have been
+    // replaced (a reconnect, a relayed → direct upgrade) and a stream handle
+    // is fenced to the session it was opened on. The protocol repeats what
+    // was lost, so reopening is all recovery needs.
+    const send = (frame) => {
+        const current = stream;
+        if (current === null) {
+            void open();
+            return;
+        }
+        const retire = () => {
+            if (stream === current) {
+                stream = null;
+                try {
+                    current.close();
+                }
+                catch {
+                    // Already unusable.
+                }
+            }
+        };
+        try {
+            void Promise.resolve(current.send(encodeFrame(frame))).catch(retire);
+        }
+        catch {
+            retire();
+        }
+    };
+    const stopEvents = options.transport.onEvent(event => {
+        if (closed || event.type !== 'stream_data')
+            return;
+        if (eventPeer(event.peerNode) !== host)
+            return;
+        const frame = decodeFrame(event.payload, label);
+        if (frame === null)
+            return;
+        if (frame.k === 'q') {
+            clock.add(frame.t0, frame.t1, frame.t2, now());
+            return;
+        }
+        if (frame.k !== 's')
+            return;
+        joined = true;
+        if (frame.iv !== undefined && frame.iv > interestAcked)
+            interestAcked = frame.iv;
+        if (frame.of === undefined || frame.c === undefined) {
+            accept(frame.tick, frame.t, frame.ack, frame.e, frame.e);
+            return;
+        }
+        // A chunk. Older assemblies still open when a newer tick shows up are
+        // finished as they are: their missing chunks were lost.
+        for (const [tick, open] of assemblies) {
+            if (tick < frame.tick)
+                finish(tick, open);
+        }
+        let assembly = assemblies.get(frame.tick);
+        if (assembly === undefined) {
+            if (newestTick !== null && frame.tick <= newestTick)
+                return; // already finished
+            assembly = { t: frame.t, ack: frame.ack, of: frame.of, parts: new Map() };
+            assemblies.set(frame.tick, assembly);
+        }
+        if (assembly.of !== frame.of)
+            return;
+        assembly.parts.set(frame.c, frame.e);
+        assembly.ack = Math.max(assembly.ack, frame.ack);
+        if (assembly.parts.size === assembly.of)
+            finish(frame.tick, assembly);
+    });
+    /**
+     * A chunked snapshot, done: every chunk, or the chunks that came, with
+     * each missing chunk's entities carried over from the previous snapshot
+     * ({@link chunkOf} is stable, so which entities a chunk carries is known
+     * whatever the previous snapshot's cut).
+     */
+    function finish(tick, assembly) {
+        assemblies.delete(tick);
+        const received = {};
+        for (const part of assembly.parts.values())
+            Object.assign(received, part);
+        let entities = received;
+        if (assembly.parts.size < assembly.of) {
+            partialSnapshots += 1;
+            const previous = snapshots.latest();
+            if (previous !== null && previous.tick < tick) {
+                entities = { ...received };
+                for (const [id, entity] of Object.entries(previous.entities)) {
+                    if (!assembly.parts.has(chunkOf(id, assembly.of)) && !(id in entities))
+                        entities[id] = entity;
+                }
+            }
+        }
+        // Reconciled against what the host actually sent this tick: a local
+        // entity carried over from a lost chunk is not the host's word.
+        accept(tick, assembly.t, assembly.ack, entities, received);
+    }
+    /** One snapshot, whole or assembled: buffered, and reconciled against. */
+    function accept(tick, time, ack, entities, sent) {
+        snapshotsSeen += 1;
+        const newest = snapshots.latest();
+        snapshots.add({ time, tick, entities });
+        if (newestTick === null || tick > newestTick)
+            newestTick = tick;
+        // Reconcile only on a snapshot newer than any seen: an older one
+        // (reordered by the carrier) must not roll the local entity back.
+        if (options.local && (newest === null || tick > newest.tick)) {
+            pending = pending.filter(input => input.seq > ack);
+            const authoritative = Object.prototype.hasOwnProperty.call(sent, options.local.id)
+                ? sent[options.local.id]
+                : undefined;
+            if (authoritative !== undefined) {
+                let replayed = authoritative;
+                for (const input of pending)
+                    replayed = options.local.predict(replayed, input.data);
+                if (predicted !== null && JSON.stringify(replayed) !== JSON.stringify(predicted)) {
+                    corrections += 1;
+                    // Blend from what is on screen now, so a correction that lands
+                    // mid-blend continues from there rather than jumping back.
+                    if (smoothing > 0)
+                        correcting = { from: drawnLocal() ?? predicted, at: now() };
+                }
+                predicted = replayed;
+            }
+        }
+    }
+    // Join, and keep the clock honest.
+    const pingEvery = 1000 / Math.max(0.5, options.pingRate ?? 4);
+    const timer = setInterval(() => {
+        if (!joined)
+            send({ n: label, k: 'h' });
+        send({ n: label, k: 'p', t0: now() });
+        sendInterest();
+        // Unacknowledged inputs are repeated even with nothing new to send, so
+        // a lost input frame is repaired without waiting for the next input.
+        if (pending.length > 0)
+            send({ n: label, k: 'i', i: pending.slice(-redundancy) });
+    }, pingEvery);
+    void open().then(() => {
+        send({ n: label, k: 'h' });
+        send({ n: label, k: 'p', t0: now() });
+        sendInterest();
+    });
+    return {
+        input(data) {
+            if (closed)
+                return;
+            seq += 1;
+            const seen = (hostNow() ?? now()) - delay;
+            pending.push({ seq, seen, data });
+            if (options.local && predicted !== null) {
+                predicted = options.local.predict(predicted, data);
+                if (correcting !== null)
+                    correcting = { ...correcting, from: options.local.predict(correcting.from, data) };
+            }
+            send({ n: label, k: 'i', i: pending.slice(-redundancy) });
+        },
+        view() {
+            const at = hostNow();
+            const latest = snapshots.latest();
+            const entities = at === null ? (latest?.entities ?? {}) : snapshots.at(at - delay, blend, options.extrapolateMs ?? 0);
+            const local = drawnLocal();
+            if (!options.local || local === null)
+                return entities;
+            return { ...entities, [options.local.id]: local };
+        },
+        setInterest(keys) {
+            interest = checkInterest(keys);
+            interestVersion += 1;
+            if (!closed)
+                sendInterest();
+        },
+        hostNow,
+        stats: () => ({
+            clock: clock.estimate(),
+            snapshots: snapshotsSeen,
+            lateSnapshots: snapshots.late,
+            pendingInputs: pending.length,
+            corrections,
+            partialSnapshots,
+        }),
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            clearInterval(timer);
+            stopEvents();
+            stream?.close();
+        },
+    };
+}

package/dist/netcode/clock.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Clock sync: one timeline for the host and its players.
+ *
+ * NTP-style. A player stamps a ping with its own clock (`t0`); the host
+ * stamps receipt (`t1`) and reply (`t2`) with its clock; the player stamps
+ * arrival (`t3`). Then
+ *
+ * ```text
+ * rtt    = (t3 - t0) - (t2 - t1)
+ * offset = ((t1 - t0) + (t2 - t3)) / 2      // host clock − player clock
+ * ```
+ *
+ * One sample is noisy — queueing on either path skews it — so the
+ * estimator keeps a window and takes the offset from the **lowest-RTT**
+ * samples, which are the ones least distorted by queueing. Jitter is the
+ * mean absolute deviation of RTT across the window. Pure arithmetic; the
+ * transport and timers live in the netcode client.
+ */
+/** A clock reading in milliseconds (e.g. `performance.now()`). */
+export type Millis = number;
+/** What the estimator currently believes. */
+export interface ClockEstimate {
+    /** Host clock minus this clock, in ms. `hostNow = now + offset`. */
+    readonly offsetMs: number;
+    /** Smoothed round-trip time (median of the window), in ms. */
+    readonly rttMs: number;
+    /** Mean absolute deviation of round-trip time, in ms. */
+    readonly jitterMs: number;
+    /** Samples the estimate rests on. */
+    readonly samples: number;
+}
+/** Samples kept. */
+export declare const CLOCK_WINDOW = 16;
+/** Accumulates ping/pong samples into a clock estimate. */
+export declare class ClockEstimator {
+    #private;
+    /**
+     * Add one exchange. Samples with a negative or non-finite RTT (clock
+     * weirdness, a reply to a ping from before a reload) are ignored.
+     * Returns whether the sample was used.
+     */
+    add(t0: Millis, t1: Millis, t2: Millis, t3: Millis): boolean;
+    /** The current estimate, or `null` before the first sample. */
+    estimate(): ClockEstimate | null;
+}

package/dist/netcode/clock.js

@@ -0,0 +1,54 @@
+/**
+ * Clock sync: one timeline for the host and its players.
+ *
+ * NTP-style. A player stamps a ping with its own clock (`t0`); the host
+ * stamps receipt (`t1`) and reply (`t2`) with its clock; the player stamps
+ * arrival (`t3`). Then
+ *
+ * ```text
+ * rtt    = (t3 - t0) - (t2 - t1)
+ * offset = ((t1 - t0) + (t2 - t3)) / 2      // host clock − player clock
+ * ```
+ *
+ * One sample is noisy — queueing on either path skews it — so the
+ * estimator keeps a window and takes the offset from the **lowest-RTT**
+ * samples, which are the ones least distorted by queueing. Jitter is the
+ * mean absolute deviation of RTT across the window. Pure arithmetic; the
+ * transport and timers live in the netcode client.
+ */
+/** Samples kept. */
+export const CLOCK_WINDOW = 16;
+/** Of the window, how many lowest-RTT samples the offset averages. */
+const BEST = 4;
+/** Accumulates ping/pong samples into a clock estimate. */
+export class ClockEstimator {
+    #window = [];
+    /**
+     * Add one exchange. Samples with a negative or non-finite RTT (clock
+     * weirdness, a reply to a ping from before a reload) are ignored.
+     * Returns whether the sample was used.
+     */
+    add(t0, t1, t2, t3) {
+        const rtt = t3 - t0 - (t2 - t1);
+        const offset = (t1 - t0 + (t2 - t3)) / 2;
+        if (!Number.isFinite(rtt) || !Number.isFinite(offset) || rtt < 0)
+            return false;
+        this.#window.push({ rtt, offset });
+        if (this.#window.length > CLOCK_WINDOW)
+            this.#window.shift();
+        return true;
+    }
+    /** The current estimate, or `null` before the first sample. */
+    estimate() {
+        const window = this.#window;
+        if (window.length === 0)
+            return null;
+        const byRtt = [...window].sort((a, b) => a.rtt - b.rtt);
+        const best = byRtt.slice(0, Math.min(BEST, byRtt.length));
+        const offsetMs = best.reduce((sum, s) => sum + s.offset, 0) / best.length;
+        const rttMs = byRtt[Math.floor((byRtt.length - 1) / 2)].rtt;
+        const mean = window.reduce((sum, s) => sum + s.rtt, 0) / window.length;
+        const jitterMs = window.reduce((sum, s) => sum + Math.abs(s.rtt - mean), 0) / window.length;
+        return { offsetMs, rttMs, jitterMs, samples: window.length };
+    }
+}