@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-TVJZ4GPS.js

@@ -0,0 +1,1553 @@
+'use strict';
+
+var chunkQCZOE65N_js = require('./chunk-QCZOE65N.js');
+var chunk66QP3SMN_js = require('./chunk-66QP3SMN.js');
+var chunkWWKMOA76_js = require('./chunk-WWKMOA76.js');
+
+// src/interactives/rooms/connect.ts
+var Connecting = {
+  Idle: 0,
+  Pending: 1,
+  Won: 2,
+  Failed: 3
+}, Settled = {
+  Waiting: 0,
+  Dialed: 1,
+  Failed: 2
+}, Attempt = class {
+  constructor(dialer, race) {
+    this.settled = Settled.Waiting;
+    this.dialed = null;
+    this.done = (dialed) => {
+      this.dialed = dialed, this.settled = dialed ? Settled.Dialed : Settled.Failed, this.race.settled(this);
+    };
+    this.failed = () => {
+      this.done(null);
+    };
+    this.dialer = dialer, this.race = race;
+  }
+  start(request) {
+    this.dialer.dial(request, this).then(this.done, this.failed);
+  }
+  frame(lane, bytes) {
+    this.race.forward(this, lane, bytes);
+  }
+  closed() {
+    this.race.lost(this);
+  }
+  backpressure(failures, status) {
+    this.race.backpressure(this, failures, status);
+  }
+}, Connector = class {
+  constructor(primary, fallback, memory, network) {
+    this.sink = null;
+    this.request = null;
+    this.first = null;
+    this.second = null;
+    this.won = null;
+    this.networkKey = "";
+    this.startedAt = 0;
+    this.lastNow = 0;
+    this.state = Connecting.Idle;
+    this.primary = primary, this.fallback = fallback, this.memory = memory, this.network = network;
+  }
+  get winner() {
+    return this.won?.dialed ?? null;
+  }
+  begin(request, sink, nowMs) {
+    this.cancel(), this.sink = sink, this.request = request, this.startedAt = nowMs, this.lastNow = nowMs, this.state = Connecting.Pending, this.networkKey = this.network();
+    let remembered = this.memory.recall(this.networkKey, nowMs), opener = this.fallback !== null && remembered === this.fallback.transport || !this.primary ? this.fallback : this.primary;
+    if (!opener) {
+      this.state = Connecting.Failed;
+      return;
+    }
+    this.first = new Attempt(opener, this), opener === this.fallback && (this.second = this.first), this.first.start(request);
+  }
+  poll(nowMs) {
+    if (this.lastNow = nowMs, this.state !== Connecting.Pending) return this.state;
+    let elapsed = nowMs - this.startedAt;
+    return !this.second && this.fallback && (elapsed >= chunkQCZOE65N_js.FALLBACK_AFTER_MS || this.first?.settled === Settled.Failed) && this.launchFallback(), this.state === Connecting.Pending && (elapsed >= chunkQCZOE65N_js.CONNECT_TIMEOUT_MS || this.exhausted()) && this.fail(), this.state;
+  }
+  cancel() {
+    for (let attempt of [this.first, this.second]) attempt?.dialed?.link.close();
+    this.first = null, this.second = null, this.won = null, this.sink = null, this.state = Connecting.Idle;
+  }
+  release() {
+    let dialed = this.winner;
+    return this.first = null, this.second = null, this.state = Connecting.Idle, dialed;
+  }
+  forward(attempt, lane, bytes) {
+    attempt === this.won && this.sink?.frame(lane, bytes);
+  }
+  lost(attempt) {
+    attempt === this.won && this.sink?.closed();
+  }
+  backpressure(attempt, failures, status) {
+    attempt === this.won && this.sink?.backpressure?.(failures, status);
+  }
+  settled(attempt) {
+    if (attempt !== this.first && attempt !== this.second) {
+      attempt.dialed?.link.close();
+      return;
+    }
+    if (attempt.settled !== Settled.Dialed) return;
+    if (this.won) {
+      attempt !== this.won && attempt.dialed?.link.close();
+      return;
+    }
+    this.won = attempt, this.state = Connecting.Won;
+    let loser = attempt === this.first ? this.second : this.first;
+    loser && loser !== attempt && loser.dialed?.link.close(), this.primary && this.fallback && this.memory.remember(this.networkKey, attempt.dialer.transport, this.lastNow);
+  }
+  launchFallback() {
+    !this.fallback || !this.request || (this.second = new Attempt(this.fallback, this), this.second.start(this.request));
+  }
+  exhausted() {
+    let firstDone = !this.first || this.first.settled === Settled.Failed, secondDone = this.second ? this.second.settled === Settled.Failed : !this.fallback;
+    return firstDone && secondDone;
+  }
+  fail() {
+    let sink = this.sink;
+    this.cancel(), this.sink = sink, this.state = Connecting.Failed;
+  }
+};
+
+// src/interactives/rooms/join.ts
+var JoinStatus = {
+  Admitted: 0,
+  Malformed: 1,
+  Forged: 2,
+  Expired: 3,
+  UnknownResume: 4,
+  Full: 5,
+  Overloaded: 6,
+  Unavailable: 7,
+  Prewarmed: 8,
+  Denied: 9
+}, LAST_STATUS = JoinStatus.Denied, LITTLE_ENDIAN = true;
+function blankReply() {
+  return {
+    status: JoinStatus.Unavailable,
+    slot: 0,
+    route: 0,
+    resume: new Uint8Array(chunkQCZOE65N_js.RESUME_TOKEN_BYTES),
+    simulationHz: 0,
+    sendHz: 0,
+    tick: 0
+  };
+}
+function joinRequest(kind, body, version) {
+  if (chunkQCZOE65N_js.JOIN_HEADER_BYTES + body.length > chunkQCZOE65N_js.MAX_JOIN_BYTES) throw new RangeError("the join request is too large");
+  let out = new Uint8Array(chunkQCZOE65N_js.JOIN_HEADER_BYTES + body.length), view = new DataView(out.buffer);
+  return view.setUint8(0, version), view.setUint8(1, kind), view.setUint16(2, body.length, (true)), out.set(body, chunkQCZOE65N_js.JOIN_HEADER_BYTES), out;
+}
+function ticketRequest(ticket, version = chunkQCZOE65N_js.JOIN_VERSION_DELTA) {
+  return joinRequest(chunkQCZOE65N_js.JOIN_TICKET, ticket, version);
+}
+function resumeRequest(token, version = chunkQCZOE65N_js.JOIN_VERSION_DELTA) {
+  return joinRequest(chunkQCZOE65N_js.JOIN_RESUME, token, version);
+}
+function withoutDeltaPresence(request) {
+  return request.length === 0 || request[0] !== chunkQCZOE65N_js.JOIN_VERSION_DELTA ? false : (request[0] = chunkQCZOE65N_js.JOIN_VERSION, true);
+}
+function decodeJoinReply(bytes, out) {
+  if (bytes.length !== chunkQCZOE65N_js.JOIN_REPLY_BYTES) return false;
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint8(0) !== chunkQCZOE65N_js.JOIN_VERSION) return false;
+  let status = view.getUint8(1);
+  return status > LAST_STATUS ? false : (out.status = status, out.slot = view.getUint16(2, (true)), out.route = view.getUint32(4, (true)), out.resume.set(bytes.subarray(8, 8 + chunkQCZOE65N_js.RESUME_TOKEN_BYTES)), out.simulationHz = view.getUint16(24, (true)), out.sendHz = view.getUint16(26, (true)), out.tick = view.getUint32(32, (true)) * chunkQCZOE65N_js.U32_RANGE + view.getUint32(28, (true)), true);
+}
+
+// src/interactives/rooms/locomotion.ts
+var FRACTION_BITS = BigInt(24), LIMIT_SQUARED = chunkQCZOE65N_js.AXIS_LIMIT * chunkQCZOE65N_js.AXIS_LIMIT;
+function perAxisUnit(unitsPerSecond, stepNs) {
+  let scaled = BigInt(unitsPerSecond) * BigInt(stepNs) << FRACTION_BITS, divisor = BigInt(chunkQCZOE65N_js.AXIS_LIMIT) * BigInt(chunkQCZOE65N_js.NANOS_PER_SECOND);
+  return Number(scaled / divisor);
+}
+function isqrt(value) {
+  let root = Math.floor(Math.sqrt(value));
+  for (; root * root > value; ) root -= 1;
+  for (; (root + 1) * (root + 1) <= value; ) root += 1;
+  return root;
+}
+function spawn(body, slot) {
+  body.x = chunkQCZOE65N_js.SPAWN_ORIGIN_UNITS + slot % chunkQCZOE65N_js.SPAWN_ROW * chunkQCZOE65N_js.SPAWN_SPACING_UNITS, body.z = chunkQCZOE65N_js.SPAWN_ORIGIN_UNITS + Math.floor(slot / chunkQCZOE65N_js.SPAWN_ROW) * chunkQCZOE65N_js.SPAWN_SPACING_UNITS, body.axisX = 0, body.axisZ = 0, body.buttons = 0;
+}
+function steer(body, axisX, axisZ, buttons) {
+  let x = Math.max(axisX, -chunkQCZOE65N_js.AXIS_LIMIT), z = Math.max(axisZ, -chunkQCZOE65N_js.AXIS_LIMIT), magnitudeSquared = x * x + z * z;
+  if (magnitudeSquared <= LIMIT_SQUARED)
+    body.axisX = x, body.axisZ = z;
+  else {
+    let magnitude = isqrt(magnitudeSquared);
+    body.axisX = Math.trunc(x * chunkQCZOE65N_js.AXIS_LIMIT / magnitude), body.axisZ = Math.trunc(z * chunkQCZOE65N_js.AXIS_LIMIT / magnitude);
+  }
+  body.buttons = buttons;
+}
+function clampUnits(value) {
+  return value < 0 ? 0 : value > chunkQCZOE65N_js.CELL_MAX_UNITS ? chunkQCZOE65N_js.CELL_MAX_UNITS : value;
+}
+var Locomotion = class {
+  constructor(simulationHz, physicsHz) {
+    this.substeps = Math.ceil(physicsHz / simulationHz), this.stepNs = Math.floor(chunkQCZOE65N_js.NANOS_PER_SECOND / (simulationHz * this.substeps)), this.walk = perAxisUnit(chunkQCZOE65N_js.WALK_UNITS_PER_SECOND, this.stepNs), this.sprint = perAxisUnit(chunkQCZOE65N_js.SPRINT_UNITS_PER_SECOND, this.stepNs);
+  }
+  step(body) {
+    let scale = (body.buttons & chunkQCZOE65N_js.BUTTON_SPRINT) !== 0 ? this.sprint : this.walk, stepX = Math.floor(body.axisX * scale / chunkQCZOE65N_js.VELOCITY_FRACTION), stepZ = Math.floor(body.axisZ * scale / chunkQCZOE65N_js.VELOCITY_FRACTION);
+    body.x = clampUnits(body.x + stepX * this.substeps), body.z = clampUnits(body.z + stepZ * this.substeps);
+  }
+};
+
+// src/interactives/rooms/motion.ts
+var EXACT = 0, LocomotionMotion = class {
+  constructor(simulationHz, physicsHz) {
+    this.toleranceUnits = (0);
+    this.body = { x: 0, z: 0, axisX: 0, axisZ: 0, buttons: 0 };
+    this.locomotion = new Locomotion(simulationHz, physicsHz);
+  }
+  get x() {
+    return this.body.x;
+  }
+  get y() {
+    return 0;
+  }
+  get z() {
+    return this.body.z;
+  }
+  spawn(slot) {
+    spawn(this.body, slot);
+  }
+  steer(axisX, axisZ, buttons) {
+    steer(this.body, axisX, axisZ, buttons);
+  }
+  step() {
+    this.locomotion.step(this.body);
+  }
+  place(x, _y, z) {
+    this.body.x = x, this.body.z = z;
+  }
+}, locomotionMotion = (simulationHz, physicsHz) => new LocomotionMotion(simulationHz, physicsHz);
+
+// src/interactives/rooms/link.ts
+var Transport = {
+  WebTransport: "web_transport",
+  WebSocket: "web_socket"
+};
+
+// src/interactives/rooms/network-memory.ts
+function known(value) {
+  return value === Transport.WebTransport || value === Transport.WebSocket;
+}
+function fresh(remembered, nowMs) {
+  return !remembered || nowMs - remembered.at > chunkQCZOE65N_js.NETWORK_MEMORY_TTL_MS ? null : remembered.transport;
+}
+var InMemoryNetworkMemory = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  recall(network, nowMs) {
+    return fresh(this.entries.get(network), nowMs);
+  }
+  remember(network, transport, nowMs) {
+    this.entries.set(network, { transport, at: nowMs });
+  }
+}, StorageNetworkMemory = class {
+  constructor() {
+    this.fallback = new InMemoryNetworkMemory();
+  }
+  recall(network, nowMs) {
+    try {
+      let raw = globalThis.localStorage?.getItem(chunkQCZOE65N_js.NETWORK_MEMORY_PREFIX + network);
+      if (!raw) return this.fallback.recall(network, nowMs);
+      let parsed = JSON.parse(raw);
+      if (typeof parsed != "object" || parsed === null) return null;
+      let entry = parsed;
+      return !known(entry.transport) || typeof entry.at != "number" ? null : fresh({ transport: entry.transport, at: entry.at }, nowMs);
+    } catch {
+      return this.fallback.recall(network, nowMs);
+    }
+  }
+  remember(network, transport, nowMs) {
+    this.fallback.remember(network, transport, nowMs);
+    try {
+      globalThis.localStorage?.setItem(chunkQCZOE65N_js.NETWORK_MEMORY_PREFIX + network, JSON.stringify({ transport, at: nowMs }));
+    } catch {
+      return;
+    }
+  }
+};
+function currentNetwork() {
+  let connection = globalThis.navigator?.connection;
+  return connection?.type ?? connection?.effectiveType ?? chunkQCZOE65N_js.DEFAULT_NETWORK;
+}
+
+// src/interactives/rooms/clock-sync.ts
+var ClockSync = class {
+  constructor() {
+    this.tickMs = 0;
+    this.sendIntervalMs = 0;
+    this.offsets = new Float64Array(chunkQCZOE65N_js.OFFSET_WINDOW);
+    this.rtts = new Float64Array(chunkQCZOE65N_js.RTT_WINDOW);
+    this.offsetCount = 0;
+    this.offsetNext = 0;
+    this.rttCount = 0;
+    this.rttNext = 0;
+    this.offsetMs = 0;
+    this.jitter = 0;
+    this.smoothedRtt = 0;
+    this.delay = 0;
+  }
+  configure(simulationHz, sendHz, handshakeRttMs) {
+    this.tickMs = chunkQCZOE65N_js.MS_PER_SECOND / simulationHz, this.sendIntervalMs = chunkQCZOE65N_js.MS_PER_SECOND / sendHz, this.offsetCount = 0, this.offsetNext = 0, this.rttCount = 0, this.rttNext = 0, this.jitter = 0, this.offsetMs = 0, this.smoothedRtt = handshakeRttMs, this.delay = chunkQCZOE65N_js.INTERPOLATION_SEND_INTERVALS * this.sendIntervalMs;
+  }
+  get tickIntervalMs() {
+    return this.tickMs;
+  }
+  get rttMs() {
+    return this.smoothedRtt;
+  }
+  get jitterMs() {
+    return this.jitter;
+  }
+  get interpolationDelayMs() {
+    return this.delay;
+  }
+  get synchronised() {
+    return this.offsetCount > 0;
+  }
+  snapshot(serverTick, nowMs) {
+    let sample = serverTick * this.tickMs - nowMs;
+    this.offsets[this.offsetNext] = sample, this.offsetNext = (this.offsetNext + 1) % chunkQCZOE65N_js.OFFSET_WINDOW, this.offsetCount < chunkQCZOE65N_js.OFFSET_WINDOW && (this.offsetCount += 1);
+    let best = sample;
+    for (let index = 0; index < this.offsetCount; index++) this.offsets[index] > best && (best = this.offsets[index]);
+    this.offsetMs = best, this.jitter += (best - sample - this.jitter) * chunkQCZOE65N_js.JITTER_SMOOTHING;
+    let target = Math.min(
+      chunkQCZOE65N_js.INTERPOLATION_SEND_INTERVALS * this.sendIntervalMs + chunkQCZOE65N_js.JITTER_MULTIPLIER * this.jitter,
+      chunkQCZOE65N_js.MAX_INTERPOLATION_DELAY_MS
+    );
+    this.delay += (target - this.delay) * chunkQCZOE65N_js.DELAY_SMOOTHING;
+  }
+  roundTrip(sampleMs) {
+    if (!(sampleMs >= 0)) return;
+    this.rtts[this.rttNext] = sampleMs, this.rttNext = (this.rttNext + 1) % chunkQCZOE65N_js.RTT_WINDOW, this.rttCount < chunkQCZOE65N_js.RTT_WINDOW && (this.rttCount += 1);
+    let lowest = sampleMs;
+    for (let index = 0; index < this.rttCount; index++) this.rtts[index] < lowest && (lowest = this.rtts[index]);
+    this.smoothedRtt += (lowest - this.smoothedRtt) * chunkQCZOE65N_js.RTT_SMOOTHING;
+  }
+  serverTick(nowMs) {
+    return (nowMs + this.offsetMs) / this.tickMs;
+  }
+  renderTick(nowMs) {
+    return (nowMs + this.offsetMs - this.delay) / this.tickMs;
+  }
+  leadTicks() {
+    return this.smoothedRtt / 2 / this.tickMs;
+  }
+};
+
+// src/interactives/rooms/inbound.ts
+var InboundQueue = class {
+  constructor() {
+    this.pool = new chunk66QP3SMN_js.FrameBufferPool(chunkQCZOE65N_js.INBOUND_POOL_SLOTS, chunkQCZOE65N_js.PACKET_BYTES);
+    this.slots = new Int32Array(chunkQCZOE65N_js.INBOUND_POOL_SLOTS);
+    this.lanes = new Uint8Array(chunkQCZOE65N_js.INBOUND_POOL_SLOTS);
+    this.lengths = new Int32Array(chunkQCZOE65N_js.INBOUND_POOL_SLOTS);
+    this.head = 0;
+    this.count = 0;
+    this.current = -1;
+    this.dropped = 0;
+    this.sendFailures = 0;
+    this.lastSendStatus = 0;
+    this.lost = false;
+  }
+  clear() {
+    for (this.release(); this.count > 0; )
+      this.pool.release(this.slots[this.head]), this.head = (this.head + 1) % chunkQCZOE65N_js.INBOUND_POOL_SLOTS, this.count -= 1;
+    this.lost = false;
+  }
+  frame(lane, bytes) {
+    if (bytes.length > chunkQCZOE65N_js.PACKET_BYTES || this.count === chunkQCZOE65N_js.INBOUND_POOL_SLOTS) {
+      this.dropped += 1;
+      return;
+    }
+    let slot = this.pool.acquire();
+    if (slot < 0) {
+      this.dropped += 1;
+      return;
+    }
+    this.pool.bytes(slot).set(bytes);
+    let at = (this.head + this.count) % chunkQCZOE65N_js.INBOUND_POOL_SLOTS;
+    this.slots[at] = slot, this.lanes[at] = lane, this.lengths[at] = bytes.length, this.count += 1;
+  }
+  closed() {
+    this.lost = true;
+  }
+  backpressure(failures, status) {
+    this.sendFailures += failures, this.lastSendStatus = status;
+  }
+  next() {
+    return this.release(), this.count === 0 ? false : (this.current = this.head, this.head = (this.head + 1) % chunkQCZOE65N_js.INBOUND_POOL_SLOTS, this.count -= 1, true);
+  }
+  get view() {
+    return this.pool.view(this.slots[this.current]);
+  }
+  get length() {
+    return this.lengths[this.current];
+  }
+  get lane() {
+    return this.lanes[this.current];
+  }
+  release() {
+    this.current < 0 || (this.pool.release(this.slots[this.current]), this.current = -1);
+  }
+};
+
+// src/interactives/rooms/input-log.ts
+var InputLog = class {
+  constructor() {
+    this.buttons = new Uint8Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.axisX = new Int16Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.axisZ = new Int16Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.yaw = new Uint16Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.clientTick = new Float64Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.subtick = new Uint8Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.sentAt = new Float64Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.frame = {
+      buttons: 0,
+      sequence: 0,
+      client_tick: 0,
+      axis_x: 0,
+      axis_z: 0,
+      yaw: 0,
+      layer: chunkQCZOE65N_js.ROOM_LAYER,
+      subtick: 0
+    };
+    this.latestSequence = 0;
+    this.appliedSequence = 0;
+    this.durableSequence = 0;
+  }
+  get latest() {
+    return this.latestSequence;
+  }
+  get applied() {
+    return this.appliedSequence;
+  }
+  get durable() {
+    return this.durableSequence;
+  }
+  get pending() {
+    return this.latestSequence - this.appliedSequence;
+  }
+  rebase(applied) {
+    this.appliedSequence = applied, this.durableSequence > applied && (this.durableSequence = applied), (this.latestSequence < applied || this.latestSequence - this.durableSequence >= chunkQCZOE65N_js.INPUT_LOG_CAPACITY) && (this.latestSequence = applied, this.durableSequence = applied);
+  }
+  reset(applied) {
+    this.latestSequence = applied, this.appliedSequence = applied, this.durableSequence = applied;
+  }
+  acknowledge(applied) {
+    return applied <= this.appliedSequence || applied > this.latestSequence ? false : (this.appliedSequence = applied, true);
+  }
+  persist(durable) {
+    durable > this.durableSequence && (this.durableSequence = Math.min(durable, this.latestSequence));
+  }
+  holds(sequence) {
+    return sequence > this.durableSequence && sequence <= this.latestSequence;
+  }
+  push(axisX, axisZ, yaw, buttons, clientTick, subtick) {
+    this.latestSequence - this.durableSequence >= chunkQCZOE65N_js.INPUT_LOG_CAPACITY && (this.durableSequence += 1);
+    let sequence = this.latestSequence + 1, at = sequence % chunkQCZOE65N_js.INPUT_LOG_CAPACITY;
+    return this.axisX[at] = axisX, this.axisZ[at] = axisZ, this.yaw[at] = yaw, this.buttons[at] = buttons, this.clientTick[at] = clientTick, this.subtick[at] = subtick, this.sentAt[at] = Number.NaN, this.latestSequence = sequence, sequence;
+  }
+  axisXOf(sequence) {
+    return this.axisX[sequence % chunkQCZOE65N_js.INPUT_LOG_CAPACITY];
+  }
+  axisZOf(sequence) {
+    return this.axisZ[sequence % chunkQCZOE65N_js.INPUT_LOG_CAPACITY];
+  }
+  buttonsOf(sequence) {
+    return this.buttons[sequence % chunkQCZOE65N_js.INPUT_LOG_CAPACITY];
+  }
+  yawOf(sequence) {
+    return this.yaw[sequence % chunkQCZOE65N_js.INPUT_LOG_CAPACITY];
+  }
+  sentAtOf(sequence) {
+    return this.holds(sequence) ? this.sentAt[sequence % chunkQCZOE65N_js.INPUT_LOG_CAPACITY] : Number.NaN;
+  }
+  write(view, offset, nowMs) {
+    let first = Math.max(this.appliedSequence, this.durableSequence) + 1, last = Math.min(this.latestSequence, first + chunkQCZOE65N_js.MAX_INPUTS_PER_PACKET - 1), at = offset, frame = this.frame;
+    for (let sequence = first; sequence <= last; sequence++) {
+      let slot = sequence % chunkQCZOE65N_js.INPUT_LOG_CAPACITY;
+      frame.buttons = this.buttons[slot], frame.sequence = sequence % chunkQCZOE65N_js.U16_RANGE, frame.client_tick = this.clientTick[slot] >>> 0, frame.axis_x = this.axisX[slot], frame.axis_z = this.axisZ[slot], frame.yaw = this.yaw[slot], frame.subtick = this.subtick[slot];
+      let written = chunk66QP3SMN_js.encodeMoveInput(view, at, frame);
+      if (written < 0) break;
+      at += written, Number.isNaN(this.sentAt[slot]) && (this.sentAt[slot] = nowMs);
+    }
+    return at - offset;
+  }
+};
+
+// src/interactives/rooms/interpolation.ts
+var Sampled = {
+  None: 0,
+  Interpolated: 1,
+  Extrapolated: 2
+}, SAMPLES = chunkQCZOE65N_js.ENTITY_CAPACITY * chunkQCZOE65N_js.REMOTE_HISTORY;
+function yawBetween(from, to, alpha) {
+  let delta = to - from;
+  return delta > chunkQCZOE65N_js.HALF_YAW_UNITS ? delta -= chunkQCZOE65N_js.YAW_UNITS_PER_TURN : delta < -chunkQCZOE65N_js.HALF_YAW_UNITS && (delta += chunkQCZOE65N_js.YAW_UNITS_PER_TURN), ((from + delta * alpha) % chunkQCZOE65N_js.YAW_UNITS_PER_TURN + chunkQCZOE65N_js.YAW_UNITS_PER_TURN) % chunkQCZOE65N_js.YAW_UNITS_PER_TURN;
+}
+var RemoteTracks = class {
+  constructor() {
+    this.ticks = new Float64Array(SAMPLES);
+    this.xs = new Int32Array(SAMPLES);
+    this.ys = new Int32Array(SAMPLES);
+    this.zs = new Int32Array(SAMPLES);
+    this.yaws = new Uint16Array(SAMPLES);
+    this.animations = new Uint8Array(SAMPLES);
+    this.heads = new Int32Array(chunkQCZOE65N_js.ENTITY_CAPACITY);
+    this.counts = new Int32Array(chunkQCZOE65N_js.ENTITY_CAPACITY);
+  }
+  reset() {
+    this.counts.fill(0), this.heads.fill(0);
+  }
+  newestTick(slot) {
+    return this.counts[slot] === 0 ? -1 : this.ticks[slot * chunkQCZOE65N_js.REMOTE_HISTORY + this.heads[slot]];
+  }
+  push(slot, tick, x, y, z, yaw, animation) {
+    if (this.counts[slot] > 0 && tick <= this.newestTick(slot)) return;
+    let head = this.counts[slot] === 0 ? 0 : (this.heads[slot] + 1) % chunkQCZOE65N_js.REMOTE_HISTORY, at = slot * chunkQCZOE65N_js.REMOTE_HISTORY + head;
+    this.ticks[at] = tick, this.xs[at] = x, this.ys[at] = y, this.zs[at] = z, this.yaws[at] = yaw, this.animations[at] = animation, this.heads[slot] = head, this.counts[slot] < chunkQCZOE65N_js.REMOTE_HISTORY && (this.counts[slot] += 1);
+  }
+  sample(slot, renderTick, capTicks, out) {
+    let count = this.counts[slot];
+    if (count === 0) return Sampled.None;
+    let base = slot * chunkQCZOE65N_js.REMOTE_HISTORY, newest = base + this.heads[slot];
+    if (renderTick >= this.ticks[newest]) {
+      if (count === 1)
+        return this.copy(newest, out), Sampled.Extrapolated;
+      let previous = base + (this.heads[slot] + chunkQCZOE65N_js.REMOTE_HISTORY - 1) % chunkQCZOE65N_js.REMOTE_HISTORY, span = this.ticks[newest] - this.ticks[previous], ahead = Math.min(renderTick - this.ticks[newest], capTicks);
+      return this.blend(previous, newest, span > 0 ? 1 + ahead / span : 1, out), Sampled.Extrapolated;
+    }
+    let later = newest;
+    for (let back = 1; back < count; back++) {
+      let earlier = base + (this.heads[slot] + chunkQCZOE65N_js.REMOTE_HISTORY - back) % chunkQCZOE65N_js.REMOTE_HISTORY;
+      if (this.ticks[earlier] <= renderTick) {
+        let span = this.ticks[later] - this.ticks[earlier];
+        return this.blend(earlier, later, span > 0 ? (renderTick - this.ticks[earlier]) / span : 0, out), Sampled.Interpolated;
+      }
+      later = earlier;
+    }
+    return this.copy(later, out), Sampled.Interpolated;
+  }
+  copy(at, out) {
+    out.x = this.xs[at], out.y = this.ys[at], out.z = this.zs[at], out.yaw = this.yaws[at], out.animation = this.animations[at];
+  }
+  blend(from, to, alpha, out) {
+    out.x = this.xs[from] + (this.xs[to] - this.xs[from]) * alpha, out.y = this.ys[from] + (this.ys[to] - this.ys[from]) * alpha, out.z = this.zs[from] + (this.zs[to] - this.zs[from]) * alpha, out.yaw = yawBetween(this.yaws[from], this.yaws[to], alpha), out.animation = this.animations[to];
+  }
+};
+
+// src/interactives/rooms/pacing.ts
+function paceOf(code) {
+  return code === chunkQCZOE65N_js.Pace.Faster ? chunkQCZOE65N_js.Pace.Faster : code === chunkQCZOE65N_js.Pace.Slower ? chunkQCZOE65N_js.Pace.Slower : chunkQCZOE65N_js.Pace.Steady;
+}
+var ClientTicker = class {
+  constructor() {
+    this.nominalMs = 0;
+    this.intervalMs = 0;
+    this.nextAt = 0;
+    this.lastAt = 0;
+    this.current = chunkQCZOE65N_js.Pace.Steady;
+    this.tick = 0;
+    this.changes = 0;
+  }
+  start(simulationHz, firstTick, nowMs) {
+    this.nominalMs = chunkQCZOE65N_js.MS_PER_SECOND / simulationHz, this.intervalMs = this.nominalMs, this.current = chunkQCZOE65N_js.Pace.Steady, this.tick = firstTick, this.lastAt = nowMs, this.nextAt = nowMs + this.intervalMs;
+  }
+  get pace() {
+    return this.current;
+  }
+  get interval() {
+    return this.intervalMs;
+  }
+  steer(pace) {
+    pace !== this.current && (this.current = pace, this.changes += 1, this.intervalMs = pace === chunkQCZOE65N_js.Pace.Faster ? this.nominalMs * chunkQCZOE65N_js.PACE_FASTER_SCALE : pace === chunkQCZOE65N_js.Pace.Slower ? this.nominalMs * chunkQCZOE65N_js.PACE_SLOWER_SCALE : this.nominalMs);
+  }
+  due(nowMs) {
+    if (nowMs < this.nextAt) return 0;
+    let count = 0;
+    for (; nowMs >= this.nextAt && count < chunkQCZOE65N_js.MAX_CATCH_UP_TICKS; )
+      this.lastAt = this.nextAt, this.nextAt += this.intervalMs, count += 1;
+    return nowMs >= this.nextAt && (this.lastAt = nowMs, this.nextAt = nowMs + this.intervalMs), count;
+  }
+  subtick(sampledAtMs) {
+    let fraction = (sampledAtMs - this.lastAt) / this.intervalMs, units = Math.floor(fraction * chunkQCZOE65N_js.SUBTICKS_PER_TICK);
+    return units < 0 ? 0 : units > chunkQCZOE65N_js.MAX_SUBTICK ? chunkQCZOE65N_js.MAX_SUBTICK : units;
+  }
+};
+
+// src/interactives/rooms/prediction.ts
+var Predictor = class {
+  constructor(motion) {
+    this.xs = new Int32Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.zs = new Int32Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY);
+    this.predicted = new Float64Array(chunkQCZOE65N_js.INPUT_LOG_CAPACITY).fill(-1);
+    this.settled = false;
+    this.offsetX = 0;
+    this.offsetZ = 0;
+    this.stats = { corrections: 0, maxUnits: 0, totalUnits: 0 };
+    this.motion = motion;
+  }
+  get x() {
+    return this.motion.x;
+  }
+  get z() {
+    return this.motion.z;
+  }
+  get renderX() {
+    return this.motion.x + this.offsetX;
+  }
+  get renderZ() {
+    return this.motion.z + this.offsetZ;
+  }
+  begin(slot, applied) {
+    this.motion.spawn(slot), this.predicted.fill(-1), this.remember(applied), this.settled = false, this.offsetX = 0, this.offsetZ = 0;
+  }
+  predict(sequence, log) {
+    this.apply(sequence, log), this.remember(sequence);
+  }
+  reconcile(applied, x, y, z, log) {
+    let at = applied % chunkQCZOE65N_js.INPUT_LOG_CAPACITY;
+    if (this.predicted[at] !== applied) return false;
+    let errorX = x - this.xs[at], errorZ = z - this.zs[at], tolerance = this.motion.toleranceUnits;
+    if (Math.abs(errorX) <= tolerance && Math.abs(errorZ) <= tolerance)
+      return this.settled = true, true;
+    let motion = this.motion, beforeX = motion.x + this.offsetX, beforeZ = motion.z + this.offsetZ;
+    motion.place(x, y, z), this.remember(applied);
+    for (let sequence = applied + 1; sequence <= log.latest; sequence++) this.predict(sequence, log);
+    if (this.settled) {
+      let units = Math.hypot(errorX, errorZ);
+      this.stats.corrections += 1, this.stats.totalUnits += units, units > this.stats.maxUnits && (this.stats.maxUnits = units), this.offsetX = beforeX - motion.x, this.offsetZ = beforeZ - motion.z;
+    }
+    return this.settled = true, true;
+  }
+  decay(elapsedMs) {
+    if (this.offsetX === 0 && this.offsetZ === 0) return;
+    let keep = Math.exp(-elapsedMs / chunkQCZOE65N_js.SMOOTHING_TIME_CONSTANT_MS);
+    this.offsetX *= keep, this.offsetZ *= keep, Math.abs(this.offsetX) < chunkQCZOE65N_js.SETTLED_OFFSET_UNITS && Math.abs(this.offsetZ) < chunkQCZOE65N_js.SETTLED_OFFSET_UNITS && (this.offsetX = 0, this.offsetZ = 0);
+  }
+  apply(sequence, log) {
+    let motion = this.motion;
+    motion.steer(log.axisXOf(sequence), log.axisZOf(sequence), log.buttonsOf(sequence)), motion.step();
+  }
+  remember(sequence) {
+    let at = sequence % chunkQCZOE65N_js.INPUT_LOG_CAPACITY;
+    this.xs[at] = this.motion.x, this.zs[at] = this.motion.z, this.predicted[at] = sequence;
+  }
+};
+
+// src/interactives/rooms/send-governor.ts
+var SendGovernor = class {
+  constructor() {
+    this.stride = 1;
+    this.shed = 0;
+    this.skipped = 0;
+    this.calmSince = 0;
+  }
+  get pressured() {
+    return this.stride > 1;
+  }
+  pressure(nowMs) {
+    this.stride = Math.min(this.stride * 2, chunkQCZOE65N_js.MAX_SEND_STRIDE), this.calmSince = nowMs;
+  }
+  recover(nowMs) {
+    this.stride === 1 || nowMs - this.calmSince < chunkQCZOE65N_js.SEND_RECOVER_MS || (this.stride >>= 1, this.calmSince = nowMs, this.stride === 1 && (this.skipped = 0));
+  }
+  admit() {
+    return this.stride === 1 ? true : (this.skipped += 1, this.skipped < this.stride ? (this.shed += 1, false) : (this.skipped = 0, true));
+  }
+  force() {
+    return this.skipped = 0, true;
+  }
+  reset() {
+    this.stride = 1, this.skipped = 0, this.calmSince = 0;
+  }
+};
+
+// src/interactives/rooms/sized-views.ts
+var SizedViews = class {
+  constructor(buffer) {
+    this.buffer = buffer, this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength), this.views = Array.from({ length: buffer.length + 1 });
+  }
+  of(length) {
+    let cached = this.views[length];
+    if (cached) return cached;
+    let view = this.buffer.subarray(0, length);
+    return this.views[length] = view, view;
+  }
+};
+
+// src/interactives/rooms/snapshots.ts
+var Decoded = {
+  Stored: 0,
+  Duplicate: 1,
+  MissingBaseline: 2,
+  Malformed: 3
+}, DELTA_FULL = chunkWWKMOA76_js.FRAME_FLAGS.presence_delta.entry_full, DELTA_ANIMATION = chunkWWKMOA76_js.FRAME_FLAGS.presence_delta.entry_animation, DELTA_FLAGS = chunkWWKMOA76_js.FRAME_FLAGS.presence_delta.entry_flags, NO_TICK = -1, NO_ROW = -1, CELLS = chunkQCZOE65N_js.SNAPSHOT_RING * chunkQCZOE65N_js.ENTITY_CAPACITY;
+function newerTick(candidate, than) {
+  let ahead = (candidate - than + chunkQCZOE65N_js.U32_RANGE) % chunkQCZOE65N_js.U32_RANGE;
+  return ahead !== 0 && ahead < chunkQCZOE65N_js.U32_RANGE / 2;
+}
+var SnapshotStore = class {
+  constructor() {
+    this.present = new Uint8Array(CELLS);
+    this.x = new Uint16Array(CELLS);
+    this.y = new Int16Array(CELLS);
+    this.z = new Uint16Array(CELLS);
+    this.yaw = new Uint16Array(CELLS);
+    this.animation = new Uint8Array(CELLS);
+    this.flags = new Uint8Array(CELLS);
+    this.ticks = new Float64Array(chunkQCZOE65N_js.SNAPSHOT_RING).fill((-1));
+    this.seen = new Float64Array(chunkQCZOE65N_js.SEEN_TICKS).fill((-1));
+    this.header = {
+      flags: 0,
+      server_tick: 0,
+      cell_index: 0,
+      acked_input: 0,
+      layer: 0,
+      baseline_age: 0,
+      count: 0,
+      entries_offset: 0,
+      end: 0
+    };
+    this.entry = { slot: 0, x: 0, y: 0, z: 0, yaw: 0, animation: 0, flags: 0 };
+    this.delta = { slot: 0, mask: 0, x: 0, y: 0, z: 0, yaw: 0, animation: 0, flags: 0 };
+    this.next = 0;
+    this.latestRow = (-1);
+    this.lastKeyframe = false;
+  }
+  reset() {
+    this.ticks.fill((-1)), this.seen.fill((-1)), this.present.fill(0), this.next = 0, this.latestRow = (-1);
+  }
+  get hasLatest() {
+    return this.latestRow !== (-1);
+  }
+  get latestTick() {
+    return this.latestRow === (-1) ? (-1) : this.ticks[this.latestRow];
+  }
+  get latest() {
+    return this.latestRow;
+  }
+  tickOf(row) {
+    return this.ticks[row];
+  }
+  row(tick) {
+    for (let row = 0; row < chunkQCZOE65N_js.SNAPSHOT_RING; row++) if (this.ticks[row] === tick) return row;
+    return (-1);
+  }
+  rowByShortTick(short) {
+    let found = (-1);
+    for (let row = 0; row < chunkQCZOE65N_js.SNAPSHOT_RING; row++) {
+      let tick = this.ticks[row];
+      tick === (-1) || (tick & chunkQCZOE65N_js.SHORT_TICK_MASK) !== short || (found === (-1) || newerTick(tick, this.ticks[found])) && (found = row);
+    }
+    return found;
+  }
+  received(tick) {
+    return this.seen[tick % chunkQCZOE65N_js.SEEN_TICKS] === tick;
+  }
+  decode(view, offset, end) {
+    let header = this.header, compact = chunk66QP3SMN_js.peekFrameCode(view, offset, end) === chunk66QP3SMN_js.FrameCode.presence_delta;
+    if ((compact ? chunk66QP3SMN_js.decodePresenceDelta(view, offset, end, header) : chunk66QP3SMN_js.decodePresenceTick(view, offset, end, header)) < 0) return Decoded.Malformed;
+    let tick = header.server_tick;
+    if (this.row(tick) !== (-1)) return Decoded.Duplicate;
+    let keyframe = (header.flags & chunkQCZOE65N_js.KEYFRAME_FLAG) !== 0, row = this.next, start = row * chunkQCZOE65N_js.ENTITY_CAPACITY;
+    if (keyframe)
+      this.present.fill(0, start, start + chunkQCZOE65N_js.ENTITY_CAPACITY);
+    else {
+      let base = this.row((tick - header.baseline_age + chunkQCZOE65N_js.U32_RANGE) % chunkQCZOE65N_js.U32_RANGE);
+      if (base === (-1)) return Decoded.MissingBaseline;
+      base !== row && this.copyRow(base * chunkQCZOE65N_js.ENTITY_CAPACITY, start);
+    }
+    return compact ? this.applyDelta(view, start) : this.applyFull(view, start), this.ticks[row] = tick, this.seen[tick % chunkQCZOE65N_js.SEEN_TICKS] = tick, this.next = (row + 1) % chunkQCZOE65N_js.SNAPSHOT_RING, this.lastKeyframe = keyframe, this.latestRow = this.newestRow(), Decoded.Stored;
+  }
+  applyFull(view, start) {
+    let header = this.header, entry = this.entry;
+    for (let index = 0; index < header.count; index++) {
+      if (chunk66QP3SMN_js.readPresenceEntry(view, header, index, entry), entry.slot >= chunkQCZOE65N_js.ENTITY_CAPACITY) continue;
+      let cell = start + entry.slot;
+      this.present[cell] = 1, this.x[cell] = entry.x, this.y[cell] = entry.y, this.z[cell] = entry.z, this.yaw[cell] = entry.yaw, this.animation[cell] = entry.animation, this.flags[cell] = entry.flags;
+    }
+  }
+  applyDelta(view, start) {
+    let header = this.header, entry = this.delta, cursor = header.entries_offset;
+    for (let index = 0; index < header.count; index++) {
+      if (cursor = chunk66QP3SMN_js.readPresenceDeltaEntry(view, cursor, header.end, entry), cursor < 0) return;
+      if (entry.slot >= chunkQCZOE65N_js.ENTITY_CAPACITY) continue;
+      let cell = start + entry.slot;
+      if (this.present[cell] = 1, (entry.mask & DELTA_FULL) !== 0) {
+        this.x[cell] = entry.x, this.y[cell] = entry.y, this.z[cell] = entry.z, this.yaw[cell] = entry.yaw, this.animation[cell] = entry.animation, this.flags[cell] = entry.flags;
+        continue;
+      }
+      this.x[cell] += entry.x, this.y[cell] += entry.y, this.z[cell] += entry.z, this.yaw[cell] += entry.yaw, (entry.mask & DELTA_ANIMATION) !== 0 && (this.animation[cell] = entry.animation), (entry.mask & DELTA_FLAGS) !== 0 && (this.flags[cell] = entry.flags);
+    }
+  }
+  newestRow() {
+    let newest = (-1);
+    for (let row = 0; row < chunkQCZOE65N_js.SNAPSHOT_RING; row++)
+      this.ticks[row] !== (-1) && (newest === (-1) || newerTick(this.ticks[row], this.ticks[newest])) && (newest = row);
+    return newest;
+  }
+  get decodedRow() {
+    return (this.next + chunkQCZOE65N_js.SNAPSHOT_RING - 1) % chunkQCZOE65N_js.SNAPSHOT_RING;
+  }
+  copyRow(from, to) {
+    let until = from + chunkQCZOE65N_js.ENTITY_CAPACITY;
+    this.present.copyWithin(to, from, until), this.x.copyWithin(to, from, until), this.y.copyWithin(to, from, until), this.z.copyWithin(to, from, until), this.yaw.copyWithin(to, from, until), this.animation.copyWithin(to, from, until), this.flags.copyWithin(to, from, until);
+  }
+};
+
+// src/interactives/rooms/client.ts
+var RoomPhase = {
+  Idle: 0,
+  Ticketing: 1,
+  Connecting: 2,
+  Joined: 3,
+  Waiting: 4,
+  Refused: 5,
+  Closed: 6
+}, GAME_CHANNEL_SLOTS = chunkWWKMOA76_js.FRAME_LIMITS.game_channel_slots, GAME_CHANNEL_RELIABLE_BASE = chunkWWKMOA76_js.FRAME_LIMITS.game_channel_reliable_base, NO_TICK2 = -1, RATE_KEY_SCALE = 65536, ROOM_INPUT_COMMAND = chunkWWKMOA76_js.FRAME_FLAGS.room_input.command, ROOM_INPUT_HEADER = chunkWWKMOA76_js.FRAME_LAYOUT.room_input.header_bytes, CHANNEL_HEADER = chunkWWKMOA76_js.FRAME_LAYOUT.channel.header_bytes, LITTLE_ENDIAN2 = true, RETRYABLE = [JoinStatus.Full, JoinStatus.Overloaded, JoinStatus.Unavailable], RoomClient = class {
+  constructor(options) {
+    this.queue = new InboundQueue();
+    this.outbound = Array.from({ length: chunkQCZOE65N_js.OUTBOUND_POOL_SLOTS }, () => new SizedViews(new Uint8Array(chunkQCZOE65N_js.PACKET_BYTES)));
+    this.reply = blankReply();
+    this.ack = { slot: 0, sequence: 0, received_mask: 0 };
+    this.streamAcks = [];
+    this.clock = new ClockSync();
+    this.ticker = new ClientTicker();
+    this.governor = new SendGovernor();
+    this.seenSendFailures = 0;
+    this.leadBoost = 0;
+    this.log = new InputLog();
+    this.store = new SnapshotStore();
+    this.tracks = new RemoteTracks();
+    this.units = { x: 0, y: 0, z: 0, yaw: 0, animation: 0 };
+    this.appliedShort = new Int32Array(chunkQCZOE65N_js.APPLIED_RING).fill((-1));
+    this.appliedSequence = new Float64Array(chunkQCZOE65N_js.APPLIED_RING);
+    this.remoteSlots = new Uint16Array(chunkQCZOE65N_js.ENTITY_CAPACITY);
+    this.roomInput = { flags: ROOM_INPUT_COMMAND, action: 0, sequence: 0, client_tick: 0, sender: 0 };
+    this.channelHeader = { flags: 0, slot: 0, sequence: 0, sender: 0 };
+    this.channelMessage = { flags: 0, slot: 0, sequence: 0, sender: 0, payload_offset: 0, payload_length: 0 };
+    this.channelSequence = 0;
+    this.statistics = {
+      slot: chunkQCZOE65N_js.WATCHER_SLOT,
+      transport: null,
+      corrections: 0,
+      maxCorrectionM: 0,
+      meanCorrectionM: 0,
+      inputsSent: 0,
+      snapshots: 0,
+      deltas: 0,
+      keyframes: 0,
+      missingBaselines: 0,
+      rttMs: 0,
+      interpolationDelayMs: 0,
+      extrapolatingFrames: 0,
+      paceChanges: 0,
+      reconnects: 0,
+      dropped: 0,
+      sendFailures: 0,
+      sendStride: 1,
+      statesShed: 0
+    };
+    this.predictor = null;
+    this.predictorRates = 0;
+    this.link = null;
+    this.stateValue = RoomPhase.Idle;
+    this.pendingTicket = null;
+    this.ticketFailed = false;
+    this.resumeToken = null;
+    this.joinVersion = chunkQCZOE65N_js.JOIN_VERSION_DELTA;
+    this.request = null;
+    this.admittedAt = 0;
+    this.dialStartedAt = 0;
+    this.retryAt = 0;
+    this.lastUpdate = 0;
+    this.outboundNext = 0;
+    this.appliedNext = 0;
+    this.remoteCountValue = 0;
+    this.joins = 0;
+    this.slotValue = chunkQCZOE65N_js.WATCHER_SLOT;
+    this.watcher = true;
+    this.started = false;
+    this.freshSnapshot = false;
+    this.lastReconciled = (-1);
+    this.extrapolating = false;
+    this.ownTick = (-1);
+    this.ownX = 0;
+    this.ownY = 0;
+    this.ownZ = 0;
+    this.ownVelocityX = 0;
+    this.ownVelocityZ = 0;
+    this.inputAxisX = 0;
+    this.inputAxisZ = 0;
+    this.inputYaw = 0;
+    this.inputButtons = 0;
+    this.inputSubtick = 0;
+    this.commandSequence = 0;
+    this.cameraSequence = 0;
+    this.cameraX = 0;
+    this.cameraZ = 0;
+    this.cameraRadius = 0;
+    this.cameraDirty = false;
+    this.cameraSentAt = Number.NEGATIVE_INFINITY;
+    this.unackedSnapshots = 0;
+    this.ticketArrived = (ticket) => {
+      this.pendingTicket = ticket;
+    };
+    this.ticketRefused = () => {
+      this.ticketFailed = true;
+    };
+    this.tickets = options.tickets, this.spectatorAckEvery = Math.max(1, Math.floor(options.spectatorAckEvery ?? chunkQCZOE65N_js.SPECTATOR_ACK_EVERY)), this.physicsHz = options.physicsHz ?? 0, this.channelSink = options.channels ?? null, this.motionFactory = options.motion ?? locomotionMotion, this.connector = new Connector(
+      options.primary ?? null,
+      options.fallback ?? null,
+      options.memory ?? new StorageNetworkMemory(),
+      options.network ?? currentNetwork
+    );
+  }
+  get state() {
+    return this.stateValue;
+  }
+  get slot() {
+    return this.slotValue;
+  }
+  ackStream(slot, sequence) {
+    this.streamAcks.push({ slot, sequence });
+  }
+  get watching() {
+    return this.watcher;
+  }
+  get extrapolatingLocal() {
+    return this.extrapolating;
+  }
+  get serverTick() {
+    return this.store.latestTick;
+  }
+  get remoteCount() {
+    return this.remoteCountValue;
+  }
+  remoteSlot(index) {
+    return this.remoteSlots[index];
+  }
+  get stats() {
+    let stats = this.statistics, corrections = this.predictor?.stats;
+    return stats.slot = this.slotValue, stats.transport = this.link?.transport ?? null, stats.corrections = corrections?.corrections ?? 0, stats.maxCorrectionM = chunk66QP3SMN_js.dequantiseCellOffset(corrections?.maxUnits ?? 0), stats.meanCorrectionM = corrections && corrections.corrections > 0 ? chunk66QP3SMN_js.dequantiseCellOffset(corrections.totalUnits / corrections.corrections) : 0, stats.rttMs = this.clock.rttMs, stats.interpolationDelayMs = this.clock.interpolationDelayMs, stats.paceChanges = this.ticker.changes, stats.dropped = this.queue.dropped, stats.sendFailures = this.queue.sendFailures, stats.sendStride = this.governor.stride, stats.statesShed = this.governor.shed, stats;
+  }
+  start(nowMs) {
+    this.stateValue === RoomPhase.Idle && (this.lastUpdate = nowMs, this.fetchTicket());
+  }
+  close() {
+    this.connector.cancel(), this.link?.close(), this.link = null, this.stateValue = RoomPhase.Closed;
+  }
+  setInput(axisX, axisZ, yawRadians, buttons, nowMs) {
+    this.inputAxisX = chunk66QP3SMN_js.quantiseAxis(axisX), this.inputAxisZ = chunk66QP3SMN_js.quantiseAxis(axisZ), this.inputYaw = chunk66QP3SMN_js.quantiseYaw(yawRadians), this.inputButtons = buttons, this.inputSubtick = this.ticker.subtick(nowMs);
+  }
+  setCamera(xMetres, zMetres, radiusMetres) {
+    this.cameraX = chunk66QP3SMN_js.quantiseCellOffset(xMetres), this.cameraZ = chunk66QP3SMN_js.quantiseCellOffset(zMetres), this.cameraRadius = Math.max(0, Math.min(Math.round(radiusMetres), chunkQCZOE65N_js.SHORT_TICK_MASK)), this.cameraSequence += 1, this.cameraDirty = true;
+  }
+  sendCommand(action, payload, length) {
+    let link = this.link;
+    if (!link || this.watcher || this.stateValue !== RoomPhase.Joined) return -1;
+    let packet = this.packet(), input = this.roomInput;
+    input.flags = ROOM_INPUT_COMMAND, input.action = action, input.sequence = (this.commandSequence + 1) % chunkQCZOE65N_js.U32_RANGE, input.client_tick = this.ticker.tick >>> 0;
+    let total = chunk66QP3SMN_js.writeRoomInputHeader(packet.view, 0, input, length);
+    if (total < 0) return total;
+    let buffer = packet.buffer;
+    for (let index = 0; index < length; index++) buffer[ROOM_INPUT_HEADER + index] = payload[index];
+    return this.commandSequence = input.sequence, link.send(chunkQCZOE65N_js.Lane.Reliable, packet.of(total)), input.sequence;
+  }
+  sendChannel(slot, payload, length) {
+    let link = this.link;
+    if (!link || this.watcher || this.stateValue !== RoomPhase.Joined || slot < 0 || slot >= GAME_CHANNEL_SLOTS) return -1;
+    let packet = this.packet(), header = this.channelHeader;
+    header.slot = slot, header.sequence = (this.channelSequence + 1) % chunkQCZOE65N_js.U32_RANGE;
+    let total = chunk66QP3SMN_js.writeChannelHeader(packet.view, 0, header, length);
+    if (total < 0) return total;
+    let buffer = packet.buffer;
+    for (let index = 0; index < length; index++) buffer[CHANNEL_HEADER + index] = payload[index];
+    return this.channelSequence = header.sequence, link.send(slot < GAME_CHANNEL_RELIABLE_BASE ? chunkQCZOE65N_js.Lane.Datagram : chunkQCZOE65N_js.Lane.Reliable, packet.of(total)), header.sequence;
+  }
+  update(nowMs) {
+    let elapsed = nowMs - this.lastUpdate;
+    switch (this.lastUpdate = nowMs, this.stateValue) {
+      case RoomPhase.Ticketing:
+        this.dial(nowMs);
+        break;
+      case RoomPhase.Connecting:
+        this.connecting(nowMs);
+        break;
+      case RoomPhase.Waiting:
+        nowMs >= this.retryAt && this.fetchTicket();
+        break;
+    }
+    if (this.stateValue === RoomPhase.Joined) {
+      if (this.drain(nowMs), this.queue.lost) {
+        this.reconnect(nowMs);
+        return;
+      }
+      this.govern(nowMs), this.play(nowMs), this.predictor?.decay(elapsed), this.watchLatency();
+    }
+  }
+  localPose(out, nowMs) {
+    let predictor = this.predictor;
+    if (!predictor || !this.started) return false;
+    let x = predictor.renderX, z = predictor.renderZ;
+    if (this.extrapolating && this.ownTick !== (-1)) {
+      let projected = this.clock.serverTick(nowMs) + this.clock.leadTicks(), ahead = Math.max(0, Math.min(projected - this.ownTick, this.capTicks()));
+      x = this.ownX + this.ownVelocityX * ahead, z = this.ownZ + this.ownVelocityZ * ahead;
+    }
+    return out.x = chunk66QP3SMN_js.dequantiseCellOffset(x), out.y = chunk66QP3SMN_js.dequantiseHeight(this.ownY), out.z = chunk66QP3SMN_js.dequantiseCellOffset(z), out.yaw = chunk66QP3SMN_js.dequantiseYaw(this.inputYaw), out.animation = 0, true;
+  }
+  presence(slot, out) {
+    let store = this.store, row = store.latest;
+    if (slot < 0 || slot >= chunkQCZOE65N_js.ENTITY_CAPACITY || !store.hasLatest) return false;
+    let cell = row * chunkQCZOE65N_js.ENTITY_CAPACITY + slot;
+    return store.present[cell] === 0 ? false : (out.tick = store.tickOf(row), out.x = store.x[cell], out.y = store.y[cell], out.z = store.z[cell], out.yaw = store.yaw[cell], out.animation = store.animation[cell], out.flags = store.flags[cell], true);
+  }
+  remotePose(slot, out, nowMs) {
+    if (slot >= chunkQCZOE65N_js.ENTITY_CAPACITY) return false;
+    let units = this.units;
+    return this.tracks.sample(slot, this.clock.renderTick(nowMs), this.capTicks(), units) === Sampled.None ? false : (out.x = chunk66QP3SMN_js.dequantiseCellOffset(units.x), out.y = chunk66QP3SMN_js.dequantiseHeight(units.y), out.z = chunk66QP3SMN_js.dequantiseCellOffset(units.z), out.yaw = chunk66QP3SMN_js.dequantiseYaw(units.yaw), out.animation = units.animation, true);
+  }
+  capTicks() {
+    return chunkQCZOE65N_js.EXTRAPOLATION_CAP_MS / this.clock.tickIntervalMs;
+  }
+  fetchTicket() {
+    this.stateValue = RoomPhase.Ticketing, this.pendingTicket = null, this.ticketFailed = false, this.tickets().then(this.ticketArrived, this.ticketRefused);
+  }
+  dial(nowMs) {
+    if (this.ticketFailed) {
+      this.waitAndRetry(nowMs);
+      return;
+    }
+    let ticket = this.pendingTicket;
+    ticket && (this.pendingTicket = null, this.begin(ticketRequest(ticket, this.joinVersion), nowMs));
+  }
+  begin(request, nowMs) {
+    this.request = request, this.queue.clear(), this.dialStartedAt = nowMs, this.stateValue = RoomPhase.Connecting, this.connector.begin(request, this.queue, nowMs);
+  }
+  connecting(nowMs) {
+    let state = this.connector.poll(nowMs);
+    if (state === Connecting.Failed) {
+      this.waitAndRetry(nowMs);
+      return;
+    }
+    if (state !== Connecting.Won) return;
+    let dialed = this.connector.release();
+    if (!dialed || !decodeJoinReply(dialed.reply, this.reply)) {
+      dialed?.link.close(), this.waitAndRetry(nowMs);
+      return;
+    }
+    let status = this.reply.status;
+    if (status === JoinStatus.Admitted) {
+      this.joined(dialed.link, nowMs);
+      return;
+    }
+    dialed.link.close();
+    let request = this.request;
+    if (status === JoinStatus.Malformed && request !== null && withoutDeltaPresence(request)) {
+      this.joinVersion = chunkQCZOE65N_js.JOIN_VERSION, this.begin(request, nowMs);
+      return;
+    }
+    status === JoinStatus.UnknownResume || status === JoinStatus.Expired ? (this.resumeToken = null, this.fetchTicket()) : RETRYABLE.indexOf(status) >= 0 ? this.waitAndRetry(nowMs) : this.stateValue = RoomPhase.Refused;
+  }
+  waitAndRetry(nowMs) {
+    this.stateValue = RoomPhase.Waiting, this.retryAt = nowMs + chunkQCZOE65N_js.RETRY_AFTER_MS;
+  }
+  reconnect(nowMs) {
+    this.link?.close(), this.link = null;
+    let token = this.resumeToken;
+    if (token && nowMs - this.admittedAt < chunkQCZOE65N_js.RESUME_GRACE_MS) {
+      this.resumeToken = null, this.begin(resumeRequest(token, this.joinVersion), nowMs);
+      return;
+    }
+    this.resumeToken = null, this.fetchTicket();
+  }
+  joined(link, nowMs) {
+    let reply = this.reply;
+    this.link = link, this.stateValue = RoomPhase.Joined, this.admittedAt = nowMs, this.resumeToken = reply.resume.slice(), this.slotValue = reply.slot, this.watcher = reply.slot === chunkQCZOE65N_js.WATCHER_SLOT, this.joins > 0 && (this.statistics.reconnects += 1), this.joins += 1, this.clock.configure(reply.simulationHz, reply.sendHz, nowMs - this.dialStartedAt);
+    let physicsHz = this.physicsHz > 0 ? this.physicsHz : reply.simulationHz * chunkQCZOE65N_js.DEFAULT_SUBSTEPS, rates = reply.simulationHz * (65536) + physicsHz;
+    (!this.predictor || this.predictorRates !== rates) && (this.predictor = new Predictor(this.motionFactory(reply.simulationHz, physicsHz)), this.predictorRates = rates), this.store.reset(), this.tracks.reset(), this.appliedShort.fill((-1)), this.remoteCountValue = 0, this.lastReconciled = (-1), this.ownTick = (-1), this.started = false, this.freshSnapshot = false, this.extrapolating = false, this.cameraDirty = this.cameraSequence > 0, this.governor.reset(), this.seenSendFailures = this.queue.sendFailures, this.leadBoost = 0;
+  }
+  govern(nowMs) {
+    let failures = this.queue.sendFailures;
+    if (failures === this.seenSendFailures) {
+      this.governor.recover(nowMs);
+      return;
+    }
+    this.seenSendFailures = failures, this.governor.pressure(nowMs);
+  }
+  drain(nowMs) {
+    let queue = this.queue;
+    for (; queue.next(); ) {
+      let view = queue.view, end = queue.length, offset = 0;
+      for (; offset < end; ) {
+        let length = chunk66QP3SMN_js.frameLength(view, offset, end);
+        if (length <= 0) break;
+        let code = chunk66QP3SMN_js.peekFrameCode(view, offset, end);
+        code === chunk66QP3SMN_js.FrameCode.presence_tick || code === chunk66QP3SMN_js.FrameCode.presence_delta ? this.snapshot(view, offset, offset + length, nowMs) : code === chunk66QP3SMN_js.FrameCode.ack && chunk66QP3SMN_js.decodeAck(view, offset, offset + length, this.ack) > 0 ? this.acknowledged(nowMs) : code === chunk66QP3SMN_js.FrameCode.channel && this.channel(view, offset, offset + length), offset += length;
+      }
+    }
+  }
+  channel(view, offset, end) {
+    let sink = this.channelSink;
+    if (sink === null) return;
+    let message = this.channelMessage;
+    chunk66QP3SMN_js.decodeChannelFrame(view, offset, end, message) < 0 || sink.deliver(message.slot, message.sender, view, message.payload_offset, message.payload_length);
+  }
+  snapshot(view, offset, end, nowMs) {
+    let store = this.store, decoded = store.decode(view, offset, end);
+    if (decoded === Decoded.MissingBaseline) {
+      this.statistics.missingBaselines += 1;
+      return;
+    }
+    if (decoded !== Decoded.Stored) return;
+    let stats = this.statistics;
+    stats.snapshots += 1, store.lastKeyframe ? stats.keyframes += 1 : stats.deltas += 1;
+    let row = store.decodedRow, tick = store.tickOf(row);
+    this.clock.snapshot(tick, nowMs), this.freshSnapshot = true;
+    let fresh2 = row === store.latest, start = row * chunkQCZOE65N_js.ENTITY_CAPACITY;
+    fresh2 && (this.remoteCountValue = 0);
+    for (let slot = 0; slot < chunkQCZOE65N_js.ENTITY_CAPACITY; slot++) {
+      let cell = start + slot;
+      if (store.present[cell] !== 0) {
+        if (slot === this.slotValue) {
+          this.observeOwn(tick, store.x[cell], store.y[cell], store.z[cell]);
+          continue;
+        }
+        this.tracks.push(slot, tick, store.x[cell], store.y[cell], store.z[cell], store.yaw[cell], store.animation[cell]), fresh2 && (this.remoteSlots[this.remoteCountValue++] = slot);
+      }
+    }
+    let short = tick & chunkQCZOE65N_js.SHORT_TICK_MASK;
+    for (let index = 0; index < chunkQCZOE65N_js.APPLIED_RING; index++)
+      this.appliedShort[index] === short && this.reconcile(this.appliedSequence[index], row);
+  }
+  observeOwn(tick, x, y, z) {
+    if (!(this.ownTick !== (-1) && !newerTick(tick, this.ownTick))) {
+      if (this.ownTick !== (-1)) {
+        let span = tick - this.ownTick;
+        this.ownVelocityX = (x - this.ownX) / span, this.ownVelocityZ = (z - this.ownZ) / span;
+      }
+      this.ownTick = tick, this.ownX = x, this.ownY = y, this.ownZ = z;
+    }
+  }
+  acknowledged(nowMs) {
+    let ack = this.ack;
+    switch (ack.slot) {
+      case chunkQCZOE65N_js.MOVE_APPLIED_SLOT:
+        this.applied(ack.sequence, ack.received_mask, nowMs);
+        return;
+      case chunkQCZOE65N_js.MOVE_DURABLE_SLOT:
+        this.log.persist(ack.sequence);
+        return;
+      case chunkQCZOE65N_js.COMMAND_DURABLE_SLOT:
+        ack.sequence > this.commandSequence && (this.commandSequence = ack.sequence);
+        return;
+      default:
+        return;
+    }
+  }
+  applied(applied, mask, nowMs) {
+    let buffered = mask & chunkQCZOE65N_js.TIMING_BUFFERED_MASK, pace = paceOf(mask >>> chunkQCZOE65N_js.TIMING_PACE_SHIFT & chunkQCZOE65N_js.TIMING_BUFFERED_MASK), short = mask >>> chunkQCZOE65N_js.TIMING_TICK_SHIFT;
+    if (this.watcher) return;
+    this.started ? this.log.acknowledge(applied) && this.clock.roundTrip(nowMs - this.log.sentAtOf(applied) - buffered * this.clock.tickIntervalMs) : this.beginSession(applied, nowMs), this.ticker.steer(pace), this.appliedShort[this.appliedNext] = short, this.appliedSequence[this.appliedNext] = applied, this.appliedNext = (this.appliedNext + 1) % chunkQCZOE65N_js.APPLIED_RING;
+    let row = this.store.rowByShortTick(short);
+    row >= 0 && this.reconcile(applied, row);
+  }
+  beginSession(applied, nowMs) {
+    let log = this.log;
+    log.latest > applied && log.holds(applied + 1) ? log.rebase(applied) : (log.reset(applied), this.predictor?.begin(this.slotValue, applied));
+    let lead = Math.ceil(this.clock.leadTicks()) + chunkQCZOE65N_js.INPUT_BUFFER_TARGET;
+    this.ticker.start(this.reply.simulationHz, this.reply.tick + lead, nowMs), this.started = true;
+  }
+  reconcile(applied, row) {
+    let predictor = this.predictor;
+    if (!predictor || !this.started) return;
+    let store = this.store, tick = store.tickOf(row);
+    if (this.lastReconciled !== (-1) && !newerTick(tick, this.lastReconciled)) return;
+    let cell = row * chunkQCZOE65N_js.ENTITY_CAPACITY + this.slotValue;
+    store.present[cell] !== 0 && predictor.reconcile(applied, store.x[cell], store.y[cell], store.z[cell], this.log) && (this.lastReconciled = tick);
+  }
+  play(nowMs) {
+    if (this.watcher) {
+      this.freshSnapshot && (this.unackedSnapshots += 1), (this.unackedSnapshots >= this.spectatorAckEvery || this.cameraDue(nowMs)) && (this.unackedSnapshots = 0, this.governor.admit() && this.send(nowMs)), this.freshSnapshot = false;
+      return;
+    }
+    if (!this.started) return;
+    let predictor = this.predictor;
+    if (!predictor) return;
+    let boost = this.leadDebt(), due = this.ticker.due(nowMs) + boost, coalesce = this.governor.pressured;
+    for (let index = 0; index < due; index++) {
+      let sequence = this.log.push(
+        this.inputAxisX,
+        this.inputAxisZ,
+        this.inputYaw,
+        this.inputButtons,
+        this.ticker.tick,
+        this.inputSubtick
+      );
+      this.ticker.tick += 1, this.inputSubtick = 0, predictor.predict(sequence, this.log), this.statistics.inputsSent += 1, coalesce || this.send(nowMs);
+    }
+    coalesce && due > 0 && (boost > 0 ? this.governor.force() : this.governor.admit()) && this.send(nowMs), this.freshSnapshot = false;
+  }
+  leadDebt() {
+    let want = this.governor.stride - 1;
+    if (want <= this.leadBoost)
+      return this.leadBoost = want, 0;
+    let extra = want - this.leadBoost;
+    return this.leadBoost = want, extra;
+  }
+  cameraDue(nowMs) {
+    return this.cameraSequence > 0 && (this.cameraDirty || nowMs - this.cameraSentAt >= chunkQCZOE65N_js.CAMERA_RESEND_MS);
+  }
+  packet() {
+    let packet = this.outbound[this.outboundNext];
+    return this.outboundNext = (this.outboundNext + 1) % chunkQCZOE65N_js.OUTBOUND_POOL_SLOTS, packet;
+  }
+  send(nowMs) {
+    let link = this.link;
+    if (!link) return;
+    let packet = this.packet(), view = packet.view, offset = this.watcher ? 0 : this.log.write(view, 0, nowMs);
+    if (this.watcher && this.cameraDue(nowMs) && (offset += this.writeCamera(view, offset, nowMs)), this.store.hasLatest) {
+      let ack = this.ack;
+      ack.slot = chunkQCZOE65N_js.SNAPSHOT_STREAM_SLOT, ack.sequence = this.store.latestTick, ack.received_mask = this.receivedMask(ack.sequence);
+      let written = chunk66QP3SMN_js.encodeAck(view, offset, ack);
+      written > 0 && (offset += written);
+    }
+    for (let i = 0; i < this.streamAcks.length; i++) {
+      let stream = this.streamAcks[i], sequence = stream.sequence();
+      if (sequence < 0) continue;
+      let ack = this.ack;
+      ack.slot = stream.slot, ack.sequence = sequence >>> 0, ack.received_mask = 0;
+      let written = chunk66QP3SMN_js.encodeAck(view, offset, ack);
+      written > 0 && (offset += written);
+    }
+    offset > 0 && link.send(chunkQCZOE65N_js.Lane.Datagram, packet.of(offset));
+  }
+  writeCamera(view, offset, nowMs) {
+    let input = this.roomInput;
+    input.flags = 0, input.action = chunkQCZOE65N_js.CAMERA_ACTION, input.sequence = this.cameraSequence, input.client_tick = 0;
+    let total = chunk66QP3SMN_js.writeRoomInputHeader(view, offset, input, chunkQCZOE65N_js.CAMERA_PAYLOAD_BYTES);
+    if (total < 0) return 0;
+    let at = offset + ROOM_INPUT_HEADER;
+    return view.setUint16(at, this.cameraX, (true)), view.setUint16(at + 2, this.cameraZ, (true)), view.setUint16(at + 4, this.cameraRadius, (true)), this.cameraDirty = false, this.cameraSentAt = nowMs, total;
+  }
+  receivedMask(latest) {
+    let simulation = this.reply.simulationHz, sends = this.reply.sendHz, mask = 0, tick = latest;
+    for (let bit = 0; bit < chunkQCZOE65N_js.ACK_HISTORY_BITS && (tick = previousSend(tick, simulation, sends), !(tick < 0)); bit++)
+      this.store.received(tick) && (mask = (mask | 1 << bit) >>> 0);
+    return mask;
+  }
+  watchLatency() {
+    let rtt = this.clock.rttMs;
+    !this.extrapolating && rtt > chunkQCZOE65N_js.HIGH_LATENCY_ENTER_MS ? this.extrapolating = true : this.extrapolating && rtt < chunkQCZOE65N_js.HIGH_LATENCY_LEAVE_MS && (this.extrapolating = false), this.extrapolating && (this.statistics.extrapolatingFrames += 1);
+  }
+};
+function sendsOn(tick, simulationHz, sendHz) {
+  return Math.floor(tick * sendHz / simulationHz) !== Math.floor((tick - 1) * sendHz / simulationHz);
+}
+function previousSend(tick, simulationHz, sendHz) {
+  for (let candidate = tick - 1; candidate > 0; candidate--)
+    if (sendsOn(candidate, simulationHz, sendHz)) return candidate;
+  return -1;
+}
+
+// src/interactives/rooms/state-replica.ts
+var ROOM_STATE_SLOT = 65520;
+var STATE_CHUNK_BYTES = 16, STATE_FRAME_VERSION = 1, STATE_HEADER_BYTES = 20;
+var MAX_STATE_FRAGMENTS = 255;
+var TickStateReplica = class {
+  constructor() {
+    this.confirmed = new Uint8Array(0);
+    this.confirmedView = new DataView(this.confirmed.buffer);
+    this.pending = new Uint8Array(0);
+    this.predictedBytes = new Uint8Array(0);
+    this.predictedView = new DataView(this.predictedBytes.buffer);
+    this.received = new Uint8Array(Math.ceil(256 / 8));
+    this.confirmedTickValue = -1;
+    this.pendingTick = -1;
+    this.pendingCount = 0;
+    this.pendingFragments = 0;
+    this.listeners = [];
+    this.predictor = null;
+    this.stats = { fragments: 0, completed: 0, keyframes: 0, stale: 0, malformed: 0 };
+  }
+  get tick() {
+    return this.confirmedTickValue;
+  }
+  get bytes() {
+    return this.confirmed.length;
+  }
+  get state() {
+    return this.confirmedView;
+  }
+  get stateBytes() {
+    return this.confirmed;
+  }
+  onState(listener) {
+    return this.listeners.push(listener), () => {
+      let at = this.listeners.indexOf(listener);
+      at >= 0 && this.listeners.splice(at, 1);
+    };
+  }
+  predict(predictor) {
+    this.predictor = predictor;
+  }
+  predicted(toTick) {
+    let predictor = this.predictor;
+    return predictor === null || this.confirmedTickValue === -1 || toTick <= this.confirmedTickValue ? this.confirmedView : (this.predictedBytes.set(this.confirmed), predictor(this.confirmedView, this.predictedView, this.confirmedTickValue, toTick), this.predictedView);
+  }
+  ingest(view, offset, length) {
+    if (length < 20 || view.getUint8(offset + 0) !== 1)
+      return this.stats.malformed++, false;
+    this.stats.fragments++;
+    let keyframe = (view.getUint8(offset + 1) & 1) !== 0, fragment = view.getUint8(offset + 2), fragments = view.getUint8(offset + 3), tick = view.getUint32(offset + 4, true), base = view.getUint32(offset + 8, true), firstChunk = view.getUint16(offset + 12, true), chunkCount = view.getUint16(offset + 14, true), stateBytes = view.getUint32(offset + 16, true);
+    if (fragment >= fragments)
+      return this.stats.malformed++, false;
+    if (this.confirmedTickValue !== -1 && tick <= this.confirmedTickValue)
+      return this.stats.stale++, false;
+    if (!keyframe && (this.confirmedTickValue === -1 || base !== this.confirmedTickValue || stateBytes !== this.confirmed.length))
+      return this.stats.stale++, false;
+    if (tick !== this.pendingTick) {
+      if (this.pendingTick !== -1 && tick < this.pendingTick)
+        return this.stats.stale++, false;
+      this.begin(tick, stateBytes, fragments, keyframe);
+    }
+    let bit = 1 << fragment % 8, byte = fragment >> 3;
+    return (this.received[byte] & bit) !== 0 ? false : this.apply(view, offset + 20, offset + length, firstChunk, chunkCount) ? (this.received[byte] |= bit, this.pendingCount++, this.pendingCount < this.pendingFragments ? false : (this.complete(keyframe), true)) : (this.stats.malformed++, this.pendingTick = -1, false);
+  }
+  begin(tick, stateBytes, fragments, keyframe) {
+    this.confirmed.length !== stateBytes && (this.confirmed = new Uint8Array(stateBytes), this.confirmedView = new DataView(this.confirmed.buffer), this.pending = new Uint8Array(stateBytes), this.predictedBytes = new Uint8Array(stateBytes), this.predictedView = new DataView(this.predictedBytes.buffer), keyframe || (this.confirmedTickValue = -1)), this.pending.set(this.confirmed), this.received.fill(0), this.pendingTick = tick, this.pendingCount = 0, this.pendingFragments = fragments;
+  }
+  apply(view, at, end, firstChunk, chunkCount) {
+    let maskBytes = Math.ceil(chunkCount / 8), read = at + maskBytes;
+    if (read > end) return false;
+    let state = this.pending;
+    for (let index = 0; index < chunkCount; index++) {
+      if ((view.getUint8(at + (index >> 3)) & 1 << index % 8) === 0) continue;
+      let from = (firstChunk + index) * 16, to = Math.min(from + 16, state.length);
+      if (from >= to || read + (to - from) > end) return false;
+      for (let i = from; i < to; i++) state[i] = view.getUint8(read++);
+    }
+    return true;
+  }
+  complete(keyframe) {
+    this.confirmed.set(this.pending), this.confirmedTickValue = this.pendingTick, this.pendingTick = -1, this.stats.completed++, keyframe && this.stats.keyframes++;
+    for (let i = 0; i < this.listeners.length; i++) this.listeners[i](this.confirmedTickValue, this.confirmedView);
+  }
+};
+
+// src/interactives/rooms/links/web-socket.ts
+var BINARY = "arraybuffer", OPEN = 1, WebSocketLink = class {
+  constructor(socket) {
+    this.transport = Transport.WebSocket;
+    this.socket = socket;
+  }
+  send(_lane, bytes) {
+    this.socket.readyState === (1) && this.socket.send(bytes);
+  }
+  close() {
+    this.socket.close();
+  }
+}, Session = class {
+  constructor(socket, request, handler, settle) {
+    this.admitted = false;
+    this.finished = false;
+    this.opened = () => {
+      this.socket.send(this.request);
+    };
+    this.message = (event) => {
+      let data = event.data;
+      if (typeof data == "string") return;
+      let bytes = new Uint8Array(data);
+      if (this.admitted) {
+        this.handler.frame(chunkQCZOE65N_js.Lane.Datagram, bytes);
+        return;
+      }
+      this.admitted = true, this.settle({ link: new WebSocketLink(this.socket), reply: bytes });
+    };
+    this.ended = () => {
+      this.finished || (this.finished = true, this.admitted ? this.handler.closed() : this.settle(null));
+    };
+    this.socket = socket, this.request = request, this.handler = handler, this.settle = settle;
+  }
+  attach() {
+    let socket = this.socket;
+    socket.binaryType = BINARY, socket.onopen = this.opened, socket.onmessage = this.message, socket.onerror = this.ended, socket.onclose = this.ended;
+  }
+}, WebSocketDialer = class {
+  constructor(url) {
+    this.transport = Transport.WebSocket;
+    this.url = url;
+  }
+  dial(request, handler) {
+    return typeof globalThis.WebSocket != "function" ? Promise.resolve(null) : new Promise((settle) => {
+      try {
+        new Session(new WebSocket(this.url), request, handler, settle).attach();
+      } catch {
+        settle(null);
+      }
+    });
+  }
+};
+
+// src/interactives/rooms/links/stream-framer.ts
+var StreamFramer = class {
+  constructor() {
+    this.buffer = new Uint8Array(chunkQCZOE65N_js.STREAM_BUFFER_BYTES);
+    this.view = new DataView(this.buffer.buffer);
+    this.start = 0;
+    this.end = 0;
+  }
+  push(chunk) {
+    return this.end + chunk.length > this.buffer.length && (this.buffer.copyWithin(0, this.start, this.end), this.end -= this.start, this.start = 0), this.end + chunk.length > this.buffer.length ? false : (this.buffer.set(chunk, this.end), this.end += chunk.length, true);
+  }
+  next() {
+    if (this.end - this.start < chunkQCZOE65N_js.LANE_LENGTH_BYTES) return null;
+    let length = this.view.getUint16(this.start, true), from = this.start + chunkQCZOE65N_js.LANE_LENGTH_BYTES;
+    return this.end - from < length ? null : (this.start = from + length, this.buffer.subarray(from, from + length));
+  }
+};
+function lengthPrefixed(bytes, out) {
+  let total = chunkQCZOE65N_js.LANE_LENGTH_BYTES + bytes.length;
+  return total > out.length ? -1 : (out[0] = bytes.length & 255, out[1] = bytes.length >>> 8, out.set(bytes, chunkQCZOE65N_js.LANE_LENGTH_BYTES), total);
+}
+
+// src/interactives/rooms/links/web-transport.ts
+var RELIABLE_SCRATCH = 8;
+function ignore() {
+}
+function shut(session) {
+  try {
+    session?.close();
+  } catch {
+    return;
+  }
+}
+var WebTransportLink = class {
+  constructor(session, stream, datagrams) {
+    this.transport = Transport.WebTransport;
+    this.next = 0;
+    this.open = true;
+    this.session = session, this.stream = stream, this.datagrams = datagrams, this.scratch = Array.from({ length: (8) }, () => new SizedViews(new Uint8Array(chunkQCZOE65N_js.PACKET_BYTES + chunkQCZOE65N_js.LANE_LENGTH_BYTES)));
+  }
+  send(lane, bytes) {
+    if (!this.open) return;
+    if (lane === chunkQCZOE65N_js.Lane.Datagram) {
+      this.datagrams.write(bytes).catch(ignore);
+      return;
+    }
+    let scratch = this.scratch[this.next];
+    this.next = (this.next + 1) % (8);
+    let length = lengthPrefixed(bytes, scratch.buffer);
+    length < 0 || this.stream.write(scratch.of(length)).catch(ignore);
+  }
+  close() {
+    this.open && (this.open = false, shut(this.session));
+  }
+}, Watch = class {
+  constructor(handler) {
+    this.done = false;
+    this.end = () => {
+      this.done || (this.done = true, this.handler.closed());
+    };
+    this.handler = handler;
+  }
+};
+async function pumpDatagrams(reader, handler, watch) {
+  try {
+    for (; ; ) {
+      let read = await reader.read();
+      if (read.done) break;
+      handler.frame(chunkQCZOE65N_js.Lane.Datagram, read.value);
+    }
+  } catch {
+    watch.end();
+    return;
+  }
+  watch.end();
+}
+async function pumpStream(reader, framer, handler, watch) {
+  try {
+    for (; ; ) {
+      for (let frame = framer.next(); frame; frame = framer.next()) handler.frame(chunkQCZOE65N_js.Lane.Reliable, frame);
+      let read = await reader.read();
+      if (read.done || !framer.push(read.value)) break;
+    }
+  } catch {
+    watch.end();
+    return;
+  }
+  watch.end();
+}
+var WebTransportDialer = class _WebTransportDialer {
+  constructor(url, options = {}) {
+    this.transport = Transport.WebTransport;
+    this.url = url, this.options = options;
+  }
+  static available() {
+    return typeof globalThis.WebTransport == "function";
+  }
+  async dial(request, handler) {
+    if (!_WebTransportDialer.available()) return null;
+    let session = null;
+    try {
+      session = new WebTransport(this.url, this.options), await session.ready;
+      let stream = await session.createBidirectionalStream(), writer = stream.writable.getWriter(), prefixed = new Uint8Array(chunkQCZOE65N_js.LANE_LENGTH_BYTES + request.length);
+      lengthPrefixed(request, prefixed), await writer.write(prefixed);
+      let reader = stream.readable.getReader(), framer = new StreamFramer(), reply = framer.next();
+      for (; !reply; ) {
+        let read = await reader.read();
+        if (read.done || !framer.push(read.value))
+          return shut(session), null;
+        reply = framer.next();
+      }
+      let copied = reply.slice(), watch = new Watch(handler), datagrams = session.datagrams.writable.getWriter(), link = new WebTransportLink(session, writer, datagrams);
+      return pumpDatagrams(session.datagrams.readable.getReader(), handler, watch), pumpStream(reader, framer, handler, watch), session.closed.then(watch.end, watch.end), { link, reply: copied };
+    } catch {
+      return shut(session), null;
+    }
+  }
+};
+
+exports.Connecting = Connecting;
+exports.Connector = Connector;
+exports.GAME_CHANNEL_RELIABLE_BASE = GAME_CHANNEL_RELIABLE_BASE;
+exports.GAME_CHANNEL_SLOTS = GAME_CHANNEL_SLOTS;
+exports.InMemoryNetworkMemory = InMemoryNetworkMemory;
+exports.JoinStatus = JoinStatus;
+exports.Locomotion = Locomotion;
+exports.LocomotionMotion = LocomotionMotion;
+exports.MAX_STATE_FRAGMENTS = (255);
+exports.ROOM_STATE_SLOT = (65520);
+exports.RoomClient = RoomClient;
+exports.RoomPhase = RoomPhase;
+exports.STATE_CHUNK_BYTES = (16);
+exports.STATE_FRAME_VERSION = (1);
+exports.STATE_HEADER_BYTES = (20);
+exports.SizedViews = SizedViews;
+exports.StorageNetworkMemory = StorageNetworkMemory;
+exports.TickStateReplica = TickStateReplica;
+exports.Transport = Transport;
+exports.WebSocketDialer = WebSocketDialer;
+exports.WebTransportDialer = WebTransportDialer;
+exports.blankReply = blankReply;
+exports.currentNetwork = currentNetwork;
+exports.decodeJoinReply = decodeJoinReply;
+exports.isqrt = isqrt;
+exports.locomotionMotion = locomotionMotion;
+exports.perAxisUnit = perAxisUnit;
+exports.previousSend = previousSend;
+exports.resumeRequest = resumeRequest;
+exports.sendsOn = sendsOn;
+exports.spawn = spawn;
+exports.steer = steer;
+exports.ticketRequest = ticketRequest;