twinwire 0.0.0-stage → 1.0.0

package/dist/browser/twinwire.mjs

@@ -0,0 +1,2052 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/budget.ts
+var TokenBucket = class {
+  constructor(rate, capacity, now) {
+    __publicField(this, "rate", rate);
+    __publicField(this, "capacity", capacity);
+    __publicField(this, "tokens");
+    __publicField(this, "at");
+    if (!(rate > 0) || !Number.isFinite(rate) || !(capacity > 0) || !Number.isFinite(capacity)) throw new RangeError("Invalid budget");
+    this.tokens = capacity;
+    this.at = now;
+  }
+  available(now) {
+    this.tokens = Math.min(this.capacity, this.tokens + Math.max(0, now - this.at) * this.rate / 1e3);
+    this.at = Math.max(this.at, now);
+    return this.tokens;
+  }
+  /** A message larger than the burst may go once the bucket is full; the debt then delays what follows. */
+  take(bytes, now) {
+    if (!Number.isFinite(bytes) || bytes < 0) throw new RangeError("Invalid byte count");
+    if (this.available(now) < Math.min(bytes, this.capacity)) return false;
+    this.tokens -= bytes;
+    return true;
+  }
+};
+
+// src/core/protocol.ts
+var VERSION = 3;
+var HEADER_BYTES = 22;
+var MTU_STATE_BYTES = 1100 - HEADER_BYTES;
+var MAX_FRAME_BYTES = 256 * 1024;
+var MAX_STATE_BYTES = MAX_FRAME_BYTES - HEADER_BYTES;
+var DEFAULT_STATE_BYTES = 64 * 1024;
+var MAX_CONTROL_BYTES = 128 * 1024;
+var MAGIC = 22356;
+var FrameKind = { state: 1, probe: 2, reply: 3, events: 4, sack: 5, stateAcked: 6 };
+var KINDS = new Set(Object.values(FrameKind));
+var isUint = (v, max = 4294967295) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= max;
+var empty = (k) => k === FrameKind.probe || k === FrameKind.reply;
+var streamed = (k) => k === FrameKind.state || k === FrameKind.stateAcked;
+function encodeFrame(f) {
+  if (!KINDS.has(f.kind) || !isUint(f.epoch) || !f.epoch || !isUint(f.stream, 65535) || !isUint(f.seq) || !Number.isFinite(f.time) || f.payload.length > MAX_STATE_BYTES || empty(f.kind) && f.payload.length !== 0 || !streamed(f.kind) && f.stream !== 0) throw new RangeError("Invalid frame");
+  const b = new Uint8Array(HEADER_BYTES + f.payload.length), v = new DataView(b.buffer);
+  v.setUint16(0, MAGIC, true);
+  v.setUint8(2, VERSION);
+  v.setUint8(3, f.kind);
+  v.setUint32(4, f.epoch, true);
+  v.setUint16(8, f.stream, true);
+  v.setUint32(10, f.seq, true);
+  v.setFloat64(14, f.time, true);
+  b.set(f.payload, HEADER_BYTES);
+  return b;
+}
+function decodeFrame(b, maxBytes = MAX_FRAME_BYTES) {
+  if (b.byteLength < HEADER_BYTES || b.byteLength > Math.min(maxBytes, MAX_FRAME_BYTES)) return null;
+  const v = new DataView(b.buffer, b.byteOffset, b.byteLength);
+  if (v.getUint16(0, true) !== MAGIC || v.getUint8(2) !== VERSION) return null;
+  const kind = v.getUint8(3), epoch = v.getUint32(4, true), time = v.getFloat64(14, true), stream = v.getUint16(8, true);
+  if (!KINDS.has(kind) || !epoch || !Number.isFinite(time) || empty(kind) && b.byteLength !== HEADER_BYTES || !streamed(kind) && stream !== 0) return null;
+  return { kind, epoch, stream, seq: v.getUint32(10, true), time, payload: b.slice(HEADER_BYTES) };
+}
+function newer(a, b) {
+  return a !== b && a - b >>> 0 < 2147483648;
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var utf8 = (s) => encoder.encode(s);
+var fromUtf8 = (b) => decoder.decode(b);
+function utf8Length(s) {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128) n += 1;
+    else if (c < 2048) n += 2;
+    else if (c >= 55296 && c <= 56319 && i + 1 < s.length) {
+      n += 4;
+      i++;
+    } else n += 3;
+  }
+  return n;
+}
+function readControl(raw, maxBytes = MAX_CONTROL_BYTES) {
+  if (raw.length > maxBytes || utf8Length(raw) > maxBytes) return null;
+  try {
+    const m = JSON.parse(raw);
+    return record(m) && typeof m.t === "string" ? m : null;
+  } catch {
+    return null;
+  }
+}
+function stringify(value, maxBytes = MAX_CONTROL_BYTES) {
+  const s = JSON.stringify(value);
+  if (s === void 0) throw new TypeError("Value is not JSON");
+  if (utf8Length(s) > maxBytes) throw new RangeError("Control frame too large");
+  return s;
+}
+
+// src/core/reliable.ts
+var ReliableEvents = class {
+  constructor(o = {}, maxBytes) {
+    __publicField(this, "next", 1);
+    __publicField(this, "received", 0);
+    __publicField(this, "acknowledged", 0);
+    __publicField(this, "highestSent", 0);
+    __publicField(this, "bytes", 0);
+    __publicField(this, "pending", /* @__PURE__ */ new Map());
+    __publicField(this, "early", /* @__PURE__ */ new Map());
+    __publicField(this, "maxEvents");
+    __publicField(this, "maxBytes");
+    __publicField(this, "maxEventBytes");
+    __publicField(this, "maxEarly");
+    const opts = typeof o === "number" ? { maxEvents: o, maxBytes } : o;
+    this.maxEvents = opts.maxEvents ?? 512;
+    this.maxBytes = opts.maxBytes ?? 1024 * 1024;
+    this.maxEventBytes = opts.maxEventBytes ?? 64 * 1024;
+    this.maxEarly = opts.maxEarly ?? 256;
+    if (![this.maxEvents, this.maxBytes, this.maxEventBytes, this.maxEarly].every((v) => Number.isInteger(v) && v > 0)) throw new RangeError("Invalid event limits");
+  }
+  push(data) {
+    const text = stringify(data, this.maxEventBytes), bytes = utf8Length(text) + 64;
+    if (bytes > this.maxEventBytes + 64) throw new RangeError("Event payload too large");
+    if (this.pending.size >= this.maxEvents || this.bytes + bytes > this.maxBytes) throw new Error("Reliable outbox full");
+    if (!Number.isSafeInteger(this.next + 1)) throw new Error("Reliable sequence exhausted");
+    const seq = this.next++;
+    this.pending.set(seq, { seq, data: JSON.parse(text), bytes, text, datagramAt: -Infinity, datagramTries: 0 });
+    this.bytes += bytes;
+    return seq;
+  }
+  get size() {
+    return this.pending.size;
+  }
+  get queuedBytes() {
+    return this.bytes;
+  }
+  get sentThrough() {
+    return this.highestSent;
+  }
+  entries() {
+    return this.pending.values();
+  }
+  sent(seq) {
+    this.highestSent = Math.max(this.highestSent, seq);
+  }
+  ack(seq) {
+    if (!Number.isSafeInteger(seq) || seq < 0 || seq > this.highestSent) throw new Error("Invalid event acknowledgement");
+    if (seq <= this.acknowledged) return false;
+    this.acknowledged = seq;
+    for (const [id, e] of this.pending) {
+      if (id > seq) break;
+      this.pending.delete(id);
+      this.bytes -= e.bytes;
+    }
+    return true;
+  }
+  /** Returns how many events were delivered. Early events wait (bounded); duplicates are dropped. */
+  receive(seq, data, deliver) {
+    if (!Number.isSafeInteger(seq) || seq < 1) throw new Error("Invalid event sequence");
+    if (seq <= this.received) return 0;
+    if (seq !== this.received + 1) {
+      if (seq - this.received > this.maxEarly) throw new Error("Event sequence gap");
+      if (!this.early.has(seq)) this.early.set(seq, data);
+      return 0;
+    }
+    deliver(data, seq);
+    this.received = seq;
+    let n = 1;
+    for (let s = seq + 1; this.early.has(s); s++) {
+      deliver(this.early.get(s), s);
+      this.early.delete(s);
+      this.received = s;
+      n++;
+    }
+    for (const s of this.early.keys()) if (s <= this.received) this.early.delete(s);
+    return n;
+  }
+  checkpoint() {
+    return {
+      next: this.next,
+      received: this.received,
+      acknowledged: this.acknowledged,
+      pending: Array.from(this.pending.values(), (e) => ({ seq: e.seq, data: structuredClone(e.data) }))
+    };
+  }
+  restore(s) {
+    if (this.next !== 1 || this.received || this.pending.size) throw new Error("Restore requires a fresh channel");
+    if (![s.next, s.received, s.acknowledged].every((v) => Number.isSafeInteger(v) && v >= 0) || s.next < 1 || s.acknowledged >= s.next || !Array.isArray(s.pending) || s.pending.length > this.maxEvents)
+      throw new Error("Invalid checkpoint");
+    if (s.pending.length !== s.next - s.acknowledged - 1) throw new Error("Incomplete checkpoint");
+    const saved = [];
+    let total = 0, expected = s.acknowledged + 1;
+    for (const e of s.pending) {
+      if (e.seq !== expected++) throw new Error("Invalid checkpoint sequence");
+      const text = stringify(e.data, this.maxEventBytes), bytes = utf8Length(text) + 64;
+      saved.push({ seq: e.seq, data: JSON.parse(text), bytes, text, datagramAt: -Infinity, datagramTries: 0 });
+      total += bytes;
+    }
+    if (total > this.maxBytes) throw new Error("Checkpoint exceeds outbox limit");
+    this.next = s.next;
+    this.received = s.received;
+    this.acknowledged = s.acknowledged;
+    this.highestSent = s.next - 1;
+    this.pending = new Map(saved.map((e) => [e.seq, e]));
+    this.bytes = total;
+  }
+};
+
+// src/core/endpoint.ts
+var DATAGRAM_EVENT_BYTES = 960;
+var Endpoint = class {
+  constructor(o = {}) {
+    __publicField(this, "events");
+    __publicField(this, "stats", {
+      bytesSent: 0,
+      bytesReceived: 0,
+      statesSent: 0,
+      statesReceived: 0,
+      stale: 0,
+      expired: 0,
+      coalesced: 0,
+      congested: 0,
+      invalid: 0,
+      fastTransitions: 0,
+      datagramRttMs: 0,
+      eventsViaDatagram: 0,
+      datagramEventFrames: 0,
+      stateAcksSent: 0,
+      stateAcksReceived: 0,
+      impairedDrops: 0
+    });
+    __publicField(this, "onState", () => {
+    });
+    __publicField(this, "onEvent", () => {
+    });
+    __publicField(this, "onFastDown", () => {
+    });
+    __publicField(this, "onFastChange", () => {
+    });
+    __publicField(this, "onEventAck", () => {
+    });
+    /** The peer has seen state `seq` on `stream` (only for states sent with `ack: true`). */
+    __publicField(this, "onStateAck", () => {
+    });
+    __publicField(this, "reliable");
+    __publicField(this, "datagram");
+    __publicField(this, "epoch", 0);
+    __publicField(this, "sequence", /* @__PURE__ */ new Map());
+    __publicField(this, "received", /* @__PURE__ */ new Map());
+    __publicField(this, "queued", /* @__PURE__ */ new Map());
+    __publicField(this, "acksOut", /* @__PURE__ */ new Map());
+    __publicField(this, "acksIn", /* @__PURE__ */ new Map());
+    __publicField(this, "lastAckSentAt", -Infinity);
+    __publicField(this, "lastEventSent", 0);
+    __publicField(this, "datagramAcked", 0);
+    __publicField(this, "ackDue", false);
+    __publicField(this, "lastProbe", -Infinity);
+    __publicField(this, "proofAt", -Infinity);
+    __publicField(this, "attachedAt", 0);
+    __publicField(this, "probes", /* @__PURE__ */ new Map());
+    __publicField(this, "probeSeq", 0);
+    __publicField(this, "fast", false);
+    __publicField(this, "now");
+    __publicField(this, "budget");
+    __publicField(this, "highWater");
+    __publicField(this, "maxStreams");
+    __publicField(this, "probeInterval");
+    __publicField(this, "probeTimeout");
+    __publicField(this, "maxStateBytes");
+    __publicField(this, "datagramStateBytes");
+    __publicField(this, "datagramEvents");
+    __publicField(this, "stateAckInterval");
+    __publicField(this, "impairment");
+    this.now = o.now ?? (() => performance.now());
+    const rate = o.bytesPerSecond ?? 32 * 1024;
+    this.budget = new TokenBucket(rate, o.burstBytes ?? Math.max(rate / 2, 16 * 1024), this.now());
+    this.highWater = o.maxBufferedBytes ?? 64 * 1024;
+    this.maxStreams = o.maxStreams ?? 1024;
+    this.probeInterval = o.probeIntervalMs ?? 250;
+    this.probeTimeout = o.probeTimeoutMs ?? 1500;
+    this.maxStateBytes = o.maxStateBytes ?? DEFAULT_STATE_BYTES;
+    this.datagramStateBytes = o.datagramStateBytes ?? 8 * 1024;
+    this.datagramEvents = o.datagramEvents ?? true;
+    this.stateAckInterval = o.stateAckIntervalMs ?? 50;
+    this.events = new ReliableEvents(o.events);
+    if (!(this.highWater > 0) || !isUint(this.maxStreams, 65536) || this.maxStreams < 1 || !(this.probeInterval >= 10) || !(this.probeTimeout >= this.probeInterval * 2) || !isUint(this.maxStateBytes, MAX_STATE_BYTES) || this.maxStateBytes < 1 || !(this.datagramStateBytes >= MTU_STATE_BYTES) || !(this.stateAckInterval >= 0)) throw new RangeError("Invalid endpoint limits");
+    if (o.impair) this.setImpairment(o.impair);
+  }
+  get active() {
+    return !!this.reliable?.open;
+  }
+  get fastActive() {
+    return this.fast && !!this.datagram?.open && this.now() - this.proofAt <= this.probeTimeout;
+  }
+  get pendingStates() {
+    return this.queued.size;
+  }
+  get connectionEpoch() {
+    return this.epoch;
+  }
+  get maxFrameBytes() {
+    return this.maxStateBytes + HEADER_BYTES;
+  }
+  /** Newest seq the peer reported for an acknowledged stream in this connection epoch. */
+  stateAck(stream) {
+    return this.acksIn.get(stream);
+  }
+  setImpairment(i) {
+    if (!i) {
+      this.impairment = void 0;
+      return;
+    }
+    const { lagMs = 0, jitterMs = 0, loss = 0, duplicate = 0 } = i;
+    if (![lagMs, jitterMs].every((v) => Number.isFinite(v) && v >= 0 && v <= 1e4) || ![loss, duplicate].every((v) => Number.isFinite(v) && v >= 0 && v <= 1)) throw new RangeError("Invalid impairment");
+    this.impairment = lagMs || jitterMs || loss || duplicate ? { lagMs, jitterMs, loss, duplicate } : void 0;
+  }
+  get impaired() {
+    return this.impairment && { ...this.impairment };
+  }
+  attach(epoch, reliable) {
+    if (!isUint(epoch) || !epoch) throw new Error("Invalid epoch");
+    this.detach();
+    this.epoch = epoch;
+    this.reliable = this.impairReliable(reliable);
+    this.ackDue = this.events.received > 0;
+    this.lastEventSent = this.events.acknowledged;
+    this.datagramAcked = 0;
+    this.sequence.clear();
+    this.received.clear();
+    this.acksOut.clear();
+    this.acksIn.clear();
+    for (const e of this.events.entries()) {
+      e.datagramAt = -Infinity;
+      e.datagramTries = 0;
+    }
+  }
+  detach() {
+    this.dropDatagram(false);
+    this.reliable = void 0;
+    this.queued.clear();
+  }
+  attachDatagram(link) {
+    this.dropDatagram(false);
+    this.datagram = this.impairDatagram(link);
+    this.attachedAt = this.now();
+    this.lastProbe = -Infinity;
+    this.proofAt = -Infinity;
+    this.probes.clear();
+  }
+  dropDatagram(notify = true) {
+    const d = this.datagram;
+    this.datagram = void 0;
+    this.proofAt = -Infinity;
+    this.probes.clear();
+    this.setFast(false);
+    try {
+      d?.close();
+    } catch {
+    }
+    if (d && notify) this.onFastDown();
+  }
+  setFast(next) {
+    if (next !== this.fast) {
+      this.fast = next;
+      this.stats.fastTransitions++;
+      this.onFastChange(next);
+    }
+  }
+  sendControl(m) {
+    const data = stringify(m), ws = this.reliable;
+    if (!ws?.open || ws.bufferedAmount > this.highWater) return false;
+    try {
+      if (!ws.send(data)) return false;
+    } catch {
+      return false;
+    }
+    this.stats.bytesSent += utf8Length(data);
+    return true;
+  }
+  sendEvent(data) {
+    const seq = this.events.push(data);
+    this.flush();
+    return seq;
+  }
+  /** Retains only the newest unsent payload per stream. Returns the state's seq (0 when offline).
+   * An accepted enqueue is not a delivery guarantee; use `ack: true` and onStateAck to learn what arrived. */
+  sendState(stream, data, time, o = {}) {
+    if (!this.active) return 0;
+    if (!isUint(stream, 65535) || !Number.isFinite(time) || data.length > this.maxStateBytes || !(o.ttlMs === void 0 || Number.isFinite(o.ttlMs) && o.ttlMs > 0) || !(o.priority === void 0 || Number.isFinite(o.priority) && o.priority >= 0)) throw new RangeError("Invalid state");
+    if (!this.sequence.has(stream) && this.sequence.size >= this.maxStreams) throw new Error("State stream limit");
+    const seq = (this.sequence.get(stream) ?? 0) + 1 >>> 0 || 1;
+    this.sequence.set(stream, seq);
+    const old = this.queued.get(stream);
+    if (old) this.stats.coalesced++;
+    const now = this.now();
+    this.queued.set(stream, {
+      frame: { kind: o.ack ? FrameKind.stateAcked : FrameKind.state, epoch: this.epoch, stream, seq, time, payload: data.slice() },
+      first: old?.first ?? now,
+      deadline: now + (o.ttlMs ?? 100),
+      priority: o.priority ?? 1
+    });
+    return seq;
+  }
+  receiveControl(m) {
+    if (m.e !== this.epoch || !this.active) return false;
+    if (m.t === "event") {
+      if (typeof m.s !== "number" || !("d" in m)) throw new Error("Invalid event");
+      this.events.receive(m.s, m.d, this.onEvent);
+      this.ackDue = !this.sendControl({ t: "ack", e: this.epoch, s: this.events.received });
+      return true;
+    }
+    if (m.t === "ack") {
+      if (typeof m.s !== "number") throw new Error("Invalid acknowledgement");
+      if (this.events.ack(m.s)) this.onEventAck(m.s);
+      return true;
+    }
+    return false;
+  }
+  receiveBinary(bytes, via) {
+    this.stats.bytesReceived += bytes.length;
+    if (!this.active) return;
+    const f = decodeFrame(bytes, this.maxFrameBytes);
+    if (!f) {
+      this.stats.invalid++;
+      return;
+    }
+    if (f.epoch !== this.epoch || via === "rtc" && !this.datagram) {
+      this.stats.stale++;
+      return;
+    }
+    switch (f.kind) {
+      case FrameKind.probe:
+        if (via === "rtc") this.sendFast(encodeFrame({ ...f, kind: FrameKind.reply }));
+        return;
+      case FrameKind.reply: {
+        if (via !== "rtc") return;
+        const sent = this.probes.get(f.seq);
+        if (sent === void 0 || sent !== f.time) return;
+        this.probes.delete(f.seq);
+        const rtt = this.now() - sent;
+        if (rtt < 0 || rtt > this.probeTimeout) return;
+        this.proofAt = this.now();
+        this.stats.datagramRttMs = rtt;
+        this.setFast(true);
+        return;
+      }
+      case FrameKind.events:
+        return this.receiveDatagramEvents(f);
+      case FrameKind.sack:
+        return this.receiveStateAcks(f);
+    }
+    const prior = this.received.get(f.stream);
+    if (prior !== void 0 && !newer(f.seq, prior)) {
+      this.stats.stale++;
+      return;
+    }
+    if (prior === void 0 && this.received.size >= this.maxStreams) {
+      this.stats.invalid++;
+      return;
+    }
+    this.received.set(f.stream, f.seq);
+    this.stats.statesReceived++;
+    if (f.kind === FrameKind.stateAcked) this.acksOut.set(f.stream, f.seq);
+    this.onState({ stream: f.stream, seq: f.seq, time: f.time, data: f.payload, via });
+  }
+  receiveDatagramEvents(f) {
+    if (f.seq <= this.events.sentThrough && this.events.ack(f.seq)) this.onEventAck(f.seq);
+    if (!f.payload.length) return;
+    let list;
+    try {
+      list = JSON.parse(fromUtf8(f.payload));
+    } catch {
+      this.stats.invalid++;
+      return;
+    }
+    if (!Array.isArray(list) || list.length > 64) {
+      this.stats.invalid++;
+      return;
+    }
+    let delivered = 0;
+    for (const item of list) {
+      if (!Array.isArray(item) || item.length !== 2 || !Number.isSafeInteger(item[0])) {
+        this.stats.invalid++;
+        return;
+      }
+      try {
+        delivered += this.events.receive(item[0], item[1], this.onEvent);
+      } catch {
+        this.stats.invalid++;
+        return;
+      }
+    }
+    if (delivered) {
+      this.stats.eventsViaDatagram += delivered;
+      this.ackDue = true;
+    }
+  }
+  receiveStateAcks(f) {
+    const p = f.payload;
+    if (p.length % 6) {
+      this.stats.invalid++;
+      return;
+    }
+    const v = new DataView(p.buffer, p.byteOffset, p.byteLength);
+    for (let at = 0; at < p.length; at += 6) {
+      const stream = v.getUint16(at, true), seq = v.getUint32(at + 2, true), sent = this.sequence.get(stream);
+      if (sent === void 0 || newer(seq, sent)) continue;
+      const prior = this.acksIn.get(stream);
+      if (prior !== void 0 && !newer(seq, prior)) continue;
+      this.acksIn.set(stream, seq);
+      this.stats.stateAcksReceived++;
+      this.onStateAck(stream, seq);
+    }
+  }
+  sendFast(b) {
+    const d = this.datagram;
+    if (!d?.open || d.bufferedAmount > this.highWater) return false;
+    try {
+      if (!d.send(b)) return false;
+    } catch {
+      return false;
+    }
+    this.stats.bytesSent += b.length;
+    return true;
+  }
+  /** Binary on the datagram path when it is proven, else the WebSocket. */
+  sendBinary(b, preferFast) {
+    const ws = this.reliable;
+    if (preferFast && this.fastActive && this.datagram && this.datagram.bufferedAmount <= this.highWater) return this.sendFast(b);
+    if (!ws?.open || ws.bufferedAmount > this.highWater) return false;
+    try {
+      if (!ws.send(b)) return false;
+    } catch {
+      return false;
+    }
+    this.stats.bytesSent += b.length;
+    return true;
+  }
+  pump() {
+    const now = this.now(), d = this.datagram;
+    if (d) {
+      if (!d.open && now - this.attachedAt > this.probeTimeout || this.fast && now - this.proofAt > this.probeTimeout || !this.fast && now - this.attachedAt > this.probeTimeout * 2) this.dropDatagram();
+      else if (d.open && now - this.lastProbe >= this.probeInterval) {
+        this.lastProbe = now;
+        const seq = this.probeSeq = this.probeSeq + 1 >>> 0;
+        this.probes.set(seq, now);
+        for (const [s, at] of this.probes) if (now - at > this.probeTimeout) this.probes.delete(s);
+        this.sendFast(encodeFrame({ kind: FrameKind.probe, epoch: this.epoch, stream: 0, seq, time: now, payload: new Uint8Array() }));
+      }
+    }
+    this.flush();
+  }
+  flush(maxPackets = 8) {
+    const ws = this.reliable, now = this.now();
+    if (!ws?.open) return;
+    if (this.ackDue) this.ackDue = !this.sendControl({ t: "ack", e: this.epoch, s: this.events.received });
+    for (const e of this.events.entries()) {
+      if (e.seq <= this.lastEventSent) continue;
+      const encoded = `{"t":"event","e":${this.epoch},"s":${e.seq},"d":${e.text}}`;
+      const size = utf8Length(encoded);
+      if (ws.bufferedAmount > this.highWater || !this.budget.take(size, now)) break;
+      try {
+        if (!ws.send(encoded)) break;
+      } catch {
+        break;
+      }
+      this.events.sent(e.seq);
+      this.lastEventSent = e.seq;
+      this.stats.bytesSent += size;
+    }
+    if (this.fastActive) this.flushDatagramEvents(now);
+    if (this.acksOut.size && now - this.lastAckSentAt >= this.stateAckInterval) this.flushStateAcks(now);
+    for (const [id, q] of this.queued) if (q.deadline <= now) {
+      this.queued.delete(id);
+      this.stats.expired++;
+    }
+    if (!this.queued.size) return;
+    const queue = [...this.queued.values()].sort((a, b) => b.priority + (now - b.first) / 100 - (a.priority + (now - a.first) / 100));
+    let count = 0;
+    for (const q of queue) {
+      if (count++ >= maxPackets) break;
+      const b = encodeFrame(q.frame);
+      if (!this.budget.take(b.length, now)) break;
+      if (!this.sendBinary(b, q.frame.payload.length <= this.datagramStateBytes)) {
+        this.stats.congested++;
+        break;
+      }
+      this.stats.statesSent++;
+      this.queued.delete(q.frame.stream);
+    }
+  }
+  /** Copies of WebSocket-sent, unacknowledged events, retried on the datagram path for UDP-like latency. */
+  flushDatagramEvents(now) {
+    const retry = Math.max(40, Math.min(200, this.stats.datagramRttMs * 1.5 + 10));
+    const items = [];
+    let bytes = 2;
+    if (this.datagramEvents) for (const e of this.events.entries()) {
+      if (e.seq > this.lastEventSent) break;
+      if (e.datagramTries >= 6 || now - e.datagramAt < retry || e.bytes - 64 > DATAGRAM_EVENT_BYTES) continue;
+      const item = `[${e.seq},${e.text}]`, size = utf8Length(item) + 1;
+      if (bytes + size > DATAGRAM_EVENT_BYTES || items.length >= 64) break;
+      items.push(item);
+      bytes += size;
+      e.datagramAt = now;
+      e.datagramTries++;
+    }
+    const ackChanged = this.events.received !== this.datagramAcked;
+    if (!items.length && !ackChanged) return;
+    const payload = utf8("[" + items.join(",") + "]");
+    if (this.sendFast(encodeFrame({ kind: FrameKind.events, epoch: this.epoch, stream: 0, seq: this.events.received >>> 0, time: now, payload }))) {
+      this.datagramAcked = this.events.received;
+      this.stats.datagramEventFrames++;
+    }
+  }
+  flushStateAcks(now) {
+    const pairs = [...this.acksOut].slice(0, 150), p = new Uint8Array(pairs.length * 6), v = new DataView(p.buffer);
+    pairs.forEach(([stream, seq], i) => {
+      v.setUint16(i * 6, stream, true);
+      v.setUint32(i * 6 + 2, seq, true);
+    });
+    if (this.sendBinary(encodeFrame({ kind: FrameKind.sack, epoch: this.epoch, stream: 0, seq: 0, time: now, payload: p }), true)) {
+      for (const [stream, seq] of pairs) if (this.acksOut.get(stream) === seq) this.acksOut.delete(stream);
+      this.lastAckSentAt = now;
+      this.stats.stateAcksSent++;
+    }
+  }
+  /** Delays a stream-like link without ever reordering it: one queue, one timer. */
+  impairReliable(link) {
+    let tail = 0, timer;
+    const queue = [];
+    const drain = () => {
+      timer = void 0;
+      const t = performance.now();
+      while (queue.length && queue[0].at <= t + 1) {
+        const { data } = queue.shift();
+        if (link.open) try {
+          link.send(data);
+        } catch {
+        }
+      }
+      if (queue.length) timer = setTimeout(drain, queue[0].at - t);
+    };
+    const self = this;
+    return {
+      get open() {
+        return link.open;
+      },
+      get bufferedAmount() {
+        return link.bufferedAmount;
+      },
+      close: () => {
+        queue.length = 0;
+        clearTimeout(timer);
+        timer = void 0;
+        link.close();
+      },
+      send(data) {
+        const i = self.impairment;
+        if (!i && !queue.length) return link.send(data);
+        if (!link.open) return false;
+        const t = performance.now(), at = Math.max(tail, t + (i?.lagMs ?? 0) + Math.random() * (i?.jitterMs ?? 0));
+        tail = at;
+        queue.push({ at, data: typeof data === "string" ? data : data.slice() });
+        if (!timer) timer = setTimeout(drain, at - t);
+        return true;
+      }
+    };
+  }
+  impairDatagram(link) {
+    const self = this;
+    return {
+      get open() {
+        return link.open;
+      },
+      get bufferedAmount() {
+        return link.bufferedAmount;
+      },
+      close: () => link.close(),
+      send(data) {
+        const i = self.impairment;
+        if (!i) return link.send(data);
+        if (!link.open) return false;
+        const copies = Math.random() < i.loss ? 0 : Math.random() < i.duplicate ? 2 : 1;
+        if (!copies) self.stats.impairedDrops++;
+        for (let n = 0; n < copies; n++) {
+          const copy = data.slice();
+          setTimeout(() => {
+            if (link.open) try {
+              link.send(copy);
+            } catch {
+            }
+          }, i.lagMs + Math.random() * i.jitterMs);
+        }
+        return true;
+      }
+    };
+  }
+};
+
+// src/core/rtc.ts
+function validSignal(m) {
+  if (!m || typeof m !== "object") return false;
+  const v = m;
+  if (v.kind === "offer" || v.kind === "answer") return typeof v.sdp === "string" && v.sdp.length > 0 && v.sdp.length <= 12e3;
+  return v.kind === "candidate" && typeof v.candidate === "string" && v.candidate.length <= 1500 && typeof v.mid === "string" && v.mid.length <= 128;
+}
+var ICE_URL = /^(stuns?|turns?):[^\s]{1,250}$/;
+function validIceServers(v) {
+  return Array.isArray(v) && v.length <= 8 && v.every((s) => {
+    if (!s || typeof s !== "object") return false;
+    const o = s, urls = Array.isArray(o.urls) ? o.urls : [o.urls];
+    return urls.length >= 1 && urls.length <= 8 && urls.every((u) => typeof u === "string" && ICE_URL.test(u)) && (o.username === void 0 || typeof o.username === "string" && o.username.length <= 256) && (o.credential === void 0 || typeof o.credential === "string" && o.credential.length <= 256);
+  });
+}
+
+// src/netcode/clock.ts
+var NetworkClock = class {
+  constructor() {
+    __publicField(this, "samples", []);
+    __publicField(this, "offset", 0);
+    __publicField(this, "target", 0);
+    __publicField(this, "initialized", false);
+    __publicField(this, "last", -Infinity);
+    __publicField(this, "rttMs", 0);
+    __publicField(this, "uncertaintyMs", Infinity);
+  }
+  get synced() {
+    return this.initialized;
+  }
+  reset() {
+    this.samples = [];
+    this.offset = this.target = 0;
+    this.initialized = false;
+    this.last = -Infinity;
+    this.uncertaintyMs = Infinity;
+  }
+  observe(sent, received, remoteTime) {
+    const rtt = received - sent;
+    if (![sent, received, remoteTime].every(Number.isFinite) || rtt < 0 || rtt > 15e3) return false;
+    this.samples.push({ rtt, offset: remoteTime - (sent + received) / 2 });
+    if (this.samples.length > 16) this.samples.shift();
+    const best = [...this.samples].sort((a, b) => a.rtt - b.rtt).slice(0, 3);
+    this.target = best.reduce((sum, s) => sum + s.offset, 0) / best.length;
+    this.rttMs = best[0].rtt;
+    this.uncertaintyMs = Math.max(...best.map((s) => Math.abs(s.offset - this.target) + s.rtt / 2));
+    if (!this.initialized) {
+      this.offset = this.target;
+      this.initialized = true;
+    }
+    return true;
+  }
+  advance(dtMs) {
+    if (!Number.isFinite(dtMs) || dtMs < 0) throw new RangeError("Invalid time step");
+    const max = dtMs * 0.05;
+    this.offset += Math.max(-max, Math.min(max, this.target - this.offset));
+  }
+  serverTime(localTime) {
+    this.last = Math.max(this.last, localTime + this.offset);
+    return this.last;
+  }
+};
+
+// src/client/rtc.ts
+var BrowserRtcPeer = class {
+  constructor(cb, config = { iceServers: [] }) {
+    __publicField(this, "cb", cb);
+    __publicField(this, "pc");
+    __publicField(this, "dc");
+    __publicField(this, "alive", true);
+    __publicField(this, "offered", false);
+    __publicField(this, "remoteReady", false);
+    __publicField(this, "localCandidates", []);
+    __publicField(this, "remoteCandidates", []);
+    __publicField(this, "chain", Promise.resolve());
+    this.pc = new RTCPeerConnection(config);
+    this.dc = this.pc.createDataChannel("twinwire", { negotiated: true, id: 0, ordered: false, maxRetransmits: 0 });
+    const pc = this.pc, dc = this.dc;
+    dc.binaryType = "arraybuffer";
+    dc.onopen = () => {
+      if (this.alive) cb.open({
+        get open() {
+          return dc.readyState === "open";
+        },
+        get bufferedAmount() {
+          return dc.bufferedAmount;
+        },
+        send(bytes) {
+          if (dc.readyState !== "open") return false;
+          dc.send(bytes.slice().buffer);
+          return true;
+        },
+        close: () => this.close()
+      });
+    };
+    dc.onmessage = (e) => {
+      if (this.alive && e.data instanceof ArrayBuffer) cb.data(new Uint8Array(e.data));
+    };
+    dc.onclose = () => {
+      if (this.alive) {
+        this.close();
+        cb.closed();
+      }
+    };
+    dc.onerror = () => {
+      if (this.alive) cb.error(new Error("RTC data channel error"));
+    };
+    pc.onconnectionstatechange = () => {
+      if (this.alive && pc.connectionState === "failed") {
+        this.close();
+        cb.closed();
+      }
+    };
+    pc.onicecandidate = (e) => {
+      if (!this.alive || !e.candidate?.candidate) return;
+      const m = { kind: "candidate", candidate: e.candidate.candidate, mid: e.candidate.sdpMid ?? "0" };
+      if (this.offered) cb.signal(m);
+      else if (this.localCandidates.length < 64) this.localCandidates.push(m);
+    };
+  }
+  async offer() {
+    await this.pc.setLocalDescription(await this.pc.createOffer());
+    if (!this.alive) return;
+    this.cb.signal({ kind: "offer", sdp: this.pc.localDescription.sdp });
+    this.offered = true;
+    for (const c of this.localCandidates) this.cb.signal(c);
+    this.localCandidates = [];
+  }
+  signal(message) {
+    this.chain = this.chain.then(async () => {
+      if (!this.alive || !validSignal(message)) return;
+      if (message.kind === "answer") {
+        await this.pc.setRemoteDescription({ type: "answer", sdp: message.sdp });
+        if (!this.alive) return;
+        this.remoteReady = true;
+        for (const c of this.remoteCandidates) await this.pc.addIceCandidate(c);
+        this.remoteCandidates = [];
+      } else if (message.kind === "candidate") {
+        const c = { candidate: message.candidate, sdpMid: message.mid };
+        if (this.remoteReady) await this.pc.addIceCandidate(c);
+        else {
+          if (this.remoteCandidates.length >= 64) throw new Error("Too many ICE candidates");
+          this.remoteCandidates.push(c);
+        }
+      }
+    }).catch((e) => {
+      if (this.alive) this.cb.error(e instanceof Error ? e : new Error(String(e)));
+    });
+    return this.chain;
+  }
+  close() {
+    if (!this.alive) return;
+    this.alive = false;
+    this.localCandidates = [];
+    this.remoteCandidates = [];
+    this.dc.onopen = this.dc.onmessage = this.dc.onclose = this.dc.onerror = null;
+    this.pc.onicecandidate = this.pc.onconnectionstatechange = null;
+    try {
+      this.dc.close();
+      this.pc.close();
+    } catch {
+    }
+  }
+};
+
+// src/client/client.ts
+var GameClient = class {
+  constructor(options) {
+    __publicField(this, "options", options);
+    __publicField(this, "endpoint");
+    __publicField(this, "clock", new NetworkClock());
+    __publicField(this, "status", "idle");
+    __publicField(this, "id", null);
+    /** ICE servers suggested by the room server (STUN/TURN), used unless options.rtc names its own. */
+    __publicField(this, "iceServers", []);
+    __publicField(this, "onStatus", () => {
+    });
+    __publicField(this, "onSession", () => {
+    });
+    __publicField(this, "onSessionLost", () => {
+    });
+    __publicField(this, "onState", () => {
+    });
+    __publicField(this, "onEvent", () => {
+    });
+    __publicField(this, "onStateAck", () => {
+    });
+    __publicField(this, "onTransport", () => {
+    });
+    __publicField(this, "onError", () => {
+    });
+    __publicField(this, "token", null);
+    __publicField(this, "socket");
+    __publicField(this, "generation", 0);
+    __publicField(this, "epoch", 0);
+    __publicField(this, "peer");
+    __publicField(this, "rtcAttempt", 0);
+    __publicField(this, "rtcStartedAt", 0);
+    __publicField(this, "rtcRetryAt", Infinity);
+    __publicField(this, "rtcFailures", 0);
+    __publicField(this, "reconnects", 0);
+    __publicField(this, "retryTimer");
+    __publicField(this, "pumpTimer");
+    __publicField(this, "lastPump", 0);
+    __publicField(this, "lastPing", -Infinity);
+    __publicField(this, "lastMessage", 0);
+    __publicField(this, "openedAt", 0);
+    __publicField(this, "wakeDeadline", Infinity);
+    __publicField(this, "pendingPings", /* @__PURE__ */ new Map());
+    __publicField(this, "pingId", 0);
+    __publicField(this, "stopped", true);
+    __publicField(this, "serverRtc", false);
+    __publicField(this, "lastTransport", "none");
+    __publicField(this, "waiters", []);
+    __publicField(this, "lifecycle");
+    __publicField(this, "interceptors", []);
+    __publicField(this, "listeners", { session: [], lost: [] });
+    const u = new URL(options.url);
+    if (!["ws:", "wss:"].includes(u.protocol) || !/^[\w:.-]{1,64}$/.test(options.room)) throw new Error("Invalid URL or room");
+    this.endpoint = this.makeEndpoint();
+    const cp = options.checkpoint;
+    if (cp) {
+      if (cp.url !== options.url || cp.room !== options.room || !/^[\w-]{20,128}$/.test(cp.token) || typeof cp.id !== "string")
+        throw new Error("Checkpoint belongs to a different endpoint or is invalid");
+      this.endpoint.events.restore(cp.events);
+      this.token = cp.token;
+      this.id = cp.id;
+    }
+  }
+  makeEndpoint() {
+    const e = new Endpoint({ ...this.options.endpoint, impair: this.options.impair ?? this.options.endpoint?.impair });
+    e.onState = (s) => this.onState(s);
+    e.onEvent = (d, s) => {
+      for (const f of this.interceptors) if (f(d, s)) return;
+      this.onEvent(d, s);
+    };
+    e.onStateAck = (stream, seq) => this.onStateAck(stream, seq);
+    e.onFastDown = () => this.stopRtc(true);
+    e.onFastChange = () => this.noteTransport();
+    return e;
+  }
+  /** Consume some events before onEvent sees them (return true to consume). Used by LobbyClient. Returns removal. */
+  intercept(fn) {
+    this.interceptors.push(fn);
+    return () => {
+      const i = this.interceptors.indexOf(fn);
+      if (i >= 0) this.interceptors.splice(i, 1);
+    };
+  }
+  /** Extra listeners next to onSession/onSessionLost. Returns removal. */
+  on(kind, fn) {
+    const list = this.listeners[kind];
+    list.push(fn);
+    return () => {
+      const i = list.indexOf(fn);
+      if (i >= 0) list.splice(i, 1);
+    };
+  }
+  lost(info) {
+    for (const f of this.listeners.lost) try {
+      f(info);
+    } catch (e) {
+      this.report(e);
+    }
+    this.onSessionLost(info);
+  }
+  /** Which path state messages take right now. */
+  get transport() {
+    return this.status !== "online" ? "none" : this.endpoint.fastActive ? "rtc" : "ws";
+  }
+  noteTransport() {
+    const t = this.transport;
+    if (t !== this.lastTransport) {
+      this.lastTransport = t;
+      try {
+        this.onTransport(t);
+      } catch (e) {
+        this.report(e);
+      }
+    }
+  }
+  report(error) {
+    this.onError(error instanceof Error ? error : new Error(String(error)));
+  }
+  setStatus(s) {
+    if (s === this.status) return;
+    this.status = s;
+    this.onStatus(s);
+    this.noteTransport();
+    if (s === "online") for (const w of this.waiters.splice(0)) w.resolve();
+    else if (s === "lost" || s === "closed") for (const w of this.waiters.splice(0)) w.reject(new Error(`Session ${s}`));
+  }
+  /** Resolves when the session is online (at once if it already is); rejects if it is lost or closed first. */
+  whenOnline() {
+    if (this.status === "online") return Promise.resolve();
+    if (this.status === "lost" || this.status === "closed") return Promise.reject(new Error(`Session ${this.status}`));
+    return new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+  }
+  connect() {
+    if (this.status === "online" || this.status === "connecting") return;
+    if (this.status === "lost") throw new Error("Call newSession() after session expiry");
+    this.stopped = false;
+    this.setStatus("connecting");
+    clearInterval(this.pumpTimer);
+    this.lastPump = performance.now();
+    this.pumpTimer = setInterval(() => this.pump(), 1e3 / (this.options.pumpHz ?? 60));
+    this.open();
+  }
+  open() {
+    if (this.stopped) return;
+    clearTimeout(this.retryTimer);
+    this.retryTimer = void 0;
+    const generation = ++this.generation;
+    const now = performance.now();
+    this.openedAt = this.lastMessage = now;
+    let ws;
+    try {
+      ws = (this.options.websocket ?? ((u) => new WebSocket(u)))(this.options.url);
+    } catch (error) {
+      this.report(error);
+      this.retry();
+      return;
+    }
+    this.socket = ws;
+    ws.binaryType = "arraybuffer";
+    ws.onopen = () => {
+      if (generation !== this.generation || this.stopped) {
+        ws.close();
+        return;
+      }
+      ws.send(stringify({
+        t: "hello",
+        v: VERSION,
+        room: this.options.room,
+        token: this.token,
+        auth: this.options.auth ?? null,
+        impair: this.options.impair ?? null
+      }));
+    };
+    ws.onmessage = (ev) => {
+      if (generation !== this.generation || this.stopped) return;
+      this.lastMessage = performance.now();
+      this.wakeDeadline = Infinity;
+      try {
+        if (ev.data instanceof ArrayBuffer) this.endpoint.receiveBinary(new Uint8Array(ev.data), "ws");
+        else if (typeof ev.data === "string") this.message(ev.data, ws);
+      } catch (error) {
+        this.report(error);
+        ws.close(4004, "protocol");
+      }
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = (ev) => {
+      if (generation !== this.generation) return;
+      this.socket = void 0;
+      this.endpoint.detach();
+      this.stopRtc(false);
+      this.clock.reset();
+      this.pendingPings.clear();
+      if (!this.stopped) {
+        if ([1002, 1008, 4001, 4002, 4004].includes(ev.code)) {
+          this.stopped = true;
+          clearInterval(this.pumpTimer);
+          clearTimeout(this.retryTimer);
+          this.setStatus("lost");
+          this.lost({ pendingEvents: this.endpoint.events.size, reason: ev.reason || `connection rejected (${ev.code})` });
+        } else {
+          this.setStatus("connecting");
+          this.retry();
+        }
+      }
+    };
+  }
+  message(raw, ws) {
+    this.endpoint.stats.bytesReceived += utf8Length(raw);
+    const m = readControl(raw);
+    if (!m) throw new Error("Invalid control message");
+    if (m.t === "reset") {
+      this.stopped = true;
+      clearInterval(this.pumpTimer);
+      clearTimeout(this.retryTimer);
+      this.stopRtc(false);
+      this.endpoint.detach();
+      ws.close();
+      this.setStatus("lost");
+      this.lost({ pendingEvents: this.endpoint.events.size, reason: typeof m.reason === "string" ? m.reason : "expired" });
+      return;
+    }
+    if (m.t === "welcome") {
+      if (this.status !== "connecting" || !isUint(m.e) || !m.e || typeof m.id !== "string" || typeof m.token !== "string" || !/^[\w-]{20,128}$/.test(m.token) || typeof m.resumed !== "boolean" || m.v !== VERSION)
+        throw new Error("Invalid welcome");
+      this.token = m.token;
+      this.id = m.id;
+      this.epoch = m.e;
+      this.reconnects = 0;
+      this.serverRtc = m.rtc === true;
+      this.iceServers = validIceServers(m.ice) ? m.ice : [];
+      this.endpoint.attach(this.epoch, {
+        get open() {
+          return ws.readyState === 1;
+        },
+        get bufferedAmount() {
+          return ws.bufferedAmount;
+        },
+        send(data) {
+          if (ws.readyState !== 1) return false;
+          ws.send(typeof data === "string" ? data : data.slice().buffer);
+          return true;
+        },
+        close() {
+          ws.close();
+        }
+      });
+      this.lastPing = -Infinity;
+      this.clock.reset();
+      this.setStatus("online");
+      const info = { id: this.id, resumed: m.resumed };
+      for (const f of this.listeners.session) try {
+        f(info);
+      } catch (e) {
+        this.report(e);
+      }
+      this.onSession(info);
+      this.rtcFailures = 0;
+      this.rtcRetryAt = performance.now();
+      this.pump();
+      return;
+    }
+    if (m.e !== this.epoch || this.status !== "online") return;
+    if (this.endpoint.receiveControl(m)) return;
+    if (m.t === "pong" && isUint(m.n) && typeof m.s === "number" && Number.isFinite(m.s)) {
+      const at = this.pendingPings.get(m.n);
+      if (at === void 0) return;
+      this.pendingPings.delete(m.n);
+      this.clock.observe(at, performance.now(), m.s);
+      return;
+    }
+    if (m.t === "signal" && m.a === this.rtcAttempt && validSignal(m.d)) {
+      void this.peer?.signal(m.d);
+      return;
+    }
+    if (m.t === "rtc-reset" && m.a === this.rtcAttempt) this.stopRtc(false);
+  }
+  retry() {
+    if (this.stopped) return;
+    clearTimeout(this.retryTimer);
+    const cap = Math.min(this.options.reconnectMaxMs ?? 8e3, (this.options.reconnectBaseMs ?? 200) * 2 ** Math.min(this.reconnects++, 8));
+    this.retryTimer = setTimeout(() => this.open(), cap * (0.5 + Math.random() / 2));
+  }
+  /** Testing: drop the connection as a network failure would (the session resumes by itself). */
+  simulateDrop() {
+    this.socket?.close(4e3, "simulated drop");
+  }
+  /** Skip the backoff wait (the network just came back, the page woke up). */
+  reconnectNow() {
+    if (this.stopped || this.status === "online") return;
+    this.reconnects = 0;
+    if (this.retryTimer !== void 0 || !this.socket) this.open();
+  }
+  rtcConfig() {
+    const own = this.options.rtc || void 0;
+    return own?.iceServers ? own : { ...own, iceServers: this.iceServers };
+  }
+  startRtc() {
+    if (!this.serverRtc || this.peer || this.options.rtc === false || typeof RTCPeerConnection === "undefined" || this.status !== "online") return;
+    const a = ++this.rtcAttempt, e = this.epoch;
+    this.rtcStartedAt = performance.now();
+    this.rtcRetryAt = Infinity;
+    try {
+      const peer = new BrowserRtcPeer({
+        signal: (d) => {
+          if (a === this.rtcAttempt && e === this.epoch) this.endpoint.sendControl({ t: "signal", e, a, d });
+        },
+        open: (link) => {
+          if (a === this.rtcAttempt && e === this.epoch && !this.stopped) this.endpoint.attachDatagram(link);
+          else link.close();
+        },
+        data: (data) => {
+          if (a === this.rtcAttempt && e === this.epoch) this.endpoint.receiveBinary(data, "rtc");
+        },
+        closed: () => {
+          if (a === this.rtcAttempt && e === this.epoch) this.stopRtc(true);
+        },
+        error: (error) => {
+          if (a === this.rtcAttempt && e === this.epoch) {
+            this.report(error);
+            this.stopRtc(true);
+          }
+        }
+      }, this.rtcConfig());
+      this.peer = peer;
+      void peer.offer().catch((error) => {
+        if (this.peer === peer) {
+          this.report(error);
+          this.stopRtc(true);
+        }
+      });
+    } catch (error) {
+      this.report(error);
+      this.stopRtc(true);
+    }
+  }
+  stopRtc(notify) {
+    const a = this.rtcAttempt, peer = this.peer;
+    this.peer = void 0;
+    if (notify && peer) this.endpoint.sendControl({ t: "rtc-reset", e: this.epoch, a });
+    this.endpoint.dropDatagram(false);
+    peer?.close();
+    this.rtcRetryAt = performance.now() + Math.min(6e4, (this.options.rtcRetryMs ?? 3e3) * 2 ** Math.min(this.rtcFailures++, 4));
+    this.noteTransport();
+  }
+  pump() {
+    if (this.stopped) return;
+    const now = performance.now();
+    this.clock.advance(Math.max(0, now - this.lastPump));
+    this.lastPump = now;
+    if (this.status === "online") {
+      if (now - this.lastMessage > (this.options.heartbeatTimeoutMs ?? 8e3) || now > this.wakeDeadline) {
+        this.wakeDeadline = Infinity;
+        this.socket?.close(4e3, "heartbeat timeout");
+        return;
+      }
+      if (now - this.lastPing >= (this.pendingPings.size < 4 && this.clock.uncertaintyMs === Infinity ? 200 : 1e3)) this.ping(now);
+      if (this.peer && now - this.rtcStartedAt > (this.options.rtcConnectTimeoutMs ?? 8e3) && !this.endpoint.fastActive) this.stopRtc(true);
+      if (!this.peer && now >= this.rtcRetryAt) this.startRtc();
+      this.endpoint.pump();
+      this.noteTransport();
+    } else if (this.socket && now - this.openedAt > 1e4) {
+      this.socket.close(4e3, "handshake timeout");
+    }
+  }
+  ping(now) {
+    const n = this.pingId = this.pingId + 1 >>> 0;
+    if (this.endpoint.sendControl({ t: "ping", e: this.epoch, n })) {
+      this.pendingPings.set(n, now);
+      this.lastPing = now;
+    }
+    for (const [id, at] of this.pendingPings) if (now - at > 1e4) this.pendingPings.delete(id);
+  }
+  sendEvent(data) {
+    return this.endpoint.sendEvent(data);
+  }
+  /** Queue the newest state for a stream. Returns its seq, or 0 before the session is online and the clock synced. */
+  sendState(stream, data, options) {
+    if (!this.clock.synced) return 0;
+    return this.endpoint.sendState(stream, data, this.clock.serverTime(performance.now()), options);
+  }
+  flush() {
+    this.endpoint.flush();
+  }
+  /** Stop the physical connection, retaining event counters and resume credentials in this instance. */
+  pause() {
+    this.stopped = true;
+    ++this.generation;
+    clearTimeout(this.retryTimer);
+    clearInterval(this.pumpTimer);
+    this.stopRtc(false);
+    this.endpoint.detach();
+    this.socket?.close(4003, "paused");
+    this.socket = void 0;
+    this.setStatus("paused");
+  }
+  resume() {
+    if (this.status === "paused") this.connect();
+  }
+  /** Explicitly discard the old logical session after expiry. Pending actions are NOT replayed into a new session. */
+  newSession() {
+    this.pause();
+    this.endpoint = this.makeEndpoint();
+    this.token = this.id = null;
+    this.epoch = 0;
+    this.connect();
+  }
+  close() {
+    if (this.status === "closed") return;
+    try {
+      this.endpoint.sendControl({ t: "leave", e: this.epoch });
+    } catch {
+    }
+    this.pause();
+    this.lifecycle?.();
+    this.lifecycle = void 0;
+    this.setStatus("closed");
+  }
+  checkpoint() {
+    return this.token && this.id ? { url: this.options.url, room: this.options.room, token: this.token, id: this.id, events: this.endpoint.events.checkpoint() } : null;
+  }
+  /** Opt-in page lifecycle integration: pause when the page goes away or stays hidden, reconnect fast when it is back,
+   * and replace a socket that died while the phone slept. Returns cleanup. */
+  bindPageLifecycle(o = {}) {
+    this.lifecycle?.();
+    const hiddenPause = o.hiddenPauseMs ?? 2e4, wakeCheck = o.wakeCheckMs ?? 1500;
+    let hideTimer;
+    const pauseNow = () => {
+      clearTimeout(hideTimer);
+      if (this.status === "online" || this.status === "connecting") this.pause();
+    };
+    const back = () => {
+      clearTimeout(hideTimer);
+      if (this.status === "paused") {
+        this.resume();
+        return;
+      }
+      if (this.status === "online") {
+        this.wakeDeadline = performance.now() + wakeCheck;
+        this.ping(performance.now());
+      } else this.reconnectNow();
+    };
+    const visible = () => {
+      if (document.visibilityState === "visible") back();
+      else {
+        clearTimeout(hideTimer);
+        hideTimer = setTimeout(pauseNow, hiddenPause);
+      }
+    };
+    const pagehide = () => pauseNow(), pageshow = () => back(), online = () => this.reconnectNow();
+    window.addEventListener("pagehide", pagehide);
+    window.addEventListener("pageshow", pageshow);
+    window.addEventListener("online", online);
+    document.addEventListener("visibilitychange", visible);
+    const off = () => {
+      clearTimeout(hideTimer);
+      window.removeEventListener("pagehide", pagehide);
+      window.removeEventListener("pageshow", pageshow);
+      window.removeEventListener("online", online);
+      document.removeEventListener("visibilitychange", visible);
+    };
+    this.lifecycle = off;
+    return off;
+  }
+};
+
+// src/core/lobby.ts
+var LOBBY_KEY = "$lobby";
+function normalizeCode(code) {
+  if (typeof code !== "string") return null;
+  const c = code.trim().toUpperCase();
+  return /^[A-Z0-9]{3,12}$/.test(c) ? c : null;
+}
+var range = (a, b) => String.fromCharCode(a) + "-" + String.fromCharCode(b);
+var INVISIBLE = new RegExp("[" + [range(0, 31), range(127, 159), range(8203, 8207), range(8232, 8238), range(8294, 8297)].join("") + "]", "g");
+function cleanName(name, max = 16) {
+  if (typeof name !== "string") return "";
+  return name.replace(/\s+/g, " ").replace(INVISIBLE, "").replace(/ +/g, " ").trim().slice(0, max);
+}
+function isLobbyMessage(d) {
+  return !!d && typeof d === "object" && !Array.isArray(d) && typeof d[LOBBY_KEY] === "string";
+}
+
+// src/client/lobby.ts
+var LobbyClient = class {
+  constructor(client, requestTimeoutMs = 2e4) {
+    __publicField(this, "client", client);
+    __publicField(this, "requestTimeoutMs", requestTimeoutMs);
+    __publicField(this, "room", null);
+    __publicField(this, "onRoom", () => {
+    });
+    /** The room was left without asking (kicked, replaced, closed, session expired). */
+    __publicField(this, "onLeft", () => {
+    });
+    __publicField(this, "pending", /* @__PURE__ */ new Map());
+    __publicField(this, "nextId", 1);
+    __publicField(this, "off");
+    this.off = [
+      client.intercept((d) => {
+        if (!isLobbyMessage(d)) return false;
+        this.message(d);
+        return true;
+      }),
+      client.on("session", ({ resumed }) => {
+        if (!resumed) this.drop("new session");
+      }),
+      client.on("lost", ({ reason }) => this.drop(reason))
+    ];
+  }
+  dispose() {
+    for (const f of this.off) f();
+    this.drop("disposed", false);
+  }
+  get me() {
+    return this.room?.members.find((m) => m.seat === this.room.you) ?? null;
+  }
+  get isHost() {
+    return !!this.me?.host;
+  }
+  /** Milliseconds until the ready countdown ends, or null when none is running. */
+  countdownMs() {
+    const end = this.room?.countdownEndsAt;
+    if (end == null || !this.client.clock.synced) return null;
+    return Math.max(0, end - this.client.clock.serverTime(performance.now()));
+  }
+  create(o = {}) {
+    return this.request({ [LOBBY_KEY]: "create", ...o });
+  }
+  join(code, o = {}) {
+    const c = normalizeCode(code);
+    if (!c) return Promise.reject(new Error("That is not a room code"));
+    return this.request({ [LOBBY_KEY]: "join", code: c, ...o });
+  }
+  quickPlay(o = {}) {
+    return this.request({ [LOBBY_KEY]: "quick", ...o });
+  }
+  async leave() {
+    await this.request({ [LOBBY_KEY]: "leave" });
+    this.set(null);
+  }
+  setReady(ready) {
+    return this.request({ [LOBBY_KEY]: "ready", ready });
+  }
+  setName(name) {
+    return this.request({ [LOBBY_KEY]: "name", name });
+  }
+  setMeta(meta) {
+    return this.request({ [LOBBY_KEY]: "meta", meta });
+  }
+  kick(seat) {
+    return this.request({ [LOBBY_KEY]: "kick", seat });
+  }
+  request(body) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("The room server did not answer"));
+      }, this.requestTimeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.client.sendEvent({ ...body, id });
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    });
+  }
+  set(room) {
+    this.room = room;
+    try {
+      this.onRoom(room);
+    } catch {
+    }
+  }
+  message(d) {
+    const op = d[LOBBY_KEY];
+    if (op === "res" && typeof d.id === "number") {
+      const p = this.pending.get(d.id);
+      if (!p) return;
+      this.pending.delete(d.id);
+      clearTimeout(p.timer);
+      if (d.ok === true) {
+        const room = d.room ?? null;
+        if (room || this.room) this.set(room);
+        p.resolve(room);
+      } else p.reject(new Error(typeof d.error === "string" ? d.error : "Request refused"));
+      return;
+    }
+    if (op === "room" && d.room && typeof d.room === "object") {
+      this.set(d.room);
+      return;
+    }
+    if (op === "left") {
+      const had = !!this.room;
+      this.set(null);
+      if (had) try {
+        this.onLeft(typeof d.reason === "string" ? d.reason : "left");
+      } catch {
+      }
+    }
+  }
+  drop(reason, notify = true) {
+    for (const p of this.pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(new Error(reason));
+    }
+    this.pending.clear();
+    if (this.room) {
+      this.set(null);
+      if (notify) try {
+        this.onLeft(reason);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/netcode/timing.ts
+var FixedStepper = class {
+  constructor(hz = 30, maxCatchUp = 4) {
+    __publicField(this, "maxCatchUp", maxCatchUp);
+    __publicField(this, "tick", 0);
+    __publicField(this, "overruns", 0);
+    __publicField(this, "droppedMs", 0);
+    __publicField(this, "accumulator", 0);
+    __publicField(this, "dtMs");
+    if (!(hz > 0) || !Number.isFinite(hz) || !Number.isInteger(maxCatchUp) || maxCatchUp < 1) throw new RangeError("Invalid tick policy");
+    this.dtMs = 1e3 / hz;
+  }
+  advance(elapsedMs, step) {
+    if (!Number.isFinite(elapsedMs) || elapsedMs < 0) throw new RangeError("Invalid elapsed time");
+    this.accumulator += elapsedMs;
+    let n = 0;
+    while (this.accumulator + 1e-8 >= this.dtMs && n < this.maxCatchUp) {
+      this.accumulator -= this.dtMs;
+      this.tick++;
+      n++;
+      step(this.dtMs / 1e3, this.tick);
+    }
+    if (this.accumulator >= this.dtMs) {
+      const discard = Math.floor(this.accumulator / this.dtMs) * this.dtMs;
+      this.accumulator -= discard;
+      this.droppedMs += discard;
+      this.overruns++;
+    }
+    return n;
+  }
+  get alpha() {
+    return Math.max(0, this.accumulator / this.dtMs);
+  }
+};
+var PROFILES = Object.freeze({
+  social: { simulationHz: 20, sendHz: 20, bytesPerSecond: 12 * 1024, interpolationMinMs: 50 },
+  action: { simulationHz: 60, sendHz: 30, bytesPerSecond: 24 * 1024, interpolationMinMs: 35 },
+  strategy: { simulationHz: 10, sendHz: 10, bytesPerSecond: 12 * 1024, interpolationMinMs: 100 },
+  turnBased: { simulationHz: 0, sendHz: 0, bytesPerSecond: 8 * 1024, interpolationMinMs: 0 }
+});
+
+// src/netcode/interpolation.ts
+var Timeline = class {
+  constructor(capacity = 64, clone = (v) => structuredClone(v)) {
+    __publicField(this, "capacity", capacity);
+    __publicField(this, "clone", clone);
+    __publicField(this, "samples", []);
+    if (!Number.isInteger(capacity) || capacity < 2 || capacity > 4096) throw new RangeError("Invalid history capacity");
+  }
+  get size() {
+    return this.samples.length;
+  }
+  clear() {
+    this.samples = [];
+  }
+  insert(sample) {
+    if (!Number.isFinite(sample.time) || !Number.isSafeInteger(sample.seq) || sample.seq < 0) throw new RangeError("Invalid snapshot");
+    if (this.samples.some((s) => s.seq === sample.seq)) return false;
+    const same2 = this.samples.findIndex((s) => s.time === sample.time);
+    if (same2 >= 0) {
+      if (this.samples[same2].seq > sample.seq) return false;
+      this.samples.splice(same2, 1);
+    }
+    const copy = { ...sample, value: this.clone(sample.value) };
+    const i = this.samples.findIndex((s) => s.time > sample.time);
+    if (i < 0) this.samples.push(copy);
+    else this.samples.splice(i, 0, copy);
+    while (this.samples.length > this.capacity) this.samples.shift();
+    return true;
+  }
+  sample(at, interpolate, extrapolate, maxExtrapolationMs = 100) {
+    if (!Number.isFinite(at) || !Number.isFinite(maxExtrapolationMs) || maxExtrapolationMs < 0) throw new RangeError("Invalid sample time");
+    const s = this.samples;
+    if (!s.length || s[0].time > at) return null;
+    let i = s.length - 1;
+    while (i > 0 && s[i].time > at) i--;
+    const a = s[i], b = s[i + 1];
+    if (b && !b.discontinuity) return { value: interpolate(this.clone(a.value), this.clone(b.value), (at - a.time) / (b.time - a.time)), mode: "interpolate", sourceTime: a.time };
+    if (!b && extrapolate && i > 0 && at > a.time && !a.discontinuity) {
+      const p = s[i - 1];
+      return { value: extrapolate(this.clone(a.value), this.clone(p.value), Math.min(at - a.time, maxExtrapolationMs), a.time - p.time), mode: "extrapolate", sourceTime: a.time };
+    }
+    return { value: this.clone(a.value), mode: "hold", sourceTime: a.time };
+  }
+};
+var AdaptivePlayback = class {
+  constructor(intervalMs, minMs = intervalMs, maxMs = 400) {
+    __publicField(this, "intervalMs", intervalMs);
+    __publicField(this, "minMs", minMs);
+    __publicField(this, "maxMs", maxMs);
+    __publicField(this, "lateness", []);
+    __publicField(this, "cursor", -Infinity);
+    __publicField(this, "delayMs");
+    if (!(intervalMs > 0) || minMs < 0 || maxMs < minMs) throw new RangeError("Invalid playback policy");
+    this.delayMs = minMs;
+  }
+  observe(arrivalOnServerClock, sampleTime) {
+    const late = arrivalOnServerClock - sampleTime;
+    if (!Number.isFinite(late) || late < -1e3 || late > 3e4) return;
+    this.lateness.push(Math.max(0, late));
+    if (this.lateness.length > 128) this.lateness.shift();
+  }
+  advance(serverNow, dtMs) {
+    if (!Number.isFinite(serverNow) || !Number.isFinite(dtMs) || dtMs < 0) throw new RangeError("Invalid clock");
+    if (this.lateness.length) {
+      const sorted = [...this.lateness].sort((a, b) => a - b);
+      const p95 = sorted[Math.floor((sorted.length - 1) * 0.95)];
+      const target = Math.max(this.minMs, Math.min(this.maxMs, p95 + this.intervalMs));
+      const rate = target > this.delayMs ? 8 : 0.5;
+      this.delayMs += (target - this.delayMs) * (1 - Math.exp(-rate * dtMs / 1e3));
+    }
+    this.cursor = Math.max(this.cursor, serverNow - this.delayMs);
+    return this.cursor;
+  }
+  reset() {
+    this.lateness = [];
+    this.cursor = -Infinity;
+    this.delayMs = this.minMs;
+  }
+};
+var lerp = (a, b, t) => a + (b - a) * t;
+var lerpAngle = (a, b, t) => a + Math.atan2(Math.sin(b - a), Math.cos(b - a)) * t;
+var lerpVec3 = (a, b, t) => ({ x: lerp(a.x, b.x, t), y: lerp(a.y, b.y, t), z: lerp(a.z, b.z, t) });
+function rewindTime(requested, now, maxRewindMs) {
+  if (![requested, now, maxRewindMs].every(Number.isFinite) || maxRewindMs < 0) throw new RangeError("Invalid rewind");
+  return Math.max(now - maxRewindMs, Math.min(now, requested));
+}
+
+// src/netcode/prediction.ts
+var Predictor = class {
+  constructor(initial, step, dtSeconds = 1 / 60, maxPending = 256, cloneState = (v) => structuredClone(v), cloneInput = (v) => structuredClone(v)) {
+    __publicField(this, "step", step);
+    __publicField(this, "dtSeconds", dtSeconds);
+    __publicField(this, "maxPending", maxPending);
+    __publicField(this, "cloneState", cloneState);
+    __publicField(this, "cloneInput", cloneInput);
+    __publicField(this, "state");
+    __publicField(this, "pending", []);
+    __publicField(this, "seq", 0);
+    __publicField(this, "ack", 0);
+    __publicField(this, "serverTick", -1);
+    if (!(dtSeconds > 0) || !Number.isFinite(dtSeconds) || !Number.isInteger(maxPending) || maxPending < 1) throw new RangeError("Invalid prediction options");
+    this.state = cloneState(initial);
+  }
+  get lastInput() {
+    return this.seq;
+  }
+  get pendingCount() {
+    return this.pending.length;
+  }
+  push(value) {
+    if (this.pending.length >= this.maxPending) throw new Error("Prediction history full: resync required");
+    if (this.seq >= 4294967295) throw new Error("Input sequence exhausted: resync required");
+    const frame = { seq: ++this.seq, value: this.cloneInput(value) };
+    this.pending.push(frame);
+    this.state = this.step(this.cloneState(this.state), this.cloneInput(value), this.dtSeconds);
+    return { seq: frame.seq, value: this.cloneInput(frame.value) };
+  }
+  reconcile(snapshot) {
+    const { ack, tick } = snapshot;
+    if (!Number.isSafeInteger(ack) || ack < 0 || ack > this.seq || !Number.isSafeInteger(tick) || tick < 0) throw new Error("Invalid authoritative snapshot");
+    if (tick <= this.serverTick) return false;
+    if (ack < this.ack) throw new Error("Authoritative acknowledgement regressed");
+    this.serverTick = tick;
+    this.ack = ack;
+    this.pending = this.pending.filter((i) => i.seq > ack);
+    let state = this.cloneState(snapshot.state);
+    for (const i of this.pending) state = this.step(state, this.cloneInput(i.value), this.dtSeconds);
+    this.state = state;
+    return true;
+  }
+  recent(count = 3) {
+    return (count <= 0 ? [] : this.pending.slice(-Math.floor(count))).map((i) => ({ seq: i.seq, value: this.cloneInput(i.value) }));
+  }
+  resync(state, tick, ack = 0) {
+    if (!Number.isSafeInteger(tick) || tick < 0 || !Number.isSafeInteger(ack) || ack < 0 || ack > 4294967295) throw new RangeError("Invalid resync");
+    this.state = this.cloneState(state);
+    this.pending = [];
+    this.serverTick = tick;
+    this.ack = this.seq = ack;
+  }
+};
+var InputInbox = class {
+  constructor(capacity = 256, clone = (v) => structuredClone(v)) {
+    __publicField(this, "capacity", capacity);
+    __publicField(this, "clone", clone);
+    __publicField(this, "applied", 0);
+    __publicField(this, "queued", /* @__PURE__ */ new Map());
+  }
+  add(input) {
+    if (!Number.isSafeInteger(input.seq) || input.seq <= this.applied || input.seq > this.applied + this.capacity || this.queued.has(input.seq)) return false;
+    this.queued.set(input.seq, this.clone(input.value));
+    return true;
+  }
+  next() {
+    const seq = this.applied + 1;
+    if (!this.queued.has(seq)) return null;
+    const value = this.queued.get(seq);
+    this.queued.delete(seq);
+    this.applied = seq;
+    return { seq, value };
+  }
+  /** Explicit game policy after an expired input gap. Never called automatically. */
+  skipThrough(seq) {
+    if (!Number.isSafeInteger(seq) || seq < this.applied || seq > this.applied + this.capacity) throw new RangeError("Invalid input skip");
+    for (const n of this.queued.keys()) if (n <= seq) this.queued.delete(n);
+    this.applied = seq;
+  }
+};
+
+// src/netcode/spatial.ts
+var SpatialGrid = class {
+  constructor(cellSize = 32, maxEntities = 1e4) {
+    __publicField(this, "cellSize", cellSize);
+    __publicField(this, "maxEntities", maxEntities);
+    __publicField(this, "items", /* @__PURE__ */ new Map());
+    __publicField(this, "cells", /* @__PURE__ */ new Map());
+    if (!(cellSize > 0) || !Number.isFinite(cellSize)) throw new RangeError("Invalid cell size");
+  }
+  validate(p) {
+    if (![p.x, p.y].every((v) => Number.isFinite(v) && Math.abs(v) <= 1e8)) throw new RangeError("Invalid position");
+  }
+  upsert(id, p) {
+    this.validate(p);
+    if (!this.items.has(id) && this.items.size >= this.maxEntities) throw new Error("Spatial entity limit");
+    const key = `${Math.floor(p.x / this.cellSize)},${Math.floor(p.y / this.cellSize)}`;
+    const old = this.items.get(id);
+    if (old && old.key !== key) {
+      const c2 = this.cells.get(old.key);
+      c2.delete(id);
+      if (!c2.size) this.cells.delete(old.key);
+    }
+    let c = this.cells.get(key);
+    if (!c) this.cells.set(key, c = /* @__PURE__ */ new Set());
+    c.add(id);
+    this.items.set(id, { ...p, key });
+  }
+  remove(id) {
+    const p = this.items.get(id);
+    if (!p) return;
+    this.items.delete(id);
+    const c = this.cells.get(p.key);
+    c.delete(id);
+    if (!c.size) this.cells.delete(p.key);
+  }
+  query(center, radius) {
+    this.validate(center);
+    if (!Number.isFinite(radius) || radius < 0) throw new RangeError("Invalid radius");
+    const minX = Math.floor((center.x - radius) / this.cellSize), maxX = Math.floor((center.x + radius) / this.cellSize);
+    const minY = Math.floor((center.y - radius) / this.cellSize), maxY = Math.floor((center.y + radius) / this.cellSize);
+    if ((maxX - minX + 1) * (maxY - minY + 1) > 4096) throw new RangeError("Query exceeds cell budget");
+    const found = /* @__PURE__ */ new Set(), r2 = radius * radius;
+    for (let x = minX; x <= maxX; x++) for (let y = minY; y <= maxY; y++) {
+      for (const id of this.cells.get(`${x},${y}`) ?? []) {
+        const p = this.items.get(id);
+        if ((p.x - center.x) ** 2 + (p.y - center.y) ** 2 <= r2) found.add(id);
+      }
+    }
+    return found;
+  }
+};
+
+// src/netcode/codec.ts
+var sizes = { u8: 1, i8: 1, u16: 2, i16: 2, u32: 4, f32: 4, f64: 8 };
+var bounds = {
+  u8: [0, 255],
+  i8: [-128, 127],
+  u16: [0, 65535],
+  i16: [-32768, 32767],
+  u32: [0, 4294967295],
+  f32: [-34028234663852886e22, 34028234663852886e22],
+  f64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+function defineSchema(schema) {
+  const fields = Object.entries(schema).map(([key, f]) => ({ key, type: f.type, scale: f.scale ?? 1 }));
+  for (const f of fields) if (!Object.hasOwn(sizes, f.type) || !(f.scale > 0) || !Number.isFinite(f.scale) || ["__proto__", "prototype", "constructor"].includes(f.key)) throw new RangeError("Invalid field");
+  const byteLength = fields.reduce((n, f) => n + sizes[f.type], 0);
+  if (!byteLength || byteLength > 1078) throw new RangeError("Schema must fit one state payload");
+  return {
+    byteLength,
+    encode(value) {
+      const b = new Uint8Array(byteLength), v = new DataView(b.buffer);
+      let at = 0;
+      for (const f of fields) {
+        const source = value[f.key];
+        if (!Number.isFinite(source)) throw new RangeError(`Invalid ${f.key}`);
+        let n = source * f.scale;
+        if (!f.type.startsWith("f")) n = Math.round(n);
+        const [min, max] = bounds[f.type];
+        if (!Number.isFinite(n) || n < min || n > max) throw new RangeError(`Out of range: ${f.key}`);
+        switch (f.type) {
+          case "u8":
+            v.setUint8(at, n);
+            break;
+          case "i8":
+            v.setInt8(at, n);
+            break;
+          case "u16":
+            v.setUint16(at, n, true);
+            break;
+          case "i16":
+            v.setInt16(at, n, true);
+            break;
+          case "u32":
+            v.setUint32(at, n, true);
+            break;
+          case "f32":
+            v.setFloat32(at, n, true);
+            break;
+          case "f64":
+            v.setFloat64(at, n, true);
+            break;
+        }
+        at += sizes[f.type];
+      }
+      return b;
+    },
+    decode(b) {
+      if (b.length !== byteLength) return null;
+      const v = new DataView(b.buffer, b.byteOffset, b.byteLength), out = /* @__PURE__ */ Object.create(null);
+      let at = 0;
+      for (const f of fields) {
+        let n;
+        switch (f.type) {
+          case "u8":
+            n = v.getUint8(at);
+            break;
+          case "i8":
+            n = v.getInt8(at);
+            break;
+          case "u16":
+            n = v.getUint16(at, true);
+            break;
+          case "i16":
+            n = v.getInt16(at, true);
+            break;
+          case "u32":
+            n = v.getUint32(at, true);
+            break;
+          case "f32":
+            n = v.getFloat32(at, true);
+            break;
+          case "f64":
+            n = v.getFloat64(at, true);
+            break;
+        }
+        if (!Number.isFinite(n) || !Number.isFinite(n / f.scale)) return null;
+        out[f.key] = n / f.scale;
+        at += sizes[f.type];
+      }
+      return out;
+    }
+  };
+}
+
+// src/netcode/replication.ts
+var sameBytes = (a, b) => a.length === b.length && a.every((v, i) => b[i] === v);
+var ReplicaSender = class {
+  constructor(maxEntities = 1024, retryMs = 100) {
+    __publicField(this, "maxEntities", maxEntities);
+    __publicField(this, "retryMs", retryMs);
+    __publicField(this, "records", /* @__PURE__ */ new Map());
+  }
+  publish(id, generation, data) {
+    if (!isUint(id, 65535) || !isUint(generation) || generation < 1 || (data?.length ?? 0) > 1067) throw new RangeError("Invalid entity");
+    const old = this.records.get(id), deleted = data === null, bytes = data?.slice() ?? new Uint8Array();
+    if (!old && this.records.size >= this.maxEntities) throw new Error("Replica entity limit");
+    if (old && generation < old.update.generation) throw new Error("Entity generation regressed");
+    if (old && generation === old.update.generation && old.update.deleted === deleted && sameBytes(old.update.data, bytes)) return { id, generation, revision: old.update.revision };
+    const revision = old && generation === old.update.generation ? old.update.revision + 1 : 1;
+    if (revision > 4294967295) throw new Error("Entity revision exhausted");
+    const update = { id, generation, revision, deleted, data: bytes };
+    this.records.set(id, { update, ack: old && generation === old.update.generation ? old.ack : 0, sent: 0, sentAt: -Infinity });
+    return { id, generation, revision };
+  }
+  due(now, limit = 64) {
+    return [...this.records.values()].filter((r) => r.ack < r.update.revision && now - r.sentAt >= this.retryMs).sort((a, b) => a.sentAt - b.sentAt).slice(0, limit).map((r) => ({ ...r.update, data: r.update.data.slice() }));
+  }
+  markSent(v, now) {
+    const r = this.records.get(v.id);
+    if (!r || r.update.generation !== v.generation || r.update.revision !== v.revision) return;
+    r.sent = v.revision;
+    r.sentAt = now;
+  }
+  acknowledge(v) {
+    const r = this.records.get(v.id);
+    if (!r || r.update.generation !== v.generation || !isUint(v.revision) || v.revision > r.sent) return false;
+    r.ack = Math.max(r.ack, v.revision);
+    return true;
+  }
+  /** Reset both sender and receiver under a new world/session generation, not while old packets remain valid. */
+  clear() {
+    this.records.clear();
+  }
+};
+var ReplicaReceiver = class {
+  constructor(maxEntities = 1024) {
+    __publicField(this, "maxEntities", maxEntities);
+    __publicField(this, "records", /* @__PURE__ */ new Map());
+  }
+  apply(u) {
+    if (!isUint(u.id, 65535) || !isUint(u.generation) || !u.generation || !isUint(u.revision) || !u.revision || u.data.length > 1067) throw new Error("Invalid entity update");
+    const old = this.records.get(u.id);
+    if (!old && this.records.size >= this.maxEntities) throw new Error("Replica receiver full");
+    const changed = !old || u.generation > old.generation || u.generation === old.generation && u.revision > old.revision;
+    if (changed) this.records.set(u.id, { ...u, data: u.data.slice() });
+    return { changed, ack: { id: u.id, generation: u.generation, revision: u.revision } };
+  }
+  get(id) {
+    const r = this.records.get(id);
+    return r && !r.deleted ? r.data.slice() : null;
+  }
+  clear() {
+    this.records.clear();
+  }
+};
+function encodeReplica(u) {
+  if (!isUint(u.id, 65535) || !isUint(u.generation) || !u.generation || !isUint(u.revision) || !u.revision || u.data.length > 1067 || u.deleted && u.data.length)
+    throw new Error("Invalid entity update");
+  const b = new Uint8Array(11 + u.data.length), v = new DataView(b.buffer);
+  v.setUint16(0, u.id, true);
+  v.setUint32(2, u.generation, true);
+  v.setUint32(6, u.revision, true);
+  v.setUint8(10, +u.deleted);
+  b.set(u.data, 11);
+  return b;
+}
+function decodeReplica(b) {
+  if (b.length < 11 || b.length > 1078) return null;
+  const v = new DataView(b.buffer, b.byteOffset, b.byteLength), flag = v.getUint8(10), generation = v.getUint32(2, true), revision = v.getUint32(6, true);
+  if (flag > 1 || !generation || !revision || flag && b.length !== 11) return null;
+  return { id: v.getUint16(0, true), generation, revision, deleted: !!flag, data: b.slice(11) };
+}
+
+// src/netcode/inputs.ts
+function encodeInputs(inputs) {
+  if (!inputs.length || inputs.length > 32) throw new RangeError("Invalid input count");
+  let size = 1, previous = -1;
+  for (const input of inputs) {
+    if (!isUint(input.seq) || input.seq <= previous || input.data.length > 1024) throw new RangeError("Invalid input");
+    previous = input.seq;
+    size += 6 + input.data.length;
+  }
+  if (size > MAX_STATE_BYTES) throw new RangeError("Input bundle exceeds one state frame");
+  const b = new Uint8Array(size), v = new DataView(b.buffer);
+  b[0] = inputs.length;
+  let at = 1;
+  for (const i of inputs) {
+    v.setUint32(at, i.seq, true);
+    v.setUint16(at + 4, i.data.length, true);
+    b.set(i.data, at + 6);
+    at += 6 + i.data.length;
+  }
+  return b;
+}
+function decodeInputs(b) {
+  if (!b.length || b.length > MAX_STATE_BYTES || !b[0] || b[0] > 32) return null;
+  const v = new DataView(b.buffer, b.byteOffset, b.byteLength), out = [];
+  let at = 1, previous = -1;
+  for (let n = 0; n < b[0]; n++) {
+    if (at + 6 > b.length) return null;
+    const seq = v.getUint32(at, true), size = v.getUint16(at + 4, true);
+    if (seq <= previous || size > 1024 || at + 6 + size > b.length) return null;
+    out.push({ seq, data: b.slice(at + 6, at + 6 + size) });
+    previous = seq;
+    at += 6 + size;
+  }
+  return at === b.length ? out : null;
+}
+
+// src/netcode/snapshots.ts
+var SnapshotHistory = class {
+  constructor(capacity = 64) {
+    __publicField(this, "capacity", capacity);
+    __publicField(this, "sent", /* @__PURE__ */ new Map());
+    __publicField(this, "acked", null);
+    if (!Number.isInteger(capacity) || capacity < 1) throw new RangeError("Invalid history capacity");
+  }
+  record(seq, value) {
+    if (!seq) return;
+    this.sent.set(seq, value);
+    while (this.sent.size > this.capacity) this.sent.delete(this.sent.keys().next().value);
+  }
+  acknowledge(seq) {
+    const value = this.sent.get(seq);
+    if (value === void 0 || this.acked && !newer(seq, this.acked.seq)) return false;
+    this.acked = { seq, value };
+    for (const k of [...this.sent.keys()]) if (!newer(k, seq)) this.sent.delete(k);
+    return true;
+  }
+  /** The acknowledged snapshot to diff against, or null for a whole snapshot. */
+  get baseline() {
+    return this.acked;
+  }
+  reset() {
+    this.sent.clear();
+    this.acked = null;
+  }
+};
+var same = (a, b) => a === b || typeof a === "object" && a !== null && typeof b === "object" && b !== null && JSON.stringify(a) === JSON.stringify(b);
+function diffEntities(base, next) {
+  const out = {};
+  for (const id of Object.keys(next)) {
+    const n = next[id], b = base?.[id];
+    let fields;
+    for (const k of Object.keys(n)) if (!b || !same(b[k], n[k])) (fields ?? (fields = {}))[k] = n[k];
+    if (b) {
+      for (const k of Object.keys(b)) if (!(k in n)) (fields ?? (fields = {}))[k] = null;
+    }
+    if (fields) (out.set ?? (out.set = {}))[id] = fields;
+  }
+  if (base) {
+    for (const id of Object.keys(base)) if (!(id in next)) (out.del ?? (out.del = [])).push(id);
+  }
+  return out;
+}
+function applyEntityDelta(base, delta) {
+  const out = {};
+  if (base) for (const id of Object.keys(base)) out[id] = { ...base[id] };
+  for (const id of delta.del ?? []) delete out[id];
+  for (const [id, fields] of Object.entries(delta.set ?? {})) {
+    const e = out[id] ?? (out[id] = {});
+    for (const [k, v] of Object.entries(fields)) {
+      if (v === null && base?.[id] && k in base[id]) delete e[k];
+      else e[k] = v;
+    }
+  }
+  return out;
+}
+export {
+  AdaptivePlayback,
+  BrowserRtcPeer,
+  DEFAULT_STATE_BYTES,
+  FixedStepper,
+  GameClient,
+  InputInbox,
+  LOBBY_KEY,
+  LobbyClient,
+  MTU_STATE_BYTES,
+  NetworkClock,
+  PROFILES,
+  Predictor,
+  ReplicaReceiver,
+  ReplicaSender,
+  SnapshotHistory,
+  SpatialGrid,
+  Timeline,
+  VERSION,
+  applyEntityDelta,
+  cleanName,
+  decodeInputs,
+  decodeReplica,
+  defineSchema,
+  diffEntities,
+  encodeInputs,
+  encodeReplica,
+  lerp,
+  lerpAngle,
+  lerpVec3,
+  normalizeCode,
+  rewindTime
+};
+//# sourceMappingURL=twinwire.mjs.map