@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-M5EXQZYY.mjs

@@ -0,0 +1,1519 @@
+import { JOIN_VERSION_DELTA, FALLBACK_AFTER_MS, CONNECT_TIMEOUT_MS, RESUME_TOKEN_BYTES, JOIN_REPLY_BYTES, JOIN_VERSION, U32_RANGE, AXIS_LIMIT, NANOS_PER_SECOND, SPAWN_ORIGIN_UNITS, SPAWN_ROW, SPAWN_SPACING_UNITS, WALK_UNITS_PER_SECOND, SPRINT_UNITS_PER_SECOND, BUTTON_SPRINT, VELOCITY_FRACTION, NETWORK_MEMORY_PREFIX, DEFAULT_NETWORK, OUTBOUND_POOL_SLOTS, PACKET_BYTES, APPLIED_RING, ENTITY_CAPACITY, WATCHER_SLOT, SPECTATOR_ACK_EVERY, SHORT_TICK_MASK, Lane, EXTRAPOLATION_CAP_MS, RETRY_AFTER_MS, RESUME_GRACE_MS, DEFAULT_SUBSTEPS, COMMAND_DURABLE_SLOT, MOVE_DURABLE_SLOT, MOVE_APPLIED_SLOT, INPUT_BUFFER_TARGET, CAMERA_RESEND_MS, SNAPSHOT_STREAM_SLOT, CAMERA_ACTION, CAMERA_PAYLOAD_BYTES, ACK_HISTORY_BITS, HIGH_LATENCY_ENTER_MS, HIGH_LATENCY_LEAVE_MS, LANE_LENGTH_BYTES, TIMING_BUFFERED_MASK, TIMING_TICK_SHIFT, JOIN_HEADER_BYTES, MAX_JOIN_BYTES, CELL_MAX_UNITS, NETWORK_MEMORY_TTL_MS, INBOUND_POOL_SLOTS, OFFSET_WINDOW, RTT_WINDOW, MS_PER_SECOND, INTERPOLATION_SEND_INTERVALS, JITTER_SMOOTHING, JITTER_MULTIPLIER, MAX_INTERPOLATION_DELAY_MS, DELAY_SMOOTHING, RTT_SMOOTHING, Pace, PACE_FASTER_SCALE, PACE_SLOWER_SCALE, MAX_CATCH_UP_TICKS, MAX_SUBTICK, MAX_SEND_STRIDE, SEND_RECOVER_MS, INPUT_LOG_CAPACITY, ROOM_LAYER, MAX_INPUTS_PER_PACKET, U16_RANGE, SNAPSHOT_RING, SEEN_TICKS, KEYFRAME_FLAG, REMOTE_HISTORY, SETTLED_OFFSET_UNITS, TIMING_PACE_SHIFT, STREAM_BUFFER_BYTES, SUBTICKS_PER_TICK, YAW_UNITS_PER_TURN, SMOOTHING_TIME_CONSTANT_MS, JOIN_TICKET, JOIN_RESUME, HALF_YAW_UNITS } from './chunk-TU5RYTYU.mjs';
+import { dequantiseCellOffset, quantiseAxis, quantiseYaw, quantiseCellOffset, writeRoomInputHeader, writeChannelHeader, dequantiseHeight, dequantiseYaw, frameLength, peekFrameCode, FrameCode, decodeAck, decodeChannelFrame, encodeAck, FrameBufferPool, encodeMoveInput, decodePresenceDelta, decodePresenceTick, readPresenceEntry, readPresenceDeltaEntry } from './chunk-OQRVEM56.mjs';
+import { FRAME_FLAGS, FRAME_LIMITS, FRAME_LAYOUT } from './chunk-SPCRQ6NO.mjs';
+
+// 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 >= FALLBACK_AFTER_MS || this.first?.settled === Settled.Failed) && this.launchFallback(), this.state === Connecting.Pending && (elapsed >= 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(RESUME_TOKEN_BYTES),
+    simulationHz: 0,
+    sendHz: 0,
+    tick: 0
+  };
+}
+function joinRequest(kind, body, version) {
+  if (JOIN_HEADER_BYTES + body.length > MAX_JOIN_BYTES) throw new RangeError("the join request is too large");
+  let out = new Uint8Array(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, JOIN_HEADER_BYTES), out;
+}
+function ticketRequest(ticket, version = JOIN_VERSION_DELTA) {
+  return joinRequest(JOIN_TICKET, ticket, version);
+}
+function resumeRequest(token, version = JOIN_VERSION_DELTA) {
+  return joinRequest(JOIN_RESUME, token, version);
+}
+function withoutDeltaPresence(request) {
+  return request.length === 0 || request[0] !== JOIN_VERSION_DELTA ? false : (request[0] = JOIN_VERSION, true);
+}
+function decodeJoinReply(bytes, out) {
+  if (bytes.length !== JOIN_REPLY_BYTES) return false;
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint8(0) !== 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 + RESUME_TOKEN_BYTES)), out.simulationHz = view.getUint16(24, (true)), out.sendHz = view.getUint16(26, (true)), out.tick = view.getUint32(32, (true)) * U32_RANGE + view.getUint32(28, (true)), true);
+}
+
+// src/interactives/rooms/locomotion.ts
+var FRACTION_BITS = BigInt(24), LIMIT_SQUARED = AXIS_LIMIT * AXIS_LIMIT;
+function perAxisUnit(unitsPerSecond, stepNs) {
+  let scaled = BigInt(unitsPerSecond) * BigInt(stepNs) << FRACTION_BITS, divisor = BigInt(AXIS_LIMIT) * BigInt(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 = SPAWN_ORIGIN_UNITS + slot % SPAWN_ROW * SPAWN_SPACING_UNITS, body.z = SPAWN_ORIGIN_UNITS + Math.floor(slot / SPAWN_ROW) * SPAWN_SPACING_UNITS, body.axisX = 0, body.axisZ = 0, body.buttons = 0;
+}
+function steer(body, axisX, axisZ, buttons) {
+  let x = Math.max(axisX, -AXIS_LIMIT), z = Math.max(axisZ, -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 * AXIS_LIMIT / magnitude), body.axisZ = Math.trunc(z * AXIS_LIMIT / magnitude);
+  }
+  body.buttons = buttons;
+}
+function clampUnits(value) {
+  return value < 0 ? 0 : value > CELL_MAX_UNITS ? CELL_MAX_UNITS : value;
+}
+var Locomotion = class {
+  constructor(simulationHz, physicsHz) {
+    this.substeps = Math.ceil(physicsHz / simulationHz), this.stepNs = Math.floor(NANOS_PER_SECOND / (simulationHz * this.substeps)), this.walk = perAxisUnit(WALK_UNITS_PER_SECOND, this.stepNs), this.sprint = perAxisUnit(SPRINT_UNITS_PER_SECOND, this.stepNs);
+  }
+  step(body) {
+    let scale = (body.buttons & BUTTON_SPRINT) !== 0 ? this.sprint : this.walk, stepX = Math.floor(body.axisX * scale / VELOCITY_FRACTION), stepZ = Math.floor(body.axisZ * scale / 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 > 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(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(NETWORK_MEMORY_PREFIX + network, JSON.stringify({ transport, at: nowMs }));
+    } catch {
+      return;
+    }
+  }
+};
+function currentNetwork() {
+  let connection = globalThis.navigator?.connection;
+  return connection?.type ?? connection?.effectiveType ?? DEFAULT_NETWORK;
+}
+
+// src/interactives/rooms/clock-sync.ts
+var ClockSync = class {
+  constructor() {
+    this.tickMs = 0;
+    this.sendIntervalMs = 0;
+    this.offsets = new Float64Array(OFFSET_WINDOW);
+    this.rtts = new Float64Array(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 = MS_PER_SECOND / simulationHz, this.sendIntervalMs = 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 = 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) % OFFSET_WINDOW, this.offsetCount < 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) * JITTER_SMOOTHING;
+    let target = Math.min(
+      INTERPOLATION_SEND_INTERVALS * this.sendIntervalMs + JITTER_MULTIPLIER * this.jitter,
+      MAX_INTERPOLATION_DELAY_MS
+    );
+    this.delay += (target - this.delay) * DELAY_SMOOTHING;
+  }
+  roundTrip(sampleMs) {
+    if (!(sampleMs >= 0)) return;
+    this.rtts[this.rttNext] = sampleMs, this.rttNext = (this.rttNext + 1) % RTT_WINDOW, this.rttCount < 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) * 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 FrameBufferPool(INBOUND_POOL_SLOTS, PACKET_BYTES);
+    this.slots = new Int32Array(INBOUND_POOL_SLOTS);
+    this.lanes = new Uint8Array(INBOUND_POOL_SLOTS);
+    this.lengths = new Int32Array(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) % INBOUND_POOL_SLOTS, this.count -= 1;
+    this.lost = false;
+  }
+  frame(lane, bytes) {
+    if (bytes.length > PACKET_BYTES || this.count === 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) % 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) % 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(INPUT_LOG_CAPACITY);
+    this.axisX = new Int16Array(INPUT_LOG_CAPACITY);
+    this.axisZ = new Int16Array(INPUT_LOG_CAPACITY);
+    this.yaw = new Uint16Array(INPUT_LOG_CAPACITY);
+    this.clientTick = new Float64Array(INPUT_LOG_CAPACITY);
+    this.subtick = new Uint8Array(INPUT_LOG_CAPACITY);
+    this.sentAt = new Float64Array(INPUT_LOG_CAPACITY);
+    this.frame = {
+      buttons: 0,
+      sequence: 0,
+      client_tick: 0,
+      axis_x: 0,
+      axis_z: 0,
+      yaw: 0,
+      layer: 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 >= 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 >= INPUT_LOG_CAPACITY && (this.durableSequence += 1);
+    let sequence = this.latestSequence + 1, at = sequence % 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 % INPUT_LOG_CAPACITY];
+  }
+  axisZOf(sequence) {
+    return this.axisZ[sequence % INPUT_LOG_CAPACITY];
+  }
+  buttonsOf(sequence) {
+    return this.buttons[sequence % INPUT_LOG_CAPACITY];
+  }
+  yawOf(sequence) {
+    return this.yaw[sequence % INPUT_LOG_CAPACITY];
+  }
+  sentAtOf(sequence) {
+    return this.holds(sequence) ? this.sentAt[sequence % INPUT_LOG_CAPACITY] : Number.NaN;
+  }
+  write(view, offset, nowMs) {
+    let first = Math.max(this.appliedSequence, this.durableSequence) + 1, last = Math.min(this.latestSequence, first + MAX_INPUTS_PER_PACKET - 1), at = offset, frame = this.frame;
+    for (let sequence = first; sequence <= last; sequence++) {
+      let slot = sequence % INPUT_LOG_CAPACITY;
+      frame.buttons = this.buttons[slot], frame.sequence = sequence % 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 = 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 = ENTITY_CAPACITY * REMOTE_HISTORY;
+function yawBetween(from, to, alpha) {
+  let delta = to - from;
+  return delta > HALF_YAW_UNITS ? delta -= YAW_UNITS_PER_TURN : delta < -HALF_YAW_UNITS && (delta += YAW_UNITS_PER_TURN), ((from + delta * alpha) % YAW_UNITS_PER_TURN + YAW_UNITS_PER_TURN) % 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(ENTITY_CAPACITY);
+    this.counts = new Int32Array(ENTITY_CAPACITY);
+  }
+  reset() {
+    this.counts.fill(0), this.heads.fill(0);
+  }
+  newestTick(slot) {
+    return this.counts[slot] === 0 ? -1 : this.ticks[slot * 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) % REMOTE_HISTORY, at = slot * 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] < 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 * 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] + REMOTE_HISTORY - 1) % 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] + REMOTE_HISTORY - back) % 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 === Pace.Faster ? Pace.Faster : code === Pace.Slower ? Pace.Slower : Pace.Steady;
+}
+var ClientTicker = class {
+  constructor() {
+    this.nominalMs = 0;
+    this.intervalMs = 0;
+    this.nextAt = 0;
+    this.lastAt = 0;
+    this.current = Pace.Steady;
+    this.tick = 0;
+    this.changes = 0;
+  }
+  start(simulationHz, firstTick, nowMs) {
+    this.nominalMs = MS_PER_SECOND / simulationHz, this.intervalMs = this.nominalMs, this.current = 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 === Pace.Faster ? this.nominalMs * PACE_FASTER_SCALE : pace === Pace.Slower ? this.nominalMs * PACE_SLOWER_SCALE : this.nominalMs);
+  }
+  due(nowMs) {
+    if (nowMs < this.nextAt) return 0;
+    let count = 0;
+    for (; nowMs >= this.nextAt && count < 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 * SUBTICKS_PER_TICK);
+    return units < 0 ? 0 : units > MAX_SUBTICK ? MAX_SUBTICK : units;
+  }
+};
+
+// src/interactives/rooms/prediction.ts
+var Predictor = class {
+  constructor(motion) {
+    this.xs = new Int32Array(INPUT_LOG_CAPACITY);
+    this.zs = new Int32Array(INPUT_LOG_CAPACITY);
+    this.predicted = new Float64Array(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 % 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 / SMOOTHING_TIME_CONSTANT_MS);
+    this.offsetX *= keep, this.offsetZ *= keep, Math.abs(this.offsetX) < SETTLED_OFFSET_UNITS && Math.abs(this.offsetZ) < 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 % 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, MAX_SEND_STRIDE), this.calmSince = nowMs;
+  }
+  recover(nowMs) {
+    this.stride === 1 || nowMs - this.calmSince < 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 = FRAME_FLAGS.presence_delta.entry_full, DELTA_ANIMATION = FRAME_FLAGS.presence_delta.entry_animation, DELTA_FLAGS = FRAME_FLAGS.presence_delta.entry_flags, NO_TICK = -1, NO_ROW = -1, CELLS = SNAPSHOT_RING * ENTITY_CAPACITY;
+function newerTick(candidate, than) {
+  let ahead = (candidate - than + U32_RANGE) % U32_RANGE;
+  return ahead !== 0 && ahead < 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(SNAPSHOT_RING).fill((-1));
+    this.seen = new Float64Array(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 < SNAPSHOT_RING; row++) if (this.ticks[row] === tick) return row;
+    return (-1);
+  }
+  rowByShortTick(short) {
+    let found = (-1);
+    for (let row = 0; row < SNAPSHOT_RING; row++) {
+      let tick = this.ticks[row];
+      tick === (-1) || (tick & SHORT_TICK_MASK) !== short || (found === (-1) || newerTick(tick, this.ticks[found])) && (found = row);
+    }
+    return found;
+  }
+  received(tick) {
+    return this.seen[tick % SEEN_TICKS] === tick;
+  }
+  decode(view, offset, end) {
+    let header = this.header, compact = peekFrameCode(view, offset, end) === FrameCode.presence_delta;
+    if ((compact ? decodePresenceDelta(view, offset, end, header) : 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 & KEYFRAME_FLAG) !== 0, row = this.next, start = row * ENTITY_CAPACITY;
+    if (keyframe)
+      this.present.fill(0, start, start + ENTITY_CAPACITY);
+    else {
+      let base = this.row((tick - header.baseline_age + U32_RANGE) % U32_RANGE);
+      if (base === (-1)) return Decoded.MissingBaseline;
+      base !== row && this.copyRow(base * ENTITY_CAPACITY, start);
+    }
+    return compact ? this.applyDelta(view, start) : this.applyFull(view, start), this.ticks[row] = tick, this.seen[tick % SEEN_TICKS] = tick, this.next = (row + 1) % 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 (readPresenceEntry(view, header, index, entry), entry.slot >= 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 = readPresenceDeltaEntry(view, cursor, header.end, entry), cursor < 0) return;
+      if (entry.slot >= 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 < 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 + SNAPSHOT_RING - 1) % SNAPSHOT_RING;
+  }
+  copyRow(from, to) {
+    let until = from + 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 = FRAME_LIMITS.game_channel_slots, GAME_CHANNEL_RELIABLE_BASE = FRAME_LIMITS.game_channel_reliable_base, NO_TICK2 = -1, RATE_KEY_SCALE = 65536, ROOM_INPUT_COMMAND = FRAME_FLAGS.room_input.command, ROOM_INPUT_HEADER = FRAME_LAYOUT.room_input.header_bytes, CHANNEL_HEADER = 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: OUTBOUND_POOL_SLOTS }, () => new SizedViews(new Uint8Array(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(APPLIED_RING).fill((-1));
+    this.appliedSequence = new Float64Array(APPLIED_RING);
+    this.remoteSlots = new Uint16Array(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: 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 = 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 = 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 ?? 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 = dequantiseCellOffset(corrections?.maxUnits ?? 0), stats.meanCorrectionM = corrections && corrections.corrections > 0 ? 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 = quantiseAxis(axisX), this.inputAxisZ = quantiseAxis(axisZ), this.inputYaw = quantiseYaw(yawRadians), this.inputButtons = buttons, this.inputSubtick = this.ticker.subtick(nowMs);
+  }
+  setCamera(xMetres, zMetres, radiusMetres) {
+    this.cameraX = quantiseCellOffset(xMetres), this.cameraZ = quantiseCellOffset(zMetres), this.cameraRadius = Math.max(0, Math.min(Math.round(radiusMetres), 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) % U32_RANGE, input.client_tick = this.ticker.tick >>> 0;
+    let total = 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(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) % U32_RANGE;
+    let total = 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 ? Lane.Datagram : 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 = dequantiseCellOffset(x), out.y = dequantiseHeight(this.ownY), out.z = dequantiseCellOffset(z), out.yaw = dequantiseYaw(this.inputYaw), out.animation = 0, true;
+  }
+  presence(slot, out) {
+    let store = this.store, row = store.latest;
+    if (slot < 0 || slot >= ENTITY_CAPACITY || !store.hasLatest) return false;
+    let cell = row * 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 >= 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 = dequantiseCellOffset(units.x), out.y = dequantiseHeight(units.y), out.z = dequantiseCellOffset(units.z), out.yaw = dequantiseYaw(units.yaw), out.animation = units.animation, true);
+  }
+  capTicks() {
+    return 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 = 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 + RETRY_AFTER_MS;
+  }
+  reconnect(nowMs) {
+    this.link?.close(), this.link = null;
+    let token = this.resumeToken;
+    if (token && nowMs - this.admittedAt < 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 === 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 * 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 = frameLength(view, offset, end);
+        if (length <= 0) break;
+        let code = peekFrameCode(view, offset, end);
+        code === FrameCode.presence_tick || code === FrameCode.presence_delta ? this.snapshot(view, offset, offset + length, nowMs) : code === FrameCode.ack && decodeAck(view, offset, offset + length, this.ack) > 0 ? this.acknowledged(nowMs) : code === 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;
+    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 * ENTITY_CAPACITY;
+    fresh2 && (this.remoteCountValue = 0);
+    for (let slot = 0; slot < 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 & SHORT_TICK_MASK;
+    for (let index = 0; index < 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 MOVE_APPLIED_SLOT:
+        this.applied(ack.sequence, ack.received_mask, nowMs);
+        return;
+      case MOVE_DURABLE_SLOT:
+        this.log.persist(ack.sequence);
+        return;
+      case COMMAND_DURABLE_SLOT:
+        ack.sequence > this.commandSequence && (this.commandSequence = ack.sequence);
+        return;
+      default:
+        return;
+    }
+  }
+  applied(applied, mask, nowMs) {
+    let buffered = mask & TIMING_BUFFERED_MASK, pace = paceOf(mask >>> TIMING_PACE_SHIFT & TIMING_BUFFERED_MASK), short = mask >>> 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) % 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()) + 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 * 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 >= CAMERA_RESEND_MS);
+  }
+  packet() {
+    let packet = this.outbound[this.outboundNext];
+    return this.outboundNext = (this.outboundNext + 1) % 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 = SNAPSHOT_STREAM_SLOT, ack.sequence = this.store.latestTick, ack.received_mask = this.receivedMask(ack.sequence);
+      let written = 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 = encodeAck(view, offset, ack);
+      written > 0 && (offset += written);
+    }
+    offset > 0 && link.send(Lane.Datagram, packet.of(offset));
+  }
+  writeCamera(view, offset, nowMs) {
+    let input = this.roomInput;
+    input.flags = 0, input.action = CAMERA_ACTION, input.sequence = this.cameraSequence, input.client_tick = 0;
+    let total = writeRoomInputHeader(view, offset, input, 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 < 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 > HIGH_LATENCY_ENTER_MS ? this.extrapolating = true : this.extrapolating && rtt < 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(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(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 < LANE_LENGTH_BYTES) return null;
+    let length = this.view.getUint16(this.start, true), from = this.start + 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 = LANE_LENGTH_BYTES + bytes.length;
+  return total > out.length ? -1 : (out[0] = bytes.length & 255, out[1] = bytes.length >>> 8, out.set(bytes, 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(PACKET_BYTES + LANE_LENGTH_BYTES)));
+  }
+  send(lane, bytes) {
+    if (!this.open) return;
+    if (lane === 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(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(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(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;
+    }
+  }
+};
+
+export { Connecting, Connector, GAME_CHANNEL_RELIABLE_BASE, GAME_CHANNEL_SLOTS, InMemoryNetworkMemory, JoinStatus, Locomotion, LocomotionMotion, MAX_STATE_FRAGMENTS, ROOM_STATE_SLOT, RoomClient, RoomPhase, STATE_CHUNK_BYTES, STATE_FRAME_VERSION, STATE_HEADER_BYTES, SizedViews, StorageNetworkMemory, TickStateReplica, Transport, WebSocketDialer, WebTransportDialer, blankReply, currentNetwork, decodeJoinReply, isqrt, locomotionMotion, perAxisUnit, previousSend, resumeRequest, sendsOn, spawn, steer, ticketRequest };