@colyseus/schema 5.0.5 → 5.0.8

package/build/input/InputDecoder.d.ts

@@ -22,11 +22,16 @@ export declare class InputDecoder<T extends Schema = any> {
     /**
      * Walk a multi-input (unreliable) packet, decoding each length-framed
      * input into the bound instance in order and invoking `onInput` after
-     * each decode. `onInput` receives the bound instance itself — reads
-     * must be synchronous; downstream code should apply the input to game
-     * state, not retain the reference.
+     * each decode. `onInput` receives the bound instance and the framework
+     * **seq** of that input (decoded from the packet's base seq + position) —
+     * the receiver dedupes the redundancy ring on it (monotonic: drop seq ≤
+     * last seen). Reads of the instance must be synchronous; downstream code
+     * should apply the input to game state, not retain the reference.
+     *
+     * Packet layout: `[baseSeq][len][body]…[len][body]` (oldest→newest);
+     * slot *i* has `seq = baseSeq + i`.
      *
      * Returns the number of inputs decoded.
      */
-    decodeAll(bytes: Uint8Array, onInput: (instance: T, index: number) => void): number;
+    decodeAll(bytes: Uint8Array, onInput: (instance: T, seq: number) => void): number;
 }

package/build/input/InputEncoder.d.ts

@@ -18,45 +18,28 @@ export interface InputEncoderOptions {
      * reliable mode (always exactly one input per packet).
      */
     historySize?: number;
-    /**
-     * When `true`, `encode()` emits only fields that changed since the
-     * previous call. First call (or first after `reset()`) still emits
-     * a full snapshot since there's no baseline to diff against.
-     *
-     * **Reliable mode:** returns an empty `Uint8Array` when nothing
-     * changed — caller can skip sending.
-     *
-     * **Unreliable mode:** no-change ticks don't push a new ring slot
-     * (avoids bloating the ring with empties); the existing ring is
-     * still re-emitted for redundancy. Wire ops use absolute values so
-     * cross-packet re-application is per-field idempotent.
-     *
-     * Decoder side is unchanged in either case: `(index|ADD)` wire ops
-     * apply to the bound instance; fields absent from a packet stay at
-     * their previously decoded value.
-     */
-    delta?: boolean;
-    /**
-     * Override the reliable-mode output buffer. Default: 256 bytes,
-     * auto-grown on overflow.
-     */
-    buffer?: Uint8Array;
 }
 /**
  * Bound single-struct encoder for client→server input packets. Holds a
  * reference to a Schema instance and produces wire-compatible bytes.
  *
- * **Reliable mode** emits one snapshot per `encode()`. The bytes decode
- * cleanly through the standard {@link Decoder}.
+ * Always delta-encodes: each `encode()` emits only the fields that changed
+ * since the previous call (via the setter-populated ChangeTree dirty set),
+ * wrapping a standard {@link Encoder}. The first call (or first after
+ * {@link reset}) emits a full snapshot, since there's no baseline to diff
+ * against.
  *
- * **Unreliable mode** pushes each snapshot onto a ring buffer of size
- * `historySize` and emits the last N snapshots in one packet, each
- * framed with a varint length prefix. Use {@link InputDecoder.decodeAll}
- * to walk the framed packet on the receiving end.
+ * **Reliable mode** emits one delta per `encode()` — or an empty
+ * `Uint8Array` when nothing changed (the caller decides whether to send a
+ * body-less keep-alive or skip the tick). The bytes decode cleanly through
+ * the standard {@link Decoder}.
  *
- * **Delta** (`delta: true`, any mode) wraps a standard {@link Encoder}
- * and emits only fields that changed since the last call, via the
- * setter-populated ChangeTree dirty set.
+ * **Unreliable mode** pushes each delta onto a ring buffer of size
+ * `historySize` and emits the last N in one packet, each framed with a
+ * varint length prefix. A no-change tick still pushes an (empty,
+ * carry-forward) slot so every tick gets a consecutive framework seq. Use
+ * {@link InputDecoder.decodeAll} to walk the framed packet. Wire ops use
+ * absolute values, so re-applying a redundant slot is per-field idempotent.
  *
  * Flat primitive fields only. Nested Schema / collection fields throw
  * at construction.
@@ -65,31 +48,33 @@ export declare class InputEncoder<T extends Schema = any> {
     readonly instance: T;
     readonly mode: InputMode;
     readonly historySize: number;
-    readonly delta: boolean;
     private readonly _desc;
     private readonly _numFields;
-    private _buffer;
-    private readonly _it;
     private _slots?;
     private readonly _slotLens?;
     private _slotHead;
     private _slotCount;
     private _outBuffer?;
-    private readonly _encoder?;
+    private _seq;
+    private readonly _encoder;
     constructor(instance: T, options?: InputEncoderOptions);
     /**
-     * Encode the bound instance. Returns a subarray of an internal
+     * The framework input seq of the most recently encoded tick (unreliable
+     * mode): monotonic, ++ per `encode()`, kept across {@link reset}. `0` in
+     * reliable mode (which sequences inputs implicitly by message count). The
+     * client keys its reconciliation replay ring by this so the server's
+     * seq-value ack lines up across packet loss.
+     */
+    get seq(): number;
+    /**
+     * Encode the bound instance's delta. Returns a subarray of an internal
      * buffer — copy if retaining across calls.
      *
-     * Output shape by configuration:
-     * - `reliable` + full: one snapshot's worth of bytes.
-     * - `reliable` + delta: only changed fields, or empty when nothing
-     *   changed.
-     * - `unreliable` + full: ring of last `historySize` snapshots,
-     *   length-framed per slot.
-     * - `unreliable` + delta: ring of last `historySize` deltas. No-
-     *   change ticks don't push a new slot but still re-emit the ring.
-     *   Empty only until the first change has been pushed.
+     * Output shape by mode:
+     * - `reliable`: only changed fields, or empty when nothing changed.
+     * - `unreliable`: ring of the last `historySize` deltas, length-framed
+     *   per slot. A no-change tick pushes an empty (carry-forward) slot but
+     *   still re-emits the ring. Empty only until the first slot is pushed.
      *
      * Buffers auto-grow on overflow; a one-time `console.warn` is
      * emitted the first time it happens.
@@ -97,19 +82,25 @@ export declare class InputEncoder<T extends Schema = any> {
     encode(): Uint8Array;
     /**
      * Reset the encoder's internal state:
-     * - Unreliable mode: drops the ring buffer.
-     * - Delta mode: re-marks every currently populated field as dirty,
-     *   so the next `encode()` emits a fresh full snapshot.
+     * - Drops the unreliable ring buffer.
+     * - Re-marks every currently populated field as dirty, so the next
+     *   `encode()` emits a fresh full snapshot.
      *
      * Useful on disconnect / reconnect / scene transitions.
      */
     reset(): void;
-    /** Write every populated primitive field into `_buffer`. */
-    private _produceFull;
+    /**
+     * Copy the bound instance's field values into `target` (a same-type instance)
+     * in place — no allocation, no `Object.keys` (cf. `Schema#assign`) and no
+     * `clone()`. For buffering a snapshot of the just-sent input into a reused
+     * slot (e.g. a client reconciliation/replay ring) without the transport
+     * having to reach into schema internals. The codec owns this because it owns
+     * the field representation. The in-place / alloc-free cousin of `clone()`,
+     * and the inverse direction of `Schema#assign(source)`.
+     */
+    copyInto(target: T): void;
     /** Delegate to the wrapped Encoder, then clear its dirty set. */
     private _produceDelta;
-    /** Emit every populated field as `(index|ADD)` + value. */
-    private _writeFields;
     private _pushAndEmitRing;
     private _emitRing;
     private static _warned;