@woosh/meep-engine 3.30.0 → 3.31.0

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

@@ -37,6 +37,32 @@ 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
@@ -48,10 +74,28 @@ export const NetworkSessionRole: Readonly<{
  * Mutation is event-driven: callers fire
  * `dataset.sendEvent(entity, "net_mutate_component", payload)`.
  *
- * Per-tick driving is a single `session.tick(dt_seconds)`. The session
- * runs fixed-timestep stepping, client time dilation, server-side input
- * buffer, AUTH_STATE dispatch, time-dilation feedback, and interpolated
- * rendering for remote-owned entities.
+ * **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
@@ -94,7 +138,10 @@ export class NetworkSession {
      *   unique across peers.
      * - `simulation_delay_ticks` is honored only under `role: 'host'`.
      *   Default 4. See {@link ServerAuthoritativeServer}.
-     * - `tick_rate_hz` defaults to 60.
+     * - `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 (60 Hz by default). 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.
@@ -108,8 +155,20 @@ export class NetworkSession {
      * - `reconnect` (client role): policy for the reconnect ladder. See
      *   {@link DEFAULT_RECONNECT_POLICY}. Set `enabled: false` to opt
      *   out entirely.
-     */
-    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, }?: {
+     * - `publish_changes` (host role, default true): at the end of every
+     *   step, send each replicated component the simulation changed — physics,
+     *   controllers, anything that wrote it directly. Components an action
+     *   wrote are already on the wire and are not sent twice. Publishing never
+     *   writes back into the host's own state. Set false to publish by hand
+     *   (`net_mutate_component`).
+     * - `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, publish_changes, late_input, reconcile, }?: {
         entity_manager: EntityManager;
         transport?: object;
         transport_factory?: (() => object);
@@ -134,13 +193,32 @@ export class NetworkSession {
         };
     });
     /**
-     * Set after `#render_interpolated_entities` writes interp values into
-     * live components; cleared by `normalize_if_dirty`. Drives the
-     * canonical-form invariant: live is canonical when this is false,
-     * polluted (smooth) when true.
-     * @private @type {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}
      */
-    private render_dirty;
+    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, {@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
@@ -205,6 +283,7 @@ export class NetworkSession {
      */
     readonly role: NetworkSessionRole | string;
     /**
+     * The network tick period, which is the `EntityManager`'s fixed step.
      * @readonly
      * @type {number}
      */
@@ -233,27 +312,63 @@ export class NetworkSession {
      */
     readonly binary_registry: BinarySerializationRegistry;
     /**
-     * Register a component class for network replication.
+     * 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.
      *
-     * The component must have a {@link BinaryClassSerializationAdapter}
-     * registered for its `typeName` in the session's `binary_registry`
-     * before {@link start} is called — that adapter handles the wire
-     * format and rewind capture.
+     * `correction` is how a client that predicts the component corrects it when the host disagrees
+     * — see {@link Correction}.
      *
-     * `interpolator` is optional. When omitted, the component's state
-     * snaps on each received update (no sub-tick smoothing). When
-     * provided, it must extend {@link BinaryInterpolationAdapter} with
-     * `kind = InterpolationKind.Linear` — Discrete and Cubic are
-     * reserved for future support and currently throw.
+     * 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.
      *
-     * The order of `replicate()` calls must match across all peers in
-     * the session: AUTH_STATE payload layout iterates components in
-     * insertion 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} [interpolator]
+     * @param {BinaryInterpolationAdapter|null} [interpolator]
      */
-    replicate(ComponentClass: Function, interpolator?: BinaryInterpolationAdapter): void;
+    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
@@ -285,12 +400,12 @@ export class NetworkSession {
     /**
      * Wire the session to the engine. After this, the EntityObserver
      * is active, the right orchestrator is constructed, and a
-     * {@link NetworkSystem} is attached. Subsequent {@link replicate}
+     * {@link NetworkSystem} is attached. Subsequent `replicate_*`
      * / {@link defineAction} / {@link defineInputSampler} calls throw.
      *
-     * Pre-condition: every component class passed to {@link replicate}
-     * must already have a `BinaryClassSerializationAdapter` registered
-     * in the session's binary_registry.
+     * Pre-condition: every replicated component class must already have a
+     * `BinaryClassSerializationAdapter` registered in the session's
+     * binary_registry.
      */
     start(): Promise<void>;
     /**
@@ -308,6 +423,11 @@ export class NetworkSession {
      * 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
      */
@@ -347,25 +467,29 @@ export class NetworkSession {
      */
     stop(): void;
     /**
-     * Fixed-timestep accumulator-driven step. Catch-up bounded by
-     * `MAX_FIXED_STEPS_PER_TICK`. Under `role: 'client'` the local frame
-     * advances at `1 / dilation_factor` per fixed step.
+     * **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.
      *
-     * @param {number} dt_seconds elapsed wall seconds since the previous call
+     * Warns once. Remove the call.
+     *
+     * @deprecated
+     * @param {number} [dt_seconds]
      */
-    tick(dt_seconds: number): void;
+    tick(dt_seconds?: number): void;
     /**
-     * Undo render-time interpolation on remote-owned components by
-     * restoring each from its latest InterpolationLog entry. Idempotent
-     * via the `render_dirty` flag — cheap when false.
-     *
-     * Called from `tick()` (top), `executor.before_execute` (per-action
-     * applies, including transport-delivered action stream), and
-     * `client.onBeforeReconcile` (before the rewind walk).
+     * 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.
      *
-     * @private
+     * 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.
      */
-    private normalize_if_dirty;
+    normalize_if_dirty(): void;
     /**
      * Dispatch one user-defined action, without needing a reference to the
      * executor or knowledge of the local peer id.
@@ -480,14 +604,19 @@ export class NetworkSession {
      * A client now seeks automatically on INITIAL_SYNC. 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 { UUID } from "../ecs/guid/UUID.js";
 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";

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

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