quake2ts 0.0.7

package/packages/engine/dist/esm/index.js

@@ -0,0 +1,1764 @@
+// src/loop.ts
+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 });
+  }
+};
+
+// src/host.ts
+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();
+  }
+};
+
+// ../shared/dist/esm/index.js
+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_NONE = 0;
+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 CvarFlags = /* @__PURE__ */ ((CvarFlags2) => {
+  CvarFlags2[CvarFlags2["None"] = 0] = "None";
+  CvarFlags2[CvarFlags2["Archive"] = 1] = "Archive";
+  CvarFlags2[CvarFlags2["UserInfo"] = 2] = "UserInfo";
+  CvarFlags2[CvarFlags2["ServerInfo"] = 4] = "ServerInfo";
+  CvarFlags2[CvarFlags2["Latch"] = 8] = "Latch";
+  CvarFlags2[CvarFlags2["Cheat"] = 16] = "Cheat";
+  return CvarFlags2;
+})(CvarFlags || {});
+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 CS_MAX_STRING_LENGTH = 96;
+var ConfigStringIndex = ((ConfigStringIndex2) => {
+  ConfigStringIndex2[ConfigStringIndex2["Name"] = 0] = "Name";
+  ConfigStringIndex2[ConfigStringIndex2["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex2[ConfigStringIndex2["Sky"] = 2] = "Sky";
+  ConfigStringIndex2[ConfigStringIndex2["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex2[ConfigStringIndex2["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex2[ConfigStringIndex2["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex2[ConfigStringIndex2["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex2[ConfigStringIndex2["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex2[ConfigStringIndex2["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex2[ConfigStringIndex2["Models"] = 62] = "Models";
+  ConfigStringIndex2[ConfigStringIndex2["Sounds"] = 62 + MAX_MODELS] = "Sounds";
+  ConfigStringIndex2[ConfigStringIndex2["Images"] = ConfigStringIndex2.Sounds + MAX_SOUNDS] = "Images";
+  ConfigStringIndex2[ConfigStringIndex2["Lights"] = ConfigStringIndex2.Images + MAX_IMAGES] = "Lights";
+  ConfigStringIndex2[ConfigStringIndex2["ShadowLights"] = ConfigStringIndex2.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
+  ConfigStringIndex2[ConfigStringIndex2["Items"] = ConfigStringIndex2.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
+  ConfigStringIndex2[ConfigStringIndex2["PlayerSkins"] = ConfigStringIndex2.Items + MAX_ITEMS] = "PlayerSkins";
+  ConfigStringIndex2[ConfigStringIndex2["General"] = ConfigStringIndex2.PlayerSkins + MAX_CLIENTS] = "General";
+  ConfigStringIndex2[ConfigStringIndex2["WheelWeapons"] = ConfigStringIndex2.General + MAX_GENERAL] = "WheelWeapons";
+  ConfigStringIndex2[ConfigStringIndex2["WheelAmmo"] = ConfigStringIndex2.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
+  ConfigStringIndex2[ConfigStringIndex2["WheelPowerups"] = ConfigStringIndex2.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
+  ConfigStringIndex2[ConfigStringIndex2["CdLoopCount"] = ConfigStringIndex2.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex2[ConfigStringIndex2["GameStyle"] = ConfigStringIndex2.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex2[ConfigStringIndex2["MaxConfigStrings"] = ConfigStringIndex2.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex2;
+})(ConfigStringIndex || {});
+var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+function configStringSize(index) {
+  if (index >= 5 && index < 59) {
+    return CS_MAX_STRING_LENGTH * (59 - index);
+  }
+  if (index >= ConfigStringIndex.General && index < ConfigStringIndex.WheelWeapons) {
+    return CS_MAX_STRING_LENGTH * (ConfigStringIndex.MaxConfigStrings - index);
+  }
+  return CS_MAX_STRING_LENGTH;
+}
+var WATERJUMP_CLEAR = 8 | 16 | 32 | 1024;
+
+// src/configstrings.ts
+function assertWithinBounds(index) {
+  if (index < 0 || index >= ConfigStringIndex.MaxConfigStrings) {
+    throw new RangeError(`Configstring index ${index} is out of range (0-${ConfigStringIndex.MaxConfigStrings - 1})`);
+  }
+}
+function assertLength(index, value) {
+  const maxLength = configStringSize(index);
+  if (value.length > maxLength) {
+    throw new RangeError(
+      `Configstring ${index} exceeds maximum length (${value.length} > ${maxLength}); limit is ${CS_MAX_STRING_LENGTH} chars per slot`
+    );
+  }
+}
+var ConfigStringRegistry = class {
+  constructor() {
+    this.values = /* @__PURE__ */ new Map();
+    this.modelCursor = ConfigStringIndex.Models;
+    this.soundCursor = ConfigStringIndex.Sounds;
+    this.imageCursor = ConfigStringIndex.Images;
+    this.lightCursor = ConfigStringIndex.Lights;
+    this.shadowLightCursor = ConfigStringIndex.ShadowLights;
+    this.itemCursor = ConfigStringIndex.Items;
+    this.playerSkinCursor = ConfigStringIndex.PlayerSkins;
+    this.generalCursor = ConfigStringIndex.General;
+  }
+  set(index, value) {
+    assertWithinBounds(index);
+    assertLength(index, value);
+    this.values.set(index, value);
+    return index;
+  }
+  get(index) {
+    return this.values.get(index);
+  }
+  getAll() {
+    const result = new Array(MAX_CONFIGSTRINGS).fill("");
+    for (const [index, value] of this.values.entries()) {
+      result[index] = value;
+    }
+    return result;
+  }
+  modelIndex(path) {
+    return this.register(path, ConfigStringIndex.Models, MAX_MODELS, "modelCursor");
+  }
+  soundIndex(path) {
+    return this.register(path, ConfigStringIndex.Sounds, MAX_SOUNDS, "soundCursor");
+  }
+  imageIndex(path) {
+    return this.register(path, ConfigStringIndex.Images, MAX_IMAGES, "imageCursor");
+  }
+  lightIndex(definition) {
+    return this.register(definition, ConfigStringIndex.Lights, MAX_LIGHTSTYLES, "lightCursor");
+  }
+  shadowLightIndex(definition) {
+    return this.register(definition, ConfigStringIndex.ShadowLights, MAX_SHADOW_LIGHTS, "shadowLightCursor");
+  }
+  itemIndex(name) {
+    return this.register(name, ConfigStringIndex.Items, MAX_ITEMS, "itemCursor");
+  }
+  playerSkinIndex(name) {
+    return this.register(name, ConfigStringIndex.PlayerSkins, MAX_CLIENTS, "playerSkinCursor");
+  }
+  generalIndex(value) {
+    return this.register(value, ConfigStringIndex.General, MAX_GENERAL, "generalCursor");
+  }
+  register(value, start, maxCount, cursorKey) {
+    for (let i = start; i < start + maxCount; i += 1) {
+      if (this.values.get(i) === value) {
+        return i;
+      }
+    }
+    const next = this[cursorKey];
+    const limit = start + maxCount;
+    if (next >= limit) {
+      throw new RangeError(`Out of configstring slots for range starting at ${start}`);
+    }
+    assertLength(next, value);
+    this.values.set(next, value);
+    this[cursorKey] = next + 1;
+    return next;
+  }
+};
+
+// src/runtime.ts
+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));
+}
+
+// src/cvars.ts
+var Cvar = class {
+  constructor({
+    name,
+    defaultValue,
+    description,
+    flags = CvarFlags.None,
+    onChange
+  }) {
+    this.modifiedCount = 0;
+    this.name = name;
+    this.defaultValue = defaultValue;
+    this.description = description;
+    this.flags = flags;
+    this._value = defaultValue;
+    this.onChange = onChange;
+  }
+  get string() {
+    return this._value;
+  }
+  get number() {
+    return Number(this._value);
+  }
+  get integer() {
+    return Math.trunc(this.number);
+  }
+  get boolean() {
+    return Boolean(this.integer);
+  }
+  set(value) {
+    if (this.flags & CvarFlags.Latch) {
+      if (value === this._value) {
+        this.latched = void 0;
+        return;
+      }
+      if (this.latched === value) {
+        return;
+      }
+      if (this.latched !== value) {
+        this.latched = value;
+      }
+      return;
+    }
+    this.apply(value);
+  }
+  reset() {
+    this.latched = void 0;
+    this.apply(this.defaultValue);
+  }
+  applyLatched() {
+    if (this.latched === void 0) {
+      return false;
+    }
+    const pending = this.latched;
+    this.latched = void 0;
+    if (pending === this._value) {
+      return false;
+    }
+    this.apply(pending);
+    return true;
+  }
+  apply(next) {
+    if (this._value === next) {
+      return;
+    }
+    const previous = this._value;
+    this._value = next;
+    this.modifiedCount += 1;
+    this.onChange?.(this, previous);
+  }
+};
+var CvarRegistry = class {
+  constructor() {
+    this.cvars = /* @__PURE__ */ new Map();
+  }
+  register(def) {
+    const existing = this.cvars.get(def.name);
+    if (existing) {
+      return existing;
+    }
+    const cvar = new Cvar(def);
+    this.cvars.set(def.name, cvar);
+    return cvar;
+  }
+  get(name) {
+    return this.cvars.get(name);
+  }
+  setValue(name, value) {
+    const cvar = this.get(name);
+    if (!cvar) {
+      throw new Error(`Unknown cvar: ${name}`);
+    }
+    cvar.set(value);
+    return cvar;
+  }
+  resetAll() {
+    for (const cvar of this.cvars.values()) {
+      cvar.reset();
+    }
+  }
+  applyLatched() {
+    let changed = false;
+    for (const cvar of this.cvars.values()) {
+      changed = cvar.applyLatched() || changed;
+    }
+    return changed;
+  }
+  list() {
+    return [...this.cvars.values()].sort((a, b) => a.name.localeCompare(b.name));
+  }
+};
+
+// src/assets/pak.ts
+var PAK_MAGIC = "PACK";
+var HEADER_SIZE = 12;
+var DIRECTORY_ENTRY_SIZE = 64;
+function readCString(view, offset, maxLength) {
+  const codes = [];
+  for (let i = 0; i < maxLength; i += 1) {
+    const code = view.getUint8(offset + i);
+    if (code === 0) {
+      break;
+    }
+    codes.push(code);
+  }
+  return String.fromCharCode(...codes);
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\/+/, "").toLowerCase();
+}
+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();
+function crc32(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i += 1) {
+    const byte = data[i];
+    crc = CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var PakParseError = class extends Error {
+};
+var PakArchive = class _PakArchive {
+  constructor(name, buffer, entries, checksum) {
+    this.name = name;
+    this.buffer = buffer;
+    this.entries = new Map(entries.map((entry) => [entry.name, entry]));
+    this.checksum = checksum;
+    this.size = buffer.byteLength;
+  }
+  static fromArrayBuffer(name, buffer) {
+    const view = new DataView(buffer);
+    if (buffer.byteLength < HEADER_SIZE) {
+      throw new PakParseError("PAK buffer too small to contain header");
+    }
+    const magic = String.fromCharCode(
+      view.getUint8(0),
+      view.getUint8(1),
+      view.getUint8(2),
+      view.getUint8(3)
+    );
+    if (magic !== PAK_MAGIC) {
+      throw new PakParseError(`Invalid PAK header magic: ${magic}`);
+    }
+    const dirOffset = view.getInt32(4, true);
+    const dirLength = view.getInt32(8, true);
+    if (dirOffset < HEADER_SIZE) {
+      throw new PakParseError(`Invalid directory offset: ${dirOffset}`);
+    }
+    if (dirLength <= 0 || dirLength % DIRECTORY_ENTRY_SIZE !== 0) {
+      throw new PakParseError(`Invalid directory length: ${dirLength}`);
+    }
+    const dirEnd = dirOffset + dirLength;
+    if (dirEnd > buffer.byteLength) {
+      throw new PakParseError("Directory exceeds buffer length");
+    }
+    const entryCount = dirLength / DIRECTORY_ENTRY_SIZE;
+    const entries = [];
+    const dedupe = /* @__PURE__ */ new Map();
+    for (let i = 0; i < entryCount; i += 1) {
+      const offset = dirOffset + i * DIRECTORY_ENTRY_SIZE;
+      const rawName = readCString(view, offset, 56);
+      const normalized = normalizePath(rawName);
+      const fileOffset = view.getInt32(offset + 56, true);
+      const fileLength = view.getInt32(offset + 60, true);
+      if (fileOffset < 0 || fileLength < 0 || fileOffset + fileLength > buffer.byteLength) {
+        throw new PakParseError(
+          `Invalid entry bounds for ${rawName || "<unnamed>"} (offset=${fileOffset}, length=${fileLength})`
+        );
+      }
+      if (!normalized) {
+        throw new PakParseError(`Entry ${i} has an empty name`);
+      }
+      const entry = { name: normalized, offset: fileOffset, length: fileLength };
+      dedupe.set(normalized, entry);
+    }
+    entries.push(...dedupe.values());
+    return new _PakArchive(name, buffer, entries, crc32(new Uint8Array(buffer)));
+  }
+  getEntry(path) {
+    return this.entries.get(normalizePath(path));
+  }
+  listEntries() {
+    return Array.from(this.entries.values());
+  }
+  readFile(path) {
+    const entry = this.getEntry(path);
+    if (!entry) {
+      throw new PakParseError(`File not found in PAK: ${path}`);
+    }
+    return new Uint8Array(this.buffer, entry.offset, entry.length);
+  }
+  validate() {
+    return {
+      checksum: this.checksum,
+      entries: this.listEntries()
+    };
+  }
+};
+function calculatePakChecksum(buffer) {
+  return crc32(new Uint8Array(buffer));
+}
+
+// src/assets/vfs.ts
+var VirtualFileSystem = class {
+  constructor(archives = []) {
+    this.mounts = [];
+    this.files = /* @__PURE__ */ new Map();
+    archives.forEach((archive) => this.mountPak(archive));
+  }
+  mountPak(archive) {
+    this.mounts.push(archive);
+    for (const entry of archive.listEntries()) {
+      const key = normalizePath(entry.name);
+      this.files.set(key, { archive, entry });
+    }
+  }
+  get mountedPaks() {
+    return [...this.mounts];
+  }
+  hasFile(path) {
+    return this.files.has(normalizePath(path));
+  }
+  stat(path) {
+    const source = this.files.get(normalizePath(path));
+    if (!source) {
+      return void 0;
+    }
+    return { path: source.entry.name, size: source.entry.length, sourcePak: source.archive.name };
+  }
+  async readFile(path) {
+    const source = this.files.get(normalizePath(path));
+    if (!source) {
+      throw new Error(`File not found in VFS: ${path}`);
+    }
+    return source.archive.readFile(path);
+  }
+  list(directory = "") {
+    const dir = normalizePath(directory).replace(/\/+$|^\//g, "");
+    const files = [];
+    const directories = /* @__PURE__ */ new Set();
+    const prefix = dir ? `${dir}/` : "";
+    for (const source of this.files.values()) {
+      if (dir && !source.entry.name.startsWith(prefix)) {
+        continue;
+      }
+      const relative = dir ? source.entry.name.slice(prefix.length) : source.entry.name;
+      const separatorIndex = relative.indexOf("/");
+      if (separatorIndex === -1) {
+        files.push({ path: source.entry.name, size: source.entry.length, sourcePak: source.archive.name });
+      } else {
+        directories.add(relative.slice(0, separatorIndex));
+      }
+    }
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return { files, directories: [...directories].sort() };
+  }
+  findByExtension(extension) {
+    const normalizedExt = extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
+    const results = [];
+    for (const source of this.files.values()) {
+      if (source.entry.name.toLowerCase().endsWith(normalizedExt)) {
+        results.push({ path: source.entry.name, size: source.entry.length, sourcePak: source.archive.name });
+      }
+    }
+    return results.sort((a, b) => a.path.localeCompare(b.path));
+  }
+};
+
+// src/assets/ingestion.ts
+var PakIngestionError = class extends Error {
+  constructor(file, cause) {
+    super(`Failed to ingest PAK: ${file}`);
+    this.file = file;
+    this.name = "PakIngestionError";
+    if (cause instanceof Error && cause.stack) {
+      this.stack = cause.stack;
+    }
+    this.cause = cause;
+  }
+};
+async function readBlobWithProgress(source, onProgress) {
+  if (typeof source.arrayBuffer === "function") {
+    const buffer = await source.arrayBuffer();
+    onProgress?.({ file: "blob", loadedBytes: buffer.byteLength, totalBytes: buffer.byteLength, state: "reading" });
+    return buffer;
+  }
+  if (typeof FileReader !== "undefined") {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onerror = () => reject(reader.error ?? new Error("Unknown FileReader error"));
+      reader.onprogress = (event) => {
+        onProgress?.({
+          file: "blob",
+          loadedBytes: event.loaded,
+          totalBytes: event.total || source.size,
+          state: "reading"
+        });
+      };
+      reader.onload = () => {
+        const result = reader.result;
+        if (result instanceof ArrayBuffer) {
+          resolve(result);
+        } else {
+          reject(new Error("Unexpected FileReader result"));
+        }
+      };
+      reader.readAsArrayBuffer(source);
+    });
+  }
+  if (typeof Response !== "undefined") {
+    const buffer = await new Response(source).arrayBuffer();
+    onProgress?.({ file: "blob", loadedBytes: buffer.byteLength, totalBytes: buffer.byteLength, state: "reading" });
+    return buffer;
+  }
+  if (typeof source.stream === "function") {
+    const reader = source.stream().getReader();
+    const chunks = [];
+    let loaded = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (!value) {
+        continue;
+      }
+      const chunk = value;
+      chunks.push(chunk);
+      loaded += chunk.byteLength;
+      onProgress?.({ file: "blob", loadedBytes: loaded, totalBytes: source.size, state: "reading" });
+    }
+    const result = new Uint8Array(loaded);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result.buffer;
+  }
+  throw new PakIngestionError("blob", new Error("Unsupported Blob type"));
+}
+async function toArrayBuffer(source, onProgress) {
+  if (source.data instanceof ArrayBuffer) {
+    onProgress?.({ file: source.name, loadedBytes: source.data.byteLength, totalBytes: source.data.byteLength, state: "reading" });
+    return source.data;
+  }
+  if (source.data instanceof Blob) {
+    const totalBytes = source.data.size;
+    return readBlobWithProgress(
+      source.data,
+      (progress) => onProgress?.({ ...progress, file: source.name, totalBytes })
+    );
+  }
+  const buffer = source.data.buffer.slice(source.data.byteOffset, source.data.byteOffset + source.data.byteLength);
+  onProgress?.({ file: source.name, loadedBytes: buffer.byteLength, totalBytes: buffer.byteLength, state: "reading" });
+  return buffer;
+}
+async function ingestPaks(vfs, sources, onProgressOrOptions) {
+  const options = typeof onProgressOrOptions === "function" ? { onProgress: onProgressOrOptions } : onProgressOrOptions ?? {};
+  const results = [];
+  for (const source of sources) {
+    try {
+      const buffer = await toArrayBuffer(source, options.onProgress);
+      const archive = PakArchive.fromArrayBuffer(source.name, buffer);
+      vfs.mountPak(archive);
+      options.onProgress?.({ file: source.name, loadedBytes: buffer.byteLength, totalBytes: buffer.byteLength, state: "parsed" });
+      results.push({ archive, mounted: true });
+    } catch (error) {
+      options.onProgress?.({ file: source.name, loadedBytes: 0, totalBytes: 0, state: "error" });
+      options.onError?.(source.name, error);
+      if (options.stopOnError) {
+        throw new PakIngestionError(source.name, error);
+      }
+    }
+  }
+  return results;
+}
+
+// src/assets/cache.ts
+var LruCache = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.map = /* @__PURE__ */ new Map();
+    if (capacity <= 0) {
+      throw new RangeError("LRU cache capacity must be greater than zero");
+    }
+  }
+  get size() {
+    return this.map.size;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value === void 0) {
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    }
+    this.map.set(key, value);
+    if (this.map.size > this.capacity) {
+      const oldestKey = this.map.keys().next();
+      if (!oldestKey.done) {
+        this.map.delete(oldestKey.value);
+      }
+    }
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  entries() {
+    return Array.from(this.map.entries()).reverse().map(([key, value]) => ({ key, value }));
+  }
+};
+
+// src/assets/browserIngestion.ts
+function toArray(files) {
+  return Array.isArray(files) ? files : Array.from(files);
+}
+function filesToPakSources(files) {
+  return toArray(files).map((file) => ({ name: file.name, data: file }));
+}
+async function ingestPakFiles(vfs, files, options) {
+  const sources = filesToPakSources(files);
+  return ingestPaks(vfs, sources, options ?? {});
+}
+function wireDropTarget(element, handler) {
+  const onDragOver = (event) => {
+    event.preventDefault();
+    event.dataTransfer?.dropEffect && (event.dataTransfer.dropEffect = "copy");
+  };
+  const onDrop = (event) => {
+    event.preventDefault();
+    const droppedFiles = event.dataTransfer?.files;
+    if (droppedFiles && droppedFiles.length > 0) {
+      handler(Array.from(droppedFiles));
+    }
+  };
+  element.addEventListener("dragover", onDragOver);
+  element.addEventListener("drop", onDrop);
+  return () => {
+    element.removeEventListener("dragover", onDragOver);
+    element.removeEventListener("drop", onDrop);
+  };
+}
+function wireFileInput(input, handler) {
+  const onChange = (event) => {
+    const target = event.target;
+    if (!target || !target.files || target.files.length === 0) {
+      return;
+    }
+    handler(target.files);
+    target.value = "";
+  };
+  input.addEventListener("change", onChange);
+  return () => input.removeEventListener("change", onChange);
+}
+
+// src/assets/md2.ts
+var MD2_MAGIC = 844121161;
+var MD2_VERSION = 8;
+var HEADER_SIZE2 = 17 * 4;
+var MD2_NORMALS = [
+  { x: -0.525731, y: 0, z: 0.850651 },
+  { x: -0.442863, y: 0.238856, z: 0.864188 },
+  { x: -0.295242, y: 0, z: 0.955423 },
+  { x: -0.309017, y: 0.5, z: 0.809017 },
+  { x: -0.16246, y: 0.262866, z: 0.951056 },
+  { x: 0, y: 0, z: 1 },
+  { x: 0, y: 0.850651, z: 0.525731 },
+  { x: -0.147621, y: 0.716567, z: 0.681718 },
+  { x: 0.147621, y: 0.716567, z: 0.681718 },
+  { x: 0, y: 0.525731, z: 0.850651 },
+  { x: 0.309017, y: 0.5, z: 0.809017 },
+  { x: 0.525731, y: 0, z: 0.850651 },
+  { x: 0.295242, y: 0, z: 0.955423 },
+  { x: 0.442863, y: 0.238856, z: 0.864188 },
+  { x: 0.16246, y: 0.262866, z: 0.951056 },
+  { x: -0.681718, y: 0.147621, z: 0.716567 },
+  { x: -0.809017, y: 0.309017, z: 0.5 },
+  { x: -0.587785, y: 0.425325, z: 0.688191 },
+  { x: -0.850651, y: 0.525731, z: 0 },
+  { x: -0.864188, y: 0.442863, z: 0.238856 },
+  { x: -0.716567, y: 0.681718, z: 0.147621 },
+  { x: -0.688191, y: 0.587785, z: 0.425325 },
+  { x: -0.5, y: 0.809017, z: 0.309017 },
+  { x: -0.238856, y: 0.864188, z: 0.442863 },
+  { x: -0.425325, y: 0.688191, z: 0.587785 },
+  { x: -0.716567, y: 0.681718, z: -0.147621 },
+  { x: -0.5, y: 0.809017, z: -0.309017 },
+  { x: -0.525731, y: 0.850651, z: 0 },
+  { x: 0, y: 0.850651, z: -0.525731 },
+  { x: -0.238856, y: 0.864188, z: -0.442863 },
+  { x: 0, y: 0.955423, z: -0.295242 },
+  { x: -0.262866, y: 0.951056, z: -0.16246 },
+  { x: 0, y: 1, z: 0 },
+  { x: 0, y: 0.955423, z: 0.295242 },
+  { x: -0.262866, y: 0.951056, z: 0.16246 },
+  { x: 0.238856, y: 0.864188, z: 0.442863 },
+  { x: 0.262866, y: 0.951056, z: 0.16246 },
+  { x: 0.5, y: 0.809017, z: 0.309017 },
+  { x: 0.238856, y: 0.864188, z: -0.442863 },
+  { x: 0.262866, y: 0.951056, z: -0.16246 },
+  { x: 0.5, y: 0.809017, z: -0.309017 },
+  { x: 0.850651, y: 0.525731, z: 0 },
+  { x: 0.716567, y: 0.681718, z: 0.147621 },
+  { x: 0.716567, y: 0.681718, z: -0.147621 },
+  { x: 0.525731, y: 0.850651, z: 0 },
+  { x: 0.425325, y: 0.688191, z: 0.587785 },
+  { x: 0.864188, y: 0.442863, z: 0.238856 },
+  { x: 0.688191, y: 0.587785, z: 0.425325 },
+  { x: 0.809017, y: 0.309017, z: 0.5 },
+  { x: 0.681718, y: 0.147621, z: 0.716567 },
+  { x: 0.587785, y: 0.425325, z: 0.688191 },
+  { x: 0.955423, y: 0.295242, z: 0 },
+  { x: 1, y: 0, z: 0 },
+  { x: 0.951056, y: 0.16246, z: 0.262866 },
+  { x: 0.850651, y: -0.525731, z: 0 },
+  { x: 0.955423, y: -0.295242, z: 0 },
+  { x: 0.864188, y: -0.442863, z: 0.238856 },
+  { x: 0.951056, y: -0.16246, z: 0.262866 },
+  { x: 0.809017, y: -0.309017, z: 0.5 },
+  { x: 0.681718, y: -0.147621, z: 0.716567 },
+  { x: 0.850651, y: 0, z: 0.525731 },
+  { x: 0.864188, y: 0.442863, z: -0.238856 },
+  { x: 0.809017, y: 0.309017, z: -0.5 },
+  { x: 0.951056, y: 0.16246, z: -0.262866 },
+  { x: 0.525731, y: 0, z: -0.850651 },
+  { x: 0.681718, y: 0.147621, z: -0.716567 },
+  { x: 0.681718, y: -0.147621, z: -0.716567 },
+  { x: 0.850651, y: 0, z: -0.525731 },
+  { x: 0.809017, y: -0.309017, z: -0.5 },
+  { x: 0.864188, y: -0.442863, z: -0.238856 },
+  { x: 0.951056, y: -0.16246, z: -0.262866 },
+  { x: 0.147621, y: 0.716567, z: -0.681718 },
+  { x: 0.309017, y: 0.5, z: -0.809017 },
+  { x: 0.425325, y: 0.688191, z: -0.587785 },
+  { x: 0.442863, y: 0.238856, z: -0.864188 },
+  { x: 0.587785, y: 0.425325, z: -0.688191 },
+  { x: 0.688191, y: 0.587785, z: -0.425325 },
+  { x: -0.147621, y: 0.716567, z: -0.681718 },
+  { x: -0.309017, y: 0.5, z: -0.809017 },
+  { x: 0, y: 0.525731, z: -0.850651 },
+  { x: -0.525731, y: 0, z: -0.850651 },
+  { x: -0.442863, y: 0.238856, z: -0.864188 },
+  { x: -0.295242, y: 0, z: -0.955423 },
+  { x: -0.16246, y: 0.262866, z: -0.951056 },
+  { x: 0, y: 0, z: -1 },
+  { x: 0.295242, y: 0, z: -0.955423 },
+  { x: 0.16246, y: 0.262866, z: -0.951056 },
+  { x: -0.442863, y: -0.238856, z: -0.864188 },
+  { x: -0.309017, y: -0.5, z: -0.809017 },
+  { x: -0.16246, y: -0.262866, z: -0.951056 },
+  { x: 0, y: -0.850651, z: -0.525731 },
+  { x: -0.147621, y: -0.716567, z: -0.681718 },
+  { x: 0.147621, y: -0.716567, z: -0.681718 },
+  { x: 0, y: -0.525731, z: -0.850651 },
+  { x: 0.309017, y: -0.5, z: -0.809017 },
+  { x: 0.442863, y: -0.238856, z: -0.864188 },
+  { x: 0.16246, y: -0.262866, z: -0.951056 },
+  { x: 0.238856, y: -0.864188, z: -0.442863 },
+  { x: 0.5, y: -0.809017, z: -0.309017 },
+  { x: 0.425325, y: -0.688191, z: -0.587785 },
+  { x: 0.716567, y: -0.681718, z: -0.147621 },
+  { x: 0.688191, y: -0.587785, z: -0.425325 },
+  { x: 0.587785, y: -0.425325, z: -0.688191 },
+  { x: 0, y: -0.955423, z: -0.295242 },
+  { x: 0, y: -1, z: 0 },
+  { x: 0.262866, y: -0.951056, z: -0.16246 },
+  { x: 0, y: -0.850651, z: 0.525731 },
+  { x: 0, y: -0.955423, z: 0.295242 },
+  { x: 0.238856, y: -0.864188, z: 0.442863 },
+  { x: 0.262866, y: -0.951056, z: 0.16246 },
+  { x: 0.5, y: -0.809017, z: 0.309017 },
+  { x: 0.716567, y: -0.681718, z: 0.147621 },
+  { x: 0.525731, y: -0.850651, z: 0 },
+  { x: -0.238856, y: -0.864188, z: -0.442863 },
+  { x: -0.5, y: -0.809017, z: -0.309017 },
+  { x: -0.262866, y: -0.951056, z: -0.16246 },
+  { x: -0.850651, y: -0.525731, z: 0 },
+  { x: -0.716567, y: -0.681718, z: -0.147621 },
+  { x: -0.716567, y: -0.681718, z: 0.147621 },
+  { x: -0.525731, y: -0.850651, z: 0 },
+  { x: -0.5, y: -0.809017, z: 0.309017 },
+  { x: -0.238856, y: -0.864188, z: 0.442863 },
+  { x: -0.262866, y: -0.951056, z: 0.16246 },
+  { x: -0.864188, y: -0.442863, z: 0.238856 },
+  { x: -0.809017, y: -0.309017, z: 0.5 },
+  { x: -0.688191, y: -0.587785, z: 0.425325 },
+  { x: -0.681718, y: -0.147621, z: 0.716567 },
+  { x: -0.442863, y: -0.238856, z: 0.864188 },
+  { x: -0.587785, y: -0.425325, z: 0.688191 },
+  { x: -0.309017, y: -0.5, z: 0.809017 },
+  { x: -0.147621, y: -0.716567, z: 0.681718 },
+  { x: -0.425325, y: -0.688191, z: 0.587785 },
+  { x: -0.16246, y: -0.262866, z: 0.951056 },
+  { x: 0.442863, y: -0.238856, z: 0.864188 },
+  { x: 0.16246, y: -0.262866, z: 0.951056 },
+  { x: 0.309017, y: -0.5, z: 0.809017 },
+  { x: 0.147621, y: -0.716567, z: 0.681718 },
+  { x: 0, y: -0.525731, z: 0.850651 },
+  { x: 0.425325, y: -0.688191, z: 0.587785 },
+  { x: 0.587785, y: -0.425325, z: 0.688191 },
+  { x: 0.688191, y: -0.587785, z: 0.425325 },
+  { x: -0.955423, y: 0.295242, z: 0 },
+  { x: -0.951056, y: 0.16246, z: 0.262866 },
+  { x: -1, y: 0, z: 0 },
+  { x: -0.850651, y: 0, z: 0.525731 },
+  { x: -0.955423, y: -0.295242, z: 0 },
+  { x: -0.951056, y: -0.16246, z: 0.262866 },
+  { x: -0.864188, y: 0.442863, z: -0.238856 },
+  { x: -0.951056, y: 0.16246, z: -0.262866 },
+  { x: -0.809017, y: 0.309017, z: -0.5 },
+  { x: -0.864188, y: -0.442863, z: -0.238856 },
+  { x: -0.951056, y: -0.16246, z: -0.262866 },
+  { x: -0.809017, y: -0.309017, z: -0.5 },
+  { x: -0.681718, y: 0.147621, z: -0.716567 },
+  { x: -0.681718, y: -0.147621, z: -0.716567 },
+  { x: -0.850651, y: 0, z: -0.525731 },
+  { x: -0.688191, y: 0.587785, z: -0.425325 },
+  { x: -0.587785, y: 0.425325, z: -0.688191 },
+  { x: -0.425325, y: 0.688191, z: -0.587785 },
+  { x: -0.425325, y: -0.688191, z: -0.587785 },
+  { x: -0.587785, y: -0.425325, z: -0.688191 },
+  { x: -0.688191, y: -0.587785, z: -0.425325 }
+];
+var Md2ParseError = class extends Error {
+};
+var Md2Loader = class {
+  constructor(vfs) {
+    this.vfs = vfs;
+  }
+  async load(path) {
+    const bytes = await this.vfs.readFile(path);
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return parseMd2(copy.buffer);
+  }
+};
+function readCString2(view, offset, maxLength) {
+  const chars = [];
+  for (let i = 0; i < maxLength; i += 1) {
+    const code = view.getUint8(offset + i);
+    if (code === 0) break;
+    chars.push(code);
+  }
+  return String.fromCharCode(...chars);
+}
+function validateSection(buffer, offset, length, label) {
+  if (length === 0) return;
+  if (offset < HEADER_SIZE2 || offset + length > buffer.byteLength) {
+    throw new Md2ParseError(`${label} section is out of bounds`);
+  }
+}
+function parseHeader(buffer) {
+  if (buffer.byteLength < HEADER_SIZE2) {
+    throw new Md2ParseError("MD2 buffer too small to contain header");
+  }
+  const view = new DataView(buffer);
+  const ident = view.getInt32(0, true);
+  const version = view.getInt32(4, true);
+  if (ident !== MD2_MAGIC) {
+    throw new Md2ParseError(`Invalid MD2 ident: ${ident}`);
+  }
+  if (version !== MD2_VERSION) {
+    throw new Md2ParseError(`Unsupported MD2 version: ${version}`);
+  }
+  const header = {
+    ident,
+    version,
+    skinWidth: view.getInt32(8, true),
+    skinHeight: view.getInt32(12, true),
+    frameSize: view.getInt32(16, true),
+    numSkins: view.getInt32(20, true),
+    numVertices: view.getInt32(24, true),
+    numTexCoords: view.getInt32(28, true),
+    numTriangles: view.getInt32(32, true),
+    numGlCommands: view.getInt32(36, true),
+    numFrames: view.getInt32(40, true),
+    offsetSkins: view.getInt32(44, true),
+    offsetTexCoords: view.getInt32(48, true),
+    offsetTriangles: view.getInt32(52, true),
+    offsetFrames: view.getInt32(56, true),
+    offsetGlCommands: view.getInt32(60, true),
+    offsetEnd: view.getInt32(64, true)
+  };
+  const expectedFrameSize = 40 + header.numVertices * 4;
+  if (header.frameSize !== expectedFrameSize) {
+    throw new Md2ParseError(`Unexpected frame size ${header.frameSize}, expected ${expectedFrameSize}`);
+  }
+  if (header.offsetEnd > buffer.byteLength) {
+    throw new Md2ParseError("MD2 offset_end exceeds buffer length");
+  }
+  return header;
+}
+function parseSkins(buffer, header) {
+  const size = header.numSkins * 64;
+  validateSection(buffer, header.offsetSkins, size, "skins");
+  const view = new DataView(buffer, header.offsetSkins, size);
+  const skins = [];
+  for (let i = 0; i < header.numSkins; i += 1) {
+    skins.push({ name: readCString2(view, i * 64, 64) });
+  }
+  return skins;
+}
+function parseTexCoords(buffer, header) {
+  const size = header.numTexCoords * 4;
+  validateSection(buffer, header.offsetTexCoords, size, "texcoords");
+  const view = new DataView(buffer, header.offsetTexCoords, size);
+  const texCoords = [];
+  for (let i = 0; i < header.numTexCoords; i += 1) {
+    const base = i * 4;
+    texCoords.push({ s: view.getInt16(base, true), t: view.getInt16(base + 2, true) });
+  }
+  return texCoords;
+}
+function parseTriangles(buffer, header) {
+  const size = header.numTriangles * 12;
+  validateSection(buffer, header.offsetTriangles, size, "triangles");
+  const view = new DataView(buffer, header.offsetTriangles, size);
+  const triangles = [];
+  for (let i = 0; i < header.numTriangles; i += 1) {
+    const base = i * 12;
+    const vertexIndices = [
+      view.getUint16(base, true),
+      view.getUint16(base + 2, true),
+      view.getUint16(base + 4, true)
+    ];
+    const texCoordIndices = [
+      view.getUint16(base + 6, true),
+      view.getUint16(base + 8, true),
+      view.getUint16(base + 10, true)
+    ];
+    if (vertexIndices.some((v) => v >= header.numVertices) || texCoordIndices.some((t) => t >= header.numTexCoords)) {
+      throw new Md2ParseError("Triangle references out of range vertex or texcoord");
+    }
+    triangles.push({ vertexIndices, texCoordIndices });
+  }
+  return triangles;
+}
+function parseFrames(buffer, header) {
+  const size = header.numFrames * header.frameSize;
+  validateSection(buffer, header.offsetFrames, size, "frames");
+  const frames = [];
+  for (let i = 0; i < header.numFrames; i += 1) {
+    const base = header.offsetFrames + i * header.frameSize;
+    const view = new DataView(buffer, base, header.frameSize);
+    const scale = { x: view.getFloat32(0, true), y: view.getFloat32(4, true), z: view.getFloat32(8, true) };
+    const translate = {
+      x: view.getFloat32(12, true),
+      y: view.getFloat32(16, true),
+      z: view.getFloat32(20, true)
+    };
+    const name = readCString2(view, 24, 16);
+    const vertices = [];
+    for (let v = 0; v < header.numVertices; v += 1) {
+      const offset = 40 + v * 4;
+      const position = {
+        x: view.getUint8(offset) * scale.x + translate.x,
+        y: view.getUint8(offset + 1) * scale.y + translate.y,
+        z: view.getUint8(offset + 2) * scale.z + translate.z
+      };
+      const normalIndex = view.getUint8(offset + 3);
+      const normal = MD2_NORMALS[normalIndex];
+      if (!normal) {
+        throw new Md2ParseError(`Invalid normal index ${normalIndex} in frame ${name}`);
+      }
+      vertices.push({ position, normalIndex, normal });
+    }
+    frames.push({ name, vertices });
+  }
+  return frames;
+}
+function parseGlCommands(buffer, header) {
+  const size = header.numGlCommands * 4;
+  validateSection(buffer, header.offsetGlCommands, size, "gl commands");
+  if (size === 0) {
+    return [];
+  }
+  const view = new DataView(buffer, header.offsetGlCommands, size);
+  const commands = [];
+  let cursor = 0;
+  while (true) {
+    if (cursor + 4 > size) {
+      throw new Md2ParseError("GL command list ended unexpectedly");
+    }
+    const count = view.getInt32(cursor, true);
+    cursor += 4;
+    if (count === 0) break;
+    const vertexCount = Math.abs(count);
+    const vertices = [];
+    const bytesNeeded = vertexCount * 12;
+    if (cursor + bytesNeeded > size) {
+      throw new Md2ParseError("GL command vertex block exceeds buffer");
+    }
+    for (let i = 0; i < vertexCount; i += 1) {
+      const s = view.getFloat32(cursor, true);
+      const t = view.getFloat32(cursor + 4, true);
+      const vertexIndex = view.getInt32(cursor + 8, true);
+      cursor += 12;
+      if (vertexIndex < 0 || vertexIndex >= header.numVertices) {
+        throw new Md2ParseError("GL command references invalid vertex index");
+      }
+      vertices.push({ s, t, vertexIndex });
+    }
+    commands.push({ mode: count > 0 ? "strip" : "fan", vertices });
+  }
+  if (cursor !== size) {
+    throw new Md2ParseError("GL command list did not consume expected data");
+  }
+  return commands;
+}
+function parseMd2(buffer) {
+  const header = parseHeader(buffer);
+  const skins = parseSkins(buffer, header);
+  const texCoords = parseTexCoords(buffer, header);
+  const triangles = parseTriangles(buffer, header);
+  const frames = parseFrames(buffer, header);
+  const glCommands = parseGlCommands(buffer, header);
+  return { header, skins, texCoords, triangles, frames, glCommands };
+}
+function groupMd2Animations(frames) {
+  const animations = [];
+  let index = 0;
+  while (index < frames.length) {
+    const name = frames[index].name;
+    const base = name.replace(/\d+$/, "") || name;
+    let end = index;
+    while (end + 1 < frames.length) {
+      const nextBase = frames[end + 1].name.replace(/\d+$/, "") || frames[end + 1].name;
+      if (nextBase !== base) break;
+      end += 1;
+    }
+    animations.push({ name: base, firstFrame: index, lastFrame: end });
+    index = end + 1;
+  }
+  return animations;
+}
+
+// src/render/context.ts
+function configureDefaultGLState(gl) {
+  gl.enable(gl.DEPTH_TEST);
+  gl.depthFunc(gl.LEQUAL);
+  gl.enable(gl.CULL_FACE);
+  gl.cullFace(gl.BACK);
+  gl.enable(gl.BLEND);
+  gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+}
+function queryExtensions(gl, required, optional, collector) {
+  for (const name of required) {
+    const ext = gl.getExtension(name);
+    if (!ext) {
+      throw new Error(`Missing required WebGL extension: ${name}`);
+    }
+    collector.set(name, ext);
+  }
+  for (const name of optional) {
+    const ext = gl.getExtension(name);
+    if (ext) {
+      collector.set(name, ext);
+    }
+  }
+}
+function createWebGLContext(canvas, options = {}) {
+  const { contextAttributes, requiredExtensions = [], optionalExtensions = [] } = options;
+  const gl = canvas.getContext("webgl2", contextAttributes ?? { antialias: true });
+  if (!gl) {
+    throw new Error("WebGL2 not supported or failed to initialize");
+  }
+  configureDefaultGLState(gl);
+  const extensions = /* @__PURE__ */ new Map();
+  queryExtensions(gl, requiredExtensions, optionalExtensions, extensions);
+  let lost = false;
+  const lostCallbacks = /* @__PURE__ */ new Set();
+  const restoreCallbacks = /* @__PURE__ */ new Set();
+  const lostListener = (event) => {
+    lost = true;
+    event.preventDefault();
+    for (const callback of lostCallbacks) {
+      callback();
+    }
+  };
+  const restoreListener = () => {
+    lost = false;
+    for (const callback of restoreCallbacks) {
+      callback();
+    }
+  };
+  canvas.addEventListener("webglcontextlost", lostListener);
+  canvas.addEventListener("webglcontextrestored", restoreListener);
+  return {
+    gl,
+    extensions,
+    isLost: () => lost,
+    onLost(callback) {
+      lostCallbacks.add(callback);
+      return () => lostCallbacks.delete(callback);
+    },
+    onRestored(callback) {
+      restoreCallbacks.add(callback);
+      return () => restoreCallbacks.delete(callback);
+    },
+    dispose() {
+      canvas.removeEventListener("webglcontextlost", lostListener);
+      canvas.removeEventListener("webglcontextrestored", restoreListener);
+      lostCallbacks.clear();
+      restoreCallbacks.clear();
+      extensions.clear();
+    }
+  };
+}
+
+// src/render/shaderProgram.ts
+function compileShader(gl, type, source) {
+  const shader = gl.createShader(type);
+  if (!shader) {
+    throw new Error("Failed to allocate shader");
+  }
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  const ok = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+  if (!ok) {
+    const log = gl.getShaderInfoLog(shader) ?? "Unknown shader compile failure";
+    gl.deleteShader(shader);
+    throw new Error(log);
+  }
+  return shader;
+}
+function linkProgram(gl, vertexShader, fragmentShader, attributeLocations) {
+  const program = gl.createProgram();
+  if (!program) {
+    throw new Error("Failed to allocate shader program");
+  }
+  gl.attachShader(program, vertexShader);
+  gl.attachShader(program, fragmentShader);
+  if (attributeLocations) {
+    for (const [name, location] of Object.entries(attributeLocations)) {
+      gl.bindAttribLocation(program, location, name);
+    }
+  }
+  gl.linkProgram(program);
+  const ok = gl.getProgramParameter(program, gl.LINK_STATUS);
+  if (!ok) {
+    const log = gl.getProgramInfoLog(program) ?? "Unknown shader link failure";
+    gl.deleteProgram(program);
+    throw new Error(log);
+  }
+  return program;
+}
+var ShaderProgram = class _ShaderProgram {
+  constructor(gl, program) {
+    this.uniformLocations = /* @__PURE__ */ new Map();
+    this.attributeLocations = /* @__PURE__ */ new Map();
+    this.gl = gl;
+    this.program = program;
+  }
+  static create(gl, sources, attributeLocations) {
+    const vertexShader = compileShader(gl, gl.VERTEX_SHADER, sources.vertex);
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, sources.fragment);
+    try {
+      const program = linkProgram(gl, vertexShader, fragmentShader, attributeLocations);
+      return new _ShaderProgram(gl, program);
+    } finally {
+      gl.deleteShader(vertexShader);
+      gl.deleteShader(fragmentShader);
+    }
+  }
+  use() {
+    this.gl.useProgram(this.program);
+  }
+  getUniformLocation(name) {
+    if (!this.uniformLocations.has(name)) {
+      const location = this.gl.getUniformLocation(this.program, name);
+      this.uniformLocations.set(name, location);
+    }
+    return this.uniformLocations.get(name) ?? null;
+  }
+  getAttributeLocation(name) {
+    if (!this.attributeLocations.has(name)) {
+      const location = this.gl.getAttribLocation(this.program, name);
+      this.attributeLocations.set(name, location);
+    }
+    return this.attributeLocations.get(name) ?? -1;
+  }
+  dispose() {
+    this.gl.deleteProgram(this.program);
+    this.uniformLocations.clear();
+    this.attributeLocations.clear();
+  }
+};
+function createProgramFromSources(gl, sources, attributeLocations) {
+  return ShaderProgram.create(gl, sources, attributeLocations);
+}
+
+// src/render/resources.ts
+var VertexBuffer = class {
+  constructor(gl, usage = gl.STATIC_DRAW, target) {
+    this.gl = gl;
+    this.target = target ?? gl.ARRAY_BUFFER;
+    const buffer = gl.createBuffer();
+    if (!buffer) {
+      throw new Error("Failed to allocate buffer");
+    }
+    this.buffer = buffer;
+    gl.bindBuffer(this.target, this.buffer);
+    gl.bufferData(this.target, 0, usage);
+  }
+  bind() {
+    this.gl.bindBuffer(this.target, this.buffer);
+  }
+  upload(data, usage = this.gl.STATIC_DRAW) {
+    this.bind();
+    this.gl.bufferData(this.target, data, usage);
+  }
+  update(data, offset = 0) {
+    this.bind();
+    this.gl.bufferSubData(this.target, offset, data);
+  }
+  dispose() {
+    this.gl.deleteBuffer(this.buffer);
+  }
+};
+var IndexBuffer = class extends VertexBuffer {
+  constructor(gl, usage = gl.STATIC_DRAW) {
+    super(gl, usage, gl.ELEMENT_ARRAY_BUFFER);
+  }
+};
+var VertexArray = class {
+  constructor(gl) {
+    this.gl = gl;
+    const vao = gl.createVertexArray();
+    if (!vao) {
+      throw new Error("Failed to allocate vertex array object");
+    }
+    this.vao = vao;
+  }
+  bind() {
+    this.gl.bindVertexArray(this.vao);
+  }
+  configureAttributes(layouts, buffer) {
+    this.bind();
+    if (buffer) {
+      buffer.bind();
+    }
+    for (const layout of layouts) {
+      this.gl.enableVertexAttribArray(layout.index);
+      this.gl.vertexAttribPointer(
+        layout.index,
+        layout.size,
+        layout.type,
+        layout.normalized ?? false,
+        layout.stride ?? 0,
+        layout.offset ?? 0
+      );
+      if (layout.divisor !== void 0) {
+        this.gl.vertexAttribDivisor(layout.index, layout.divisor);
+      }
+    }
+  }
+  dispose() {
+    this.gl.deleteVertexArray(this.vao);
+  }
+};
+var Texture2D = class {
+  constructor(gl, target = gl.TEXTURE_2D) {
+    this.gl = gl;
+    this.target = target;
+    const texture = gl.createTexture();
+    if (!texture) {
+      throw new Error("Failed to allocate texture");
+    }
+    this.texture = texture;
+  }
+  bind(unit = 0) {
+    this.gl.activeTexture(this.gl.TEXTURE0 + unit);
+    this.gl.bindTexture(this.target, this.texture);
+  }
+  setParameters(params) {
+    this.bind();
+    if (params.wrapS !== void 0) {
+      this.gl.texParameteri(this.target, this.gl.TEXTURE_WRAP_S, params.wrapS);
+    }
+    if (params.wrapT !== void 0) {
+      this.gl.texParameteri(this.target, this.gl.TEXTURE_WRAP_T, params.wrapT);
+    }
+    if (params.minFilter !== void 0) {
+      this.gl.texParameteri(this.target, this.gl.TEXTURE_MIN_FILTER, params.minFilter);
+    }
+    if (params.magFilter !== void 0) {
+      this.gl.texParameteri(this.target, this.gl.TEXTURE_MAG_FILTER, params.magFilter);
+    }
+  }
+  uploadImage(level, internalFormat, width, height, border, format, type, data) {
+    this.bind();
+    this.gl.texImage2D(this.target, level, internalFormat, width, height, border, format, type, data);
+  }
+  dispose() {
+    this.gl.deleteTexture(this.texture);
+  }
+};
+var Framebuffer = class {
+  constructor(gl) {
+    this.gl = gl;
+    const framebuffer = gl.createFramebuffer();
+    if (!framebuffer) {
+      throw new Error("Failed to allocate framebuffer");
+    }
+    this.framebuffer = framebuffer;
+  }
+  bind(target = this.gl.FRAMEBUFFER) {
+    this.gl.bindFramebuffer(target, this.framebuffer);
+  }
+  attachTexture2D(attachment, texture, level = 0) {
+    this.bind();
+    this.gl.framebufferTexture2D(this.gl.FRAMEBUFFER, attachment, texture.target, texture.texture, level);
+  }
+  dispose() {
+    this.gl.deleteFramebuffer(this.framebuffer);
+  }
+};
+
+// src/render/bsp.ts
+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 createAtlasBuilder(size, padding) {
+  const channelCount = 4;
+  return {
+    width: size,
+    height: size,
+    padding,
+    data: new Uint8Array(size * size * channelCount),
+    cursorX: 0,
+    cursorY: 0,
+    rowHeight: 0
+  };
+}
+function detectChannels(lightmap) {
+  const pixels = lightmap.width * lightmap.height;
+  if (pixels === 0) {
+    throw new Error("Invalid lightmap with zero area");
+  }
+  const channels = lightmap.samples.byteLength / pixels;
+  if (!Number.isInteger(channels) || channels < 3 || channels > 4) {
+    throw new Error("Unsupported lightmap channel count");
+  }
+  return channels;
+}
+function writeLightmapIntoAtlas(atlas, placement, lightmap) {
+  const channels = detectChannels(lightmap);
+  const stride = atlas.width * 4;
+  const startX = placement.x + atlas.padding;
+  const startY = placement.y + atlas.padding;
+  let srcIndex = 0;
+  for (let y = 0; y < lightmap.height; y++) {
+    const destRow = (startY + y) * stride + startX * 4;
+    for (let x = 0; x < lightmap.width; x++) {
+      const dest = destRow + x * 4;
+      atlas.data[dest] = lightmap.samples[srcIndex];
+      atlas.data[dest + 1] = lightmap.samples[srcIndex + 1];
+      atlas.data[dest + 2] = lightmap.samples[srcIndex + 2];
+      atlas.data[dest + 3] = channels === 4 ? lightmap.samples[srcIndex + 3] : 255;
+      srcIndex += channels;
+    }
+  }
+}
+function placeLightmap(builders, lightmap, options) {
+  const paddedWidth = lightmap.width + options.lightmapPadding * 2;
+  const paddedHeight = lightmap.height + options.lightmapPadding * 2;
+  if (paddedWidth > options.atlasSize || paddedHeight > options.atlasSize) {
+    throw new Error("Lightmap too large for atlas");
+  }
+  for (const atlas2 of builders) {
+    if (atlas2.cursorX + paddedWidth > atlas2.width) {
+      atlas2.cursorX = 0;
+      atlas2.cursorY += atlas2.rowHeight + options.lightmapPadding;
+      atlas2.rowHeight = 0;
+    }
+    if (atlas2.cursorY + paddedHeight > atlas2.height) {
+      continue;
+    }
+    const placement2 = {
+      atlasIndex: builders.indexOf(atlas2),
+      x: atlas2.cursorX,
+      y: atlas2.cursorY,
+      width: lightmap.width,
+      height: lightmap.height
+    };
+    atlas2.cursorX += paddedWidth + options.lightmapPadding;
+    atlas2.rowHeight = Math.max(atlas2.rowHeight, paddedHeight);
+    return { placement: placement2, atlas: atlas2 };
+  }
+  const atlas = createAtlasBuilder(options.atlasSize, options.lightmapPadding);
+  builders.push(atlas);
+  const placement = { atlasIndex: builders.length - 1, x: 0, y: 0, width: lightmap.width, height: lightmap.height };
+  atlas.cursorX = paddedWidth + options.lightmapPadding;
+  atlas.rowHeight = paddedHeight;
+  return { placement, atlas };
+}
+function ensureFloat32(array) {
+  return array instanceof Float32Array ? array : new Float32Array(array);
+}
+function ensureIndexArray(indices, vertexCount) {
+  if (!indices) {
+    const generated = new Uint16Array(vertexCount);
+    for (let i = 0; i < vertexCount; i++) {
+      generated[i] = i;
+    }
+    return generated;
+  }
+  const converted = indices instanceof Uint16Array ? indices : new Uint16Array(indices);
+  return converted;
+}
+function remapLightmapCoords(coords, placement) {
+  const remapped = new Float32Array(coords.length);
+  for (let i = 0; i < coords.length; i += 2) {
+    remapped[i] = placement.offset[0] + coords[i] * placement.scale[0];
+    remapped[i + 1] = placement.offset[1] + coords[i + 1] * placement.scale[1];
+  }
+  return remapped;
+}
+function buildVertexData(surface, placement) {
+  const vertices = ensureFloat32(surface.vertices);
+  const texCoords = ensureFloat32(surface.textureCoords);
+  const lightmapCoords = placement ? remapLightmapCoords(ensureFloat32(surface.lightmapCoords ?? surface.textureCoords), placement) : ensureFloat32(surface.lightmapCoords ?? new Float32Array(texCoords.length));
+  const vertexCount = vertices.length / 3;
+  if (texCoords.length / 2 !== vertexCount) {
+    throw new Error("Texture coordinates count mismatch");
+  }
+  if (lightmapCoords.length / 2 !== vertexCount) {
+    throw new Error("Lightmap coordinates count mismatch");
+  }
+  const interleaved = new Float32Array(vertexCount * 7);
+  for (let i = 0; i < vertexCount; i++) {
+    const v = i * 3;
+    const t = i * 2;
+    const o = i * 7;
+    interleaved[o] = vertices[v];
+    interleaved[o + 1] = vertices[v + 1];
+    interleaved[o + 2] = vertices[v + 2];
+    interleaved[o + 3] = texCoords[t];
+    interleaved[o + 4] = texCoords[t + 1];
+    interleaved[o + 5] = lightmapCoords[t];
+    interleaved[o + 6] = lightmapCoords[t + 1];
+  }
+  return interleaved;
+}
+function buildBspGeometry(gl, surfaces, options = {}) {
+  const resolved = {
+    atlasSize: options.atlasSize ?? 1024,
+    lightmapPadding: options.lightmapPadding ?? 1
+  };
+  const atlasBuilders = [];
+  const placements = /* @__PURE__ */ new Map();
+  surfaces.forEach((surface, index) => {
+    if (!surface.lightmap) {
+      return;
+    }
+    const { placement, atlas } = placeLightmap(atlasBuilders, surface.lightmap, resolved);
+    writeLightmapIntoAtlas(atlas, placement, surface.lightmap);
+    placements.set(index, {
+      atlasIndex: placement.atlasIndex,
+      offset: [
+        (placement.x + resolved.lightmapPadding) / resolved.atlasSize,
+        (placement.y + resolved.lightmapPadding) / resolved.atlasSize
+      ],
+      scale: [placement.width / resolved.atlasSize, placement.height / resolved.atlasSize]
+    });
+  });
+  const lightmaps = atlasBuilders.map((builder) => {
+    const texture = new Texture2D(gl);
+    texture.setParameters({
+      wrapS: gl.CLAMP_TO_EDGE,
+      wrapT: gl.CLAMP_TO_EDGE,
+      minFilter: gl.LINEAR,
+      magFilter: gl.LINEAR
+    });
+    texture.uploadImage(0, gl.RGBA, builder.width, builder.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, builder.data);
+    return { texture, width: builder.width, height: builder.height, pixels: builder.data };
+  });
+  const results = surfaces.map((surface, index) => {
+    const placement = placements.get(index);
+    const vertexData = buildVertexData(surface, placement);
+    const indexData = ensureIndexArray(surface.indices, vertexData.length / 7);
+    const vertexBuffer = new VertexBuffer(gl, gl.STATIC_DRAW, gl.ARRAY_BUFFER);
+    vertexBuffer.upload(vertexData);
+    const indexBuffer = new IndexBuffer(gl, gl.STATIC_DRAW);
+    indexBuffer.upload(indexData);
+    const vao = new VertexArray(gl);
+    vao.configureAttributes(BSP_VERTEX_LAYOUT, vertexBuffer);
+    return {
+      vao,
+      vertexBuffer,
+      indexBuffer,
+      indexCount: indexData.length,
+      texture: surface.texture,
+      surfaceFlags: surface.surfaceFlags ?? SURF_NONE,
+      lightmap: placement,
+      vertexData,
+      indexData
+    };
+  });
+  return { surfaces: results, lightmaps };
+}
+
+// src/index.ts
+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);
+    }
+  };
+}
+export {
+  BSP_VERTEX_LAYOUT,
+  ConfigStringRegistry,
+  Cvar,
+  CvarRegistry,
+  EngineHost,
+  EngineRuntime,
+  FixedTimestepLoop,
+  Framebuffer,
+  IndexBuffer,
+  LruCache,
+  Md2Loader,
+  Md2ParseError,
+  PakArchive,
+  PakIngestionError,
+  PakParseError,
+  ShaderProgram,
+  Texture2D,
+  VertexArray,
+  VertexBuffer,
+  VirtualFileSystem,
+  buildBspGeometry,
+  calculatePakChecksum,
+  createEngine,
+  createEngineRuntime,
+  createProgramFromSources,
+  createWebGLContext,
+  filesToPakSources,
+  groupMd2Animations,
+  ingestPakFiles,
+  ingestPaks,
+  parseMd2,
+  wireDropTarget,
+  wireFileInput
+};
+//# sourceMappingURL=index.js.map