@colyseus/core 0.17.44 → 0.18.1

package/build/Protocol.mjs

@@ -1,5 +1,5 @@
 // packages/core/src/Protocol.ts
-import { Packr } from "@colyseus/msgpackr";
+import { Packr, RESERVE_START_SPACE } from "msgpackr";
 import { encode } from "@colyseus/schema";
 import { Protocol } from "@colyseus/shared-types";
 var IpcProtocol = {
@@ -9,63 +9,128 @@ var IpcProtocol = {
 };
 var packr = new Packr({
   useRecords: false
-  // increased compatibility with decoders other than "msgpackr"
+  // interop with non-msgpackr decoders
 });
-packr.encode(void 0);
+var frameBuffer = Buffer.allocUnsafe(8192);
+function ensureFrameCapacity(capacity) {
+  if (capacity > frameBuffer.byteLength) {
+    const next = Buffer.allocUnsafe(capacity);
+    frameBuffer.copy(next);
+    frameBuffer = next;
+  }
+}
+var it = { offset: 0 };
 var getMessageBytes = {
-  [Protocol.JOIN_ROOM]: (reconnectionToken, serializerId, handshake) => {
-    const it = { offset: 1 };
-    packr.buffer[0] = Protocol.JOIN_ROOM;
-    packr.buffer[it.offset++] = Buffer.byteLength(reconnectionToken, "utf8");
-    encode.utf8Write(packr.buffer, reconnectionToken, it);
-    packr.buffer[it.offset++] = Buffer.byteLength(serializerId, "utf8");
-    encode.utf8Write(packr.buffer, serializerId, it);
+  /**
+   * Build the JOIN_ROOM payload.
+   *
+   * Wire layout:
+   *   [JOIN_ROOM byte][rt-len][rt][sid-len][sid][stateReflectionLen varint][stateReflection][...sections]
+   *
+   * The varint length prefix on `stateReflection` is required because the
+   * schema decoder on the SDK side runs `while (offset < bytes.byteLength)`
+   * — without a boundary it consumes past the state reflection into the
+   * trailing tagged-section bytes, producing "definition mismatch" warnings.
+   * Length is `0` when no state reflection is present.
+   *
+   * Each trailing section is `[tag (uint8)][length (varint)][payload]`. The
+   * SDK skips unknown tags via `length`, so new sections can be added without
+   * breaking older clients. See {@link HandshakeSection} in shared-types.
+   */
+  [Protocol.JOIN_ROOM]: (reconnectionToken, serializerId, handshake, extraSections) => {
+    const reconnectionTokenLength = Buffer.byteLength(reconnectionToken, "utf8");
+    const serializerIdLength = Buffer.byteLength(serializerId, "utf8");
     let handshakeLength = handshake?.byteLength || 0;
-    if (handshakeLength > packr.buffer.byteLength - it.offset) {
-      packr.useBuffer(Buffer.alloc(it.offset + handshakeLength, packr.buffer));
+    let extraLength = 0;
+    if (extraSections !== void 0) {
+      for (let i = 0; i < extraSections.length; i++) {
+        extraLength += 1 + 9 + extraSections[i].bytes.byteLength;
+      }
     }
+    ensureFrameCapacity(1 + 1 + reconnectionTokenLength + 1 + serializerIdLength + 9 + handshakeLength + extraLength);
+    it.offset = 1;
+    frameBuffer[0] = Protocol.JOIN_ROOM;
+    frameBuffer[it.offset++] = reconnectionTokenLength;
+    encode.utf8Write(frameBuffer, reconnectionToken, it);
+    frameBuffer[it.offset++] = serializerIdLength;
+    encode.utf8Write(frameBuffer, serializerId, it);
+    encode.number(frameBuffer, handshakeLength, it);
     if (handshakeLength > 0) {
-      packr.buffer.set(handshake, it.offset);
+      frameBuffer.set(handshake, it.offset);
+      it.offset += handshakeLength;
     }
-    return Buffer.from(packr.buffer.subarray(0, it.offset + handshakeLength));
+    if (extraSections !== void 0) {
+      for (let i = 0; i < extraSections.length; i++) {
+        const section = extraSections[i];
+        frameBuffer[it.offset++] = section.tag;
+        encode.number(frameBuffer, section.bytes.byteLength, it);
+        frameBuffer.set(section.bytes, it.offset);
+        it.offset += section.bytes.byteLength;
+      }
+    }
+    return Buffer.from(frameBuffer.subarray(0, it.offset));
   },
   [Protocol.ERROR]: (code, message = "") => {
-    const it = { offset: 1 };
-    packr.buffer[0] = Protocol.ERROR;
-    encode.number(packr.buffer, code, it);
-    encode.string(packr.buffer, message, it);
-    return Buffer.from(packr.buffer.subarray(0, it.offset));
+    ensureFrameCapacity(1 + 9 + 9 + Buffer.byteLength(message, "utf8"));
+    it.offset = 1;
+    frameBuffer[0] = Protocol.ERROR;
+    encode.number(frameBuffer, code, it);
+    encode.string(frameBuffer, message, it);
+    return Buffer.from(frameBuffer.subarray(0, it.offset));
   },
   [Protocol.ROOM_STATE]: (bytes) => {
     return [Protocol.ROOM_STATE, ...bytes];
   },
+  /**
+   * Reply to a client {@link Protocol.ROOM_REQUEST}.
+   *
+   * Wire layout: `[ROOM_RESPONSE byte][requestId varint][status uint8][msgpack payload?]`
+   *
+   * `requestId` is opaque — echoed back exactly as the SDK sent it so the
+   * pending callback/promise can be correlated. `status` is a
+   * {@link ResponseStatus} (0 = OK, 1 = REJECTED, 2 = ERROR). The payload is
+   * omitted when a handler resolves with `undefined`. Returns a fresh Buffer copy
+   * for the same back-pressure reason documented on `raw` below.
+   */
+  [Protocol.ROOM_RESPONSE]: (requestId, status, message) => {
+    it.offset = 1;
+    frameBuffer[0] = Protocol.ROOM_RESPONSE;
+    encode.number(frameBuffer, requestId, it);
+    frameBuffer[it.offset++] = status;
+    const headerLength = it.offset;
+    if (message !== void 0) {
+      const packed = packr.pack(message, RESERVE_START_SPACE | headerLength);
+      packed.set(frameBuffer.subarray(0, headerLength), 0);
+      return Buffer.from(packed);
+    }
+    return Buffer.from(frameBuffer.subarray(0, headerLength));
+  },
   [Protocol.PING]: () => {
-    packr.buffer[0] = Protocol.PING;
-    return Buffer.from(packr.buffer.subarray(0, 1));
+    frameBuffer[0] = Protocol.PING;
+    return Buffer.from(frameBuffer.subarray(0, 1));
   },
+  // Returns a fresh copy: frameBuffer/packr are reused next call, but callers pass
+  // the result to async consumers (Node retains it for libuv writev across ticks).
+  // See benchmark/test-buffer-corruption.ts for the back-pressure repro.
   raw: (code, type, message, rawMessage) => {
-    const it = { offset: 1 };
-    packr.buffer[0] = code;
+    it.offset = 1;
+    frameBuffer[0] = code;
     if (typeof type === "string") {
-      encode.string(packr.buffer, type, it);
+      encode.string(frameBuffer, type, it);
     } else {
-      encode.number(packr.buffer, type, it);
+      encode.number(frameBuffer, type, it);
     }
+    const headerLength = it.offset;
     if (message !== void 0) {
-      packr.position = 0;
-      if (process.env.NODE_ENV !== "production") {
-        packr.useBuffer(packr.buffer);
-      }
-      const endOfBufferOffset = packr.pack(message, 2048 + it.offset).byteLength;
-      return Buffer.from(packr.buffer.subarray(0, endOfBufferOffset));
+      const packed = packr.pack(message, RESERVE_START_SPACE | headerLength);
+      packed.set(frameBuffer.subarray(0, headerLength), 0);
+      return Buffer.from(packed);
     } else if (rawMessage !== void 0) {
-      if (rawMessage.length + it.offset > packr.buffer.byteLength) {
-        packr.useBuffer(Buffer.alloc(it.offset + rawMessage.length, packr.buffer));
-      }
-      packr.buffer.set(rawMessage, it.offset);
-      return Buffer.from(packr.buffer.subarray(0, it.offset + rawMessage.byteLength));
+      ensureFrameCapacity(headerLength + rawMessage.byteLength);
+      frameBuffer.set(rawMessage, headerLength);
+      return Buffer.from(frameBuffer.subarray(0, headerLength + rawMessage.byteLength));
     } else {
-      return Buffer.from(packr.buffer.subarray(0, it.offset));
+      return Buffer.from(frameBuffer.subarray(0, headerLength));
     }
   }
 };

package/build/Protocol.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/Protocol.ts"],
-  "sourcesContent": ["import { Packr } from '@colyseus/msgpackr';\nimport { encode, type Iterator } from '@colyseus/schema';\nimport { Protocol } from '@colyseus/shared-types';\n\n// Inter-process communication protocol\nexport const IpcProtocol = {\n  SUCCESS: 0,\n  ERROR: 1,\n  TIMEOUT: 2,\n} as const;\nexport type IpcProtocol = typeof IpcProtocol[keyof typeof IpcProtocol];\n\nconst packr = new Packr({\n  useRecords: false, // increased compatibility with decoders other than \"msgpackr\"\n});\n\n// msgpackr workaround: initialize buffer\npackr.encode(undefined);\n\nexport const getMessageBytes = {\n  [Protocol.JOIN_ROOM]: (reconnectionToken: string, serializerId: string, handshake?: Uint8Array) => {\n    const it: Iterator = { offset: 1 };\n    packr.buffer[0] = Protocol.JOIN_ROOM;\n\n    packr.buffer[it.offset++] = Buffer.byteLength(reconnectionToken, \"utf8\");\n    encode.utf8Write(packr.buffer, reconnectionToken, it);\n\n    packr.buffer[it.offset++] = Buffer.byteLength(serializerId, \"utf8\");\n    encode.utf8Write(packr.buffer, serializerId, it);\n\n    let handshakeLength = handshake?.byteLength || 0;\n\n    // check if buffer needs to be resized\n    if (handshakeLength > packr.buffer.byteLength - it.offset) {\n      packr.useBuffer(Buffer.alloc(it.offset + handshakeLength, packr.buffer));\n    }\n\n    if (handshakeLength > 0) {\n      packr.buffer.set(handshake, it.offset);\n    }\n\n    return Buffer.from(packr.buffer.subarray(0, it.offset + handshakeLength));\n  },\n\n  [Protocol.ERROR]: (code: number, message: string = '') => {\n    const it: Iterator = { offset: 1 };\n    packr.buffer[0] = Protocol.ERROR;\n\n    encode.number(packr.buffer, code, it);\n    encode.string(packr.buffer, message, it);\n\n    return Buffer.from(packr.buffer.subarray(0, it.offset));\n  },\n\n  [Protocol.ROOM_STATE]: (bytes: number[]) => {\n    return [Protocol.ROOM_STATE, ...bytes];\n  },\n\n  [Protocol.PING]: () => {\n    packr.buffer[0] = Protocol.PING;\n    return Buffer.from(packr.buffer.subarray(0, 1));\n  },\n\n  raw: (code: Protocol, type: string | number, message?: any, rawMessage?: Uint8Array | Buffer) => {\n    const it: Iterator = { offset: 1 };\n    packr.buffer[0] = code;\n\n    if (typeof (type) === 'string') {\n      encode.string(packr.buffer, type, it);\n\n    } else {\n      encode.number(packr.buffer, type, it);\n    }\n\n    if (message !== undefined) {\n      // force to encode from offset\n      packr.position = 0;\n\n      //\n      // TODO: remove this after issue is fixed https://github.com/kriszyp/msgpackr/issues/139\n      //\n      // - This check is only required when running integration tests.\n      //   (colyseus.js' usage of msgpackr/buffer is conflicting)\n      //\n      if (process.env.NODE_ENV !== \"production\") {\n        packr.useBuffer(packr.buffer);\n      }\n\n      // pack message into the same packr.buffer\n      const endOfBufferOffset = packr.pack(message, 2048 + it.offset).byteLength;\n                                                 // 2048 = RESERVE_START_SPACE\n      return Buffer.from(packr.buffer.subarray(0, endOfBufferOffset));\n\n    } else if (rawMessage !== undefined) {\n\n      // check if buffer needs to be resized\n      // TODO: can we avoid this?\n      if (rawMessage.length + it.offset > packr.buffer.byteLength) {\n        packr.useBuffer(Buffer.alloc(it.offset + rawMessage.length, packr.buffer));\n      }\n\n      // copy raw message into packr.buffer\n      packr.buffer.set(rawMessage, it.offset);\n\n      return Buffer.from(packr.buffer.subarray(0, it.offset + rawMessage.byteLength));\n\n    } else {\n      return Buffer.from(packr.buffer.subarray(0, it.offset));\n    }\n  },\n\n};\n\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { Packr, RESERVE_START_SPACE } from 'msgpackr';\nimport { encode, type Iterator } from '@colyseus/schema';\nimport { Protocol } from '@colyseus/shared-types';\n\n// Inter-process communication protocol\nexport const IpcProtocol = {\n  SUCCESS: 0,\n  ERROR: 1,\n  TIMEOUT: 2,\n} as const;\nexport type IpcProtocol = typeof IpcProtocol[keyof typeof IpcProtocol];\n\nconst packr = new Packr({\n  useRecords: false, // interop with non-msgpackr decoders\n});\n\n// Buffer for assembling outgoing frames; keeps us off msgpackr's internal\n// buffer so `core` can use the upstream package directly.\nlet frameBuffer = Buffer.allocUnsafe(8192);\n\n// Grow to `capacity`, preserving written bytes (`rawMessage` writes the header\n// before the payload size is known).\nfunction ensureFrameCapacity(capacity: number) {\n  if (capacity > frameBuffer.byteLength) {\n    const next = Buffer.allocUnsafe(capacity);\n    frameBuffer.copy(next);\n    frameBuffer = next;\n  }\n}\n\n// Shared across calls to avoid a per-call allocation on the hot send path.\n// Safe: encode.* mutate `.offset` in place and never re-enter this module.\nconst it: Iterator = { offset: 0 };\n\nexport const getMessageBytes = {\n  /**\n   * Build the JOIN_ROOM payload.\n   *\n   * Wire layout:\n   *   [JOIN_ROOM byte][rt-len][rt][sid-len][sid][stateReflectionLen varint][stateReflection][...sections]\n   *\n   * The varint length prefix on `stateReflection` is required because the\n   * schema decoder on the SDK side runs `while (offset < bytes.byteLength)`\n   * \u2014 without a boundary it consumes past the state reflection into the\n   * trailing tagged-section bytes, producing \"definition mismatch\" warnings.\n   * Length is `0` when no state reflection is present.\n   *\n   * Each trailing section is `[tag (uint8)][length (varint)][payload]`. The\n   * SDK skips unknown tags via `length`, so new sections can be added without\n   * breaking older clients. See {@link HandshakeSection} in shared-types.\n   */\n  [Protocol.JOIN_ROOM]: (\n    reconnectionToken: string,\n    serializerId: string,\n    handshake?: Uint8Array,\n    extraSections?: Array<{ tag: number; bytes: Uint8Array }>,\n  ) => {\n    const reconnectionTokenLength = Buffer.byteLength(reconnectionToken, \"utf8\");\n    const serializerIdLength = Buffer.byteLength(serializerId, \"utf8\");\n    let handshakeLength = handshake?.byteLength || 0;\n\n    // per section: 1 tag byte + 9 (max varint) + payload\n    let extraLength = 0;\n    if (extraSections !== undefined) {\n      for (let i = 0; i < extraSections.length; i++) {\n        extraLength += 1 + 9 + extraSections[i].bytes.byteLength;\n      }\n    }\n\n    // capacity: header + 9 (handshake-len varint) + handshake + sections\n    ensureFrameCapacity(1 + 1 + reconnectionTokenLength + 1 + serializerIdLength + 9 + handshakeLength + extraLength);\n\n    it.offset = 1;\n    frameBuffer[0] = Protocol.JOIN_ROOM;\n\n    frameBuffer[it.offset++] = reconnectionTokenLength;\n    encode.utf8Write(frameBuffer, reconnectionToken, it);\n\n    frameBuffer[it.offset++] = serializerIdLength;\n    encode.utf8Write(frameBuffer, serializerId, it);\n\n    encode.number(frameBuffer, handshakeLength, it);\n    if (handshakeLength > 0) {\n      frameBuffer.set(handshake, it.offset);\n      it.offset += handshakeLength;\n    }\n\n    if (extraSections !== undefined) {\n      for (let i = 0; i < extraSections.length; i++) {\n        const section = extraSections[i];\n        frameBuffer[it.offset++] = section.tag;\n        encode.number(frameBuffer, section.bytes.byteLength, it);\n        frameBuffer.set(section.bytes, it.offset);\n        it.offset += section.bytes.byteLength;\n      }\n    }\n\n    return Buffer.from(frameBuffer.subarray(0, it.offset));\n  },\n\n  [Protocol.ERROR]: (code: number, message: string = '') => {\n    // capacity: 1 + code varint + length-prefixed message\n    ensureFrameCapacity(1 + 9 + 9 + Buffer.byteLength(message, \"utf8\"));\n\n    it.offset = 1;\n    frameBuffer[0] = Protocol.ERROR;\n\n    encode.number(frameBuffer, code, it);\n    encode.string(frameBuffer, message, it);\n\n    return Buffer.from(frameBuffer.subarray(0, it.offset));\n  },\n\n  [Protocol.ROOM_STATE]: (bytes: number[]) => {\n    return [Protocol.ROOM_STATE, ...bytes];\n  },\n\n  /**\n   * Reply to a client {@link Protocol.ROOM_REQUEST}.\n   *\n   * Wire layout: `[ROOM_RESPONSE byte][requestId varint][status uint8][msgpack payload?]`\n   *\n   * `requestId` is opaque \u2014 echoed back exactly as the SDK sent it so the\n   * pending callback/promise can be correlated. `status` is a\n   * {@link ResponseStatus} (0 = OK, 1 = REJECTED, 2 = ERROR). The payload is\n   * omitted when a handler resolves with `undefined`. Returns a fresh Buffer copy\n   * for the same back-pressure reason documented on `raw` below.\n   */\n  [Protocol.ROOM_RESPONSE]: (requestId: number, status: number, message?: any): Buffer => {\n    it.offset = 1;\n    frameBuffer[0] = Protocol.ROOM_RESPONSE;\n\n    encode.number(frameBuffer, requestId, it);\n    frameBuffer[it.offset++] = status;\n    const headerLength = it.offset;\n\n    if (message !== undefined) {\n      // reserve `headerLength` bytes up front in the pack output for the header\n      const packed = packr.pack(message, RESERVE_START_SPACE | headerLength);\n      packed.set(frameBuffer.subarray(0, headerLength), 0);\n      return Buffer.from(packed);\n    }\n\n    return Buffer.from(frameBuffer.subarray(0, headerLength));\n  },\n\n  [Protocol.PING]: () => {\n    frameBuffer[0] = Protocol.PING;\n    return Buffer.from(frameBuffer.subarray(0, 1));\n  },\n\n  // Returns a fresh copy: frameBuffer/packr are reused next call, but callers pass\n  // the result to async consumers (Node retains it for libuv writev across ticks).\n  // See benchmark/test-buffer-corruption.ts for the back-pressure repro.\n  raw: (code: Protocol, type: string | number, message?: any, rawMessage?: Uint8Array | Buffer): Buffer => {\n    it.offset = 1;\n    frameBuffer[0] = code;\n\n    if (typeof (type) === 'string') {\n      encode.string(frameBuffer, type, it);\n\n    } else {\n      encode.number(frameBuffer, type, it);\n    }\n    const headerLength = it.offset;\n\n    if (message !== undefined) {\n      // reserve `headerLength` bytes up front in the pack output for the header\n      const packed = packr.pack(message, RESERVE_START_SPACE | headerLength);\n      packed.set(frameBuffer.subarray(0, headerLength), 0);\n      return Buffer.from(packed);\n\n    } else if (rawMessage !== undefined) {\n      ensureFrameCapacity(headerLength + rawMessage.byteLength);\n      frameBuffer.set(rawMessage, headerLength);\n      return Buffer.from(frameBuffer.subarray(0, headerLength + rawMessage.byteLength));\n\n    } else {\n      return Buffer.from(frameBuffer.subarray(0, headerLength));\n    }\n  },\n\n};\n\n"],
+  "mappings": "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",
   "names": []
 }

package/build/Rewind.cjs

@@ -0,0 +1,385 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/core/src/Rewind.ts
+var Rewind_exports = {};
+__export(Rewind_exports, {
+  Rewind: () => Rewind,
+  RewindView: () => RewindView
+});
+module.exports = __toCommonJS(Rewind_exports);
+var import_schema = require("@colyseus/schema");
+var import_Utils = require("./utils/Utils.cjs");
+var DEFAULT_MAX_REWIND_MS = 500;
+var DEFAULT_SAMPLE_INTERVAL_MS = 1e3 / 60;
+var $HISTORY = /* @__PURE__ */ Symbol("rewind.history");
+function fieldIndexOf(instance, field) {
+  const md = instance.constructor[import_Utils.$METADATA];
+  const idx = md?.[field];
+  return typeof idx === "number" ? idx : -1;
+}
+var EntityHistory = class {
+  constructor(fields, fieldIdx, maxRewindMs, sampleIntervalMs, step, reckoned, groupId) {
+    // hold (vs lerp) between samples
+    this.head = 0;
+    // next write slot
+    this.count = 0;
+    this.fields = fields;
+    this.fieldIdx = fieldIdx;
+    this.step = step;
+    this.reckoned = reckoned;
+    this.groupId = groupId;
+    this.cap = Math.max(2, Math.ceil(maxRewindMs / sampleIntervalMs) + 4);
+    this.t = new Float64Array(this.cap);
+    this.cols = fields.map(() => new Float64Array(this.cap));
+  }
+  /** `values` = the entity's dense `$values` array. Direct array reads — no
+   *  per-field megamorphic accessor. */
+  record(time, values) {
+    const fieldIdx = this.fieldIdx;
+    this.t[this.head] = time;
+    for (let f = 0; f < fieldIdx.length; f++) this.cols[f][this.head] = values[fieldIdx[f]];
+    this.head = (this.head + 1) % this.cap;
+    if (this.count < this.cap) this.count++;
+  }
+  /** Interpolated value of column `col` at `time`, clamped to the retained range. */
+  valueAt(time, col) {
+    const c = this.cols[col];
+    const oldest = (this.head - this.count + this.cap) % this.cap;
+    if (time <= this.t[oldest]) return c[oldest];
+    const newest = (this.head - 1 + this.cap) % this.cap;
+    if (time >= this.t[newest]) return c[newest];
+    let prev = oldest;
+    for (let i = 1; i < this.count; i++) {
+      const idx = (oldest + i) % this.cap;
+      if (this.t[idx] >= time) {
+        if (this.step) return c[prev];
+        const t0 = this.t[prev], t1 = this.t[idx];
+        const a = t1 > t0 ? (time - t0) / (t1 - t0) : 0;
+        return c[prev] + (c[idx] - c[prev]) * a;
+      }
+      prev = idx;
+    }
+    return c[newest];
+  }
+};
+function historyForField(instance, field) {
+  const arr = instance[$HISTORY];
+  if (arr === void 0) return void 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i].fields.indexOf(field) >= 0) return arr[i];
+  }
+  return void 0;
+}
+var RewindView = class {
+  constructor() {
+    this._time = 0;
+    this._reckonTime = 0;
+  }
+  /** The clamped server-time (ms) this view reads at — after the maxRewindMs
+   *  clamp and the live (newest-sample) fallback. Mostly for logging/debug. */
+  get time() {
+    return this._time;
+  }
+  /** The clamped server-time (ms) `mode: "reckon"` groups read at — the
+   *  client's reconstructed simulation instant, not the raw stamp (see
+   *  {@link Rewind.at}). Always a resolved instant: a clamped direct stamp,
+   *  or the midpoint/live reconstruction when unstamped. `0` only before the
+   *  first `record()`. */
+  get reckonTime() {
+    return this._reckonTime;
+  }
+  /** @internal Aim at a rewind + clamped times ({@link Rewind.at} owns the clamps). */
+  _retarget(rewind, at, reckonAt) {
+    this.rewind = rewind;
+    this._time = at;
+    this._reckonTime = reckonAt;
+    return this;
+  }
+  /** Rewound value of a numeric `field` on `entity` (live if it isn't tracked). */
+  value(entity, field) {
+    if (this.rewind === void 0) {
+      throw new Error("RewindView is not aimed \u2014 obtain it from rewind.at()/lastSeenBy(), or pass it to them as `out`.");
+    }
+    const h = historyForField(entity, field);
+    if (h === void 0) return entity[field];
+    return h.valueAt(h.reckoned ? this._reckonTime : this._time, h.fields.indexOf(field));
+  }
+  /**
+   * Batch {@link value} reads: the `fields` YOU list define the result's shape
+   * (`Record<field, number>`). Pass `out` to fill (and return) a reused scratch
+   * instead of allocating — its properties beyond `fields` are left untouched,
+   * so a scratch can carry extra context (an `alive` flag, say).
+   */
+  read(entity, fields, out) {
+    const o = out ?? {};
+    for (let i = 0; i < fields.length; i++) o[fields[i]] = this.value(entity, fields[i]);
+    return o;
+  }
+};
+var Rewind = class _Rewind {
+  constructor(defaultMaxRewindMs) {
+    this.groups = [];
+    this._sampleIntervalMs = DEFAULT_SAMPLE_INTERVAL_MS;
+    this._lastRecordedAt = -1;
+    /** Default view returned by at/lastSeenBy when no `out` is given — one per
+     *  Rewind, re-aimed per call (zero alloc, zero userland setup). */
+    this._view = new RewindView();
+    this.defaultMaxRewindMs = defaultMaxRewindMs;
+  }
+  static {
+    this.byRoom = /* @__PURE__ */ new WeakMap();
+  }
+  /** One `Rewind` per room (idempotent). `room` is only the cache key. */
+  static get(room, opts) {
+    let r = _Rewind.byRoom.get(room);
+    if (r === void 0) {
+      r = new _Rewind(opts?.maxRewindMs ?? DEFAULT_MAX_REWIND_MS);
+      _Rewind.byRoom.set(room, r);
+    }
+    return r;
+  }
+  /** The default rewind window (ms). Use it to bound a hit test:
+   *  `Math.max(renderTime, now - rewind.maxRewindMs)`. */
+  get maxRewindMs() {
+    return this.defaultMaxRewindMs;
+  }
+  /** Server time of the last {@link record} (or -1). The auto-record skips a tick
+   *  whose time was already recorded manually — your `record()` wins. */
+  get lastRecordedAt() {
+    return this._lastRecordedAt;
+  }
+  /** Track every entity in a collection (Map/Array/Set schema). `fields` narrows
+   *  to its element's numeric fields. `interpolate` (a mode or a per-entity fn,
+   *  default `linear`) picks how `valueAt` reconstructs between samples — use
+   *  `step` for discrete-motion entities (e.g. teleporters). `mode` picks the
+   *  lag-comp timeline (default `"snapshot"`; see {@link AttachOptions}). */
+  attachAll(collection, opts) {
+    const c = collection;
+    this.groups.push({ entities: () => c.values(), fields: opts.fields, resolvedByCtor: /* @__PURE__ */ new Map(), maxRewindMs: opts.maxRewindMs ?? this.defaultMaxRewindMs, interpolate: opts.interpolate ?? "linear", reckoned: opts.mode === "reckon", groupId: this.groups.length });
+    return this;
+  }
+  /** Track a single entity (e.g. a boss). `fields` narrows to its numeric fields. */
+  attach(instance, opts) {
+    const one = [instance];
+    this.groups.push({ entities: () => one, fields: opts.fields, resolvedByCtor: /* @__PURE__ */ new Map(), maxRewindMs: opts.maxRewindMs ?? this.defaultMaxRewindMs, interpolate: opts.interpolate ?? "linear", reckoned: opts.mode === "reckon", groupId: this.groups.length });
+    return this;
+  }
+  /**
+   * Snapshot every tracked entity at `now`. Call once per tick, AFTER they move —
+   * {@link Room.allowRewindState} does this for you. `sampleIntervalMs` (the gap
+   * between records) sizes the history rings; the framework passes the sim
+   * interval. Calling this yourself during a tick suppresses that tick's
+   * auto-record (see {@link lastRecordedAt}).
+   */
+  record(now, sampleIntervalMs) {
+    if (sampleIntervalMs !== void 0 && sampleIntervalMs > 0) this._sampleIntervalMs = sampleIntervalMs;
+    this._lastRecordedAt = now;
+    for (const g of this.groups) {
+      for (const e of g.entities()) {
+        const t = e;
+        let arr = t[$HISTORY];
+        if (arr === void 0) {
+          arr = [];
+          t[$HISTORY] = arr;
+        }
+        let h;
+        for (let i = 0; i < arr.length; i++) {
+          if (arr[i].groupId === g.groupId) {
+            h = arr[i];
+            break;
+          }
+        }
+        if (h === void 0) {
+          h = this.createHistory(g, e);
+          arr.push(h);
+        }
+        h.record(now, t[import_schema.$values]);
+      }
+    }
+  }
+  /** Cold path — first time an entity is seen by `record()` for a given group.
+   *  Resolves the field→`$values` indices (cached per constructor for array-form
+   *  `fields`; fn-form resolves per entity) and bakes in the group's `mode`. */
+  createHistory(g, e) {
+    let rf;
+    if (typeof g.fields === "function") {
+      rf = this.resolveFields(e, g.fields(e));
+    } else {
+      let cached = g.resolvedByCtor.get(e.constructor);
+      if (cached === void 0) {
+        cached = this.resolveFields(e, g.fields);
+        g.resolvedByCtor.set(e.constructor, cached);
+      }
+      rf = cached;
+    }
+    const interp = typeof g.interpolate === "function" ? g.interpolate(e) : g.interpolate;
+    return new EntityHistory(rf.fields, rf.idx, g.maxRewindMs, this._sampleIntervalMs, interp === "step", g.reckoned, g.groupId);
+  }
+  /** Keep only the fields this entity's type declares (unknown → read live). */
+  resolveFields(e, names) {
+    const fields = [];
+    const idx = [];
+    for (const name of names) {
+      const i = fieldIndexOf(e, name);
+      if (i >= 0) {
+        fields.push(name);
+        idx.push(i);
+      }
+    }
+    return { fields, idx };
+  }
+  /**
+   * `instance`'s `field` value at past `time` (interpolated from history). Falls
+   * back to the live value when the entity has no history yet, or the field
+   * isn't tracked.
+   */
+  valueAt(instance, time, field) {
+    const h = historyForField(instance, field);
+    if (h === void 0) return instance[field];
+    return h.valueAt(time, h.fields.indexOf(field));
+  }
+  /**
+   * Which timeline(s) the attached groups rewind to — `reckon` true iff any
+   * group is `mode:"reckon"`, `snapshot` true iff any is `mode:"snapshot"`. The
+   * room reads this once (groups are declared in `onCreate`, before any join) to
+   * pick which stamp(s) the client must ship: reckon-only / render-only / both /
+   * none. @internal
+   */
+  timelineMode() {
+    let reckon = false, snapshot = false;
+    for (const g of this.groups) {
+      if (g.reckoned) reckon = true;
+      else snapshot = true;
+    }
+    return { reckon, snapshot };
+  }
+  /**
+   * @internal Wire a resolver from sessionId → that client's auto-stamped
+   * `renderTime`. Called by {@link Room.allowRewindState} so {@link lastSeenBy}
+   * works for `mode:"snapshot"` groups; auto-enabled by attaching one.
+   */
+  bindRenderTime(resolver) {
+    this._renderTimeOf = resolver;
+  }
+  /**
+   * @internal Wire a resolver for the CURRENT server time (ms, same epoch as
+   * `record` times). Called by {@link Room.allowRewindState}; standalone users
+   * (tests/harnesses) should bind their own. Anchors the reckon midpoint in
+   * {@link at} at the true processing instant — the `lastRecordedAt` fallback
+   * is one tick stale by hit-test time, biasing the aim ~half a tick early:
+   * imperceptible on slow horizontal motion, but enough to flip knife-edge
+   * stomp/hit verdicts on fast vertical movers (a bobbing jumper).
+   */
+  bindNow(resolver) {
+    this._nowOf = resolver;
+  }
+  /**
+   * @internal Wire a resolver from sessionId → that client's auto-stamped
+   * reckon-display instant (`input(sid).reckonTime`). Called by
+   * {@link Room.allowRewindState}. With it, {@link lastSeenBy} aims
+   * `mode:"reckon"` groups at the EXACT instant the client displayed them
+   * (immune to its RTT-estimation error); without it (or while the stamp is
+   * still 0), the midpoint reconstruction in {@link at} is the fallback.
+   */
+  bindReckonTime(resolver) {
+    this._reckonTimeOf = resolver;
+  }
+  /**
+   * A {@link RewindView} of the tracked world at `time` (an acting client's render
+   * time), with the two things every hit test re-implements baked in:
+   *  - **clamp** to `[lastRecordedAt − maxRewindMs, lastRecordedAt]` — an
+   *    anti-spoof / clock-skew bound (a client can't rewind arbitrarily far), and
+   *  - **live fallback**: `time <= 0` (the client's clock hasn't synced) → the
+   *    newest recorded sample (≈ current position).
+   *
+   * Sugar over {@link valueAt}; pass the render time yourself (e.g. from
+   * `input(sid).renderTime`, or a value stored on the entity). For the common
+   * "rewind to a specific client's view" case use {@link lastSeenBy}.
+   *
+   * Re-aims and returns this Rewind's internal view by default — zero alloc,
+   * nothing to declare. Pass `out` to aim a view of your own instead; needed
+   * only to hold several views at once — see the {@link RewindView} doc.
+   */
+  at(time, out) {
+    return this._aim(time, 0, out);
+  }
+  /**
+   * Shared aiming: clamp the snapshot-timeline `time`, and resolve the reckon
+   * timeline either from the DIRECT `reckonStamp` (the instant the client's
+   * forward-reckoned entities were displayed at — exact, immune to the
+   * client's RTT-estimation error) or, when absent (0), by reconstruction.
+   */
+  _aim(time, reckonStamp, out) {
+    const newest = this._lastRecordedAt;
+    const oldest = newest - this.defaultMaxRewindMs;
+    const at = time <= 0 ? newest : time < oldest ? oldest : time > newest ? newest : time;
+    let reckonAt;
+    if (reckonStamp > 0) {
+      reckonAt = reckonStamp < oldest ? oldest : reckonStamp > newest ? newest : reckonStamp;
+    } else if (time <= 0) {
+      reckonAt = newest;
+    } else {
+      const anchor = this._nowOf !== void 0 ? this._nowOf() : newest;
+      const mid = (time + anchor) / 2;
+      reckonAt = mid < oldest ? oldest : mid > newest ? newest : mid;
+    }
+    return (out ?? this._view)._retarget(this, at, reckonAt);
+  }
+  /**
+   * A {@link RewindView} of the world as session `sessionId` LAST saw it —
+   * resolves the render time stamped on that client's most recently CONSUMED
+   * input (hence "last": under a multi-frame `drain()` it is the newest frame's
+   * stamp) and hands off to {@link at}. This is the "what you see is what you
+   * hit" path:
+   *
+   * ```ts
+   * const seen = this.rewind.lastSeenBy(shooterSessionId);
+   * const hit = overlaps(bullet, seen.value(target, "x"), seen.value(target, "y"));
+   * ```
+   *
+   * Requires the room's framework input (`this.defineInput(Input)`) — the
+   * per-client stamp auto-enables from the `attachAll` `mode` of the groups you
+   * rewind (declaration order vs `allowRewindState` doesn't matter). A client
+   * that merely hasn't stamped yet (clock still syncing, unknown sessionId) is
+   * NOT an error — it reads 0 and the view falls back to live. Use
+   * {@link at} with an explicit time if you stamp render times yourself.
+   *
+   * Re-aims and returns this Rewind's internal view by default — zero alloc,
+   * nothing to declare. Pass `out` to aim a view of your own instead; needed
+   * only to hold several views at once — see the {@link RewindView} doc.
+   */
+  lastSeenBy(sessionId, out) {
+    if (this._renderTimeOf === void 0) {
+      throw new Error(
+        "Rewind.lastSeenBy(sessionId) needs the framework input API. Declare `this.defineInput(Input)` (stamps auto-enable from your attachAll `mode`), or call `at(time)` and pass the render time yourself."
+      );
+    }
+    return this._aim(
+      this._renderTimeOf(sessionId),
+      this._reckonTimeOf !== void 0 ? this._reckonTimeOf(sessionId) : 0,
+      out
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Rewind,
+  RewindView
+});