@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-RQXN5A34.mjs

@@ -0,0 +1,613 @@
+import { TickRoomError, tickLayout, describeRegion, aligned, defineTickRoom, LOCKSTEP_TABLE_ALIGN } from './chunk-PBL6YL5L.mjs';
+
+// src/interactives/tick/random.ts
+var U64 = (1n << 64n) - 1n, SEED_GAMMA = 0x9e3779b97f4a7c15n, SEED_MIX_A = 0xbf58476d1ce4e5b9n, SEED_MIX_B = 0x94d049bb133111ebn, WORD_MASK = 0xffffffffn, HIGH_SCALE = 67108864, DOUBLE_SPAN = 9007199254740992;
+function seedValue(seed) {
+  return (typeof seed == "bigint" ? seed : BigInt(seed)) & U64;
+}
+function seededWords(seed) {
+  let state = seedValue(seed), mix = () => {
+    state = state + SEED_GAMMA & U64;
+    let mixed = state;
+    return mixed = (mixed ^ mixed >> 30n) * SEED_MIX_A & U64, mixed = (mixed ^ mixed >> 27n) * SEED_MIX_B & U64, mixed ^ mixed >> 31n;
+  }, low = mix(), high = mix(), words = [
+    Number(low & WORD_MASK),
+    Number(low >> 32n),
+    Number(high & WORD_MASK),
+    Number(high >> 32n)
+  ];
+  return words.every((w) => w === 0) ? [1, 0, 0, 0] : words;
+}
+function rotl(value, shift) {
+  return value << shift | value >>> 32 - shift;
+}
+function nextWord(header) {
+  let s = header, result = Math.imul(rotl(Math.imul(s[9], 5), 7), 9) >>> 0, t = s[9] << 9;
+  return s[10] ^= s[8], s[11] ^= s[9], s[9] ^= s[10], s[8] ^= s[11], s[10] ^= t, s[11] = rotl(s[11], 11), result;
+}
+function nextRandom(header) {
+  return ((nextWord(header) >>> 5) * (67108864) + (nextWord(header) >>> 6)) / (9007199254740992);
+}
+
+// src/interactives/tick/simulation.ts
+var WORD_SPAN = 4294967296, NANOS_PER_MILLI = 1e6, NANOS_PER_SECOND = 1e9, DEFAULT_RATE_HZ = 60;
+function bodies(seats) {
+  return {
+    alive: new Uint8Array(seats),
+    x: new Int32Array(seats),
+    y: new Int32Array(seats),
+    z: new Int32Array(seats),
+    yaw: new Uint16Array(seats),
+    axisX: new Int16Array(seats),
+    axisZ: new Int16Array(seats),
+    buttons: new Uint8Array(seats),
+    animation: new Uint8Array(seats),
+    flags: new Uint8Array(seats)
+  };
+}
+function putWide(header, low, high, value) {
+  header[low] = value % (4294967296), header[high] = Math.floor(value / (4294967296));
+}
+function createTickRoomSimulation(room, options) {
+  let seats = options.seats;
+  if (!Number.isInteger(seats) || seats < 1 || seats > 1024) throw new TickRoomError("invalid_seats", `a tick room seats 1 to ${1024}, got ${String(seats)}`);
+  let rateHz = options.rateHz ?? (60);
+  if (!Number.isFinite(rateHz) || rateHz <= 0) throw new TickRoomError("invalid_step_rate", `the tick rate must be positive, got ${String(rateHz)}`);
+  let stepNs = Math.round((1e9) / rateHz), layout = tickLayout(seats, room.stateBytes), buffer = new ArrayBuffer(layout.total), region = new Uint8Array(buffer), header = new Uint32Array(buffer, 0, 32);
+  describeRegion(header, layout, stepNs, seededWords(options.seed)), header[29] = room.replicatedBytes;
+  let held = bodies(seats), commandBytes = new Uint8Array(4096), commandView = new DataView(commandBytes.buffer), commandLength = 0, commandCount = 0, tick = 0, onLog = options.onLog ?? null, commands = new DataView(buffer, layout.commands, 4096), outbound = [], outboundBytes = 0, columns = {
+    alive: new Uint8Array(buffer, layout.alive, seats),
+    x: new Int32Array(buffer, layout.x, seats),
+    y: new Int32Array(buffer, layout.y, seats),
+    z: new Int32Array(buffer, layout.z, seats),
+    yaw: new Uint16Array(buffer, layout.yaw, seats),
+    axisX: new Int16Array(buffer, layout.axisX, seats),
+    axisZ: new Int16Array(buffer, layout.axisZ, seats),
+    buttons: new Uint8Array(buffer, layout.buttons, seats),
+    animation: new Uint8Array(buffer, layout.animation, seats),
+    flags: new Uint8Array(buffer, layout.flags, seats)
+  }, ctx = {
+    seats,
+    ...columns,
+    state: new DataView(buffer, layout.state, layout.stateBytes),
+    stateBytes: new Uint8Array(buffer, layout.state, layout.stateBytes),
+    random: () => nextRandom(header),
+    get tick() {
+      return header[0] + header[1] * (4294967296);
+    },
+    get timeMs() {
+      return header[2] + header[3] * (4294967296);
+    },
+    get commandCount() {
+      return header[5];
+    },
+    eachCommand(visit) {
+      let offset = 0;
+      for (let index = 0; index < header[5]; index += 1) {
+        let slot = commands.getUint16(offset, true), action = commands.getUint16(offset + 2, true), length = commands.getUint16(offset + 4, true);
+        visit(slot, action, new Uint8Array(buffer, layout.commands + offset + 8, length)), offset += 8 + aligned(length);
+      }
+    },
+    outbox(action, payload) {
+      let size = 8 + aligned(payload.length);
+      return !Number.isInteger(action) || action < 0 || action > 65535 || outbound.length >= 16 || outboundBytes + size > 4096 ? false : (outbound.push({ tick: header[0] + header[1] * (4294967296), action, payload: payload.slice() }), outboundBytes += size, true);
+    },
+    log(...parts) {
+      onLog !== null && onLog(header[0] + header[1] * (4294967296), parts.map((p) => String(p)).join(" "));
+    }
+  };
+  Object.freeze(ctx);
+  let seat = (index) => {
+    if (!Number.isInteger(index) || index < 0 || index >= seats) throw new TickRoomError("invalid_seat", `seat ${String(index)} is outside 0..${seats - 1}`);
+    return index;
+  }, load = () => {
+    putWide(header, 0, 1, tick), putWide(header, 2, 3, Math.floor(tick * stepNs / (1e6))), header[5] = commandCount, header[6] = commandLength, region.set(commandBytes.subarray(0, commandLength), layout.commands), columns.alive.set(held.alive), columns.x.set(held.x), columns.y.set(held.y), columns.z.set(held.z), columns.yaw.set(held.yaw), columns.axisX.set(held.axisX), columns.axisZ.set(held.axisZ), columns.buttons.set(held.buttons), columns.animation.set(held.animation), columns.flags.set(held.flags);
+  }, apply = () => {
+    for (let slot = 0; slot < seats; slot++) {
+      if (held.alive[slot] === 0) continue;
+      let x = columns.x[slot], z = columns.z[slot];
+      if (x < 0 || x > 65535 || z < 0 || z > 65535)
+        throw new TickRoomError("invalid_decision", `the room placed seat ${slot} outside the cell at (${x}, ${z})`);
+      held.x[slot] = x, held.y[slot] = columns.y[slot], held.z[slot] = z, held.yaw[slot] = columns.yaw[slot], held.animation[slot] = columns.animation[slot], held.flags[slot] = columns.flags[slot];
+    }
+  };
+  return room.init?.(ctx), {
+    layout,
+    region,
+    replicated: new Uint8Array(buffer, layout.state, room.replicatedBytes),
+    ctx,
+    stepNs,
+    get tick() {
+      return tick;
+    },
+    join(index, x = 0, y = 0, z = 0) {
+      let s = seat(index);
+      held.alive[s] = 1, held.x[s] = x, held.y[s] = y, held.z[s] = z;
+    },
+    leave(index) {
+      let s = seat(index);
+      held.alive[s] = 0, held.axisX[s] = 0, held.axisZ[s] = 0, held.buttons[s] = 0;
+    },
+    input(index, axisX, axisZ, buttons) {
+      let s = seat(index);
+      held.axisX[s] = axisX, held.axisZ[s] = axisZ, held.buttons[s] = buttons;
+    },
+    command(index, action, payload) {
+      let s = seat(index), padded = aligned(payload.length);
+      if (payload.length > 512) throw new TickRoomError("command_too_large", `a command payload holds at most ${512} bytes, got ${payload.length}`);
+      if (commandLength + 8 + padded > 4096) throw new TickRoomError("commands_full", `this tick's ${4096} byte command area is full`);
+      commandView.setUint16(commandLength, s, true), commandView.setUint16(commandLength + 2, action, true), commandView.setUint16(commandLength + 4, payload.length, true), commandView.setUint16(commandLength + 6, 0, true), commandBytes.set(payload, commandLength + 8), commandBytes.fill(0, commandLength + 8 + payload.length, commandLength + 8 + padded), commandLength += 8 + padded, commandCount += 1;
+    },
+    drainOutbox() {
+      let drained = outbound;
+      return outbound = [], drained;
+    },
+    step() {
+      tick += 1, load(), commandLength = 0, commandCount = 0, outboundBytes = 0, room.step(ctx), apply();
+    },
+    snapshot() {
+      let image = new Uint8Array(16 + layout.stateBytes), view = new DataView(image.buffer);
+      for (let i = 0; i < 4; i++) view.setUint32(i * 4, header[8 + i], true);
+      return image.set(ctx.stateBytes, 16), image;
+    },
+    restore(image) {
+      if (image.length !== 16 + layout.stateBytes)
+        throw new TickRoomError("invalid_snapshot", `the snapshot holds ${image.length} bytes; this room's is ${16 + layout.stateBytes}`);
+      let view = new DataView(image.buffer, image.byteOffset, image.byteLength);
+      for (let i = 0; i < 4; i++) header[8 + i] = view.getUint32(i * 4, true);
+      ctx.stateBytes.set(image.subarray(16));
+    }
+  };
+}
+
+// src/interactives/tick/lockstep.ts
+var LOCKSTEP_MAX_SEATS = 16, LOCKSTEP_WINDOW = 128, LOCKSTEP_INPUT_STRIDE = 4, LOCKSTEP_AXIS_X = 0, LOCKSTEP_AXIS_Z = 1, LOCKSTEP_BUTTONS = 2, LOCKSTEP_PRESENT = 3, LOCKSTEP_AXIS_LIMIT = 127, LOCKSTEP_INPUT_ACTION = 65025, LOCKSTEP_BATCH_HEADER_BYTES = 12, LOCKSTEP_MAX_BATCH = 48, LOCKSTEP_BATCH_BYTES = (12) + (48) * 3, LOCKSTEP_CONFIG_TAG = 67, LOCKSTEP_CONFIG_HEADER_BYTES = 4, LOCKSTEP_CONFIG_MAX_WORDS = 8, LockstepRecord = { lobby: 1, start: 2, seedLow: 3, seedHigh: 4, check: 5, depart: 6, configLow: 7, configHigh: 8 }, LockstepPhase = { waiting: 0, lobby: 1, running: 2 }, INPUT_BYTES = 3, BATCH_VERSION = 1, RECORD_KIND_SHIFT = 4, RECORD_SEAT_MASK = 15, RECORD_VALUE_MASK = 16777215, RECORD_HIGH_SHIFT = 16, BYTE_MASK = 255, TICK16_MASK = 65535, TICK16_SPAN = 65536, TICK16_HALF = 32768, SEED_LOW_BITS = 24, SEED_SPAN = 4294967296, DEFAULT_INPUT_DELAY = 2, MAX_INPUT_DELAY = 8, DEFAULT_RATE_HZ2 = 60, DEFAULT_MAX_LEAD = 24, DEFAULT_LOBBY_SECONDS = 10, DEFAULT_STALL_SECONDS = 3, MS_PER_SECOND = 1e3, DECISECOND_MS = 100, LOBBY_COUNT_MASK = 255, LOBBY_TIME_SHIFT = 8, LOBBY_TIME_MAX = 65535, MAX_ADVANCE_PER_STEP = 8, FNV_OFFSET = 2166136261, FNV_PRIME = 16777619, WORD_BYTES = 4, FIXED_RECORDS = 4, CONFIG_RECORDS = 2, PHASE_LOBBY = 0, PHASE_RUNNING = 1, START_SEEN = 1, SEED_LOW_SEEN = 2, SEED_HIGH_SEEN = 4, CONFIG_LOW_SEEN = 8, CONFIG_HIGH_SEEN = 16, START_READY = (1) | (2) | (4), CONFIG_READY = START_READY | (8) | (16), CONFIG_HIGH_SHIFT = 24, CONFIG_SEND_EVERY = 15, R_PHASE = 0, R_TICK = 1, R_SEED = 2, R_HUMANS = 3, R_LOBBY_AT = 4, R_ADVANCED_AT = 5, R_STEPS = 6, R_CONFIG = 7, R_CONFIG_SEATS = 8, R_CONFIG_LENGTH = 9, R_CONFIG_WORDS = 10, R_DEPART = (10) + (8), R_RING = R_DEPART + (16), RING_CELLS = (128) * (16), REFEREE_WORDS = R_RING + RING_CELLS, RING_INPUT_AT = REFEREE_WORDS * (4), LOCKSTEP_REFEREE_BYTES = RING_INPUT_AT + RING_CELLS * (4);
+function invalid(message) {
+  throw new TickRoomError("invalid_lockstep", message);
+}
+function defineLockstep(definition) {
+  let { seats, stateBytes } = definition;
+  (!Number.isInteger(seats) || seats < 1 || seats > (16)) && invalid(`a lockstep match seats 1 to ${(16)}, got ${String(seats)}`), (!Number.isInteger(stateBytes) || stateBytes < 1 || stateBytes > 262144 - LOCKSTEP_REFEREE_BYTES) && invalid(`lockstep state is 1 to ${262144 - LOCKSTEP_REFEREE_BYTES} bytes, got ${String(stateBytes)}`);
+  let rateHz = definition.rateHz ?? (60);
+  (!Number.isFinite(rateHz) || rateHz <= 0) && invalid(`the match rate must be positive, got ${String(rateHz)}`);
+  let inputDelay = definition.inputDelay ?? (2);
+  return (!Number.isInteger(inputDelay) || inputDelay < 0 || inputDelay > (8)) && invalid(`input delay is 0 to ${(8)} ticks, got ${String(inputDelay)}`), (typeof definition.init != "function" || typeof definition.step != "function") && invalid("a lockstep match needs init and step"), { seats, stateBytes, rateHz, inputDelay, init: (state, seed, humans) => definition.init(state, seed, humans), step: (state, inputs, tick) => definition.step(state, inputs, tick) };
+}
+function lockstepChecksum(bytes) {
+  let h = (2166136261);
+  for (let i = 0; i < bytes.length; i++)
+    h ^= bytes[i], h = Math.imul(h, (16777619));
+  return h >>> 0 & (16777215);
+}
+function encodeLockstepConfig(words) {
+  words.length > (8) && invalid(`a lockstep match config holds at most ${(8)} words, got ${words.length}`);
+  let out = new Uint8Array((4) + words.length * (4));
+  out[0] = (67), out[1] = words.length;
+  for (let i = 0; i < words.length; i++)
+    Number.isInteger(words[i]) || invalid(`lockstep match config word ${i} is not an integer`), writeU32(out, (4) + i * (4), words[i] >>> 0);
+  return out;
+}
+function lockstepConfigHash(payload, length = payload.length) {
+  let h = (2166136261);
+  for (let i = 0; i < length; i++)
+    h ^= payload[i], h = Math.imul(h, (16777619));
+  return h >>> 0;
+}
+function quantiseLockstepAxis(value) {
+  let scaled = Math.round(value * (127));
+  return scaled > (127) ? (127) : scaled < -(127) ? -(127) : scaled;
+}
+function popcount(mask) {
+  let m = mask >>> 0, count = 0;
+  for (; m !== 0; )
+    m &= m - 1, count++;
+  return count;
+}
+function readU16(bytes, at) {
+  return bytes[at] | bytes[at + 1] << 8;
+}
+function readU32(bytes, at) {
+  return (bytes[at] | bytes[at + 1] << 8 | bytes[at + 2] << 16 | bytes[at + 3] << 24) >>> 0;
+}
+function writeU32(bytes, at, value) {
+  bytes[at] = value & (255), bytes[at + 1] = value >>> 8 & (255), bytes[at + 2] = value >>> 16 & (255), bytes[at + 3] = value >>> 24 & (255);
+}
+function unwrapTick16(low, near) {
+  let candidate = near - (near & (65535)) + (low & (65535));
+  return candidate < near - (32768) ? candidate += (65536) : candidate > near + (32768) && candidate >= (65536) && (candidate -= (65536)), candidate;
+}
+function refereeViews(bytes, stateBytes) {
+  let buffer = bytes.buffer, base = bytes.byteOffset;
+  return {
+    bytes,
+    words: new Uint32Array(buffer, base, REFEREE_WORDS),
+    inputs: new Int8Array(buffer, base + RING_INPUT_AT, RING_CELLS * (4)),
+    state: new DataView(buffer, base + LOCKSTEP_REFEREE_BYTES, stateBytes),
+    stateBytes: new Uint8Array(buffer, base + LOCKSTEP_REFEREE_BYTES, stateBytes)
+  };
+}
+function ringCell(tick, seat) {
+  return tick % (128) * (16) + seat;
+}
+function defineLockstepRoom(rules, options = {}) {
+  let minPlayers = options.minPlayers ?? 1;
+  (!Number.isInteger(minPlayers) || minPlayers < 1 || minPlayers > rules.seats) && invalid(`minPlayers is 1 to ${rules.seats}, got ${String(minPlayers)}`);
+  let lobbyMs = Math.round((options.lobbySeconds ?? (10)) * (1e3)), stallMs = Math.round((options.stallSeconds ?? (3)) * (1e3)), seats = rules.seats, delay = rules.inputDelay, frame = new Int16Array(seats * (4)), views = null, current = null, configure = options.configure ?? null, records = configure === null ? (4) : (4) + (2), configWords = new Int32Array((8)), configured = null, configuredHash = 0, configuredLength = 0, bind = (ctx) => ((views === null || views.bytes !== ctx.stateBytes) && (views = refereeViews(ctx.stateBytes, rules.stateBytes)), views), resolveConfig = (length) => {
+    if (configure === null) return null;
+    let out = configure(configWords.slice(0, length));
+    return out === null || out.seats !== rules.seats || out.stateBytes !== rules.stateBytes || out.inputDelay !== rules.inputDelay || out.rateHz !== rules.rateHz ? null : out;
+  }, rulesOf = (w) => {
+    if (configure === null || w[(9)] === 0) return rules;
+    if (configured === null || configuredHash !== w[(7)] || configuredLength !== w[(9)]) {
+      let length = w[(9)] - 1;
+      for (let i = 0; i < length; i++) configWords[i] = w[(10) + i] | 0;
+      configured = resolveConfig(length) ?? rules, configuredHash = w[(7)], configuredLength = w[(9)];
+    }
+    return configured;
+  }, clearConfig = (w) => {
+    w[(7)] = 0, w[(8)] = 0, w[(9)] = 0;
+  }, ingestConfig = (slot, payload, w) => {
+    if (configure === null || w[(0)] !== (0) || payload.length < (4)) return;
+    let count = payload[1], length = (4) + count * (4);
+    if (count > (8) || payload.length < length) return;
+    let hash = lockstepConfigHash(payload, length);
+    if (w[(9)] !== 0) {
+      hash === w[(7)] && w[(9)] === count + 1 && (w[(8)] |= 1 << slot);
+      return;
+    }
+    for (let i = 0; i < count; i++) configWords[i] = readU32(payload, (4) + i * (4)) | 0;
+    if (resolveConfig(count) !== null) {
+      for (let i = 0; i < count; i++) w[(10) + i] = configWords[i];
+      w[(7)] = hash, w[(9)] = count + 1, w[(8)] = 1 << slot, configured = null;
+    }
+  }, ingest = (slot, action, payload) => {
+    let v = current;
+    if (action !== (65025) || v === null || slot >= seats || payload.length === 0) return;
+    if (payload[0] === (67)) {
+      ingestConfig(slot, payload, v.words);
+      return;
+    }
+    if (payload.length < (12) || payload[0] !== (1)) return;
+    let w = v.words, count = readU16(payload, 2), first = readU32(payload, 4), tick = w[(1)];
+    if (!(payload.length < (12) + count * (3)))
+      for (let i = 0; i < count; i++) {
+        let t = first + i;
+        if (t <= tick || t > tick + (128)) continue;
+        let cell = ringCell(t, slot), at = (12) + i * (3);
+        w[R_RING + cell] = t;
+        let o = cell * (4);
+        v.inputs[o + (0)] = payload[at], v.inputs[o + (1)] = payload[at + 1], v.inputs[o + (2)] = payload[at + 2];
+      }
+  }, aliveMask = (ctx) => {
+    let mask = 0, limit = Math.min(seats, ctx.seats);
+    for (let s = 0; s < limit; s++) ctx.alive[s] !== 0 && (mask |= 1 << s);
+    return mask;
+  }, active = (w, seat, tick) => {
+    let depart = w[R_DEPART + seat];
+    return (w[(3)] >>> seat & 1) === 1 && (depart === 0 || tick < depart);
+  }, lobby = (ctx, v) => {
+    let w = v.words, alive = aliveMask(ctx);
+    configure !== null && w[(9)] !== 0 && (w[(8)] & alive) === 0 && clearConfig(w);
+    let ready = configure === null ? alive : (w[(8)] & alive) >>> 0, count = popcount(ready);
+    if (count < minPlayers) {
+      w[(4)] = 0;
+      return;
+    }
+    if (w[(4)] === 0 && (w[(4)] = ctx.timeMs + 1), !(count >= Math.min(seats, ctx.seats)) && ctx.timeMs + 1 - w[(4)] < lobbyMs) return;
+    let seed = Math.floor(ctx.random() * (4294967296)) >>> 0;
+    w.fill(0, R_DEPART, REFEREE_WORDS), w[(2)] = seed, w[(3)] = ready, w[(1)] = 0, w[(5)] = ctx.timeMs, w[(0)] = (1), v.stateBytes.fill(0), rulesOf(w).init(v.state, seed, ready);
+  }, fill = (v, next) => {
+    let w = v.words;
+    for (let s = 0; s < seats; s++) {
+      let o = s * (4), on = active(w, s, next), real = on && next > delay, i = ringCell(next, s) * (4);
+      frame[o + (0)] = real ? v.inputs[i + (0)] : 0, frame[o + (1)] = real ? v.inputs[i + (1)] : 0, frame[o + (2)] = real ? v.inputs[i + (2)] & (255) : 0, frame[o + (3)] = on ? 1 : 0;
+    }
+  }, run = (ctx, v) => {
+    let w = v.words, humans = w[(3)], playing = rulesOf(w);
+    for (let s = 0; s < seats; s++)
+      (humans >>> s & 1) === 0 || w[R_DEPART + s] !== 0 || (s >= ctx.seats || ctx.alive[s] === 0) && (w[R_DEPART + s] = w[(1)] + 1);
+    for (let advanced = 0; advanced < (8); advanced++) {
+      let next = w[(1)] + 1, missing = 0;
+      if (next > delay)
+        for (let s = 0; s < seats; s++) active(w, s, next) && w[R_RING + ringCell(next, s)] !== next && (missing |= 1 << s);
+      if (missing !== 0) {
+        if (ctx.timeMs - w[(5)] < stallMs) break;
+        for (let s = 0; s < seats; s++) (missing >>> s & 1) === 1 && (w[R_DEPART + s] = next);
+      }
+      fill(v, next), playing.step(v.state, frame, next), w[(1)] = next, w[(5)] = ctx.timeMs;
+    }
+  }, publish = (ctx, v) => {
+    let w = v.words, steps = w[(6)] + 1 >>> 0;
+    w[(6)] = steps;
+    let kind = LockstepRecord.lobby, seat = 0, value = 0;
+    if (w[(0)] !== (1)) {
+      let lobbyAt = w[(4)], left = lobbyAt === 0 ? lobbyMs : Math.max(0, lobbyMs - (ctx.timeMs + 1 - lobbyAt));
+      value = popcount(aliveMask(ctx)) & (255) | Math.min((65535), Math.ceil(left / (100))) << (8);
+    } else {
+      let k = steps % (records + seats);
+      k === 0 ? (kind = LockstepRecord.start, value = w[(3)]) : k === 1 ? (kind = LockstepRecord.seedLow, value = w[(2)] & (16777215)) : k === 2 ? (kind = LockstepRecord.seedHigh, value = w[(2)] >>> (24)) : k === 3 ? (kind = LockstepRecord.check, value = lockstepChecksum(v.stateBytes)) : k === (4) && records > (4) ? (kind = LockstepRecord.configLow, value = w[(7)] & (16777215)) : k === (4) + 1 && records > (4) ? (kind = LockstepRecord.configHigh, value = w[(7)] >>> (24)) : (kind = LockstepRecord.depart, seat = k - records, value = w[R_DEPART + seat] & (16777215));
+    }
+    let low = (value & (65535)) << 16 >> 16, high = value >>> (16) & (255), tag = kind << (4) | seat & (15), tick16 = w[(1)] & (65535);
+    for (let i = 0; i < ctx.seats; i++)
+      ctx.alive[i] !== 0 && (ctx.yaw[i] = tick16, ctx.y[i] = low, ctx.flags[i] = high, ctx.animation[i] = tag);
+  };
+  return defineTickRoom({
+    stateBytes: LOCKSTEP_REFEREE_BYTES + rules.stateBytes,
+    step(ctx) {
+      let v = bind(ctx);
+      current = v, ctx.eachCommand(ingest), current = null, v.words[(0)] === (0) ? lobby(ctx, v) : run(ctx, v), publish(ctx, v);
+    }
+  });
+}
+function lockstepRefereeTick(stateBytes) {
+  return readU32(stateBytes, (1) * (4));
+}
+function lockstepRefereeState(stateBytes, rules) {
+  return stateBytes.subarray(LOCKSTEP_REFEREE_BYTES, LOCKSTEP_REFEREE_BYTES + rules.stateBytes);
+}
+function decodeLockstepRecord(animation, y, flags, out) {
+  let kind = (animation & (255)) >>> (4);
+  return kind < LockstepRecord.lobby || kind > LockstepRecord.configHigh ? false : (out.kind = kind, out.seat = animation & (15), out.value = (y & (65535) | (flags & (255)) << (16)) >>> 0, true);
+}
+var LockstepSession = class {
+  constructor(rules, options) {
+    this.stats = { rollbacks: 0, resimulatedTicks: 0, maxRollback: 0, stalls: 0, checks: 0, desyncs: 0, worldMisses: 0 };
+    this.phase = LockstepPhase.waiting;
+    this.tick = 0;
+    this.confirmed = 0;
+    this.refereeTick = 0;
+    this.humans = 0;
+    this.seed = 0;
+    this.lobbyPlayers = 0;
+    this.lobbySeconds = 0;
+    this.configRefused = false;
+    this.configSendIn = 0;
+    this.pendingConfig = 0;
+    this.inputTick = new Uint32Array(RING_CELLS);
+    this.input = new Int8Array(RING_CELLS * (3));
+    this.used = new Int16Array(RING_CELLS * (4));
+    this.stateTick = new Float64Array((128)).fill(-1);
+    this.lastKnownTick = new Uint32Array((16));
+    this.lastKnown = new Int8Array((16) * (3));
+    this.depart = new Uint32Array((16));
+    this.peerAck = new Uint32Array((16));
+    this.out = new Uint8Array(LOCKSTEP_BATCH_BYTES);
+    this.rollbackFrom = 0;
+    this.startSeen = 0;
+    this.pendingHumans = 0;
+    this.pendingSeed = 0;
+    this.lastCheck = 0;
+    this.localX = 0;
+    this.localZ = 0;
+    this.localButtons = 0;
+    this.rules = rules, this.seats = rules.seats, this.delay = rules.inputDelay, this.seat = options.seat, this.link = options.link ?? null, this.world = options.world ?? null, this.maxLead = options.maxLead ?? (24), this.config = options.config === void 0 || options.config === null ? null : encodeLockstepConfig(options.config), this.configHash = this.config === null ? null : lockstepConfigHash(this.config), (!Number.isInteger(this.seat) || this.seat < -1 || this.seat >= this.seats) && invalid(`seat ${String(this.seat)} is outside -1..${this.seats - 1}`), (!Number.isInteger(this.maxLead) || this.maxLead < 1 || this.maxLead + this.delay >= (128) / 2) && invalid(`maxLead must keep the lead under ${(128) / 2} ticks`), this.stateBytes = options.stateBytes ?? new Uint8Array(rules.stateBytes), (this.stateBytes.byteLength !== rules.stateBytes || this.stateBytes.byteOffset % LOCKSTEP_TABLE_ALIGN !== 0) && invalid(`stateBytes must be ${rules.stateBytes} bytes on a ${LOCKSTEP_TABLE_ALIGN}-byte boundary`), this.state = new DataView(this.stateBytes.buffer, this.stateBytes.byteOffset, this.stateBytes.byteLength), this.states = new Uint8Array((128) * rules.stateBytes), this.stateSlots = Array.from({ length: (128) }, (_, slot) => this.states.subarray(slot * rules.stateBytes, (slot + 1) * rules.stateBytes)), this.inputs = new Int16Array(this.seats * (4));
+  }
+  get running() {
+    return this.phase === LockstepPhase.running;
+  }
+  get lead() {
+    return this.tick - this.confirmed;
+  }
+  isHuman(seat) {
+    return (this.humans >>> seat & 1) === 1;
+  }
+  departedAt(seat) {
+    return this.depart[seat];
+  }
+  confirmedInputs(tick, out) {
+    if (tick < 1 || tick > this.confirmed || tick <= this.tick - (128) || this.stateTick[tick % (128)] !== tick) return false;
+    for (let s = 0; s < this.seats; s++) {
+      let o = s * (4), on = this.active(s, tick), real = on && tick > this.delay, i = ringCell(tick, s) * (3);
+      out[o + (0)] = real ? this.input[i] : 0, out[o + (1)] = real ? this.input[i + 1] : 0, out[o + (2)] = real ? this.input[i + 2] & (255) : 0, out[o + (3)] = on ? 1 : 0;
+    }
+    return true;
+  }
+  confirmedState(tick, out) {
+    return tick < 0 || tick > this.confirmed || this.stateTick[tick % (128)] !== tick || this.rollbackFrom !== 0 && this.rollbackFrom <= tick ? false : (out.set(this.stateSlots[tick % (128)]), true);
+  }
+  begin(seed, humans) {
+    this.seed = seed >>> 0, this.humans = humans >>> 0, this.phase = LockstepPhase.running, this.tick = 0, this.confirmed = 0, this.rollbackFrom = 0, this.lastCheck = 0, this.inputTick.fill(0), this.stateTick.fill(-1), this.lastKnownTick.fill(0), this.lastKnown.fill(0), this.depart.fill(0), this.peerAck.fill(0), this.stateBytes.fill(0), this.world?.clear(), this.rules.init(this.state, this.seed, this.humans), this.save(0);
+  }
+  setInput(axisX, axisZ, buttons) {
+    this.localX = quantiseLockstepAxis(axisX), this.localZ = quantiseLockstepAxis(axisZ), this.localButtons = buttons & (255);
+  }
+  advance() {
+    if (this.link?.poll(this), this.phase !== LockstepPhase.running)
+      return this.offerConfig(), false;
+    if (this.advanceFrontier(), this.tick - this.confirmed >= this.maxLead || this.link !== null && this.tick - this.refereeTick >= (48))
+      return this.stats.stalls++, this.send(), false;
+    let t = this.tick + 1, own = this.seat;
+    own >= 0 && this.active(own, t + this.delay) && this.store(own, t + this.delay, this.localX, this.localZ, this.localButtons);
+    let from = this.rollbackFrom;
+    return this.rollbackFrom = 0, from !== 0 && from <= this.tick && this.resimulate(from), this.simulate(t), this.tick = t, this.advanceFrontier(), this.send(), true;
+  }
+  receive(view, offset, length) {
+    if (length < (12) || view.getUint8(offset) !== (1)) return;
+    let seat = view.getUint8(offset + 1), count = view.getUint16(offset + 2, true), first = view.getUint32(offset + 4, true), ack = view.getUint32(offset + 8, true);
+    if (!(seat >= this.seats || length < (12) + count * (3)) && (ack > this.peerAck[seat] && (this.peerAck[seat] = ack), !(this.phase !== LockstepPhase.running || seat === this.seat || !this.isHuman(seat))))
+      for (let i = 0; i < count; i++) {
+        let at = offset + (12) + i * (3);
+        this.accept(seat, first + i, view.getInt8(at), view.getInt8(at + 1), view.getUint8(at + 2));
+      }
+  }
+  record(kind, seat, value, tick16) {
+    if (this.refereeTick = unwrapTick16(tick16, this.refereeTick), kind === LockstepRecord.lobby) {
+      if (this.phase === LockstepPhase.running) return;
+      this.phase = LockstepPhase.lobby, this.lobbyPlayers = value & (255), this.lobbySeconds = (value >>> (8)) * (100) / (1e3);
+      return;
+    }
+    if (this.phase !== LockstepPhase.running) {
+      if (kind === LockstepRecord.start ? (this.pendingHumans = value, this.startSeen |= (1)) : kind === LockstepRecord.seedLow ? (this.pendingSeed = this.pendingSeed - (this.pendingSeed & (16777215)) + value >>> 0, this.startSeen |= (2)) : kind === LockstepRecord.seedHigh ? (this.pendingSeed = (this.pendingSeed & (16777215)) + (value & (255)) * ((16777215) + 1) >>> 0, this.startSeen |= (4)) : kind === LockstepRecord.configLow ? (this.pendingConfig = this.pendingConfig - (this.pendingConfig & (16777215)) + value >>> 0, this.startSeen |= (8)) : kind === LockstepRecord.configHigh && (this.pendingConfig = (this.pendingConfig & (16777215)) + (value & (255)) * ((16777215) + 1) >>> 0, this.startSeen |= (16)), (this.configHash === null ? (this.startSeen & START_READY) === START_READY : this.startSeen === CONFIG_READY) && !this.configRefused) {
+        if (this.configHash !== null && this.pendingConfig !== this.configHash) {
+          this.configRefused = true;
+          return;
+        }
+        this.begin(this.pendingSeed, this.pendingHumans), this.refereeTick = unwrapTick16(tick16, 0);
+      }
+      return;
+    }
+    if (kind === LockstepRecord.check) {
+      let t = this.refereeTick;
+      if (t === 0 || t > this.confirmed || t === this.lastCheck || this.stateTick[t % (128)] !== t || this.rollbackFrom !== 0 && this.rollbackFrom <= t) return;
+      this.lastCheck = t, this.stats.checks++, lockstepChecksum(this.stateSlots[t % (128)]) !== value && this.stats.desyncs++;
+      return;
+    }
+    kind === LockstepRecord.depart && value !== 0 && seat < this.seats && this.isHuman(seat) && this.depart[seat] === 0 && (this.depart[seat] = value, value <= this.tick && this.markRollback(value));
+  }
+  offerConfig() {
+    let config = this.config;
+    if (!(config === null || this.link === null || this.configRefused)) {
+      if (this.configSendIn > 0) {
+        this.configSendIn--;
+        return;
+      }
+      this.configSendIn = (15), this.link.toReferee(config, config.length);
+    }
+  }
+  active(seat, tick) {
+    let depart = this.depart[seat];
+    return this.isHuman(seat) && (depart === 0 || tick < depart);
+  }
+  markRollback(tick) {
+    (this.rollbackFrom === 0 || tick < this.rollbackFrom) && (this.rollbackFrom = tick);
+  }
+  store(seat, tick, x, z, buttons) {
+    let cell = ringCell(tick, seat);
+    this.inputTick[cell] = tick;
+    let o = cell * (3);
+    if (this.input[o] = x, this.input[o + 1] = z, this.input[o + 2] = buttons, tick >= this.lastKnownTick[seat]) {
+      this.lastKnownTick[seat] = tick;
+      let k = seat * (3);
+      this.lastKnown[k] = x, this.lastKnown[k + 1] = z, this.lastKnown[k + 2] = buttons;
+    }
+  }
+  accept(seat, tick, x, z, buttons) {
+    if (tick <= this.delay || tick <= this.confirmed || tick >= this.confirmed + (128) || !this.active(seat, tick)) return;
+    let cell = ringCell(tick, seat);
+    if (this.inputTick[cell] === tick || (this.store(seat, tick, x, z, buttons), tick > this.tick)) return;
+    let u = cell * (4);
+    (this.used[u + (0)] !== x || this.used[u + (1)] !== z || this.used[u + (2)] !== (buttons & (255))) && this.markRollback(tick);
+  }
+  known(seat, tick) {
+    return tick <= this.delay || this.inputTick[ringCell(tick, seat)] === tick;
+  }
+  simulate(tick) {
+    let frame = this.inputs;
+    for (let s = 0; s < this.seats; s++) {
+      let o = s * (4), cell = ringCell(tick, s), on = this.active(s, tick), x = 0, z = 0, b = 0;
+      if (on && tick > this.delay) {
+        let known = this.inputTick[cell] === tick, i = known ? cell * (3) : s * (3), source = known ? this.input : this.lastKnown;
+        x = source[i], z = source[i + 1], b = source[i + 2] & (255);
+      }
+      frame[o + (0)] = x, frame[o + (1)] = z, frame[o + (2)] = b, frame[o + (3)] = on ? 1 : 0;
+      let u = cell * (4);
+      this.used[u + (0)] = x, this.used[u + (1)] = z, this.used[u + (2)] = b, this.used[u + (3)] = on ? 1 : 0;
+    }
+    this.rules.step(this.state, frame, tick), this.save(tick);
+  }
+  save(tick) {
+    let size = this.rules.stateBytes, slot = tick % (128);
+    this.states.set(this.stateBytes, slot * size), this.stateTick[slot] = tick, this.world?.save(tick);
+  }
+  resimulate(from) {
+    let base = from - 1, slot = base % (128);
+    if (this.stateTick[slot] !== base) return;
+    this.stateBytes.set(this.stateSlots[slot]), this.world !== null && !this.world.restore(base) && (this.stats.worldMisses++, this.world.clear());
+    let span = this.tick - base;
+    for (let t = from; t <= this.tick; t++) this.simulate(t);
+    let stats = this.stats;
+    stats.rollbacks++, stats.resimulatedTicks += span, span > stats.maxRollback && (stats.maxRollback = span);
+  }
+  advanceFrontier() {
+    for (; this.confirmed < this.tick; ) {
+      let t = this.confirmed + 1;
+      for (let s = 0; s < this.seats; s++) if (this.active(s, t) && !this.known(s, t)) return;
+      this.confirmed = t;
+    }
+  }
+  send() {
+    let link = this.link, own = this.seat;
+    if (link === null || own < 0 || !this.isHuman(own)) return;
+    let latest = this.lastKnownTick[own];
+    if (latest <= this.delay) return;
+    let floor = this.delay + 1, toReferee = Math.max(floor, this.refereeTick + 1), length = this.encode(toReferee, latest);
+    length > 0 && link.toReferee(this.out, length);
+    let peers = 0, oldest = latest + 1;
+    for (let s = 0; s < this.seats; s++)
+      s === own || !this.active(s, this.tick + 1) || (peers++, this.peerAck[s] + 1 < oldest && (oldest = this.peerAck[s] + 1));
+    peers !== 0 && (length = this.encode(Math.max(floor, oldest, latest - (48) + 1), latest), length > 0 && link.toPeers(this.out, length));
+  }
+  encode(from, to) {
+    if (to < from) return 0;
+    let own = this.seat, count = Math.min((48), to - from + 1), out = this.out;
+    out[0] = (1), out[1] = own, out[2] = count & (255), out[3] = count >>> 8 & (255), writeU32(out, 4, from), writeU32(out, 8, this.confirmed);
+    for (let i = 0; i < count; i++) {
+      let tick = from + i, cell = ringCell(tick, own), at = (12) + i * (3), known = this.inputTick[cell] === tick, o = cell * (3);
+      out[at] = known ? this.input[o] & (255) : 0, out[at + 1] = known ? this.input[o + 1] & (255) : 0, out[at + 2] = known ? this.input[o + 2] & (255) : 0;
+    }
+    return (12) + count * (3);
+  }
+};
+
+// src/interactives/tick/lockstep-loopback.ts
+var REFEREE = -1, DEFAULT_SEED = 1, XORSHIFT_A = 13, XORSHIFT_B = 17, XORSHIFT_C = 5, LoopbackLink = class {
+  constructor(net, seat) {
+    this.net = net, this.seat = seat;
+  }
+  toReferee(payload, length) {
+    this.net.post(this.seat, (-1), payload.slice(0, length));
+  }
+  toPeers(payload, length) {
+    for (let s = 0; s < this.net.sessions.length; s++) s !== this.seat && this.net.connected[s] && this.net.post(this.seat, s, payload.slice(0, length));
+  }
+  poll(session) {
+    this.net.deliver(this.seat, session);
+  }
+}, LockstepLoopback = class {
+  constructor(room, rules, options) {
+    this.sessions = [];
+    this.connected = [];
+    this.now = 0;
+    this.queue = [];
+    this.lastDue = /* @__PURE__ */ new Map();
+    this.record = { kind: 1, seat: 0, value: 0 };
+    this.latencyTicks = options.latencyTicks ?? 0, this.jitterTicks = options.jitterTicks ?? 0, this.random = (options.seed ?? (1)) >>> 0 || (1), this.referee = createTickRoomSimulation(room, { seats: options.roomSeats ?? rules.seats, seed: options.seed ?? (1), rateHz: rules.rateHz });
+    for (let s = 0; s < options.players; s++)
+      this.referee.join(s), this.connected.push(true), this.sessions.push(new LockstepSession(rules, { seat: s, link: new LoopbackLink(this, s), maxLead: options.maxLead, config: options.configs?.[s] ?? null, world: options.worlds?.[s] ?? null }));
+  }
+  disconnect(seat) {
+    this.connected[seat] = false, this.referee.leave(seat);
+  }
+  post(from, to, bytes, animation = 0, y = 0, flags = 0, yaw = 0) {
+    let key = `${from}>${to}`, jitter = this.jitterTicks > 0 ? this.next() % (this.jitterTicks + 1) : 0, due = Math.max(this.now + this.latencyTicks + jitter, this.lastDue.get(key) ?? 0);
+    this.lastDue.set(key, due), this.queue.push({ due, from, to, bytes, animation, y, flags, yaw });
+  }
+  deliver(seat, session) {
+    if (this.connected[seat])
+      for (let i = 0; i < this.queue.length; i++) {
+        let p = this.queue[i];
+        p.to !== seat || p.due > this.now || (this.queue.splice(i--, 1), p.bytes !== null ? session.receive(new DataView(p.bytes.buffer, p.bytes.byteOffset, p.bytes.byteLength), 0, p.bytes.byteLength) : decodeLockstepRecord(p.animation, p.y, p.flags, this.record) && session.record(this.record.kind, this.record.seat, this.record.value, p.yaw));
+      }
+  }
+  step() {
+    for (let s = 0; s < this.sessions.length; s++) this.connected[s] && this.sessions[s].advance();
+    for (let i = 0; i < this.queue.length; i++) {
+      let p = this.queue[i];
+      p.to !== (-1) || p.due > this.now || (this.queue.splice(i--, 1), this.connected[p.from] && p.bytes !== null && this.referee.command(p.from, (65025), p.bytes));
+    }
+    this.referee.step();
+    let ctx = this.referee.ctx;
+    for (let s = 0; s < this.sessions.length; s++)
+      if (!(!this.connected[s] || ctx.alive[s] === 0)) {
+        for (let t = 0; t < this.sessions.length; t++) this.connected[t] && this.post((-1), t, null, ctx.animation[s], ctx.y[s], ctx.flags[s], ctx.yaw[s]);
+        break;
+      }
+    this.now++;
+  }
+  next() {
+    let x = this.random;
+    return x ^= x << (13), x ^= x >>> (17), x ^= x << (5), this.random = x >>> 0, this.random;
+  }
+};
+
+export { LOCKSTEP_AXIS_LIMIT, LOCKSTEP_AXIS_X, LOCKSTEP_AXIS_Z, LOCKSTEP_BATCH_BYTES, LOCKSTEP_BUTTONS, LOCKSTEP_CONFIG_HEADER_BYTES, LOCKSTEP_CONFIG_MAX_WORDS, LOCKSTEP_CONFIG_TAG, LOCKSTEP_INPUT_ACTION, LOCKSTEP_INPUT_STRIDE, LOCKSTEP_MAX_SEATS, LOCKSTEP_PRESENT, LOCKSTEP_REFEREE_BYTES, LOCKSTEP_WINDOW, LockstepLoopback, LockstepPhase, LockstepRecord, LockstepSession, createTickRoomSimulation, decodeLockstepRecord, defineLockstep, defineLockstepRoom, encodeLockstepConfig, lockstepChecksum, lockstepConfigHash, lockstepRefereeState, lockstepRefereeTick, quantiseLockstepAxis, seededWords, unwrapTick16 };