quake2ts 0.0.7

package/apps/viewer/dist/cjs/index.cjs

@@ -0,0 +1,1087 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  bootstrapViewer: () => bootstrapViewer
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../packages/client/dist/esm/index.js
+function createClient(imports) {
+  let latestFrame;
+  return {
+    init(initial) {
+      latestFrame = initial;
+      void imports.engine.trace({ x: 0, y: 0, z: 0 }, { x: 1, y: 0, z: 0 });
+    },
+    predict(next) {
+      const { origin, velocity } = next;
+      return {
+        origin: {
+          x: origin.x + velocity.x,
+          y: origin.y + velocity.y,
+          z: origin.z + velocity.z
+        },
+        velocity
+      };
+    },
+    render(sample) {
+      latestFrame = sample.latest ?? latestFrame;
+      void sample;
+    },
+    shutdown() {
+      latestFrame = void 0;
+    }
+  };
+}
+
+// ../../packages/engine/dist/esm/index.js
+var DEFAULT_FIXED_DELTA_MS = 25;
+var DEFAULT_MAX_SUBSTEPS = 5;
+var defaultNow = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+var defaultScheduler = (tick) => {
+  if (typeof requestAnimationFrame === "function") {
+    requestAnimationFrame(() => tick());
+  } else {
+    setTimeout(tick, DEFAULT_FIXED_DELTA_MS);
+  }
+};
+var FixedTimestepLoop = class {
+  constructor(callbacks, options = {}) {
+    this.callbacks = callbacks;
+    this.accumulatorMs = 0;
+    this.frame = 0;
+    this.running = false;
+    this.tick = () => {
+      if (!this.running) return;
+      const nowMs = this.options.now();
+      const elapsed = this.lastTimeMs === void 0 ? 0 : nowMs - this.lastTimeMs;
+      this.lastTimeMs = nowMs;
+      this.advance(elapsed, nowMs);
+      if (this.running) {
+        this.options.schedule(this.tick);
+      }
+    };
+    const fixedDeltaMs = options.fixedDeltaMs ?? DEFAULT_FIXED_DELTA_MS;
+    const maxSubSteps = options.maxSubSteps ?? DEFAULT_MAX_SUBSTEPS;
+    this.options = {
+      fixedDeltaMs,
+      maxSubSteps,
+      maxDeltaMs: options.maxDeltaMs ?? fixedDeltaMs * maxSubSteps,
+      startTimeMs: options.startTimeMs,
+      now: options.now ?? defaultNow,
+      schedule: options.schedule ?? defaultScheduler
+    };
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.lastTimeMs = this.options.startTimeMs ?? this.options.now();
+    this.options.schedule(this.tick);
+  }
+  stop() {
+    this.running = false;
+  }
+  pump(elapsedMs) {
+    const nowMs = (this.lastTimeMs ?? 0) + elapsedMs;
+    this.lastTimeMs = nowMs;
+    this.advance(elapsedMs, nowMs);
+  }
+  isRunning() {
+    return this.running;
+  }
+  get frameNumber() {
+    return this.frame;
+  }
+  advance(elapsedMs, nowMs) {
+    const clampedDelta = Math.min(Math.max(elapsedMs, 0), this.options.maxDeltaMs);
+    this.accumulatorMs = Math.min(
+      this.accumulatorMs + clampedDelta,
+      this.options.fixedDeltaMs * this.options.maxSubSteps
+    );
+    let steps = 0;
+    while (this.accumulatorMs >= this.options.fixedDeltaMs && steps < this.options.maxSubSteps) {
+      this.frame += 1;
+      this.callbacks.simulate({ frame: this.frame, deltaMs: this.options.fixedDeltaMs, nowMs });
+      this.accumulatorMs -= this.options.fixedDeltaMs;
+      steps += 1;
+    }
+    const alpha = this.options.fixedDeltaMs === 0 ? 0 : this.accumulatorMs / this.options.fixedDeltaMs;
+    this.callbacks.render?.({ alpha, nowMs, accumulatorMs: this.accumulatorMs, frame: this.frame });
+  }
+};
+var EngineHost = class {
+  constructor(game, client, options = {}) {
+    this.game = game;
+    this.client = client;
+    this.started = false;
+    this.stepSimulation = (step) => {
+      this.previousFrame = this.latestFrame;
+      this.latestFrame = this.game.frame(step);
+    };
+    this.renderClient = (renderContext) => {
+      if (!this.client) return;
+      this.client.render({
+        ...renderContext,
+        previous: this.previousFrame,
+        latest: this.latestFrame
+      });
+    };
+    const now = options.loop?.now?.() ?? Date.now();
+    this.startTimeMs = options.startTimeMs ?? options.loop?.startTimeMs ?? now;
+    this.loop = new FixedTimestepLoop(
+      {
+        simulate: this.stepSimulation,
+        render: this.renderClient
+      },
+      { ...options.loop, startTimeMs: this.startTimeMs }
+    );
+  }
+  start() {
+    if (this.started) return;
+    this.latestFrame = this.game.init(this.startTimeMs) ?? this.latestFrame;
+    this.client?.init(this.latestFrame);
+    this.started = true;
+    this.loop.start();
+  }
+  stop() {
+    if (!this.started) return;
+    this.loop.stop();
+    this.client?.shutdown();
+    this.game.shutdown();
+    this.previousFrame = void 0;
+    this.latestFrame = void 0;
+    this.started = false;
+  }
+  pump(elapsedMs) {
+    this.loop.pump(elapsedMs);
+  }
+  getLatestFrame() {
+    return this.latestFrame;
+  }
+  isRunning() {
+    return this.loop.isRunning();
+  }
+};
+var DEG_TO_RAD = Math.PI / 180;
+var DEG2RAD_FACTOR = Math.PI / 180;
+var RAD2DEG_FACTOR = 180 / Math.PI;
+var CONTENTS_SOLID = 1 << 0;
+var CONTENTS_WINDOW = 1 << 1;
+var CONTENTS_AUX = 1 << 2;
+var CONTENTS_LAVA = 1 << 3;
+var CONTENTS_SLIME = 1 << 4;
+var CONTENTS_WATER = 1 << 5;
+var CONTENTS_MIST = 1 << 6;
+var CONTENTS_NO_WATERJUMP = 1 << 13;
+var CONTENTS_PROJECTILECLIP = 1 << 14;
+var CONTENTS_AREAPORTAL = 1 << 15;
+var CONTENTS_PLAYERCLIP = 1 << 16;
+var CONTENTS_MONSTERCLIP = 1 << 17;
+var CONTENTS_CURRENT_0 = 1 << 18;
+var CONTENTS_CURRENT_90 = 1 << 19;
+var CONTENTS_CURRENT_180 = 1 << 20;
+var CONTENTS_CURRENT_270 = 1 << 21;
+var CONTENTS_CURRENT_UP = 1 << 22;
+var CONTENTS_CURRENT_DOWN = 1 << 23;
+var CONTENTS_ORIGIN = 1 << 24;
+var CONTENTS_MONSTER = 1 << 25;
+var CONTENTS_DEADMONSTER = 1 << 26;
+var CONTENTS_DETAIL = 1 << 27;
+var CONTENTS_TRANSLUCENT = 1 << 28;
+var CONTENTS_LADDER = 1 << 29;
+var CONTENTS_PLAYER = 1 << 30;
+var CONTENTS_PROJECTILE = 1 << 31;
+var SURF_LIGHT = 1 << 0;
+var SURF_SLICK = 1 << 1;
+var SURF_SKY = 1 << 2;
+var SURF_WARP = 1 << 3;
+var SURF_TRANS33 = 1 << 4;
+var SURF_TRANS66 = 1 << 5;
+var SURF_FLOWING = 1 << 6;
+var SURF_NODRAW = 1 << 7;
+var SURF_ALPHATEST = 1 << 25;
+var SURF_N64_UV = 1 << 28;
+var SURF_N64_SCROLL_X = 1 << 29;
+var SURF_N64_SCROLL_Y = 1 << 30;
+var SURF_N64_SCROLL_FLIP = 1 << 31;
+var MASK_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_PLAYERSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_DEADSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_MONSTERSOLID = CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_WATER = CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME;
+var MASK_OPAQUE = CONTENTS_SOLID | CONTENTS_SLIME | CONTENTS_LAVA;
+var MASK_SHOT = CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_WINDOW | CONTENTS_DEADMONSTER;
+var MASK_CURRENT = CONTENTS_CURRENT_0 | CONTENTS_CURRENT_90 | CONTENTS_CURRENT_180 | CONTENTS_CURRENT_270 | CONTENTS_CURRENT_UP | CONTENTS_CURRENT_DOWN;
+var MASK_BLOCK_SIGHT = CONTENTS_SOLID | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_LADDER_NAV_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_WALK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTERCLIP;
+var MASK_PROJECTILE = MASK_SHOT | CONTENTS_PROJECTILECLIP;
+var MAX_CLIENTS = 256;
+var MAX_LIGHTSTYLES = 256;
+var MAX_MODELS = 8192;
+var MAX_SOUNDS = 2048;
+var MAX_IMAGES = 512;
+var MAX_ITEMS = 256;
+var MAX_GENERAL = MAX_CLIENTS * 2;
+var MAX_SHADOW_LIGHTS = 256;
+var MAX_WHEEL_ITEMS = 32;
+var ConfigStringIndex = ((ConfigStringIndex22) => {
+  ConfigStringIndex22[ConfigStringIndex22["Name"] = 0] = "Name";
+  ConfigStringIndex22[ConfigStringIndex22["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex22[ConfigStringIndex22["Sky"] = 2] = "Sky";
+  ConfigStringIndex22[ConfigStringIndex22["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex22[ConfigStringIndex22["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex22[ConfigStringIndex22["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex22[ConfigStringIndex22["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex22[ConfigStringIndex22["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex22[ConfigStringIndex22["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex22[ConfigStringIndex22["Models"] = 62] = "Models";
+  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS] = "Sounds";
+  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS] = "Images";
+  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES] = "Lights";
+  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
+  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
+  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS] = "PlayerSkins";
+  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS] = "General";
+  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL] = "WheelWeapons";
+  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
+  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
+  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex22[ConfigStringIndex22["GameStyle"] = ConfigStringIndex22.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex22[ConfigStringIndex22["MaxConfigStrings"] = ConfigStringIndex22.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex22;
+})(ConfigStringIndex || {});
+var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+var EngineRuntime = class {
+  constructor(engine, host) {
+    this.engine = engine;
+    this.host = host;
+    this.started = false;
+  }
+  start() {
+    if (this.started) return;
+    this.engine.init();
+    this.host.start();
+    this.started = true;
+  }
+  stop() {
+    if (!this.started) return;
+    this.host.stop();
+    this.engine.shutdown();
+    this.started = false;
+  }
+  pump(elapsedMs) {
+    this.host.pump(elapsedMs);
+  }
+  getLatestFrame() {
+    return this.host.getLatestFrame();
+  }
+  isRunning() {
+    return this.started && this.host.isRunning();
+  }
+};
+function createEngineRuntime(engine, game, client, options) {
+  return new EngineRuntime(engine, new EngineHost(game, client, options));
+}
+function createCrcTable() {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i += 1) {
+    let crc = i;
+    for (let j = 0; j < 8; j += 1) {
+      crc = (crc & 1) !== 0 ? 3988292384 ^ crc >>> 1 : crc >>> 1;
+    }
+    table[i] = crc >>> 0;
+  }
+  return table;
+}
+var CRC_TABLE = createCrcTable();
+var HEADER_SIZE2 = 17 * 4;
+var FLOAT_BYTES = 4;
+var STRIDE = 7 * FLOAT_BYTES;
+var BSP_VERTEX_LAYOUT = [
+  // Position
+  { index: 0, size: 3, type: 5126, stride: STRIDE, offset: 0 },
+  // Diffuse UV
+  { index: 1, size: 2, type: 5126, stride: STRIDE, offset: 3 * FLOAT_BYTES },
+  // Lightmap UV
+  { index: 2, size: 2, type: 5126, stride: STRIDE, offset: 5 * FLOAT_BYTES }
+];
+function createEngine(imports) {
+  return {
+    init() {
+      void imports.trace({ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 0 });
+    },
+    shutdown() {
+    },
+    createMainLoop(callbacks, options) {
+      return new FixedTimestepLoop(callbacks, options);
+    }
+  };
+}
+
+// ../../packages/game/dist/esm/index.js
+var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
+var DEG_TO_RAD2 = Math.PI / 180;
+var DEG2RAD_FACTOR2 = Math.PI / 180;
+var RAD2DEG_FACTOR2 = 180 / Math.PI;
+var CONTENTS_SOLID2 = 1 << 0;
+var CONTENTS_WINDOW2 = 1 << 1;
+var CONTENTS_AUX2 = 1 << 2;
+var CONTENTS_LAVA2 = 1 << 3;
+var CONTENTS_SLIME2 = 1 << 4;
+var CONTENTS_WATER2 = 1 << 5;
+var CONTENTS_MIST2 = 1 << 6;
+var CONTENTS_NO_WATERJUMP2 = 1 << 13;
+var CONTENTS_PROJECTILECLIP2 = 1 << 14;
+var CONTENTS_AREAPORTAL2 = 1 << 15;
+var CONTENTS_PLAYERCLIP2 = 1 << 16;
+var CONTENTS_MONSTERCLIP2 = 1 << 17;
+var CONTENTS_CURRENT_02 = 1 << 18;
+var CONTENTS_CURRENT_902 = 1 << 19;
+var CONTENTS_CURRENT_1802 = 1 << 20;
+var CONTENTS_CURRENT_2702 = 1 << 21;
+var CONTENTS_CURRENT_UP2 = 1 << 22;
+var CONTENTS_CURRENT_DOWN2 = 1 << 23;
+var CONTENTS_ORIGIN2 = 1 << 24;
+var CONTENTS_MONSTER2 = 1 << 25;
+var CONTENTS_DEADMONSTER2 = 1 << 26;
+var CONTENTS_DETAIL2 = 1 << 27;
+var CONTENTS_TRANSLUCENT2 = 1 << 28;
+var CONTENTS_LADDER2 = 1 << 29;
+var CONTENTS_PLAYER2 = 1 << 30;
+var CONTENTS_PROJECTILE2 = 1 << 31;
+var SURF_LIGHT2 = 1 << 0;
+var SURF_SLICK2 = 1 << 1;
+var SURF_SKY2 = 1 << 2;
+var SURF_WARP2 = 1 << 3;
+var SURF_TRANS332 = 1 << 4;
+var SURF_TRANS662 = 1 << 5;
+var SURF_FLOWING2 = 1 << 6;
+var SURF_NODRAW2 = 1 << 7;
+var SURF_ALPHATEST2 = 1 << 25;
+var SURF_N64_UV2 = 1 << 28;
+var SURF_N64_SCROLL_X2 = 1 << 29;
+var SURF_N64_SCROLL_Y2 = 1 << 30;
+var SURF_N64_SCROLL_FLIP2 = 1 << 31;
+var MASK_SOLID2 = CONTENTS_SOLID2 | CONTENTS_WINDOW2;
+var MASK_PLAYERSOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
+var MASK_DEADSOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2;
+var MASK_MONSTERSOLID2 = CONTENTS_SOLID2 | CONTENTS_MONSTERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
+var MASK_WATER2 = CONTENTS_WATER2 | CONTENTS_LAVA2 | CONTENTS_SLIME2;
+var MASK_OPAQUE2 = CONTENTS_SOLID2 | CONTENTS_SLIME2 | CONTENTS_LAVA2;
+var MASK_SHOT2 = CONTENTS_SOLID2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2 | CONTENTS_WINDOW2 | CONTENTS_DEADMONSTER2;
+var MASK_CURRENT2 = CONTENTS_CURRENT_02 | CONTENTS_CURRENT_902 | CONTENTS_CURRENT_1802 | CONTENTS_CURRENT_2702 | CONTENTS_CURRENT_UP2 | CONTENTS_CURRENT_DOWN2;
+var MASK_BLOCK_SIGHT2 = CONTENTS_SOLID2 | CONTENTS_LAVA2 | CONTENTS_SLIME2 | CONTENTS_MONSTER2 | CONTENTS_PLAYER2;
+var MASK_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2;
+var MASK_LADDER_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_WINDOW2;
+var MASK_WALK_NAV_SOLID2 = CONTENTS_SOLID2 | CONTENTS_PLAYERCLIP2 | CONTENTS_WINDOW2 | CONTENTS_MONSTERCLIP2;
+var MASK_PROJECTILE2 = MASK_SHOT2 | CONTENTS_PROJECTILECLIP2;
+var MAX_CLIENTS2 = 256;
+var MAX_LIGHTSTYLES2 = 256;
+var MAX_MODELS2 = 8192;
+var MAX_SOUNDS2 = 2048;
+var MAX_IMAGES2 = 512;
+var MAX_ITEMS2 = 256;
+var MAX_GENERAL2 = MAX_CLIENTS2 * 2;
+var MAX_SHADOW_LIGHTS2 = 256;
+var MAX_WHEEL_ITEMS2 = 32;
+var ConfigStringIndex2 = ((ConfigStringIndex22) => {
+  ConfigStringIndex22[ConfigStringIndex22["Name"] = 0] = "Name";
+  ConfigStringIndex22[ConfigStringIndex22["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex22[ConfigStringIndex22["Sky"] = 2] = "Sky";
+  ConfigStringIndex22[ConfigStringIndex22["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex22[ConfigStringIndex22["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex22[ConfigStringIndex22["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex22[ConfigStringIndex22["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex22[ConfigStringIndex22["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex22[ConfigStringIndex22["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex22[ConfigStringIndex22["Models"] = 62] = "Models";
+  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS2] = "Sounds";
+  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS2] = "Images";
+  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES2] = "Lights";
+  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES2] = "ShadowLights";
+  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS2] = "Items";
+  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS2] = "PlayerSkins";
+  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS2] = "General";
+  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL2] = "WheelWeapons";
+  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS2] = "WheelAmmo";
+  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS2] = "WheelPowerups";
+  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS2] = "CdLoopCount";
+  ConfigStringIndex22[ConfigStringIndex22["GameStyle"] = ConfigStringIndex22.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex22[ConfigStringIndex22["MaxConfigStrings"] = ConfigStringIndex22.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex22;
+})(ConfigStringIndex2 || {});
+var MAX_CONFIGSTRINGS2 = ConfigStringIndex2.MaxConfigStrings;
+var WATERJUMP_CLEAR2 = 8 | 16 | 32 | 1024;
+var ZERO = { ...ZERO_VEC3 };
+function copyVec3() {
+  return { ...ZERO };
+}
+var Entity = class {
+  constructor(index) {
+    this.inUse = false;
+    this.freePending = false;
+    this.linkPrevious = null;
+    this.linkNext = null;
+    this.classname = "";
+    this.spawnflags = 0;
+    this.origin = copyVec3();
+    this.old_origin = copyVec3();
+    this.velocity = copyVec3();
+    this.avelocity = copyVec3();
+    this.angles = copyVec3();
+    this.mins = copyVec3();
+    this.maxs = copyVec3();
+    this.size = copyVec3();
+    this.mass = 0;
+    this.gravity = 1;
+    this.movetype = 0;
+    this.modelindex = 0;
+    this.frame = 0;
+    this.skin = 0;
+    this.effects = 0;
+    this.renderfx = 0;
+    this.health = 0;
+    this.max_health = 0;
+    this.takedamage = false;
+    this.dmg = 0;
+    this.deadflag = 0;
+    this.enemy = null;
+    this.movetarget = null;
+    this.goalentity = null;
+    this.ideal_yaw = 0;
+    this.yaw_speed = 0;
+    this.groundentity = null;
+    this.groundentity_linkcount = 0;
+    this.waterlevel = 0;
+    this.watertype = 0;
+    this.nextthink = 0;
+    this.solid = 0;
+    this.flags = 0;
+    this.svflags = 0;
+    this.index = index;
+  }
+  reset() {
+    this.inUse = false;
+    this.freePending = false;
+    this.linkPrevious = null;
+    this.linkNext = null;
+    this.classname = "";
+    this.spawnflags = 0;
+    this.target = void 0;
+    this.targetname = void 0;
+    this.team = void 0;
+    this.message = void 0;
+    this.origin = copyVec3();
+    this.old_origin = copyVec3();
+    this.velocity = copyVec3();
+    this.avelocity = copyVec3();
+    this.angles = copyVec3();
+    this.mins = copyVec3();
+    this.maxs = copyVec3();
+    this.size = copyVec3();
+    this.mass = 0;
+    this.gravity = 1;
+    this.movetype = 0;
+    this.modelindex = 0;
+    this.frame = 0;
+    this.skin = 0;
+    this.effects = 0;
+    this.renderfx = 0;
+    this.health = 0;
+    this.max_health = 0;
+    this.takedamage = false;
+    this.dmg = 0;
+    this.deadflag = 0;
+    this.enemy = null;
+    this.movetarget = null;
+    this.goalentity = null;
+    this.ideal_yaw = 0;
+    this.yaw_speed = 0;
+    this.groundentity = null;
+    this.groundentity_linkcount = 0;
+    this.waterlevel = 0;
+    this.watertype = 0;
+    this.nextthink = 0;
+    this.think = void 0;
+    this.touch = void 0;
+    this.use = void 0;
+    this.pain = void 0;
+    this.die = void 0;
+    this.solid = 0;
+    this.flags = 0;
+    this.svflags = 0;
+  }
+};
+var MAX_EDICTS = 2048;
+var WORLD_INDEX = 0;
+var EntityPool = class {
+  constructor(maxEntities = MAX_EDICTS) {
+    this.freeList = [];
+    this.pendingFree = [];
+    this.activeHead = null;
+    if (maxEntities < 1 || !Number.isInteger(maxEntities)) {
+      throw new Error("EntityPool requires a positive integer size");
+    }
+    this.entities = new Array(maxEntities);
+    for (let i = 0; i < maxEntities; i += 1) {
+      this.entities[i] = new Entity(i);
+      if (i !== WORLD_INDEX) {
+        this.freeList.push(i);
+      }
+    }
+    const world = this.entities[WORLD_INDEX];
+    world.inUse = true;
+    world.classname = "worldspawn";
+    this.activeHead = world;
+  }
+  get world() {
+    return this.entities[WORLD_INDEX];
+  }
+  get capacity() {
+    return this.entities.length;
+  }
+  get activeCount() {
+    let count = 0;
+    for (const _ of this) {
+      count += 1;
+    }
+    return count;
+  }
+  [Symbol.iterator]() {
+    let current = this.activeHead;
+    return {
+      next: () => {
+        if (!current) {
+          return { done: true, value: void 0 };
+        }
+        const value = current;
+        current = current.linkNext;
+        return { done: false, value };
+      }
+    };
+  }
+  spawn() {
+    const index = this.freeList.pop();
+    if (index === void 0) {
+      throw new Error("No free entities available");
+    }
+    const entity = this.entities[index];
+    entity.reset();
+    entity.inUse = true;
+    this.link(entity);
+    return entity;
+  }
+  deferFree(entity) {
+    if (entity.index === WORLD_INDEX) {
+      throw new Error("Cannot free world entity");
+    }
+    if (!entity.inUse || entity.freePending) {
+      return;
+    }
+    this.unlink(entity);
+    entity.inUse = false;
+    entity.freePending = true;
+    this.pendingFree.push(entity.index);
+  }
+  flushFreeList() {
+    if (this.pendingFree.length === 0) {
+      return;
+    }
+    for (const index of this.pendingFree) {
+      const entity = this.entities[index];
+      entity.reset();
+      this.freeList.push(index);
+    }
+    this.pendingFree.length = 0;
+  }
+  link(entity) {
+    entity.linkNext = this.activeHead;
+    if (this.activeHead) {
+      this.activeHead.linkPrevious = entity;
+    }
+    this.activeHead = entity;
+    entity.linkPrevious = null;
+  }
+  unlink(entity) {
+    if (entity.linkPrevious) {
+      entity.linkPrevious.linkNext = entity.linkNext;
+    }
+    if (entity.linkNext) {
+      entity.linkNext.linkPrevious = entity.linkPrevious;
+    }
+    if (this.activeHead === entity) {
+      this.activeHead = entity.linkNext;
+    }
+    entity.linkPrevious = null;
+    entity.linkNext = null;
+  }
+};
+var ThinkScheduler = class {
+  constructor() {
+    this.queue = [];
+  }
+  schedule(entity, timeSeconds) {
+    entity.nextthink = timeSeconds;
+    this.queue.push({ entity, time: timeSeconds });
+    this.queue.sort((a, b) => a.time === b.time ? a.entity.index - b.entity.index : a.time - b.time);
+  }
+  cancel(entity) {
+    if (this.queue.length === 0) {
+      return;
+    }
+    for (let i = this.queue.length - 1; i >= 0; i -= 1) {
+      if (this.queue[i].entity === entity) {
+        this.queue.splice(i, 1);
+      }
+    }
+  }
+  runDueThinks(currentTimeSeconds) {
+    while (this.queue.length > 0) {
+      const next = this.queue[0];
+      if (next.time > currentTimeSeconds) {
+        break;
+      }
+      this.queue.shift();
+      const { entity, time } = next;
+      if (!entity.inUse || entity.freePending) {
+        continue;
+      }
+      if (!entity.think) {
+        continue;
+      }
+      if (entity.nextthink !== time) {
+        continue;
+      }
+      entity.think(entity);
+    }
+  }
+};
+function computeBounds(entity) {
+  return {
+    min: {
+      x: entity.origin.x + entity.mins.x,
+      y: entity.origin.y + entity.mins.y,
+      z: entity.origin.z + entity.mins.z
+    },
+    max: {
+      x: entity.origin.x + entity.maxs.x,
+      y: entity.origin.y + entity.maxs.y,
+      z: entity.origin.z + entity.maxs.z
+    }
+  };
+}
+function boundsIntersect(a, b) {
+  return !(a.min.x > b.max.x || a.max.x < b.min.x || a.min.y > b.max.y || a.max.y < b.min.y || a.min.z > b.max.z || a.max.z < b.min.z);
+}
+var EntitySystem = class {
+  constructor(maxEntities) {
+    this.currentTimeSeconds = 0;
+    this.pool = new EntityPool(maxEntities);
+    this.thinkScheduler = new ThinkScheduler();
+  }
+  get world() {
+    return this.pool.world;
+  }
+  get activeCount() {
+    return this.pool.activeCount;
+  }
+  get timeSeconds() {
+    return this.currentTimeSeconds;
+  }
+  forEachEntity(callback) {
+    for (const entity of this.pool) {
+      callback(entity);
+    }
+  }
+  spawn() {
+    return this.pool.spawn();
+  }
+  free(entity) {
+    this.thinkScheduler.cancel(entity);
+    this.pool.deferFree(entity);
+  }
+  scheduleThink(entity, nextThinkSeconds) {
+    this.thinkScheduler.schedule(entity, nextThinkSeconds);
+  }
+  beginFrame(timeSeconds) {
+    this.currentTimeSeconds = timeSeconds;
+  }
+  runFrame() {
+    this.thinkScheduler.runDueThinks(this.currentTimeSeconds);
+    this.runTouches();
+    this.pool.flushFreeList();
+  }
+  runTouches() {
+    const world = this.pool.world;
+    const activeEntities = [];
+    for (const entity of this.pool) {
+      if (entity === world) {
+        continue;
+      }
+      if (!entity.inUse || entity.freePending) {
+        continue;
+      }
+      activeEntities.push(entity);
+    }
+    for (let i = 0; i < activeEntities.length; i += 1) {
+      const first = activeEntities[i];
+      let firstBounds = null;
+      for (let j = i + 1; j < activeEntities.length; j += 1) {
+        const second = activeEntities[j];
+        if (!first.touch && !second.touch) {
+          continue;
+        }
+        if (!firstBounds) {
+          firstBounds = computeBounds(first);
+        }
+        const secondBounds = computeBounds(second);
+        if (!boundsIntersect(firstBounds, secondBounds)) {
+          continue;
+        }
+        if (first.touch) {
+          first.touch(first, second);
+        }
+        if (second.touch) {
+          second.touch(second, first);
+        }
+      }
+    }
+  }
+};
+var orderedStageNames = [
+  "prep",
+  "simulate",
+  "finish"
+];
+var GameFrameLoop = class {
+  constructor(initialStages) {
+    this.timeMs = 0;
+    this.frame = 0;
+    this.stageHandlers = {
+      prep: [],
+      simulate: [],
+      finish: []
+    };
+    this.stageCounts = {
+      prep: 0,
+      simulate: 0,
+      finish: 0
+    };
+    this.stageCompactionNeeded = {
+      prep: false,
+      simulate: false,
+      finish: false
+    };
+    if (initialStages) {
+      for (const stageName of orderedStageNames) {
+        const handler = initialStages[stageName];
+        if (handler) {
+          this.addStage(stageName, handler);
+        }
+      }
+    }
+  }
+  addStage(stage, handler) {
+    const handlers = this.stageHandlers[stage];
+    handlers.push(handler);
+    this.stageCounts[stage] += 1;
+    return () => {
+      const index = handlers.indexOf(handler);
+      if (index >= 0 && handlers[index]) {
+        handlers[index] = void 0;
+        this.stageCounts[stage] -= 1;
+        this.stageCompactionNeeded[stage] = true;
+      }
+    };
+  }
+  reset(startTimeMs) {
+    this.timeMs = startTimeMs;
+    this.frame = 0;
+  }
+  advance(step) {
+    const previousTimeMs = this.timeMs;
+    this.timeMs = previousTimeMs + step.deltaMs;
+    this.frame = step.frame;
+    const context = {
+      ...step,
+      timeMs: this.timeMs,
+      previousTimeMs,
+      deltaSeconds: step.deltaMs / 1e3
+    };
+    this.runStage("prep", context);
+    if (this.stageCounts.simulate === 0) {
+      throw new Error("GameFrameLoop requires at least one simulate stage");
+    }
+    this.runStage("simulate", context);
+    this.runStage("finish", context);
+    return context;
+  }
+  runStage(stage, context) {
+    const handlers = this.stageHandlers[stage];
+    for (let i = 0; i < handlers.length; i += 1) {
+      const handler = handlers[i];
+      if (!handler) {
+        continue;
+      }
+      handler(context);
+    }
+    if (this.stageCompactionNeeded[stage]) {
+      this.compactStageHandlers(stage);
+    }
+  }
+  compactStageHandlers(stage) {
+    const handlers = this.stageHandlers[stage];
+    let writeIndex = 0;
+    for (let readIndex = 0; readIndex < handlers.length; readIndex += 1) {
+      const handler = handlers[readIndex];
+      if (handler) {
+        handlers[writeIndex] = handler;
+        writeIndex += 1;
+      }
+    }
+    handlers.length = writeIndex;
+    this.stageCompactionNeeded[stage] = false;
+  }
+  get time() {
+    return this.timeMs;
+  }
+  get frameNumber() {
+    return this.frame;
+  }
+};
+var ZERO_STATE = {
+  frameNumber: 0,
+  timeSeconds: 0,
+  previousTimeSeconds: 0,
+  deltaSeconds: 0
+};
+var LevelClock = class {
+  constructor() {
+    this.state = ZERO_STATE;
+  }
+  start(startTimeMs) {
+    const startSeconds = startTimeMs / 1e3;
+    this.state = {
+      frameNumber: 0,
+      timeSeconds: startSeconds,
+      previousTimeSeconds: startSeconds,
+      deltaSeconds: 0
+    };
+  }
+  tick(context) {
+    this.state = {
+      frameNumber: context.frame,
+      timeSeconds: context.timeMs / 1e3,
+      previousTimeSeconds: context.previousTimeMs / 1e3,
+      deltaSeconds: context.deltaSeconds
+    };
+    return this.state;
+  }
+  get current() {
+    return this.state;
+  }
+};
+var ZERO_VEC32 = { x: 0, y: 0, z: 0 };
+function createGame(engine, options) {
+  const gravity = options.gravity;
+  const levelClock = new LevelClock();
+  const frameLoop = new GameFrameLoop();
+  const entities = new EntitySystem();
+  frameLoop.addStage("prep", (context) => {
+    levelClock.tick(context);
+    entities.beginFrame(levelClock.current.timeSeconds);
+  });
+  frameLoop.addStage("simulate", ({ deltaSeconds }) => {
+    velocity = {
+      x: velocity.x + gravity.x * deltaSeconds,
+      y: velocity.y + gravity.y * deltaSeconds,
+      z: velocity.z + gravity.z * deltaSeconds
+    };
+    origin = {
+      x: origin.x + velocity.x * deltaSeconds,
+      y: origin.y + velocity.y * deltaSeconds,
+      z: origin.z + velocity.z * deltaSeconds
+    };
+    entities.runFrame();
+  });
+  let origin = { ...ZERO_VEC32 };
+  let velocity = { ...ZERO_VEC32 };
+  const snapshot = (frame) => ({
+    frame,
+    timeMs: frameLoop.time,
+    state: {
+      gravity: { ...gravity },
+      origin: { ...origin },
+      velocity: { ...velocity },
+      level: { ...levelClock.current },
+      entities: {
+        activeCount: entities.activeCount,
+        worldClassname: entities.world.classname
+      }
+    }
+  });
+  const resetState = (startTimeMs) => {
+    frameLoop.reset(startTimeMs);
+    levelClock.start(startTimeMs);
+    origin = { ...ZERO_VEC32 };
+    velocity = { ...ZERO_VEC32 };
+    entities.beginFrame(startTimeMs / 1e3);
+    entities.runFrame();
+  };
+  return {
+    init(startTimeMs) {
+      resetState(startTimeMs);
+      void engine.trace({ x: 0, y: 0, z: 0 }, gravity);
+      return snapshot(0);
+    },
+    shutdown() {
+    },
+    spawnWorld() {
+    },
+    frame(step) {
+      const context = frameLoop.advance(step);
+      return snapshot(context.frame);
+    },
+    entities
+  };
+}
+
+// ../../packages/shared/dist/esm/index.js
+var ZERO_VEC33 = { x: 0, y: 0, z: 0 };
+var DEG_TO_RAD3 = Math.PI / 180;
+var DEG2RAD_FACTOR3 = Math.PI / 180;
+var RAD2DEG_FACTOR3 = 180 / Math.PI;
+var CONTENTS_SOLID3 = 1 << 0;
+var CONTENTS_WINDOW3 = 1 << 1;
+var CONTENTS_AUX3 = 1 << 2;
+var CONTENTS_LAVA3 = 1 << 3;
+var CONTENTS_SLIME3 = 1 << 4;
+var CONTENTS_WATER3 = 1 << 5;
+var CONTENTS_MIST3 = 1 << 6;
+var CONTENTS_NO_WATERJUMP3 = 1 << 13;
+var CONTENTS_PROJECTILECLIP3 = 1 << 14;
+var CONTENTS_AREAPORTAL3 = 1 << 15;
+var CONTENTS_PLAYERCLIP3 = 1 << 16;
+var CONTENTS_MONSTERCLIP3 = 1 << 17;
+var CONTENTS_CURRENT_03 = 1 << 18;
+var CONTENTS_CURRENT_903 = 1 << 19;
+var CONTENTS_CURRENT_1803 = 1 << 20;
+var CONTENTS_CURRENT_2703 = 1 << 21;
+var CONTENTS_CURRENT_UP3 = 1 << 22;
+var CONTENTS_CURRENT_DOWN3 = 1 << 23;
+var CONTENTS_ORIGIN3 = 1 << 24;
+var CONTENTS_MONSTER3 = 1 << 25;
+var CONTENTS_DEADMONSTER3 = 1 << 26;
+var CONTENTS_DETAIL3 = 1 << 27;
+var CONTENTS_TRANSLUCENT3 = 1 << 28;
+var CONTENTS_LADDER3 = 1 << 29;
+var CONTENTS_PLAYER3 = 1 << 30;
+var CONTENTS_PROJECTILE3 = 1 << 31;
+var SURF_LIGHT3 = 1 << 0;
+var SURF_SLICK3 = 1 << 1;
+var SURF_SKY3 = 1 << 2;
+var SURF_WARP3 = 1 << 3;
+var SURF_TRANS333 = 1 << 4;
+var SURF_TRANS663 = 1 << 5;
+var SURF_FLOWING3 = 1 << 6;
+var SURF_NODRAW3 = 1 << 7;
+var SURF_ALPHATEST3 = 1 << 25;
+var SURF_N64_UV3 = 1 << 28;
+var SURF_N64_SCROLL_X3 = 1 << 29;
+var SURF_N64_SCROLL_Y3 = 1 << 30;
+var SURF_N64_SCROLL_FLIP3 = 1 << 31;
+var MASK_SOLID3 = CONTENTS_SOLID3 | CONTENTS_WINDOW3;
+var MASK_PLAYERSOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
+var MASK_DEADSOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3;
+var MASK_MONSTERSOLID3 = CONTENTS_SOLID3 | CONTENTS_MONSTERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
+var MASK_WATER3 = CONTENTS_WATER3 | CONTENTS_LAVA3 | CONTENTS_SLIME3;
+var MASK_OPAQUE3 = CONTENTS_SOLID3 | CONTENTS_SLIME3 | CONTENTS_LAVA3;
+var MASK_SHOT3 = CONTENTS_SOLID3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3 | CONTENTS_WINDOW3 | CONTENTS_DEADMONSTER3;
+var MASK_CURRENT3 = CONTENTS_CURRENT_03 | CONTENTS_CURRENT_903 | CONTENTS_CURRENT_1803 | CONTENTS_CURRENT_2703 | CONTENTS_CURRENT_UP3 | CONTENTS_CURRENT_DOWN3;
+var MASK_BLOCK_SIGHT3 = CONTENTS_SOLID3 | CONTENTS_LAVA3 | CONTENTS_SLIME3 | CONTENTS_MONSTER3 | CONTENTS_PLAYER3;
+var MASK_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3;
+var MASK_LADDER_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_WINDOW3;
+var MASK_WALK_NAV_SOLID3 = CONTENTS_SOLID3 | CONTENTS_PLAYERCLIP3 | CONTENTS_WINDOW3 | CONTENTS_MONSTERCLIP3;
+var MASK_PROJECTILE3 = MASK_SHOT3 | CONTENTS_PROJECTILECLIP3;
+var MAX_CLIENTS3 = 256;
+var MAX_LIGHTSTYLES3 = 256;
+var MAX_MODELS3 = 8192;
+var MAX_SOUNDS3 = 2048;
+var MAX_IMAGES3 = 512;
+var MAX_ITEMS3 = 256;
+var MAX_GENERAL3 = MAX_CLIENTS3 * 2;
+var MAX_SHADOW_LIGHTS3 = 256;
+var MAX_WHEEL_ITEMS3 = 32;
+var ConfigStringIndex3 = ((ConfigStringIndex22) => {
+  ConfigStringIndex22[ConfigStringIndex22["Name"] = 0] = "Name";
+  ConfigStringIndex22[ConfigStringIndex22["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex22[ConfigStringIndex22["Sky"] = 2] = "Sky";
+  ConfigStringIndex22[ConfigStringIndex22["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex22[ConfigStringIndex22["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex22[ConfigStringIndex22["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex22[ConfigStringIndex22["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex22[ConfigStringIndex22["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex22[ConfigStringIndex22["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex22[ConfigStringIndex22["Models"] = 62] = "Models";
+  ConfigStringIndex22[ConfigStringIndex22["Sounds"] = 62 + MAX_MODELS3] = "Sounds";
+  ConfigStringIndex22[ConfigStringIndex22["Images"] = ConfigStringIndex22.Sounds + MAX_SOUNDS3] = "Images";
+  ConfigStringIndex22[ConfigStringIndex22["Lights"] = ConfigStringIndex22.Images + MAX_IMAGES3] = "Lights";
+  ConfigStringIndex22[ConfigStringIndex22["ShadowLights"] = ConfigStringIndex22.Lights + MAX_LIGHTSTYLES3] = "ShadowLights";
+  ConfigStringIndex22[ConfigStringIndex22["Items"] = ConfigStringIndex22.ShadowLights + MAX_SHADOW_LIGHTS3] = "Items";
+  ConfigStringIndex22[ConfigStringIndex22["PlayerSkins"] = ConfigStringIndex22.Items + MAX_ITEMS3] = "PlayerSkins";
+  ConfigStringIndex22[ConfigStringIndex22["General"] = ConfigStringIndex22.PlayerSkins + MAX_CLIENTS3] = "General";
+  ConfigStringIndex22[ConfigStringIndex22["WheelWeapons"] = ConfigStringIndex22.General + MAX_GENERAL3] = "WheelWeapons";
+  ConfigStringIndex22[ConfigStringIndex22["WheelAmmo"] = ConfigStringIndex22.WheelWeapons + MAX_WHEEL_ITEMS3] = "WheelAmmo";
+  ConfigStringIndex22[ConfigStringIndex22["WheelPowerups"] = ConfigStringIndex22.WheelAmmo + MAX_WHEEL_ITEMS3] = "WheelPowerups";
+  ConfigStringIndex22[ConfigStringIndex22["CdLoopCount"] = ConfigStringIndex22.WheelPowerups + MAX_WHEEL_ITEMS3] = "CdLoopCount";
+  ConfigStringIndex22[ConfigStringIndex22["GameStyle"] = ConfigStringIndex22.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex22[ConfigStringIndex22["MaxConfigStrings"] = ConfigStringIndex22.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex22;
+})(ConfigStringIndex3 || {});
+var MAX_CONFIGSTRINGS3 = ConfigStringIndex3.MaxConfigStrings;
+var WATERJUMP_CLEAR3 = 8 | 16 | 32 | 1024;
+
+// src/index.ts
+function bootstrapViewer() {
+  const engine = createEngine({
+    trace(start, end) {
+      return { start, end, fraction: 1 };
+    }
+  });
+  const game = createGame({
+    trace(start, end) {
+      return { start, end, fraction: 1 };
+    }
+  }, { gravity: ZERO_VEC33 });
+  const client = createClient({ engine: { trace: () => ({ start: ZERO_VEC33, end: ZERO_VEC33, fraction: 1 }) } });
+  const runtime = createEngineRuntime(engine, game, client);
+  runtime.start();
+  return { engine, game, client, runtime };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bootstrapViewer
+});
+//# sourceMappingURL=index.cjs.map