@woosh/meep-engine 3.62.0 → 3.63.0

package/src/engine/network/NetworkSession.d.ts

@@ -1,662 +0,0 @@
-/**
- * Roles a session can occupy. The orchestrator it wires up underneath is
- * uniquely determined by the role.
- *
- *   - `'client'`  → {@link ServerAuthoritativeClient }: predicts locally
- *                   when an input sampler is registered; reconciles to
- *                   server-authoritative state arriving via AUTH_STATE.
- *                   With no input sampler, a client is a pure spectator
- *                   — it receives the action stream, smooths via
- *                   interpolation, and never predicts or rewinds. This
- *                   is the default role and covers both "playing" and
- *                   "spectating" use cases.
- *   - `'host'`    → {@link ServerAuthoritativeServer }: simulation
- *                   authority for one or more clients; runs the optional
- *                   server-side input buffer (`simulation_delay_ticks`).
- */
-export type NetworkSessionRole = string;
-/**
- * Roles a session can occupy. The orchestrator it wires up underneath is
- * uniquely determined by the role.
- *
- *   - `'client'`  → {@link ServerAuthoritativeClient}: predicts locally
- *                   when an input sampler is registered; reconciles to
- *                   server-authoritative state arriving via AUTH_STATE.
- *                   With no input sampler, a client is a pure spectator
- *                   — it receives the action stream, smooths via
- *                   interpolation, and never predicts or rewinds. This
- *                   is the default role and covers both "playing" and
- *                   "spectating" use cases.
- *   - `'host'`    → {@link ServerAuthoritativeServer}: simulation
- *                   authority for one or more clients; runs the optional
- *                   server-side input buffer (`simulation_delay_ticks`).
- *
- * @readonly @enum {string}
- */
-export const NetworkSessionRole: Readonly<{
-    Client: "client";
-    Host: "host";
-}>;
-/**
- * How a client brings the entities it predicts back in line with the host's authoritative state.
- */
-export type NetworkSessionReconcile = string;
-/**
- * How a client brings the entities it predicts back in line with the host's authoritative state.
- *
- * @readonly @enum {string}
- */
-export const NetworkSessionReconcile: Readonly<{
-    /**
-     * Compare the host's state for frame S with what this client predicted for S. Equal: nothing
-     * to do. Different: carry the difference observed at S into the present, component by
-     * component, as each component's {@link Correction} says — a pose by its offset and turn, a
-     * velocity by its difference, a value with no notion of difference by the host's value. No
-     * rewind, no replay, so it holds for state produced by physics and any other fixed-step system,
-     * not only by actions.
-     */
-    Correct: "correct";
-    /**
-     * Rewind the action log to S, apply the host's state, and re-execute this client's input for
-     * every frame since. Exact when everything predicted is produced by deterministic actions; a
-     * replay re-executes actions only, never the engine's systems.
-     */
-    Replay: "replay";
-}>;
-/**
- * High-level networking facade. Wraps the orchestrator + state machinery
- * into one config + lifecycle surface. The lower-level orchestrators
- * remain reachable through `session.server` / `session.client` /
- * `session.peer` for callers that need to override defaults post-hoc.
- *
- * Replication is component-driven: attaching a {@link NetworkIdentity}
- * to an entity registers it with the session via an `EntityObserver`.
- *
- * **What travels is what goes through the action executor**, and nothing
- * else: actions (`send`, a client's input), and direct writes their writer
- * reports — `dataset.sendEvent(entity, "net_mutate_component", payload)`.
- * The session never looks for changes by itself. That is what keeps a tick's
- * cost in what changed and what is owned, never in the size of the world;
- * the stack is built for worlds of millions of networked objects. A
- * replicated component written directly and not reported stays where it was
- * written. Ownership is set when an identity attaches, or by the join, and
- * `owner_peer_id` / `network_id` are not written afterwards. The README's
- * "What the session assumes" has the whole contract and its measured costs.
- *
- * **The session runs on the engine's clock.** The `EntityManager`'s fixed
- * step is the network tick: each step opens a network frame before any
- * system's `fixedUpdate` and closes it after the last, so everything the
- * step simulates — physics, controllers, game code — happens inside the
- * frame. There is nothing to call per frame; `entity_manager.update(dt)`
- * (the engine loop) drives it. Client time dilation is applied as the
- * `EntityManager`'s `fixedStepTimeScale`.
- *
- * What arrives from the network is applied as a step opens, never when the
- * transport happens to deliver it: a browser delivers packets whenever its
- * event loop gets to them, which is usually between a frame's render blend and
- * its draw. And the session's timers — the render playout, idle reaping, the
- * grace window — run on the frame time the engine passes to `update`, so they
- * pause with the engine and follow any engine that is driven by hand.
- *
- * **Networked entities are smooth by default.** The session attaches an
- * {@link Interpolated} to each one and keeps it in line with ownership: on
- * the host, and for entities the client owns (and predicts), the local
- * fixed-step timeline; for everything else on a client, the network's
- * render-delayed playout. Both are blended by the engine's
- * {@link InterpolationSystem}, which the session adds if the engine has
- * none.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class NetworkSession {
-    /**
-     * @param {{
-     *   entity_manager: EntityManager,
-     *   transport?: object,
-     *   transport_factory?: (() => object),
-     *   role?: 'client'|'host',
-     *   local_peer_id?: number,
-     *   simulation_delay_ticks?: number,
-     *   tick_rate_hz?: number,
-     *   binary_registry?: BinarySerializationRegistry,
-     *   scope_filter?: object,
-     *   time_dilation?: TimeDilation,
-     *   adaptive_render_delay?: AdaptiveRenderDelay,
-     *   server_resume_grace_ms?: number,
-     *   connection_timeout_ms?: number,
-     *   reconnect?: {
-     *     enabled?: boolean,
-     *     max_attempts?: number,
-     *     base_delay_ms?: number,
-     *     max_delay_ms?: number,
-     *     exponential_factor?: number,
-     *     total_timeout_ms?: number,
-     *     accept_state_resync?: boolean,
-     *   },
-     * }} options
-     *
-     * - `transport` is not connected at construction — call {@link connect}
-     *   with an explicit remote peer id after {@link start}.
-     * - `transport_factory` (client role): zero-arg function that returns
-     *   a fresh `Transport` on each reconnect attempt. Required for
-     *   automatic reconnect; without it, transport-level disconnects fall
-     *   straight through to `onConnectionPermanentlyLost`.
-     * - `role` defaults to `'client'`. See {@link NetworkSessionRole}.
-     * - `local_peer_id` defaults to 0 for host, 1 for client. Must be
-     *   unique across peers.
-     * - `simulation_delay_ticks` is honored only under `role: 'host'`.
-     *   Default 4. See {@link ServerAuthoritativeServer}.
-     * - `tick_rate_hz`: the network tick rate, which is the engine's fixed-step
-     *   rate — given, it sets `entity_manager.fixedUpdateStepSize`; omitted, the
-     *   session uses the step the engine already has. Every
-     *   peer must run the same rate.
-     * - `frame_capacity` sizes the action-log ring (rollback depth + back-fill
-     *   range + retransmit window — see {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}).
-     *   Default 32. Raise it for high-RTT / lossy links.
-     * - `time_dilation` (client role): defaults to one built for round trips up to
-     *   `frame_capacity` frames. One of your own should be too: its
-     *   `max_round_trip_frames` is what keeps it from overshooting.
-     * - `scope_filter` defaults to {@link OwnerAwareScope} on the host.
-     * - `server_resume_grace_ms` (host role): how long peer state is
-     *   retained after a transport drop before being freed. Default 30s.
-     * - `connection_timeout_ms`: inbound-silence budget before a peer is
-     *   reaped (host → grace, client → reconnect ladder). Default 10s; set 0
-     *   to disable. Mainly for connectionless transports, which never emit a
-     *   disconnect event — see {@link DEFAULT_CONNECTION_TIMEOUT_MS}.
-     * - `reconnect` (client role): policy for the reconnect ladder. See
-     *   {@link DEFAULT_RECONNECT_POLICY}. Set `enabled: false` to opt
-     *   out entirely.
-     * - `reconcile` (client role): see {@link NetworkSessionReconcile}. Default
-     *   `'correct'`.
-     * - `late_input` (host role): what to do with client input that arrives
-     *   for a frame already simulated — see {@link LateInput}. Default
-     *   `'apply'`: fold it into the current frame. `'rollback'` rewinds and
-     *   replays, which re-executes actions only, never the engine's systems.
-     */
-    constructor({ entity_manager, transport, transport_factory, role, local_peer_id, simulation_delay_ticks, tick_rate_hz, frame_capacity, binary_registry, scope_filter, time_dilation, adaptive_render_delay, server_resume_grace_ms, connection_timeout_ms, reconnect, late_input, reconcile, }?: {
-        entity_manager: EntityManager;
-        transport?: object;
-        transport_factory?: (() => object);
-        role?: 'client' | 'host';
-        local_peer_id?: number;
-        simulation_delay_ticks?: number;
-        tick_rate_hz?: number;
-        binary_registry?: BinarySerializationRegistry;
-        scope_filter?: object;
-        time_dilation?: TimeDilation;
-        adaptive_render_delay?: AdaptiveRenderDelay;
-        server_resume_grace_ms?: number;
-        connection_timeout_ms?: number;
-        reconnect?: {
-            enabled?: boolean;
-            max_attempts?: number;
-            base_delay_ms?: number;
-            max_delay_ms?: number;
-            exponential_factor?: number;
-            total_timeout_ms?: number;
-            accept_state_resync?: boolean;
-        };
-    });
-    /**
-     * @deprecated Always false. Render blends are owned by the {@link InterpolationSystem}, which
-     * restores them itself; {@link normalize_if_dirty} restores unconditionally.
-     * @type {boolean}
-     */
-    render_dirty: boolean;
-    /**
-     * Client: authoritative states that differed from the prediction and were corrected.
-     * @type {number}
-     */
-    correction_count: number;
-    /**
-     * Client: authoritative states that could not be compared because the prediction for their
-     * frame is not held (before the first predicted frame, or older than the history).
-     * @type {number}
-     */
-    correction_skipped_count: number;
-    /**
-     * Client: how many times it found itself more than the host's input window behind the frame the
-     * host last named, or was told by the host's depth feedback that its input lands below the
-     * host's window, and re-took the host's time. A tab in the background, a debugger, a laptop
-     * asleep — see {@link #retake_host_time_if_stalled}. Diagnostic: a game that sees these on a
-     * machine that never left the foreground has a client that cannot keep the step.
-     * @type {number}
-     */
-    stall_count: number;
-    /**
-     * Client, {@link NetworkSessionReconcile.Correct}: a component of an authoritative state
-     * differed from the prediction, and the present was corrected. Once per component corrected.
-     * Args: `(entity_id, server_frame, component_class, magnitude)` — the size of the correction as
-     * the component's {@link Correction} measures it (a pose: how far the position moved, in world
-     * units). Diagnostic: a steady stream of these on a quiet link means the client simulates
-     * something differently from the host.
-     * @type {Signal}
-     */
-    onCorrection: Signal;
-    /**
-     * Server-issued session token (raw UUID v1 bytes). Set on first
-     * INITIAL_SYNC arrival; refreshed on every Tier-3 resync. Sent in
-     * `RESUME_HELLO` to claim continuity with a prior session record.
-     * Observable to game code for diagnostics; not auth-grade.
-     * @type {UUID|null}
-     */
-    session_token: UUID | null;
-    /**
-     * Host: a connected peer's transport reported a disconnect (the peer
-     * has entered the grace window). Args: `(peer_id, reason)`.
-     * @type {Signal}
-     */
-    onPeerLost: Signal;
-    /**
-     * Host: a peer has been permanently freed — either via
-     * `drop_peer()`, a grace-window timeout, or a peer-initiated
-     * DISCONNECT. Args: `(peer_id, reason)`.
-     * @type {Signal}
-     */
-    onPeerPermanentlyDropped: Signal;
-    /**
-     * Client: the transport has reported a disconnect, and the
-     * reconnect ladder has started. Args: `(reason)`.
-     * @type {Signal}
-     */
-    onConnectionLost: Signal;
-    /**
-     * Client: about to rebuild the transport and dial the host. Args:
-     * `(attempt_number)`.
-     * @type {Signal}
-     */
-    onReconnectAttempt: Signal;
-    /**
-     * Client: reconnect succeeded. Args: `({ state_resynced: boolean })` —
-     * `state_resynced` is `true` if we fell through to Tier-3 (server
-     * had purged our state and re-sent INITIAL_SYNC), `false` for the
-     * happy Tier-2 path where the action stream just resumed.
-     * @type {Signal}
-     */
-    onReconnected: Signal;
-    /**
-     * Client: a join has completed — the host's FINAL page has landed, every networked entity's
-     * state is here, and from now on this client's input is sent. No arguments. A world is sent
-     * as pages over as many ticks as its size takes; until this fires it is still arriving.
-     * @type {Signal}
-     */
-    onSynced: Signal;
-    /**
-     * Client: the reconnect ladder is exhausted, or the host explicitly
-     * kicked us with a DISCONNECT packet, or `reconnect.enabled` is
-     * false and the link dropped. Args: `(reason)`.
-     * @type {Signal}
-     */
-    onConnectionPermanentlyLost: Signal;
-    /**
-     * @readonly
-     * @type {EntityManager}
-     */
-    readonly entity_manager: EntityManager;
-    /**
-     * @readonly
-     * @type {EntityComponentDataset}
-     */
-    readonly world: EntityComponentDataset;
-    /**
-     * @readonly
-     * @type {NetworkSessionRole|string}
-     */
-    readonly role: NetworkSessionRole | string;
-    /**
-     * The network tick period, which is the `EntityManager`'s fixed step.
-     * @readonly
-     * @type {number}
-     */
-    readonly tick_period_ms: number;
-    /**
-     * @readonly
-     * @type {number}
-     */
-    readonly simulation_delay_ticks: number;
-    /**
-     * Depth of the action-log ring passed to the orchestrator. Bounds
-     * rollback depth, back-fill range, and retransmit window — see
-     * {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}.
-     * @readonly
-     * @type {number}
-     */
-    readonly frame_capacity: number;
-    /**
-     * @readonly
-     * @type {number}
-     */
-    readonly local_peer_id: number;
-    /**
-     * @readonly
-     * @type {BinarySerializationRegistry}
-     */
-    readonly binary_registry: BinarySerializationRegistry;
-    /**
-     * Replicate `ComponentClass`, and draw it between network ticks by blending. A network tick is
-     * coarser than a rendered frame, and a component shown only as each state lands moves in steps;
-     * `interpoland` says how it is drawn instead — the layout each tick's state is recorded in, and
-     * the blend of two records for a rendered frame.
-     *
-     * - `interpoland.component_class` is `ComponentClass`, and its blend is of kind
-     *   {@link InterpolationKind.Linear}.
-     * - `interpoland.type_id` names its records. No two components one session replicates may share
-     *   one; {@link start} checks.
-     * - `ComponentClass` has `copy(other)`: while a blend is drawn over the component, its simulated
-     *   value is held with it, and put back exactly before the next step.
-     *
-     * `correction` is how a client that predicts the component corrects it when the host disagrees
-     * — see {@link Correction}.
-     *
-     * See {@link replicate_discrete} for a component with no in-between.
-     *
-     * Like every replicated component, `ComponentClass` needs a
-     * {@link BinaryClassSerializationAdapter} registered for its `typeName` in `binary_registry`
-     * before {@link start} — its wire format. Components are laid out on the wire in the order they
-     * are replicated, so every peer must replicate the same components in the same order.
-     *
-     * @param {Function} ComponentClass
-     * @param {Interpoland} interpoland
-     * @param {Correction} correction
-     */
-    replicate_interpolated(ComponentClass: Function, interpoland: Interpoland, correction: Correction): void;
-    /**
-     * Replicate `ComponentClass`, and draw it as each state lands, with no blend between network
-     * ticks. For a value that has no in-between — a count, a name, a state machine's state.
-     *
-     * `correction` is how a client that predicts the component corrects it when the host disagrees
-     * — see {@link Correction}.
-     *
-     * Like every replicated component, `ComponentClass` needs a
-     * {@link BinaryClassSerializationAdapter} registered for its `typeName` in `binary_registry`
-     * before {@link start} — its wire format. Components are laid out on the wire in the order they
-     * are replicated, so every peer must replicate the same components in the same order.
-     *
-     * @param {Function} ComponentClass
-     * @param {Correction} correction
-     */
-    replicate_discrete(ComponentClass: Function, correction: Correction): void;
-    /**
-     * **Deprecated.** Use {@link replicate_interpolated} or {@link replicate_discrete}, which say how
-     * the component is drawn. Warns once.
-     *
-     * Keeps its meaning: `replicate(C)` replicates `C` discretely; `replicate(C, interpolator)` blends
-     * it with `interpolator`, recorded in its replication layout. A component blended this way needs
-     * `copy(other)`, as with {@link replicate_interpolated}. A client corrects what it registers by
-     * taking the host's value ({@link HOST_VALUE_CORRECTION}).
-     *
-     * @deprecated
-     * @param {Function} ComponentClass
-     * @param {BinaryInterpolationAdapter|null} [interpolator]
-     */
-    replicate(ComponentClass: Function, interpolator?: BinaryInterpolationAdapter | null): void;
-    /**
-     * Register a user-defined {@link SimAction} subclass with the
-     * session. The action's `type_id` is assigned by the underlying
-     * registry when {@link start} runs. Calling code constructs
-     * instances directly (`new MyAction(...)`) and dispatches via
-     * {@link send} or returns them from the input sampler.
-     *
-     * @param {Function} SimActionClass class extending SimAction
-     */
-    defineAction(SimActionClass: Function): void;
-    /**
-     * Install a per-tick input sampler (client role only). The sampler
-     * is called once per local sim tick at predict time and must return
-     * an array of {@link SimAction} instances representing the local
-     * peer's inputs for that frame. The session executes them locally
-     * (predict), records their serialized bytes for replay, and forwards
-     * them over the action stream.
-     *
-     * The sampler is NOT called during reconciliation replay — the
-     * recorded bytes are deserialized and re-executed instead, so the
-     * action set faithfully reproduces what the user originally
-     * sampled at that frame.
-     *
-     * Return `[]` (or `null`) for ticks with no inputs.
-     *
-     * @param {(frame: number) => Array<SimAction>|null} sampler_fn
-     */
-    defineInputSampler(sampler_fn: (frame: number) => Array<SimAction> | null): void;
-    /**
-     * Wire the session to the engine. After this, the EntityObserver
-     * is active, the right orchestrator is constructed, and a
-     * {@link NetworkSystem} is attached until {@link stop}. Subsequent `replicate_*`
-     * / {@link defineAction} / {@link defineInputSampler} calls throw.
-     *
-     * Pre-condition: every replicated component class must already have a
-     * `BinaryClassSerializationAdapter` registered in the session's
-     * binary_registry.
-     */
-    start(): Promise<void>;
-    /**
-     * Connect to a remote peer. Host can connect many peers (one per
-     * client); client typically connects one (the server). Called both
-     * for first-time connects and reconnect attempts — the session
-     * detects which based on whether a `session_token` is cached
-     * (client) or whether the peer is in the grace window (host).
-     *
-     * The two roles differ on what happens when `remote_peer_id` already
-     * has a transport bound. Client-side the newest one wins and the
-     * previous binding is released, because that is what lets a back-off
-     * retry supersede an attempt still hanging on a socket that never
-     * finished connecting. Host-side the call throws: which transport owns
-     * a peer id is the matchmaking layer's decision, not a race between
-     * whatever connections happen to arrive.
-     *
-     * A client sends its input on the new connection only once the host has
-     * answered it. A RESUME_ACCEPT sends everything predicted meanwhile; an
-     * INITIAL_SYNC drops everything predicted before it, on the world it
-     * replaces. See the network README, "Connecting, and coming back".
-     *
-     * @param {number} remote_peer_id
-     * @param {object} transport
-     */
-    connect(remote_peer_id: number, transport: object): void;
-    /**
-     * Host-only: forcibly free a peer's state, regardless of whether
-     * they are actively connected, in the grace window, or already
-     * unknown. Fires `onPeerPermanentlyDropped(peer_id, reason)`.
-     * Sends a DISCONNECT packet if the peer is still actively
-     * connected so the remote can short-circuit its reconnect attempts.
-     *
-     * Policy for *when* to drop (high server load, anti-cheat, admin
-     * kick, etc.) is the caller's; the session provides the mechanism.
-     *
-     * This is also the release valve for a peer the session itself will not
-     * readmit. A client that lost its session token is refused by
-     * {@link ResumeRejectReason.NoSessionToken} because it cannot prove any
-     * right to the record being held for it — but a deployment whose
-     * matchmaking layer has already authenticated the player knows better
-     * than the session does. Dropping the peer discards the record, and the
-     * client's next `connect()` is taken for a fresh one.
-     *
-     * @param {number} peer_id
-     * @param {string} [reason]
-     */
-    drop_peer(peer_id: number, reason?: string): void;
-    /**
-     * Client-only: voluntarily disconnect from the server. Sends a
-     * DISCONNECT packet so the host can free state immediately and
-     * skip the grace window. Disables reconnect for this session.
-     *
-     * @param {string} [reason]
-     */
-    disconnect(reason?: string): void;
-    /**
-     * Tear down. Idempotent — safe to call from cleanup paths.
-     *
-     * Takes back from the engine what {@link start} put in it: the {@link NetworkSystem} is out of
-     * the engine's loop when this returns, so another session can start on the same engine; this one
-     * does not start again. The
-     * networked entities stay in the world, and their `network_id`s are released — an id means
-     * nothing without the session that gave it. The {@link InterpolationSystem} stays too, whoever
-     * added it: it is the engine's, and blends whatever else is interpolated; the session only
-     * withdraws its own source from it.
-     *
-     * @returns {Promise} resolves once the engine has shut the {@link NetworkSystem} down
-     */
-    stop(): Promise<any>;
-    /**
-     * **Deprecated; does nothing.** The session used to run its own fixed-step clock here, next to
-     * the engine's: two clocks, so network frame N and the engine's step N were unrelated, and
-     * nothing interpolated against one could be blended on the other. The session now runs on the
-     * `EntityManager`'s fixed step — `entity_manager.update(dt)`, which the engine loop already
-     * calls, drives it — and calling this as well would advance it twice.
-     *
-     * Warns once. Remove the call.
-     *
-     * @deprecated
-     * @param {number} [dt_seconds]
-     */
-    tick(dt_seconds?: number): void;
-    /**
-     * Put the truth back wherever a render blend is in the live components — the
-     * {@link InterpolationSystem}'s restore. Anything written over a blend since goes with it; what
-     * is written after this call stays. Idempotent and cheap when nothing is blended.
-     *
-     * Runs before every action the executor applies (an action captures the prior value of what it
-     * overwrites, and that must not be a blend), before a reconciliation, and at the start of every
-     * fixed step. Game code that writes a networked entity's state between steps calls it first.
-     * The name is kept from when the session owned its own blend.
-     */
-    normalize_if_dirty(): void;
-    /**
-     * Dispatch one user-defined action, without needing a reference to the
-     * executor or knowledge of the local peer id.
-     *
-     * Called with a frame open — from an `onLocalSim` handler on a host, or an
-     * `onPredict` handler on a client — the action executes immediately, into
-     * that frame. Its provenance follows its context: on a host, actions a
-     * local-sim handler executes are the frame's DERIVED output, recomputed on
-     * every replay of the frame rather than replayed from the log. That is what
-     * a handler that sends every tick wants, and it is why such a handler does
-     * not accumulate copies under rollback.
-     *
-     * Called with NO frame open — between ticks, from a lobby event, a timer, a
-     * console command — a host queues the action via
-     * {@link ServerAuthoritativeServer#enqueue_action}: it applies once, on the
-     * next frame the server simulates, and is recorded as INPUT, so replays
-     * take it from the log. This is the path for a one-shot. Do NOT reach for a
-     * latched local-sim handler (`if (already_sent) return`) instead: the
-     * handler's output is derived, so the replay expects it to be re-emitted,
-     * and a latch that stops it re-emitting loses the action the first time a
-     * rollback crosses its frame.
-     *
-     * (A client outside a prediction frame has nowhere to put the action and
-     * still throws — client actions are re-derived from the InputRing during
-     * reconciliation, so they belong in an `onPredict` handler.)
-     *
-     * @param {SimAction} action_instance
-     */
-    send(action_instance: SimAction): void;
-    /**
-     * @returns {ServerAuthoritativeServer|null}
-     */
-    get server(): ServerAuthoritativeServer;
-    /**
-     * @returns {ServerAuthoritativeClient|null}
-     */
-    get client(): ServerAuthoritativeClient;
-    /**
-     * @returns {NetworkPeer|null}
-     */
-    get peer(): NetworkPeer;
-    /**
-     * @returns {InterpolationLog|null}
-     */
-    get interpolation_log(): InterpolationLog;
-    /**
-     * @returns {AdaptiveRenderDelay}
-     */
-    get adaptive_render_delay(): AdaptiveRenderDelay;
-    /**
-     * @returns {TimeDilation}
-     */
-    get time_dilation(): TimeDilation;
-    /**
-     * How many entities this session treats as somebody else's — the set that is blended at render
-     * time and normalized before simulation.
-     *
-     * Exposed because its being empty is the observable symptom of a client that thinks it owns the
-     * host's world, and there was no way to see it from outside. Zero here on a connected client
-     * that has received a snapshot means nothing will be interpolated and the client is about to
-     * send the host its own state back.
-     *
-     * @returns {number}
-     */
-    get remote_entity_count(): number;
-    /**
-     * Per-peer delivery accounting, for a game that wants to know whether the wire is actually
-     * delivering what it was handed.
-     *
-     * `skipped_unapplied` should be zero. It counts frames that reached this peer and were dropped
-     * below the applied watermark without ever running — which happens when slices reorder on a
-     * sender pinned to the ring floor, and which the sender cannot see, because the channel-level
-     * ack for the packet returns either way and credits those frames as delivered.
-     *
-     * Until this existed the shortfall was invisible from both ends: it was found by a consumer
-     * counting events dispatched on the host against events applied on the client, and a missing
-     * explosion looks like a rendering bug. Set `max_packets_per_tick: 1` and this climbs under
-     * jitter; on the default it should stay at zero.
-     *
-     * `skipped_duplicate` is the healthy counterpart and is expected to be large — it is the action
-     * stream's own redundancy arriving and being correctly ignored.
-     *
-     * @param {number} peer_id
-     * @returns {{skipped_unapplied: number, skipped_duplicate: number}}
-     */
-    delivery_stats(peer_id: number): {
-        skipped_unapplied: number;
-        skipped_duplicate: number;
-    };
-    /**
-     * Most recent locally-completed sim frame.
-     */
-    get current_frame(): number;
-    /**
-     * Move this session's frame counter to `frame`.
-     *
-     * **Joining a match in progress needs this and there was no way to do it.** The host is at
-     * frame 6,000; a client has to start tagging its inputs near 6,000 or the host discards every
-     * one of them — `ServerAuthoritativeServer.tick` trims pending actions older than
-     * `sim_frame - frame_capacity + 1`, and a client tagging frame 0 against a host at 6,000 has
-     * every input dropped. It moves on its own screen and never moves on the host's — and until
-     * 2026-10-15 no signal fired; the host's `onPendingActionDropped` now reports each such drop
-     * as `'window'`.
-     *
-     * Everything needed was already there except the setter. INITIAL_SYNC carries the host's frame,
-     * `NetworkPeer` writes it, and `onInitialSync` dispatches it — and the handler named it
-     * `_frame_number` and dropped it on the floor. `#local_frame` being `#`-private meant an
-     * application could not set it either, so the only lever left was ticking the session forward
-     * with the input sampler silenced until its counter caught up: 28,801 calls and 62 ms of wall
-     * clock for an hour-old host. Reported as GAP-042.
-     *
-     * A client now seeks automatically on INITIAL_SYNC, and again whenever it finds itself more than
-     * the host's input window behind the frame the host last named — a stall, see
-     * {@link #retake_host_time_if_stalled}. This is the manual door, for a caller that computes its
-     * own lead.
-     *
-     * A client sends the host nothing it predicted before its last sync, and knows it by frame: its
-     * input starts at the frame the sync sought to. A caller whose own lead is shorter moves that
-     * start back with it, so what it predicts on the synced world is sent however it counts it.
-     *
-     * @param {number} frame
-     */
-    seek_to_frame(frame: number): void;
-    #private;
-}
-import Signal from "../../core/events/signal/Signal.js";
-import { UUID } from "../ecs/guid/UUID.js";
-import { BinarySerializationRegistry } from "../ecs/storage/binary/BinarySerializationRegistry.js";
-import { Interpoland } from "../interpolation/Interpoland.js";
-import { BinaryInterpolationAdapter } from "../interpolation/BinaryInterpolationAdapter.js";
-import { SimAction } from "./sim/SimAction.js";
-import { ServerAuthoritativeServer } from "./orchestrator/ServerAuthoritativeServer.js";
-import { ServerAuthoritativeClient } from "./orchestrator/ServerAuthoritativeClient.js";
-import { NetworkPeer } from "./orchestrator/NetworkPeer.js";
-import { InterpolationLog } from "../interpolation/InterpolationLog.js";
-import { AdaptiveRenderDelay } from "./time/AdaptiveRenderDelay.js";
-import { TimeDilation } from "./time/TimeDilation.js";
-//# sourceMappingURL=NetworkSession.d.ts.map

package/src/engine/network/NetworkSession.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NetworkSession.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/NetworkSession.js"],"names":[],"mappings":"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"}