quake2ts 0.0.7 → 0.0.39

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

@@ -130,7 +130,27 @@ var EngineHost = class {
 };
 
 // ../shared/dist/esm/index.js
+var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
 var DEG_TO_RAD = Math.PI / 180;
+function subtractVec3(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function scaleVec3(a, scalar) {
+  return { x: a.x * scalar, y: a.y * scalar, z: a.z * scalar };
+}
+function dotVec3(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function lengthSquaredVec3(a) {
+  return dotVec3(a, a);
+}
+function lengthVec3(a) {
+  return Math.sqrt(lengthSquaredVec3(a));
+}
+function normalizeVec3(a) {
+  const len = lengthVec3(a);
+  return len === 0 ? a : scaleVec3(a, 1 / len);
+}
 var DEG2RAD_FACTOR = Math.PI / 180;
 var RAD2DEG_FACTOR = 180 / Math.PI;
 var CONTENTS_SOLID = 1 << 0;
@@ -186,6 +206,7 @@ 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_CHECKCOUNT = Number.MAX_SAFE_INTEGER - 1;
 var CvarFlags = /* @__PURE__ */ ((CvarFlags2) => {
   CvarFlags2[CvarFlags2["None"] = 0] = "None";
   CvarFlags2[CvarFlags2["Archive"] = 1] = "Archive";
@@ -291,6 +312,14 @@ var ConfigStringRegistry = class {
   soundIndex(path) {
     return this.register(path, ConfigStringIndex.Sounds, MAX_SOUNDS, "soundCursor");
   }
+  findSoundIndex(path) {
+    for (let i = ConfigStringIndex.Sounds; i < ConfigStringIndex.Sounds + MAX_SOUNDS; i += 1) {
+      if (this.values.get(i) === path) {
+        return i;
+      }
+    }
+    return void 0;
+  }
   imageIndex(path) {
     return this.register(path, ConfigStringIndex.Images, MAX_IMAGES, "imageCursor");
   }
@@ -659,6 +688,72 @@ var VirtualFileSystem = class {
   }
 };
 
+// src/assets/pakValidation.ts
+var RERELEASE_KNOWN_PAKS = Object.freeze([
+  // Base campaign
+  { name: "pak0.pak", checksum: 2378051181, description: "Base game assets" },
+  { name: "pak0.pak@baseq2", checksum: 2378051181, description: "Base game assets (baseq2)" },
+  // Mission packs bundled with the rerelease
+  { name: "pak0.pak@rogue", checksum: 3373211245, description: "Ground Zero (rogue) mission pack" },
+  { name: "pak0.pak@xatrix", checksum: 1358269824, description: "The Reckoning (xatrix) mission pack" }
+]);
+var PakValidationError = class extends Error {
+  constructor(result) {
+    super(
+      result.status === "unknown" ? `Unknown PAK not allowed: ${result.name}` : `PAK checksum mismatch for ${result.name}`
+    );
+    this.result = result;
+    this.name = "PakValidationError";
+  }
+};
+var PakValidator = class {
+  constructor(knownPaks = RERELEASE_KNOWN_PAKS) {
+    this.known = /* @__PURE__ */ new Map();
+    knownPaks.forEach((pak) => this.known.set(this.normalizePakName(pak.name), pak));
+  }
+  validateArchive(archive, nameOverride) {
+    const pakName = this.normalizePakName(nameOverride ?? ("name" in archive ? archive.name : "unknown"));
+    const checksum = archive.checksum;
+    const size = "size" in archive ? archive.size : void 0;
+    const known = this.known.get(pakName);
+    if (!known) {
+      return { name: pakName, checksum, status: "unknown", size };
+    }
+    if (known.checksum !== checksum) {
+      return {
+        name: pakName,
+        checksum,
+        expectedChecksum: known.checksum,
+        status: "mismatch",
+        size,
+        description: known.description
+      };
+    }
+    return {
+      name: pakName,
+      checksum,
+      expectedChecksum: known.checksum,
+      status: "valid",
+      size,
+      description: known.description
+    };
+  }
+  assertValid(archive, nameOverride) {
+    const outcome = this.validateArchive(archive, nameOverride);
+    if (outcome.status === "mismatch") {
+      throw new PakValidationError(outcome);
+    }
+    return outcome;
+  }
+  normalizePakName(name) {
+    const normalized = normalizePath(name);
+    const parts = normalized.split("/");
+    const filename = parts.pop() ?? normalized;
+    const directory = parts.pop();
+    return directory ? `${filename}@${directory}` : filename;
+  }
+};
+
 // src/assets/ingestion.ts
 var PakIngestionError = class extends Error {
   constructor(file, cause) {
@@ -750,18 +845,47 @@ async function toArrayBuffer(source, onProgress) {
 }
 async function ingestPaks(vfs, sources, onProgressOrOptions) {
   const options = typeof onProgressOrOptions === "function" ? { onProgress: onProgressOrOptions } : onProgressOrOptions ?? {};
+  const shouldPersist = options.persistIndexes ?? Boolean(options.pakIndexStore);
+  const enforceValidation = options.enforceValidation ?? Boolean(options.validator);
+  const allowUnknownPaks = options.allowUnknownPaks ?? true;
+  const stopOnError = options.stopOnError ?? false;
   const results = [];
   for (const source of sources) {
     try {
       const buffer = await toArrayBuffer(source, options.onProgress);
       const archive = PakArchive.fromArrayBuffer(source.name, buffer);
+      const validation = options.validator?.validateArchive(archive);
+      if (validation) {
+        options.onValidationResult?.(validation);
+        const isMismatch = validation.status === "mismatch";
+        const isUnknown = validation.status === "unknown";
+        if (isMismatch && enforceValidation || isUnknown && !allowUnknownPaks) {
+          const validationError = new PakValidationError(validation);
+          options.onError?.(source.name, validationError);
+          if (stopOnError) {
+            throw new PakIngestionError(source.name, validationError);
+          }
+          results.push({ archive, mounted: false, validation });
+          continue;
+        }
+      }
       vfs.mountPak(archive);
+      if (shouldPersist && options.pakIndexStore) {
+        try {
+          await options.pakIndexStore.persist(archive);
+        } catch (error) {
+          options.onError?.(source.name, error);
+          if (stopOnError) {
+            throw new PakIngestionError(source.name, error);
+          }
+        }
+      }
       options.onProgress?.({ file: source.name, loadedBytes: buffer.byteLength, totalBytes: buffer.byteLength, state: "parsed" });
-      results.push({ archive, mounted: true });
+      results.push({ archive, mounted: true, validation });
     } catch (error) {
       options.onProgress?.({ file: source.name, loadedBytes: 0, totalBytes: 0, state: "error" });
       options.onError?.(source.name, error);
-      if (options.stopOnError) {
+      if (stopOnError) {
         throw new PakIngestionError(source.name, error);
       }
     }
@@ -1240,6 +1364,1393 @@ function groupMd2Animations(frames) {
   return animations;
 }
 
+// src/assets/md3.ts
+var MD3_IDENT = 860898377;
+var MD3_VERSION = 15;
+var Md3ParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Md3ParseError";
+  }
+};
+function readString(view, offset, length) {
+  const bytes = new Uint8Array(view.buffer, view.byteOffset + offset, length);
+  const decoded = new TextDecoder("utf-8").decode(bytes);
+  return decoded.replace(/\0.*$/, "").trim();
+}
+function decodeLatLngNormal(latLng) {
+  const lat = (latLng >> 8 & 255) * (2 * Math.PI / 255);
+  const lng = (latLng & 255) * (2 * Math.PI / 255);
+  const sinLng = Math.sin(lng);
+  return {
+    x: Math.cos(lat) * sinLng,
+    y: Math.sin(lat) * sinLng,
+    z: Math.cos(lng)
+  };
+}
+function validateOffset(name, offset, size, bufferLength) {
+  if (offset < 0 || offset + size > bufferLength) {
+    throw new Md3ParseError(`${name} exceeds buffer bounds`);
+  }
+}
+function parseHeader2(view) {
+  const ident = view.getInt32(0, true);
+  if (ident !== MD3_IDENT) {
+    throw new Md3ParseError(`Invalid MD3 ident: ${ident}`);
+  }
+  const version = view.getInt32(4, true);
+  if (version !== MD3_VERSION) {
+    throw new Md3ParseError(`Unsupported MD3 version: ${version}`);
+  }
+  const name = readString(view, 8, 64);
+  const flags = view.getInt32(72, true);
+  const numFrames = view.getInt32(76, true);
+  const numTags = view.getInt32(80, true);
+  const numSurfaces = view.getInt32(84, true);
+  const numSkins = view.getInt32(88, true);
+  const ofsFrames = view.getInt32(92, true);
+  const ofsTags = view.getInt32(96, true);
+  const ofsSurfaces = view.getInt32(100, true);
+  const ofsEnd = view.getInt32(104, true);
+  if (numFrames <= 0 || numSurfaces < 0 || numTags < 0) {
+    throw new Md3ParseError("Invalid MD3 counts");
+  }
+  return {
+    ident,
+    version,
+    name,
+    flags,
+    numFrames,
+    numTags,
+    numSurfaces,
+    numSkins,
+    ofsFrames,
+    ofsTags,
+    ofsSurfaces,
+    ofsEnd
+  };
+}
+function parseFrames2(view, header) {
+  const frames = [];
+  const frameSize = 56;
+  validateOffset("Frames", header.ofsFrames, header.numFrames * frameSize, view.byteLength);
+  for (let i = 0; i < header.numFrames; i += 1) {
+    const base = header.ofsFrames + i * frameSize;
+    frames.push({
+      minBounds: {
+        x: view.getFloat32(base, true),
+        y: view.getFloat32(base + 4, true),
+        z: view.getFloat32(base + 8, true)
+      },
+      maxBounds: {
+        x: view.getFloat32(base + 12, true),
+        y: view.getFloat32(base + 16, true),
+        z: view.getFloat32(base + 20, true)
+      },
+      localOrigin: {
+        x: view.getFloat32(base + 24, true),
+        y: view.getFloat32(base + 28, true),
+        z: view.getFloat32(base + 32, true)
+      },
+      radius: view.getFloat32(base + 36, true),
+      name: readString(view, base + 40, 16)
+    });
+  }
+  return frames;
+}
+function parseTags(view, header) {
+  const tags = [];
+  const tagSize = 112;
+  const totalSize = header.numFrames * header.numTags * tagSize;
+  validateOffset("Tags", header.ofsTags, totalSize, view.byteLength);
+  for (let frame = 0; frame < header.numFrames; frame += 1) {
+    const frameTags = [];
+    for (let tagIndex = 0; tagIndex < header.numTags; tagIndex += 1) {
+      const base = header.ofsTags + (frame * header.numTags + tagIndex) * tagSize;
+      const originOffset = base + 64;
+      const axisOffset = originOffset + 12;
+      frameTags.push({
+        name: readString(view, base, 64),
+        origin: {
+          x: view.getFloat32(originOffset, true),
+          y: view.getFloat32(originOffset + 4, true),
+          z: view.getFloat32(originOffset + 8, true)
+        },
+        axis: [
+          {
+            x: view.getFloat32(axisOffset, true),
+            y: view.getFloat32(axisOffset + 4, true),
+            z: view.getFloat32(axisOffset + 8, true)
+          },
+          {
+            x: view.getFloat32(axisOffset + 12, true),
+            y: view.getFloat32(axisOffset + 16, true),
+            z: view.getFloat32(axisOffset + 20, true)
+          },
+          {
+            x: view.getFloat32(axisOffset + 24, true),
+            y: view.getFloat32(axisOffset + 28, true),
+            z: view.getFloat32(axisOffset + 32, true)
+          }
+        ]
+      });
+    }
+    tags.push(frameTags);
+  }
+  return tags;
+}
+function parseSurface(view, offset) {
+  const ident = view.getInt32(offset, true);
+  if (ident !== MD3_IDENT) {
+    throw new Md3ParseError(`Invalid surface ident at ${offset}: ${ident}`);
+  }
+  const name = readString(view, offset + 4, 64);
+  const flags = view.getInt32(offset + 68, true);
+  const numFrames = view.getInt32(offset + 72, true);
+  const numShaders = view.getInt32(offset + 76, true);
+  const numVerts = view.getInt32(offset + 80, true);
+  const numTriangles = view.getInt32(offset + 84, true);
+  const ofsTriangles = view.getInt32(offset + 88, true);
+  const ofsShaders = view.getInt32(offset + 92, true);
+  const ofsSt = view.getInt32(offset + 96, true);
+  const ofsXyzNormals = view.getInt32(offset + 100, true);
+  const ofsEnd = view.getInt32(offset + 104, true);
+  if (numFrames <= 0 || numVerts <= 0 || numTriangles <= 0) {
+    throw new Md3ParseError(`Invalid surface counts for ${name}`);
+  }
+  const surfaceSize = ofsEnd;
+  validateOffset(`Surface ${name}`, offset, surfaceSize, view.byteLength);
+  const triangles = [];
+  const triangleStart = offset + ofsTriangles;
+  for (let i = 0; i < numTriangles; i += 1) {
+    const base = triangleStart + i * 12;
+    triangles.push({
+      indices: [view.getInt32(base, true), view.getInt32(base + 4, true), view.getInt32(base + 8, true)]
+    });
+  }
+  const shaders = [];
+  const shaderStart = offset + ofsShaders;
+  for (let i = 0; i < numShaders; i += 1) {
+    const base = shaderStart + i * 68;
+    shaders.push({ name: readString(view, base, 64), shaderIndex: view.getInt32(base + 64, true) });
+  }
+  const texCoords = [];
+  const stStart = offset + ofsSt;
+  for (let i = 0; i < numVerts; i += 1) {
+    const base = stStart + i * 8;
+    texCoords.push({ s: view.getFloat32(base, true), t: view.getFloat32(base + 4, true) });
+  }
+  const vertices = [];
+  const xyzStart = offset + ofsXyzNormals;
+  for (let frame = 0; frame < numFrames; frame += 1) {
+    const frameVertices = [];
+    for (let i = 0; i < numVerts; i += 1) {
+      const base = xyzStart + (frame * numVerts + i) * 8;
+      const x = view.getInt16(base, true) / 64;
+      const y = view.getInt16(base + 2, true) / 64;
+      const z = view.getInt16(base + 4, true) / 64;
+      const latLng = view.getUint16(base + 6, true);
+      frameVertices.push({ position: { x, y, z }, latLng, normal: decodeLatLngNormal(latLng) });
+    }
+    vertices.push(frameVertices);
+  }
+  return {
+    surface: { name, flags, numFrames, shaders, triangles, texCoords, vertices },
+    nextOffset: offset + ofsEnd
+  };
+}
+function parseMd3(buffer) {
+  if (buffer.byteLength < 108) {
+    throw new Md3ParseError("MD3 buffer too small for header");
+  }
+  const view = new DataView(buffer);
+  const header = parseHeader2(view);
+  validateOffset("MD3 end", header.ofsEnd, 0, buffer.byteLength);
+  const frames = parseFrames2(view, header);
+  const tags = parseTags(view, header);
+  const surfaces = [];
+  let surfaceOffset = header.ofsSurfaces;
+  for (let i = 0; i < header.numSurfaces; i += 1) {
+    const { surface, nextOffset } = parseSurface(view, surfaceOffset);
+    surfaces.push(surface);
+    surfaceOffset = nextOffset;
+  }
+  if (surfaceOffset !== header.ofsEnd) {
+    throw new Md3ParseError("Surface parsing did not reach ofsEnd");
+  }
+  return { header, frames, tags, surfaces };
+}
+var Md3Loader = class {
+  constructor(vfs) {
+    this.vfs = vfs;
+  }
+  async load(path) {
+    const data = await this.vfs.readFile(path);
+    return parseMd3(data.slice().buffer);
+  }
+};
+
+// src/assets/animation.ts
+function advanceAnimation(state, deltaSeconds) {
+  const duration = (state.sequence.end - state.sequence.start + 1) / state.sequence.fps;
+  const loop = state.sequence.loop !== false;
+  let time = state.time + deltaSeconds;
+  if (loop) {
+    time = (time % duration + duration) % duration;
+  } else if (time > duration) {
+    time = duration;
+  }
+  return { ...state, time: Math.max(0, Math.min(time, duration)) };
+}
+function computeFrameBlend(state) {
+  const totalFrames = state.sequence.end - state.sequence.start + 1;
+  const frameDuration = 1 / state.sequence.fps;
+  const loop = state.sequence.loop !== false;
+  const framePosition = state.time / frameDuration;
+  if (!loop && framePosition >= totalFrames) {
+    return { frame: state.sequence.end, nextFrame: state.sequence.end, lerp: 0 };
+  }
+  const normalizedPosition = loop ? framePosition % totalFrames : Math.min(framePosition, totalFrames - 1);
+  const baseFrame = Math.floor(normalizedPosition);
+  const frame = state.sequence.start + baseFrame;
+  const nextFrame = baseFrame + 1 >= totalFrames ? loop ? state.sequence.start : state.sequence.end : frame + 1;
+  const lerp2 = !loop && baseFrame >= totalFrames - 1 ? 0 : normalizedPosition - baseFrame;
+  return { frame, nextFrame, lerp: lerp2 };
+}
+function createAnimationState(sequence) {
+  return { sequence, time: 0 };
+}
+function interpolateVec3(a, b, t) {
+  return {
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+    z: a.z + (b.z - a.z) * t
+  };
+}
+
+// src/assets/wal.ts
+var WalParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WalParseError";
+  }
+};
+function parseWal(buffer) {
+  if (buffer.byteLength < 100) {
+    throw new WalParseError("WAL buffer too small");
+  }
+  const view = new DataView(buffer);
+  const nameBytes = new Uint8Array(buffer, 0, 32);
+  const name = new TextDecoder("utf-8").decode(nameBytes).replace(/\0.*$/, "").trim();
+  const width = view.getInt32(32, true);
+  const height = view.getInt32(36, true);
+  const offsets = [view.getInt32(40, true), view.getInt32(44, true), view.getInt32(48, true), view.getInt32(52, true)];
+  const animNameBytes = new Uint8Array(buffer, 56, 32);
+  const animName = new TextDecoder("utf-8").decode(animNameBytes).replace(/\0.*$/, "").trim();
+  const flags = view.getInt32(88, true);
+  const contents = view.getInt32(92, true);
+  const value = view.getInt32(96, true);
+  if (width <= 0 || height <= 0) {
+    throw new WalParseError("Invalid WAL dimensions");
+  }
+  const mipmaps = [];
+  let currentWidth = width;
+  let currentHeight = height;
+  for (let level = 0; level < offsets.length; level += 1) {
+    const offset = offsets[level];
+    const expectedSize = Math.max(1, currentWidth * currentHeight | 0);
+    if (offset <= 0 || offset + expectedSize > buffer.byteLength) {
+      throw new WalParseError(`Invalid WAL mip offset for level ${level}`);
+    }
+    const data = new Uint8Array(buffer, offset, expectedSize);
+    mipmaps.push({ level, width: currentWidth, height: currentHeight, data });
+    currentWidth = Math.max(1, currentWidth >> 1);
+    currentHeight = Math.max(1, currentHeight >> 1);
+  }
+  return { name, width, height, mipmaps, animName, flags, contents, value };
+}
+
+// src/assets/pcx.ts
+var PcxParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PcxParseError";
+  }
+};
+function parsePcx(buffer) {
+  if (buffer.byteLength < 128) {
+    throw new PcxParseError("PCX buffer too small for header");
+  }
+  const view = new DataView(buffer);
+  const manufacturer = view.getUint8(0);
+  const encoding = view.getUint8(2);
+  const bitsPerPixel = view.getUint8(3);
+  const xMin = view.getUint16(4, true);
+  const yMin = view.getUint16(6, true);
+  const xMax = view.getUint16(8, true);
+  const yMax = view.getUint16(10, true);
+  if (manufacturer !== 10 || encoding !== 1) {
+    throw new PcxParseError("Unsupported PCX encoding");
+  }
+  if (bitsPerPixel !== 8) {
+    throw new PcxParseError("Only 8bpp PCX files are supported");
+  }
+  const width = xMax - xMin + 1;
+  const height = yMax - yMin + 1;
+  const bytesPerLine = view.getUint16(66, true);
+  const paletteMarkerOffset = buffer.byteLength - 769;
+  if (paletteMarkerOffset < 128 || new DataView(buffer, paletteMarkerOffset, 1).getUint8(0) !== 12) {
+    throw new PcxParseError("Missing PCX palette");
+  }
+  const palette = new Uint8Array(buffer, paletteMarkerOffset + 1, 768);
+  const encoded = new Uint8Array(buffer, 128, paletteMarkerOffset - 128);
+  const pixels = new Uint8Array(width * height);
+  let srcIndex = 0;
+  let dstIndex = 0;
+  for (let y = 0; y < height; y += 1) {
+    let written = 0;
+    while (written < bytesPerLine && srcIndex < encoded.length) {
+      let count = 1;
+      let value = encoded[srcIndex++];
+      if ((value & 192) === 192) {
+        count = value & 63;
+        if (srcIndex >= encoded.length) {
+          throw new PcxParseError("Unexpected end of PCX RLE data");
+        }
+        value = encoded[srcIndex++];
+      }
+      for (let i = 0; i < count && written < bytesPerLine; i += 1) {
+        if (written < width) {
+          pixels[dstIndex++] = value;
+        }
+        written += 1;
+      }
+    }
+  }
+  return { width, height, bitsPerPixel, pixels, palette };
+}
+function pcxToRgba(image) {
+  const rgba = new Uint8Array(image.width * image.height * 4);
+  for (let i = 0; i < image.pixels.length; i += 1) {
+    const colorIndex = image.pixels[i];
+    const paletteIndex = colorIndex * 3;
+    const rgbaIndex = i * 4;
+    rgba[rgbaIndex] = image.palette[paletteIndex];
+    rgba[rgbaIndex + 1] = image.palette[paletteIndex + 1];
+    rgba[rgbaIndex + 2] = image.palette[paletteIndex + 2];
+    rgba[rgbaIndex + 3] = colorIndex === 255 ? 0 : 255;
+  }
+  return rgba;
+}
+
+// src/assets/texture.ts
+var TextureCache = class {
+  constructor(options = {}) {
+    this.cache = new LruCache(options.capacity ?? 128);
+  }
+  get size() {
+    return this.cache.size;
+  }
+  get(key) {
+    return this.cache.get(key.toLowerCase());
+  }
+  set(key, texture) {
+    this.cache.set(key.toLowerCase(), texture);
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+function walToRgba(wal, palette) {
+  const levels = [];
+  for (const mip of wal.mipmaps) {
+    const rgba = new Uint8Array(mip.width * mip.height * 4);
+    for (let i = 0; i < mip.data.length; i += 1) {
+      const colorIndex = mip.data[i];
+      const paletteIndex = colorIndex * 3;
+      const outIndex = i * 4;
+      rgba[outIndex] = palette[paletteIndex];
+      rgba[outIndex + 1] = palette[paletteIndex + 1];
+      rgba[outIndex + 2] = palette[paletteIndex + 2];
+      rgba[outIndex + 3] = colorIndex === 255 ? 0 : 255;
+    }
+    levels.push({ level: mip.level, width: mip.width, height: mip.height, rgba });
+  }
+  return { width: wal.width, height: wal.height, levels, source: "wal" };
+}
+function preparePcxTexture(pcx) {
+  const rgba = pcxToRgba(pcx);
+  const level = { level: 0, width: pcx.width, height: pcx.height, rgba };
+  return { width: pcx.width, height: pcx.height, levels: [level], source: "pcx" };
+}
+function parseWalTexture(buffer, palette) {
+  return walToRgba(parseWal(buffer), palette);
+}
+
+// src/assets/wav.ts
+var WavParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WavParseError";
+  }
+};
+function readString2(view, offset, length) {
+  return new TextDecoder("ascii").decode(new Uint8Array(view.buffer, view.byteOffset + offset, length));
+}
+function parseWav(buffer) {
+  if (buffer.byteLength < 44) {
+    throw new WavParseError("WAV buffer too small");
+  }
+  const view = new DataView(buffer);
+  if (readString2(view, 0, 4) !== "RIFF" || readString2(view, 8, 4) !== "WAVE") {
+    throw new WavParseError("Invalid WAV header");
+  }
+  let offset = 12;
+  let fmtOffset = -1;
+  let dataOffset = -1;
+  let fmtSize = 0;
+  let dataSize = 0;
+  while (offset + 8 <= buffer.byteLength) {
+    const chunkId = readString2(view, offset, 4);
+    const chunkSize = view.getUint32(offset + 4, true);
+    const chunkDataOffset = offset + 8;
+    if (chunkId === "fmt ") {
+      fmtOffset = chunkDataOffset;
+      fmtSize = chunkSize;
+    } else if (chunkId === "data") {
+      dataOffset = chunkDataOffset;
+      dataSize = chunkSize;
+    }
+    offset = chunkDataOffset + chunkSize;
+  }
+  if (fmtOffset === -1 || dataOffset === -1) {
+    throw new WavParseError("Missing fmt or data chunk");
+  }
+  const audioFormat = view.getUint16(fmtOffset, true);
+  const channels = view.getUint16(fmtOffset + 2, true);
+  const sampleRate = view.getUint32(fmtOffset + 4, true);
+  const bitsPerSample = view.getUint16(fmtOffset + 14, true);
+  if (audioFormat !== 1) {
+    throw new WavParseError("Only PCM WAV is supported");
+  }
+  const bytesPerSample = bitsPerSample / 8;
+  const frameCount = dataSize / (bytesPerSample * channels);
+  const samples = new Float32Array(frameCount * channels);
+  for (let frame = 0; frame < frameCount; frame += 1) {
+    for (let ch = 0; ch < channels; ch += 1) {
+      const sampleIndex = frame * channels + ch;
+      const byteOffset = dataOffset + sampleIndex * bytesPerSample;
+      let value = 0;
+      if (bitsPerSample === 8) {
+        value = view.getUint8(byteOffset);
+        samples[sampleIndex] = (value - 128) / 128;
+      } else if (bitsPerSample === 16) {
+        value = view.getInt16(byteOffset, true);
+        samples[sampleIndex] = value / 32768;
+      } else if (bitsPerSample === 24) {
+        const b0 = view.getUint8(byteOffset);
+        const b1 = view.getUint8(byteOffset + 1);
+        const b2 = view.getInt8(byteOffset + 2);
+        value = b0 | b1 << 8 | b2 << 16;
+        samples[sampleIndex] = value / 8388608;
+      } else {
+        throw new WavParseError(`Unsupported bitsPerSample: ${bitsPerSample}`);
+      }
+    }
+  }
+  return { sampleRate, channels, bitsPerSample, samples };
+}
+
+// src/assets/ogg.ts
+import { OggVorbisDecoder } from "@wasm-audio-decoders/ogg-vorbis";
+var OggDecodeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OggDecodeError";
+  }
+};
+async function decodeOgg(buffer, decoder = new OggVorbisDecoder()) {
+  await decoder.ready;
+  const result = await decoder.decode(new Uint8Array(buffer));
+  const errors = result.errors;
+  if (errors && errors.length > 0) {
+    throw new OggDecodeError(errors.map((err) => err.message).join("; "));
+  }
+  return {
+    sampleRate: result.sampleRate,
+    channels: result.channelData.length,
+    bitDepth: result.bitDepth,
+    channelData: result.channelData
+  };
+}
+
+// src/assets/audio.ts
+var AudioRegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AudioRegistryError";
+  }
+};
+var AudioRegistry = class {
+  constructor(vfs, options = {}) {
+    this.vfs = vfs;
+    this.refCounts = /* @__PURE__ */ new Map();
+    this.cache = new LruCache(options.cacheSize ?? 64);
+  }
+  get size() {
+    return this.cache.size;
+  }
+  async load(path) {
+    const normalized = path.toLowerCase();
+    const cached = this.cache.get(normalized);
+    if (cached) {
+      this.refCounts.set(normalized, (this.refCounts.get(normalized) ?? 0) + 1);
+      return cached;
+    }
+    const data = await this.vfs.readFile(path);
+    const arrayBuffer = data.slice().buffer;
+    const audio = await this.decodeByExtension(path, arrayBuffer);
+    this.cache.set(normalized, audio);
+    this.refCounts.set(normalized, 1);
+    return audio;
+  }
+  release(path) {
+    const normalized = path.toLowerCase();
+    const count = this.refCounts.get(normalized) ?? 0;
+    if (count <= 1) {
+      this.cache.delete(normalized);
+      this.refCounts.delete(normalized);
+    } else {
+      this.refCounts.set(normalized, count - 1);
+    }
+  }
+  clearAll() {
+    this.cache.clear();
+    this.refCounts.clear();
+  }
+  async decodeByExtension(path, buffer) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".wav")) {
+      const wav = parseWav(buffer);
+      const channels = wav.channels;
+      const channelData = Array.from({ length: channels }, () => new Float32Array(wav.samples.length / channels));
+      for (let i = 0; i < wav.samples.length; i += 1) {
+        channelData[i % channels][Math.floor(i / channels)] = wav.samples[i];
+      }
+      return { sampleRate: wav.sampleRate, channels, bitDepth: wav.bitsPerSample, channelData };
+    }
+    if (lower.endsWith(".ogg") || lower.endsWith(".oga")) {
+      return decodeOgg(buffer);
+    }
+    throw new AudioRegistryError(`Unsupported audio format: ${path}`);
+  }
+};
+
+// src/assets/pakIndexStore.ts
+var DEFAULT_DB_NAME = "quake2ts-pak-indexes";
+var DEFAULT_STORE_NAME = "pak-indexes";
+function getIndexedDb() {
+  if (typeof indexedDB !== "undefined") {
+    return indexedDB;
+  }
+  if (typeof window !== "undefined" && "indexedDB" in window) {
+    return window.indexedDB;
+  }
+  if (typeof globalThis !== "undefined" && "indexedDB" in globalThis) {
+    return globalThis.indexedDB;
+  }
+  return void 0;
+}
+function openDatabase(dbName, storeName) {
+  const idb = getIndexedDb();
+  if (!idb) {
+    return Promise.reject(new Error("IndexedDB is not available in this environment"));
+  }
+  return new Promise((resolve, reject) => {
+    const request = idb.open(dbName, 1);
+    request.onupgradeneeded = () => {
+      const { result } = request;
+      if (!result.objectStoreNames.contains(storeName)) {
+        result.createObjectStore(storeName, { keyPath: "key" });
+      }
+    };
+    request.onerror = () => reject(request.error ?? new Error("Unknown IndexedDB error"));
+    request.onsuccess = () => resolve(request.result);
+  });
+}
+function runTransaction(db, storeName, mode, runner) {
+  return new Promise((resolve, reject) => {
+    const transaction = db.transaction(storeName, mode);
+    const store = transaction.objectStore(storeName);
+    const request = runner(store);
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB transaction error"));
+  });
+}
+function buildKey(name, checksum) {
+  return `${normalizePath(name)}:${checksum.toString(16)}`;
+}
+function cloneEntries(entries) {
+  return entries.map((entry) => ({ ...entry }));
+}
+var PakIndexStore = class {
+  constructor(dbName = DEFAULT_DB_NAME, storeName = DEFAULT_STORE_NAME) {
+    this.dbName = dbName;
+    this.storeName = storeName;
+  }
+  get isSupported() {
+    return Boolean(getIndexedDb());
+  }
+  async persist(archive) {
+    if (!this.isSupported) {
+      return void 0;
+    }
+    const validation = archive.validate();
+    const record = {
+      ...validation,
+      key: buildKey(archive.name, validation.checksum),
+      name: archive.name,
+      size: archive.size,
+      persistedAt: Date.now(),
+      entries: cloneEntries(validation.entries)
+    };
+    const db = await openDatabase(this.dbName, this.storeName);
+    await runTransaction(db, this.storeName, "readwrite", (store) => store.put(record));
+    db.close();
+    return record;
+  }
+  async find(name, checksum) {
+    if (!this.isSupported) {
+      return void 0;
+    }
+    const db = await openDatabase(this.dbName, this.storeName);
+    const key = checksum !== void 0 ? buildKey(name, checksum) : void 0;
+    const record = await runTransaction(db, this.storeName, "readonly", (store) => {
+      if (key) {
+        return store.get(key);
+      }
+      return store.getAll();
+    });
+    db.close();
+    if (!record) {
+      return void 0;
+    }
+    if (Array.isArray(record)) {
+      const normalized = normalizePath(name);
+      const matches = record.filter((candidate) => normalizePath(candidate.name) === normalized);
+      if (matches.length === 0) {
+        return void 0;
+      }
+      return matches.sort((a, b) => b.persistedAt - a.persistedAt)[0];
+    }
+    return record;
+  }
+  async remove(name, checksum) {
+    if (!this.isSupported) {
+      return false;
+    }
+    const db = await openDatabase(this.dbName, this.storeName);
+    const key = checksum !== void 0 ? buildKey(name, checksum) : void 0;
+    const result = await runTransaction(db, this.storeName, "readwrite", (store) => {
+      if (key) {
+        return store.delete(key);
+      }
+      const prefix = `${normalizePath(name)}:`;
+      return store.delete(IDBKeyRange.bound(prefix, `${prefix}\uFFFF`, false, true));
+    });
+    db.close();
+    return typeof result === "number" ? result > 0 : true;
+  }
+  async clear() {
+    if (!this.isSupported) {
+      return;
+    }
+    const db = await openDatabase(this.dbName, this.storeName);
+    await runTransaction(db, this.storeName, "readwrite", (store) => store.clear());
+    db.close();
+  }
+  async list() {
+    if (!this.isSupported) {
+      return [];
+    }
+    const db = await openDatabase(this.dbName, this.storeName);
+    const result = await runTransaction(db, this.storeName, "readonly", (store) => store.getAll());
+    db.close();
+    return result.sort((a, b) => b.persistedAt - a.persistedAt);
+  }
+};
+
+// src/assets/manager.ts
+var AssetDependencyError = class extends Error {
+  constructor(missing, message) {
+    super(message ?? `Missing dependencies: ${missing.join(", ")}`);
+    this.missing = missing;
+    this.name = "AssetDependencyError";
+  }
+};
+var AssetDependencyTracker = class {
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map();
+  }
+  register(assetKey, dependencies = []) {
+    const node = this.nodes.get(assetKey) ?? { dependencies: /* @__PURE__ */ new Set(), loaded: false };
+    dependencies.forEach((dependency) => node.dependencies.add(dependency));
+    this.nodes.set(assetKey, node);
+    dependencies.forEach((dependency) => {
+      if (!this.nodes.has(dependency)) {
+        this.nodes.set(dependency, { dependencies: /* @__PURE__ */ new Set(), loaded: false });
+      }
+    });
+  }
+  markLoaded(assetKey) {
+    const node = this.nodes.get(assetKey) ?? { dependencies: /* @__PURE__ */ new Set(), loaded: false };
+    const missing = this.getMissingDependencies(assetKey, node);
+    if (missing.length > 0) {
+      throw new AssetDependencyError(missing, `Asset ${assetKey} is missing dependencies: ${missing.join(", ")}`);
+    }
+    node.loaded = true;
+    this.nodes.set(assetKey, node);
+  }
+  markUnloaded(assetKey) {
+    const node = this.nodes.get(assetKey);
+    if (node) {
+      node.loaded = false;
+    }
+  }
+  isLoaded(assetKey) {
+    return this.nodes.get(assetKey)?.loaded ?? false;
+  }
+  missingDependencies(assetKey) {
+    const node = this.nodes.get(assetKey);
+    if (!node) {
+      return [];
+    }
+    return this.getMissingDependencies(assetKey, node);
+  }
+  reset() {
+    this.nodes.clear();
+  }
+  getMissingDependencies(assetKey, node) {
+    const missing = [];
+    for (const dependency of node.dependencies) {
+      if (!this.nodes.get(dependency)?.loaded) {
+        missing.push(dependency);
+      }
+    }
+    return missing;
+  }
+};
+var AssetManager = class {
+  constructor(vfs, options = {}) {
+    this.vfs = vfs;
+    this.textures = new TextureCache({ capacity: options.textureCacheCapacity ?? 128 });
+    this.audio = new AudioRegistry(vfs, { cacheSize: options.audioCacheSize ?? 64 });
+    this.dependencyTracker = options.dependencyTracker ?? new AssetDependencyTracker();
+    this.md2 = new Md2Loader(vfs);
+    this.md3 = new Md3Loader(vfs);
+  }
+  isAssetLoaded(type, path) {
+    return this.dependencyTracker.isLoaded(this.makeKey(type, path));
+  }
+  registerTexture(path, texture) {
+    this.textures.set(path, texture);
+    const key = this.makeKey("texture", path);
+    this.dependencyTracker.register(key);
+    this.dependencyTracker.markLoaded(key);
+  }
+  async loadSound(path) {
+    const audio = await this.audio.load(path);
+    const key = this.makeKey("sound", path);
+    this.dependencyTracker.register(key);
+    this.dependencyTracker.markLoaded(key);
+    return audio;
+  }
+  async loadMd2Model(path, textureDependencies = []) {
+    const modelKey = this.makeKey("model", path);
+    const dependencyKeys = textureDependencies.map((dep) => this.makeKey("texture", dep));
+    this.dependencyTracker.register(modelKey, dependencyKeys);
+    const missing = this.dependencyTracker.missingDependencies(modelKey);
+    if (missing.length > 0) {
+      throw new AssetDependencyError(missing, `Asset ${modelKey} is missing dependencies: ${missing.join(", ")}`);
+    }
+    const model = await this.md2.load(path);
+    this.dependencyTracker.markLoaded(modelKey);
+    return model;
+  }
+  async loadMd3Model(path, textureDependencies = []) {
+    const modelKey = this.makeKey("model", path);
+    const dependencyKeys = textureDependencies.map((dep) => this.makeKey("texture", dep));
+    this.dependencyTracker.register(modelKey, dependencyKeys);
+    const missing = this.dependencyTracker.missingDependencies(modelKey);
+    if (missing.length > 0) {
+      throw new AssetDependencyError(missing, `Asset ${modelKey} is missing dependencies: ${missing.join(", ")}`);
+    }
+    const model = await this.md3.load(path);
+    this.dependencyTracker.markLoaded(modelKey);
+    return model;
+  }
+  resetForLevelChange() {
+    this.textures.clear();
+    this.audio.clearAll();
+    this.dependencyTracker.reset();
+  }
+  makeKey(type, path) {
+    return `${type}:${normalizePath(path)}`;
+  }
+};
+
+// src/audio/constants.ts
+var MAX_SOUND_CHANNELS = 32;
+var SoundChannel = /* @__PURE__ */ ((SoundChannel2) => {
+  SoundChannel2[SoundChannel2["Auto"] = 0] = "Auto";
+  SoundChannel2[SoundChannel2["Weapon"] = 1] = "Weapon";
+  SoundChannel2[SoundChannel2["Voice"] = 2] = "Voice";
+  SoundChannel2[SoundChannel2["Item"] = 3] = "Item";
+  SoundChannel2[SoundChannel2["Body"] = 4] = "Body";
+  SoundChannel2[SoundChannel2["Aux"] = 5] = "Aux";
+  SoundChannel2[SoundChannel2["Footstep"] = 6] = "Footstep";
+  SoundChannel2[SoundChannel2["Aux3"] = 7] = "Aux3";
+  SoundChannel2[SoundChannel2["NoPhsAdd"] = 8] = "NoPhsAdd";
+  SoundChannel2[SoundChannel2["Reliable"] = 16] = "Reliable";
+  SoundChannel2[SoundChannel2["ForcePos"] = 32] = "ForcePos";
+  return SoundChannel2;
+})(SoundChannel || {});
+var ATTN_LOOP_NONE = -1;
+var ATTN_NONE = 0;
+var ATTN_NORM = 1;
+var ATTN_IDLE = 2;
+var ATTN_STATIC = 3;
+var SOUND_FULLVOLUME = 80;
+var SOUND_LOOP_ATTENUATE = 3e-3;
+function attenuationToDistanceMultiplier(attenuation) {
+  return attenuation === ATTN_STATIC ? attenuation * 1e-3 : attenuation * 5e-4;
+}
+function calculateMaxAudibleDistance(attenuation) {
+  const distMult = attenuationToDistanceMultiplier(attenuation);
+  return distMult <= 0 ? Number.POSITIVE_INFINITY : SOUND_FULLVOLUME + 1 / distMult;
+}
+
+// src/audio/context.ts
+var AudioContextController = class {
+  constructor(factory) {
+    this.factory = factory;
+  }
+  getContext() {
+    if (!this.context) {
+      this.context = this.factory();
+    }
+    return this.context;
+  }
+  async resume() {
+    const ctx = this.getContext();
+    if (ctx.state === "suspended") {
+      await ctx.resume();
+    }
+  }
+  getState() {
+    return this.context?.state ?? "suspended";
+  }
+};
+function createAudioGraph(controller) {
+  const context = controller.getContext();
+  const master = context.createGain();
+  master.gain.value = 1;
+  const compressor = context.createDynamicsCompressor();
+  const filter = context.createBiquadFilter?.();
+  if (filter) {
+    filter.type = "lowpass";
+    filter.frequency.value = 2e4;
+    filter.Q.value = 0.707;
+    master.connect(filter);
+    filter.connect(compressor);
+  } else {
+    master.connect(compressor);
+  }
+  compressor.connect(context.destination);
+  return { context, master, compressor, filter };
+}
+
+// src/audio/registry.ts
+var SoundRegistry = class {
+  constructor(configStrings = new ConfigStringRegistry()) {
+    this.configStrings = configStrings;
+    this.buffers = /* @__PURE__ */ new Map();
+  }
+  registerName(name) {
+    return this.configStrings.soundIndex(name);
+  }
+  register(name, buffer) {
+    const index = this.registerName(name);
+    this.buffers.set(index, buffer);
+    return index;
+  }
+  find(name) {
+    return this.configStrings.findSoundIndex(name);
+  }
+  get(index) {
+    return this.buffers.get(index);
+  }
+  has(index) {
+    return this.buffers.has(index);
+  }
+};
+
+// src/audio/precache.ts
+var SoundPrecache = class {
+  constructor(options) {
+    this.vfs = options.vfs;
+    this.registry = options.registry;
+    this.contextController = options.context;
+    this.soundRoot = options.soundRoot ?? "sound/";
+    this.decodeAudio = options.decodeAudio ?? ((context, data) => {
+      if (!context.decodeAudioData) {
+        throw new Error("decodeAudioData is not available on the provided audio context");
+      }
+      return context.decodeAudioData(data);
+    });
+  }
+  async precache(paths) {
+    const unique = [...new Set(paths.map((p) => this.normalize(p)))];
+    const report = { loaded: [], skipped: [], missing: [], errors: {} };
+    const context = this.contextController.getContext();
+    for (const path of unique) {
+      try {
+        const existingIndex = this.registry.find(path);
+        if (existingIndex !== void 0 && this.registry.has(existingIndex)) {
+          report.skipped.push(path);
+          continue;
+        }
+        const stat = this.vfs.stat(path);
+        if (!stat) {
+          report.missing.push(path);
+          continue;
+        }
+        const bytes = await this.vfs.readFile(path);
+        const copy = bytes.slice().buffer;
+        const buffer = await this.decodeAudio(context, copy);
+        this.registry.register(path, buffer);
+        report.loaded.push(path);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        report.errors[path] = err;
+      }
+    }
+    return report;
+  }
+  normalize(path) {
+    const normalized = normalizePath(path.replace(/^\//, ""));
+    if (normalized.startsWith(this.soundRoot)) {
+      return normalized;
+    }
+    return normalizePath(`${this.soundRoot}${normalized}`);
+  }
+};
+
+// src/audio/channels.ts
+var CHANNEL_MASK = 7;
+var baseChannel = (entchannel) => entchannel & CHANNEL_MASK;
+function createInitialChannels(playerEntity) {
+  return Array.from({ length: MAX_SOUND_CHANNELS }, () => ({
+    entnum: 0,
+    entchannel: 0 /* Auto */,
+    endTimeMs: 0,
+    isPlayer: false,
+    active: false
+  })).map((channel) => ({ ...channel, isPlayer: channel.entnum === playerEntity }));
+}
+function pickChannel(channels, entnum, entchannel, context) {
+  if (entchannel < 0) {
+    throw new Error("pickChannel: entchannel must be non-negative");
+  }
+  const normalizedEntchannel = baseChannel(entchannel);
+  let firstToDie = -1;
+  let lifeLeft = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < channels.length; i += 1) {
+    const channel = channels[i];
+    const channelBase = baseChannel(channel.entchannel);
+    if (normalizedEntchannel !== 0 /* Auto */ && channel.entnum === entnum && channelBase === normalizedEntchannel) {
+      firstToDie = i;
+      break;
+    }
+    if (channel.active && channel.entnum === context.playerEntity && entnum !== context.playerEntity) {
+      continue;
+    }
+    const remainingLife = channel.endTimeMs - context.nowMs;
+    if (firstToDie === -1 || remainingLife < lifeLeft) {
+      lifeLeft = remainingLife;
+      firstToDie = i;
+    }
+  }
+  return firstToDie === -1 ? void 0 : firstToDie;
+}
+
+// src/audio/spatialization.ts
+function spatializeOrigin(origin, listener, masterVolume, attenuation, isListenerSound) {
+  if (isListenerSound) {
+    return { left: masterVolume, right: masterVolume, distanceComponent: 0 };
+  }
+  const sourceVec = subtractVec3(origin, listener.origin);
+  const distance = lengthVec3(sourceVec);
+  const normalized = normalizeVec3(sourceVec);
+  let dist = distance - SOUND_FULLVOLUME;
+  if (dist < 0) dist = 0;
+  dist *= attenuationToDistanceMultiplier(attenuation);
+  const dot = dotVec3(listener.right, normalized);
+  const mono = listener.mono ?? false;
+  const rscale = mono || attenuation === 0 ? 1 : 0.5 * (1 + dot);
+  const lscale = mono || attenuation === 0 ? 1 : 0.5 * (1 - dot);
+  const right = Math.max(0, Math.floor(masterVolume * (1 - dist) * rscale));
+  const left = Math.max(0, Math.floor(masterVolume * (1 - dist) * lscale));
+  return { left, right, distanceComponent: dist };
+}
+
+// src/audio/system.ts
+var AudioSystem = class {
+  constructor(options) {
+    this.activeSources = /* @__PURE__ */ new Map();
+    this.contextController = options.context;
+    this.registry = options.registry;
+    this.playerEntity = options.playerEntity;
+    this.channels = createInitialChannels(options.playerEntity);
+    this.listener = options.listener ?? { origin: ZERO_VEC3, right: { x: 1, y: 0, z: 0 } };
+    this.sfxVolume = options.sfxVolume ?? 1;
+    this.masterVolume = options.masterVolume ?? 1;
+    this.resolveOcclusion = options.resolveOcclusion;
+    this.graph = createAudioGraph(this.contextController);
+    this.graph.master.gain.value = this.masterVolume;
+  }
+  setListener(listener) {
+    this.listener = listener;
+  }
+  setMasterVolume(volume) {
+    this.masterVolume = volume;
+    this.graph.master.gain.value = volume;
+  }
+  setSfxVolume(volume) {
+    this.sfxVolume = volume;
+  }
+  async ensureRunning() {
+    await this.contextController.resume();
+  }
+  play(request) {
+    const buffer = this.registry.get(request.soundIndex);
+    if (!buffer) return void 0;
+    const ctx = this.graph.context;
+    const nowMs = ctx.currentTime * 1e3;
+    const channelIndex = pickChannel(this.channels, request.entity, request.channel, {
+      nowMs,
+      playerEntity: this.playerEntity
+    });
+    if (channelIndex === void 0) return void 0;
+    const existing = this.activeSources.get(channelIndex);
+    if (existing) {
+      existing.source.onended = null;
+      existing.source.stop();
+      this.activeSources.delete(channelIndex);
+    }
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    source.loop = request.looping ?? false;
+    const origin = request.origin ?? this.listener.origin;
+    const gain = ctx.createGain();
+    const panner = this.createPanner(ctx, request.attenuation);
+    const occlusion = this.resolveOcclusion?.(this.listener, origin, request.attenuation);
+    const occlusionScale = clamp01(occlusion?.gainScale ?? 1);
+    const occlusionFilter = this.resolveOcclusion ? this.createOcclusionFilter(ctx, occlusion?.lowpassHz ?? 2e4) : void 0;
+    this.applyOriginToPanner(panner, origin);
+    const isListenerSound = request.entity === this.playerEntity;
+    const spatial = spatializeOrigin(origin, this.listener, request.volume, request.attenuation, isListenerSound);
+    const attenuationScale = request.volume === 0 ? 0 : Math.max(spatial.left, spatial.right) / Math.max(1, request.volume);
+    const gainValue = attenuationScale * (request.volume / 255) * this.masterVolume * this.sfxVolume;
+    gain.gain.value = gainValue * occlusionScale;
+    const startTimeSec = ctx.currentTime + (request.timeOffsetMs ?? 0) / 1e3;
+    const endTimeMs = (request.looping ? Number.POSITIVE_INFINITY : buffer.duration * 1e3) + startTimeSec * 1e3;
+    source.connect(panner);
+    if (occlusionFilter) {
+      panner.connect(occlusionFilter);
+      occlusionFilter.connect(gain);
+    } else {
+      panner.connect(gain);
+    }
+    gain.connect(this.graph.master);
+    source.start(startTimeSec);
+    source.onended = () => {
+      this.channels[channelIndex].active = false;
+      this.activeSources.delete(channelIndex);
+    };
+    const active = {
+      channelIndex,
+      entnum: request.entity,
+      entchannel: baseChannel(request.channel),
+      endTimeMs,
+      source,
+      panner,
+      gain,
+      baseGain: gainValue,
+      origin,
+      attenuation: request.attenuation,
+      occlusion: occlusionFilter ? { scale: occlusionScale, lowpassHz: occlusion?.lowpassHz, filter: occlusionFilter } : occlusion ? { scale: occlusionScale, lowpassHz: occlusion.lowpassHz } : void 0
+    };
+    this.channels[channelIndex] = {
+      entnum: request.entity,
+      entchannel: baseChannel(request.channel),
+      endTimeMs,
+      isPlayer: request.entity === this.playerEntity,
+      active: true
+    };
+    this.activeSources.set(channelIndex, active);
+    return active;
+  }
+  stop(channelIndex) {
+    const active = this.activeSources.get(channelIndex);
+    if (!active) return;
+    active.source.stop();
+    this.channels[channelIndex].active = false;
+    this.activeSources.delete(channelIndex);
+  }
+  stopEntitySounds(entnum) {
+    for (const [index, active] of [...this.activeSources.entries()]) {
+      if (active.entnum !== entnum) continue;
+      active.source.stop();
+      this.channels[index].active = false;
+      this.activeSources.delete(index);
+    }
+  }
+  updateEntityPosition(entnum, origin) {
+    for (const active of this.activeSources.values()) {
+      if (active.entnum !== entnum) continue;
+      this.applyOriginToPanner(active.panner, origin);
+      active.origin = origin;
+      if (this.resolveOcclusion) {
+        const occlusion = this.resolveOcclusion(this.listener, origin, active.attenuation);
+        this.applyOcclusion(active, occlusion);
+      }
+    }
+  }
+  positionedSound(origin, soundIndex, volume, attenuation) {
+    return this.play({
+      entity: 0,
+      channel: 0 /* Auto */,
+      soundIndex,
+      volume,
+      attenuation,
+      origin
+    });
+  }
+  ambientSound(origin, soundIndex, volume) {
+    return this.play({
+      entity: 0,
+      channel: 0 /* Auto */,
+      soundIndex,
+      volume,
+      attenuation: ATTN_NONE,
+      origin,
+      looping: true
+    });
+  }
+  getChannelState(index) {
+    return this.channels[index];
+  }
+  getDiagnostics() {
+    return {
+      activeChannels: this.activeSources.size,
+      masterVolume: this.masterVolume,
+      sfxVolume: this.sfxVolume,
+      channels: [...this.channels],
+      activeSounds: [...this.activeSources.values()].map((sound) => ({
+        entnum: sound.entnum,
+        entchannel: sound.entchannel,
+        channelIndex: sound.channelIndex,
+        origin: sound.origin,
+        gain: sound.gain.gain.value,
+        baseGain: sound.baseGain,
+        attenuation: sound.attenuation,
+        maxDistance: sound.panner.maxDistance,
+        distanceModel: sound.panner.distanceModel,
+        occlusion: sound.occlusion ? { scale: sound.occlusion.scale, lowpassHz: sound.occlusion.lowpassHz } : void 0
+      }))
+    };
+  }
+  setUnderwater(enabled, cutoffHz = 400) {
+    const filter = this.graph.filter;
+    if (!filter) return;
+    filter.type = "lowpass";
+    filter.Q.value = 0.707;
+    filter.frequency.value = enabled ? cutoffHz : 2e4;
+  }
+  createPanner(context, attenuation) {
+    const panner = context.createPanner ? context.createPanner() : Object.assign(context.createGain(), {
+      positionX: { value: this.listener.origin.x },
+      positionY: { value: this.listener.origin.y },
+      positionZ: { value: this.listener.origin.z }
+    });
+    return this.configurePanner(panner, attenuation);
+  }
+  configurePanner(panner, attenuation) {
+    const distMult = attenuationToDistanceMultiplier(attenuation);
+    panner.refDistance = SOUND_FULLVOLUME;
+    panner.maxDistance = calculateMaxAudibleDistance(attenuation);
+    panner.rolloffFactor = distMult;
+    panner.distanceModel = attenuation === 0 ? "linear" : "inverse";
+    panner.positionX.value = this.listener.origin.x;
+    panner.positionY.value = this.listener.origin.y;
+    panner.positionZ.value = this.listener.origin.z;
+    return panner;
+  }
+  applyOriginToPanner(panner, origin) {
+    panner.positionX.value = origin.x;
+    panner.positionY.value = origin.y;
+    panner.positionZ.value = origin.z;
+  }
+  createOcclusionFilter(context, cutoffHz) {
+    if (!context.createBiquadFilter) return void 0;
+    const filter = context.createBiquadFilter();
+    filter.type = "lowpass";
+    filter.Q.value = 0.707;
+    filter.frequency.value = clamp(cutoffHz, 10, 2e4);
+    return filter;
+  }
+  applyOcclusion(active, occlusion) {
+    const scale = clamp01(occlusion?.gainScale ?? 1);
+    active.gain.gain.value = active.baseGain * scale;
+    if (active.occlusion?.filter) {
+      const cutoff = occlusion?.lowpassHz ?? 2e4;
+      active.occlusion.filter.frequency.value = clamp(cutoff, 10, 2e4);
+    }
+    if (active.occlusion) {
+      active.occlusion.scale = scale;
+      active.occlusion.lowpassHz = occlusion?.lowpassHz;
+    } else if (occlusion) {
+      active.occlusion = { scale, lowpassHz: occlusion.lowpassHz };
+    }
+  }
+};
+var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+var clamp01 = (value) => clamp(value, 0, 1);
+
+// src/audio/music.ts
+var MusicSystem = class {
+  constructor(options) {
+    this.createElement = options.createElement;
+    this.resolveSource = options.resolveSource ?? (async (path) => path);
+    this.volume = options.volume ?? 1;
+  }
+  async play(track, { loop = true, restart = false } = {}) {
+    if (this.track === track && this.element) {
+      this.element.loop = loop;
+      this.element.volume = this.volume;
+      if (restart) {
+        this.element.currentTime = 0;
+      }
+      if (this.element.paused || restart) {
+        await this.element.play();
+      }
+      return;
+    }
+    const src = await this.resolveSource(track);
+    const element = this.createElement();
+    element.src = src;
+    element.loop = loop;
+    element.volume = this.volume;
+    element.currentTime = 0;
+    element.load();
+    await element.play();
+    this.element = element;
+    this.track = track;
+  }
+  pause() {
+    if (!this.element || this.element.paused) return;
+    this.element.pause();
+  }
+  async resume() {
+    if (!this.element || !this.element.paused) return;
+    await this.element.play();
+  }
+  stop() {
+    if (!this.element) return;
+    this.element.pause();
+    this.element.currentTime = 0;
+    this.element = void 0;
+    this.track = void 0;
+  }
+  setVolume(volume) {
+    this.volume = volume;
+    if (this.element) {
+      this.element.volume = volume;
+    }
+  }
+  getState() {
+    const playing = Boolean(this.element && !this.element.paused && !this.element.ended);
+    const paused = Boolean(this.element?.paused);
+    return { track: this.track, paused, playing, volume: this.volume };
+  }
+};
+
+// src/audio/api.ts
+var AudioApi = class {
+  constructor(options) {
+    this.registry = options.registry;
+    this.system = options.system;
+    this.music = options.music;
+  }
+  soundindex(name) {
+    return this.registry.registerName(name);
+  }
+  sound(entity, channel, soundindex, volume, attenuation, timeofs) {
+    this.system.play({
+      entity,
+      channel,
+      soundIndex: soundindex,
+      volume,
+      attenuation,
+      timeOffsetMs: timeofs
+    });
+  }
+  positioned_sound(origin, soundindex, volume, attenuation) {
+    this.system.positionedSound(origin, soundindex, volume, attenuation);
+  }
+  loop_sound(entity, channel, soundindex, volume, attenuation) {
+    this.system.play({
+      entity,
+      channel,
+      soundIndex: soundindex,
+      volume,
+      attenuation,
+      looping: true
+    });
+  }
+  stop_entity_sounds(entnum) {
+    this.system.stopEntitySounds(entnum);
+  }
+  set_listener(listener) {
+    this.system.setListener(listener);
+  }
+  play_music(track, loop = true) {
+    if (!this.music) {
+      return Promise.resolve();
+    }
+    return this.music.play(track, { loop });
+  }
+  pause_music() {
+    this.music?.pause();
+  }
+  resume_music() {
+    return this.music?.resume() ?? Promise.resolve();
+  }
+  stop_music() {
+    this.music?.stop();
+  }
+  set_music_volume(volume) {
+    this.music?.setVolume(volume);
+  }
+  play_ambient(origin, soundindex, volume) {
+    this.system.ambientSound(origin, soundindex, volume);
+  }
+  play_channel(request) {
+    this.system.play({ ...request });
+  }
+};
+
 // src/render/context.ts
 function configureDefaultGLState(gl) {
   gl.enable(gl.DEPTH_TEST);
@@ -1501,6 +3012,43 @@ var Texture2D = class {
     this.gl.deleteTexture(this.texture);
   }
 };
+var TextureCubeMap = class {
+  constructor(gl) {
+    this.gl = gl;
+    this.target = gl.TEXTURE_CUBE_MAP;
+    const texture = gl.createTexture();
+    if (!texture) {
+      throw new Error("Failed to allocate cubemap 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);
+    }
+  }
+  uploadFace(faceTarget, level, internalFormat, width, height, border, format, type, data) {
+    this.bind();
+    this.gl.texImage2D(faceTarget, level, internalFormat, width, height, border, format, type, data);
+  }
+  dispose() {
+    this.gl.deleteTexture(this.texture);
+  }
+};
 var Framebuffer = class {
   constructor(gl) {
     this.gl = gl;
@@ -1713,6 +3261,728 @@ function buildBspGeometry(gl, surfaces, options = {}) {
   return { surfaces: results, lightmaps };
 }
 
+// src/render/culling.ts
+function normalizePlane(plane) {
+  const { normal, distance } = plane;
+  const length = Math.sqrt(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z);
+  if (length === 0) {
+    return plane;
+  }
+  const inv = 1 / length;
+  return {
+    normal: { x: normal.x * inv, y: normal.y * inv, z: normal.z * inv },
+    distance: distance * inv
+  };
+}
+function extractFrustumPlanes(matrix) {
+  if (matrix.length !== 16) {
+    throw new Error("View-projection matrix must contain 16 elements");
+  }
+  const m00 = matrix[0];
+  const m01 = matrix[4];
+  const m02 = matrix[8];
+  const m03 = matrix[12];
+  const m10 = matrix[1];
+  const m11 = matrix[5];
+  const m12 = matrix[9];
+  const m13 = matrix[13];
+  const m20 = matrix[2];
+  const m21 = matrix[6];
+  const m22 = matrix[10];
+  const m23 = matrix[14];
+  const m30 = matrix[3];
+  const m31 = matrix[7];
+  const m32 = matrix[11];
+  const m33 = matrix[15];
+  const planes = [
+    // Left
+    normalizePlane({ normal: { x: m30 + m00, y: m31 + m01, z: m32 + m02 }, distance: m33 + m03 }),
+    // Right
+    normalizePlane({ normal: { x: m30 - m00, y: m31 - m01, z: m32 - m02 }, distance: m33 - m03 }),
+    // Bottom
+    normalizePlane({ normal: { x: m30 + m10, y: m31 + m11, z: m32 + m12 }, distance: m33 + m13 }),
+    // Top
+    normalizePlane({ normal: { x: m30 - m10, y: m31 - m11, z: m32 - m12 }, distance: m33 - m13 }),
+    // Near
+    normalizePlane({ normal: { x: m30 + m20, y: m31 + m21, z: m32 + m22 }, distance: m33 + m23 }),
+    // Far
+    normalizePlane({ normal: { x: m30 - m20, y: m31 - m21, z: m32 - m22 }, distance: m33 - m23 })
+  ];
+  return planes;
+}
+function planeDistance(plane, point) {
+  return plane.normal.x * point.x + plane.normal.y * point.y + plane.normal.z * point.z + plane.distance;
+}
+function boxIntersectsFrustum(mins, maxs, planes) {
+  for (const plane of planes) {
+    const x = plane.normal.x >= 0 ? maxs.x : mins.x;
+    const y = plane.normal.y >= 0 ? maxs.y : mins.y;
+    const z = plane.normal.z >= 0 ? maxs.z : mins.z;
+    if (planeDistance(plane, { x, y, z }) < 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/render/bspTraversal.ts
+function childIsLeaf(index) {
+  return index < 0;
+}
+function childLeafIndex(index) {
+  return -index - 1;
+}
+function distanceToPlane(plane, point) {
+  return plane.normal[0] * point.x + plane.normal[1] * point.y + plane.normal[2] * point.z - plane.dist;
+}
+function isClusterVisible(visibility, fromCluster, testCluster) {
+  if (!visibility) {
+    return true;
+  }
+  if (fromCluster < 0 || testCluster < 0) {
+    return true;
+  }
+  const rowBytes = Math.ceil(visibility.numClusters / 8);
+  const row = visibility.clusters[fromCluster].pvs;
+  const byteIndex = Math.floor(testCluster / 8);
+  const bit = 1 << testCluster % 8;
+  if (byteIndex < 0 || byteIndex >= rowBytes) {
+    return false;
+  }
+  return (row[byteIndex] & bit) !== 0;
+}
+function leafIntersectsFrustum(leaf, planes) {
+  const mins = { x: leaf.mins[0], y: leaf.mins[1], z: leaf.mins[2] };
+  const maxs = { x: leaf.maxs[0], y: leaf.maxs[1], z: leaf.maxs[2] };
+  return boxIntersectsFrustum(mins, maxs, planes);
+}
+function findLeafForPoint(map, point) {
+  let nodeIndex = 0;
+  while (nodeIndex >= 0) {
+    const node = map.nodes[nodeIndex];
+    const plane = map.planes[node.planeIndex];
+    const dist = distanceToPlane(plane, point);
+    const side = dist >= 0 ? 0 : 1;
+    const child = node.children[side];
+    if (childIsLeaf(child)) {
+      return childLeafIndex(child);
+    }
+    nodeIndex = child;
+  }
+  return -1;
+}
+function collectFacesFromLeaf(map, leafIndex) {
+  const leaf = map.leafs[leafIndex];
+  const faces = [];
+  for (let i = 0; i < leaf.numLeafFaces; i += 1) {
+    faces.push(map.leafLists.leafFaces[leafIndex][i]);
+  }
+  return faces;
+}
+function traverse(map, nodeIndex, camera, frustum, viewCluster, visibleFaces, visitedFaces) {
+  if (childIsLeaf(nodeIndex)) {
+    const leafIndex = childLeafIndex(nodeIndex);
+    const leaf = map.leafs[leafIndex];
+    if (!isClusterVisible(map.visibility, viewCluster, leaf.cluster)) {
+      return;
+    }
+    if (!leafIntersectsFrustum(leaf, frustum)) {
+      return;
+    }
+    const center = {
+      x: (leaf.mins[0] + leaf.maxs[0]) * 0.5,
+      y: (leaf.mins[1] + leaf.maxs[1]) * 0.5,
+      z: (leaf.mins[2] + leaf.maxs[2]) * 0.5
+    };
+    const dx = center.x - camera.x;
+    const dy = center.y - camera.y;
+    const dz = center.z - camera.z;
+    const leafSortKey = -(dx * dx + dy * dy + dz * dz);
+    for (const faceIndex of collectFacesFromLeaf(map, leafIndex)) {
+      if (visitedFaces.has(faceIndex)) {
+        continue;
+      }
+      visitedFaces.add(faceIndex);
+      visibleFaces.push({ faceIndex, leafIndex, sortKey: leafSortKey });
+    }
+    return;
+  }
+  const node = map.nodes[nodeIndex];
+  const plane = map.planes[node.planeIndex];
+  const dist = distanceToPlane(plane, camera);
+  const nearChild = dist >= 0 ? node.children[0] : node.children[1];
+  const farChild = dist >= 0 ? node.children[1] : node.children[0];
+  if (boxIntersectsFrustum(
+    { x: node.mins[0], y: node.mins[1], z: node.mins[2] },
+    { x: node.maxs[0], y: node.maxs[1], z: node.maxs[2] },
+    frustum
+  )) {
+    traverse(map, nearChild, camera, frustum, viewCluster, visibleFaces, visitedFaces);
+    traverse(map, farChild, camera, frustum, viewCluster, visibleFaces, visitedFaces);
+  }
+}
+function gatherVisibleFaces(map, cameraPosition, frustum) {
+  const viewLeaf = findLeafForPoint(map, cameraPosition);
+  const viewCluster = viewLeaf >= 0 ? map.leafs[viewLeaf].cluster : -1;
+  const visibleFaces = [];
+  const visitedFaces = /* @__PURE__ */ new Set();
+  traverse(map, 0, cameraPosition, frustum, viewCluster, visibleFaces, visitedFaces);
+  return visibleFaces;
+}
+
+// src/render/bspPipeline.ts
+var BSP_SURFACE_VERTEX_SOURCE = `#version 300 es
+precision highp float;
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec2 a_texCoord;
+layout(location = 2) in vec2 a_lightmapCoord;
+
+uniform mat4 u_modelViewProjection;
+uniform vec2 u_texScroll;
+uniform vec2 u_lightmapScroll;
+
+out vec2 v_texCoord;
+out vec2 v_lightmapCoord;
+
+vec2 applyScroll(vec2 uv, vec2 scroll) {
+  return uv + scroll;
+}
+
+void main() {
+  v_texCoord = applyScroll(a_texCoord, u_texScroll);
+  v_lightmapCoord = applyScroll(a_lightmapCoord, u_lightmapScroll);
+  gl_Position = u_modelViewProjection * vec4(a_position, 1.0);
+}`;
+var BSP_SURFACE_FRAGMENT_SOURCE = `#version 300 es
+precision highp float;
+
+in vec2 v_texCoord;
+in vec2 v_lightmapCoord;
+
+uniform sampler2D u_diffuseMap;
+uniform sampler2D u_lightmapAtlas;
+uniform vec4 u_lightStyleFactors;
+uniform float u_alpha;
+uniform bool u_applyLightmap;
+uniform bool u_warp;
+uniform float u_time;
+
+out vec4 o_color;
+
+vec2 warpCoords(vec2 uv) {
+  // Quake II warp applies a subtle sinusoidal offset; we mirror the rerelease scale.
+  if (!u_warp) {
+    return uv;
+  }
+  float s = uv.x + sin(uv.y * 0.125 + u_time) * 0.125;
+  float t = uv.y + sin(uv.x * 0.125 + u_time) * 0.125;
+  return vec2(s, t);
+}
+
+void main() {
+  vec2 warpedTex = warpCoords(v_texCoord);
+  vec4 base = texture(u_diffuseMap, warpedTex);
+
+  if (u_applyLightmap) {
+    vec3 light = texture(u_lightmapAtlas, warpCoords(v_lightmapCoord)).rgb;
+    float styleScale = dot(u_lightStyleFactors, vec4(1.0));
+    base.rgb *= light * styleScale;
+  }
+
+  o_color = vec4(base.rgb, base.a * u_alpha);
+}`;
+var DEFAULT_STYLE_INDICES = [0, 255, 255, 255];
+function resolveLightStyles(styleIndices = DEFAULT_STYLE_INDICES, styleValues = []) {
+  const factors = new Float32Array(4);
+  for (let i = 0; i < 4; i += 1) {
+    const styleIndex = styleIndices[i] ?? 255;
+    if (styleIndex === 255) {
+      factors[i] = 0;
+      continue;
+    }
+    const value = styleValues[styleIndex];
+    factors[i] = value !== void 0 ? value : 1;
+  }
+  return factors;
+}
+function computeFlowOffset(timeSeconds) {
+  const cycle = timeSeconds * 0.25 % 1;
+  return [-cycle, 0];
+}
+function deriveSurfaceRenderState(surfaceFlags = SURF_NONE, timeSeconds = 0) {
+  const flowing = (surfaceFlags & SURF_FLOWING) !== 0;
+  const warp = (surfaceFlags & SURF_WARP) !== 0;
+  const sky = (surfaceFlags & SURF_SKY) !== 0;
+  const trans33 = (surfaceFlags & SURF_TRANS33) !== 0;
+  const trans66 = (surfaceFlags & SURF_TRANS66) !== 0;
+  const alpha = trans33 ? 0.33 : trans66 ? 0.66 : 1;
+  const blend = trans33 || trans66;
+  const depthWrite = !blend && !sky;
+  const flowOffset = flowing ? computeFlowOffset(timeSeconds) : [0, 0];
+  return {
+    alpha,
+    blend,
+    depthWrite,
+    warp,
+    flowOffset,
+    sky
+  };
+}
+var BspSurfacePipeline = class {
+  constructor(gl) {
+    this.gl = gl;
+    this.program = ShaderProgram.create(
+      gl,
+      { vertex: BSP_SURFACE_VERTEX_SOURCE, fragment: BSP_SURFACE_FRAGMENT_SOURCE },
+      { a_position: 0, a_texCoord: 1, a_lightmapCoord: 2 }
+    );
+    this.uniformMvp = this.program.getUniformLocation("u_modelViewProjection");
+    this.uniformTexScroll = this.program.getUniformLocation("u_texScroll");
+    this.uniformLmScroll = this.program.getUniformLocation("u_lightmapScroll");
+    this.uniformLightStyles = this.program.getUniformLocation("u_lightStyleFactors");
+    this.uniformAlpha = this.program.getUniformLocation("u_alpha");
+    this.uniformApplyLightmap = this.program.getUniformLocation("u_applyLightmap");
+    this.uniformWarp = this.program.getUniformLocation("u_warp");
+    this.uniformDiffuse = this.program.getUniformLocation("u_diffuseMap");
+    this.uniformLightmap = this.program.getUniformLocation("u_lightmapAtlas");
+    this.uniformTime = this.program.getUniformLocation("u_time");
+  }
+  bind(options) {
+    const {
+      modelViewProjection,
+      styleIndices = DEFAULT_STYLE_INDICES,
+      styleValues = [],
+      diffuseSampler = 0,
+      lightmapSampler = 1,
+      surfaceFlags = SURF_NONE,
+      timeSeconds = 0
+    } = options;
+    const state = deriveSurfaceRenderState(surfaceFlags, timeSeconds);
+    const styles = resolveLightStyles(styleIndices, styleValues);
+    this.program.use();
+    this.gl.uniformMatrix4fv(this.uniformMvp, false, modelViewProjection);
+    this.gl.uniform2f(this.uniformTexScroll, state.flowOffset[0], state.flowOffset[1]);
+    this.gl.uniform2f(this.uniformLmScroll, state.flowOffset[0], state.flowOffset[1]);
+    this.gl.uniform4fv(this.uniformLightStyles, styles);
+    this.gl.uniform1f(this.uniformAlpha, state.alpha);
+    this.gl.uniform1i(this.uniformApplyLightmap, state.sky ? 0 : 1);
+    this.gl.uniform1i(this.uniformWarp, state.warp ? 1 : 0);
+    this.gl.uniform1f(this.uniformTime, timeSeconds);
+    this.gl.uniform1i(this.uniformDiffuse, diffuseSampler);
+    this.gl.uniform1i(this.uniformLightmap, lightmapSampler);
+    return state;
+  }
+  dispose() {
+    this.program.dispose();
+  }
+};
+function applySurfaceState(gl, state) {
+  gl.depthMask(state.depthWrite);
+  if (state.blend) {
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+  } else {
+    gl.disable(gl.BLEND);
+  }
+}
+
+// src/render/skybox.ts
+var SKYBOX_POSITIONS = new Float32Array([
+  // Front
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  // Back
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  // Left
+  -1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  // Right
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  // Top
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  // Bottom
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  1
+]);
+var SKYBOX_VERTEX_SHADER = `#version 300 es
+precision highp float;
+
+layout(location = 0) in vec3 a_position;
+
+uniform mat4 u_viewProjectionNoTranslation;
+uniform vec2 u_scroll;
+
+out vec3 v_direction;
+
+void main() {
+  vec3 dir = normalize(a_position);
+  dir.xy += u_scroll;
+  v_direction = dir;
+  gl_Position = u_viewProjectionNoTranslation * vec4(a_position, 1.0);
+}`;
+var SKYBOX_FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+in vec3 v_direction;
+uniform samplerCube u_skybox;
+
+out vec4 o_color;
+
+void main() {
+  o_color = texture(u_skybox, v_direction);
+}`;
+var SkyboxPipeline = class {
+  constructor(gl) {
+    this.gl = gl;
+    this.program = ShaderProgram.create(
+      gl,
+      { vertex: SKYBOX_VERTEX_SHADER, fragment: SKYBOX_FRAGMENT_SHADER },
+      { a_position: 0 }
+    );
+    this.vao = new VertexArray(gl);
+    this.vbo = new VertexBuffer(gl, gl.STATIC_DRAW);
+    this.vbo.upload(SKYBOX_POSITIONS, gl.STATIC_DRAW);
+    const layout = [{ index: 0, size: 3, type: gl.FLOAT, stride: 12, offset: 0 }];
+    this.vao.configureAttributes(layout, this.vbo);
+    this.uniformViewProj = this.program.getUniformLocation("u_viewProjectionNoTranslation");
+    this.uniformScroll = this.program.getUniformLocation("u_scroll");
+    this.uniformSampler = this.program.getUniformLocation("u_skybox");
+    this.cubemap = new TextureCubeMap(gl);
+    this.cubemap.setParameters({
+      minFilter: gl.LINEAR,
+      magFilter: gl.LINEAR,
+      wrapS: gl.CLAMP_TO_EDGE,
+      wrapT: gl.CLAMP_TO_EDGE
+    });
+  }
+  bind(options) {
+    const { viewProjection, scroll, textureUnit = 0 } = options;
+    this.program.use();
+    this.gl.depthMask(false);
+    this.gl.uniformMatrix4fv(this.uniformViewProj, false, viewProjection);
+    this.gl.uniform2f(this.uniformScroll, scroll[0], scroll[1]);
+    this.gl.uniform1i(this.uniformSampler, textureUnit);
+    this.cubemap.bind(textureUnit);
+    this.vao.bind();
+  }
+  draw() {
+    this.gl.drawArrays(this.gl.TRIANGLES, 0, SKYBOX_POSITIONS.length / 3);
+  }
+  dispose() {
+    this.vbo.dispose();
+    this.vao.dispose();
+    this.cubemap.dispose();
+    this.program.dispose();
+  }
+};
+function removeViewTranslation(viewMatrix) {
+  const noTranslation = viewMatrix.slice();
+  noTranslation[12] = 0;
+  noTranslation[13] = 0;
+  noTranslation[14] = 0;
+  return noTranslation;
+}
+function computeSkyScroll(timeSeconds, scrollSpeeds = [0.01, 0.02]) {
+  const [sx, sy] = scrollSpeeds;
+  return [sx * timeSeconds, sy * timeSeconds];
+}
+
+// src/render/md2Pipeline.ts
+var MD2_VERTEX_SHADER = `#version 300 es
+precision highp float;
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec3 a_normal;
+layout(location = 2) in vec2 a_texCoord;
+
+uniform mat4 u_modelViewProjection;
+uniform vec3 u_lightDir;
+
+out vec2 v_texCoord;
+out float v_light;
+
+void main() {
+  vec3 normal = normalize(a_normal);
+  v_light = max(dot(normal, normalize(u_lightDir)), 0.0);
+  v_texCoord = a_texCoord;
+  gl_Position = u_modelViewProjection * vec4(a_position, 1.0);
+}`;
+var MD2_FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+in vec2 v_texCoord;
+in float v_light;
+
+uniform sampler2D u_diffuseMap;
+uniform vec4 u_tint;
+
+out vec4 o_color;
+
+void main() {
+  vec4 albedo = texture(u_diffuseMap, v_texCoord) * u_tint;
+  o_color = vec4(albedo.rgb * v_light, albedo.a);
+}`;
+function normalizeVec32(v) {
+  const lengthSq = v.x * v.x + v.y * v.y + v.z * v.z;
+  if (lengthSq <= 0) {
+    return { x: 0, y: 0, z: 1 };
+  }
+  const inv = 1 / Math.sqrt(lengthSq);
+  return { x: v.x * inv, y: v.y * inv, z: v.z * inv };
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpVec3(a, b, t) {
+  return {
+    x: lerp(a.x, b.x, t),
+    y: lerp(a.y, b.y, t),
+    z: lerp(a.z, b.z, t)
+  };
+}
+function normalizeUv(s, t, header) {
+  return [s / header.skinWidth, 1 - t / header.skinHeight];
+}
+function buildMd2Geometry(model) {
+  if (model.glCommands.length === 0) {
+    const vertices2 = [];
+    const indices2 = [];
+    model.triangles.forEach((triangle) => {
+      const baseIndex = vertices2.length;
+      for (let i = 0; i < 3; i += 1) {
+        const vertexIndex = triangle.vertexIndices[i];
+        const texCoordIndex = triangle.texCoordIndices[i];
+        const texCoord = model.texCoords[texCoordIndex];
+        vertices2.push({
+          vertexIndex,
+          texCoord: normalizeUv(texCoord.s, texCoord.t, model.header)
+        });
+      }
+      indices2.push(baseIndex, baseIndex + 1, baseIndex + 2);
+    });
+    return { vertices: vertices2, indices: new Uint16Array(indices2) };
+  }
+  const vertices = [];
+  const indices = [];
+  for (const command of model.glCommands) {
+    const start = vertices.length;
+    vertices.push(
+      ...command.vertices.map((vertex) => ({
+        vertexIndex: vertex.vertexIndex,
+        texCoord: [vertex.s, 1 - vertex.t]
+      }))
+    );
+    if (command.mode === "strip") {
+      for (let i = 0; i < command.vertices.length - 2; i += 1) {
+        const even = i % 2 === 0;
+        const a = start + i + (even ? 0 : 1);
+        const b = start + i + (even ? 1 : 0);
+        const c = start + i + 2;
+        indices.push(a, b, c);
+      }
+    } else {
+      for (let i = 1; i < command.vertices.length - 1; i += 1) {
+        indices.push(start, start + i, start + i + 1);
+      }
+    }
+  }
+  return { vertices, indices: new Uint16Array(indices) };
+}
+function buildMd2VertexData(model, geometry, blend) {
+  const { currentFrame, nextFrame, lerp: lerp2 } = blend;
+  const frameA = model.frames[currentFrame];
+  const frameB = model.frames[nextFrame];
+  if (!frameA || !frameB) {
+    throw new Error("Requested MD2 frames are out of range");
+  }
+  const data = new Float32Array(geometry.vertices.length * 8);
+  geometry.vertices.forEach((vertex, index) => {
+    const vA = frameA.vertices[vertex.vertexIndex];
+    const vB = frameB.vertices[vertex.vertexIndex];
+    if (!vA || !vB) {
+      throw new Error("MD2 vertex index out of range for frame");
+    }
+    const position = lerpVec3(vA.position, vB.position, lerp2);
+    const normal = normalizeVec32(lerpVec3(vA.normal, vB.normal, lerp2));
+    const base = index * 8;
+    data[base] = position.x;
+    data[base + 1] = position.y;
+    data[base + 2] = position.z;
+    data[base + 3] = normal.x;
+    data[base + 4] = normal.y;
+    data[base + 5] = normal.z;
+    data[base + 6] = vertex.texCoord[0];
+    data[base + 7] = vertex.texCoord[1];
+  });
+  return data;
+}
+var Md2MeshBuffers = class {
+  constructor(gl, model, blend) {
+    this.gl = gl;
+    this.geometry = buildMd2Geometry(model);
+    this.vertexBuffer = new VertexBuffer(gl, gl.STATIC_DRAW);
+    this.indexBuffer = new IndexBuffer(gl, gl.STATIC_DRAW);
+    this.vertexArray = new VertexArray(gl);
+    this.indexCount = this.geometry.indices.length;
+    this.vertexArray.configureAttributes(
+      [
+        { index: 0, size: 3, type: gl.FLOAT, stride: 32, offset: 0 },
+        { index: 1, size: 3, type: gl.FLOAT, stride: 32, offset: 12 },
+        { index: 2, size: 2, type: gl.FLOAT, stride: 32, offset: 24 }
+      ],
+      this.vertexBuffer
+    );
+    this.vertexArray.bind();
+    this.indexBuffer.bind();
+    this.indexBuffer.upload(this.geometry.indices, gl.STATIC_DRAW);
+    this.update(model, blend);
+  }
+  update(model, blend) {
+    const data = buildMd2VertexData(model, this.geometry, blend);
+    this.vertexBuffer.upload(data, this.gl.STATIC_DRAW);
+  }
+  bind() {
+    this.vertexArray.bind();
+    this.indexBuffer.bind();
+  }
+  dispose() {
+    this.vertexBuffer.dispose();
+    this.indexBuffer.dispose();
+    this.vertexArray.dispose();
+  }
+};
+var Md2Pipeline = class {
+  constructor(gl) {
+    this.gl = gl;
+    this.program = ShaderProgram.create(
+      gl,
+      { vertex: MD2_VERTEX_SHADER, fragment: MD2_FRAGMENT_SHADER },
+      { a_position: 0, a_normal: 1, a_texCoord: 2 }
+    );
+    this.uniformMvp = this.program.getUniformLocation("u_modelViewProjection");
+    this.uniformLightDir = this.program.getUniformLocation("u_lightDir");
+    this.uniformTint = this.program.getUniformLocation("u_tint");
+    this.uniformDiffuse = this.program.getUniformLocation("u_diffuseMap");
+  }
+  bind(options) {
+    const { modelViewProjection, lightDirection = [0, 0, 1], tint = [1, 1, 1, 1], diffuseSampler = 0 } = options;
+    const lightVec = new Float32Array(lightDirection);
+    const tintVec = new Float32Array(tint);
+    this.program.use();
+    this.gl.uniformMatrix4fv(this.uniformMvp, false, modelViewProjection);
+    this.gl.uniform3fv(this.uniformLightDir, lightVec);
+    this.gl.uniform4fv(this.uniformTint, tintVec);
+    this.gl.uniform1i(this.uniformDiffuse, diffuseSampler);
+  }
+  draw(mesh) {
+    mesh.bind();
+    this.gl.drawElements(this.gl.TRIANGLES, mesh.indexCount, this.gl.UNSIGNED_SHORT, 0);
+  }
+  dispose() {
+    this.program.dispose();
+  }
+};
+
 // src/index.ts
 function createEngine(imports) {
   return {
@@ -1727,7 +3997,23 @@ function createEngine(imports) {
   };
 }
 export {
+  ATTN_IDLE,
+  ATTN_LOOP_NONE,
+  ATTN_NONE,
+  ATTN_NORM,
+  ATTN_STATIC,
+  AssetDependencyError,
+  AssetDependencyTracker,
+  AssetManager,
+  AudioApi,
+  AudioContextController,
+  AudioRegistry,
+  AudioRegistryError,
+  AudioSystem,
+  BSP_SURFACE_FRAGMENT_SOURCE,
+  BSP_SURFACE_VERTEX_SOURCE,
   BSP_VERTEX_LAYOUT,
+  BspSurfacePipeline,
   ConfigStringRegistry,
   Cvar,
   CvarRegistry,
@@ -1737,27 +4023,79 @@ export {
   Framebuffer,
   IndexBuffer,
   LruCache,
+  MAX_SOUND_CHANNELS,
+  MD2_FRAGMENT_SHADER,
+  MD2_VERTEX_SHADER,
   Md2Loader,
+  Md2MeshBuffers,
   Md2ParseError,
+  Md2Pipeline,
+  Md3Loader,
+  Md3ParseError,
+  MusicSystem,
   PakArchive,
+  PakIndexStore,
   PakIngestionError,
   PakParseError,
+  PakValidationError,
+  PakValidator,
+  RERELEASE_KNOWN_PAKS,
+  SKYBOX_FRAGMENT_SHADER,
+  SKYBOX_VERTEX_SHADER,
+  SOUND_FULLVOLUME,
+  SOUND_LOOP_ATTENUATE,
   ShaderProgram,
+  SkyboxPipeline,
+  SoundChannel,
+  SoundPrecache,
+  SoundRegistry,
   Texture2D,
+  TextureCache,
+  TextureCubeMap,
   VertexArray,
   VertexBuffer,
   VirtualFileSystem,
+  advanceAnimation,
+  applySurfaceState,
+  attenuationToDistanceMultiplier,
+  boxIntersectsFrustum,
   buildBspGeometry,
+  buildMd2Geometry,
+  buildMd2VertexData,
+  calculateMaxAudibleDistance,
   calculatePakChecksum,
+  computeFrameBlend,
+  computeSkyScroll,
+  createAnimationState,
+  createAudioGraph,
   createEngine,
   createEngineRuntime,
+  createInitialChannels,
   createProgramFromSources,
   createWebGLContext,
+  decodeOgg,
+  deriveSurfaceRenderState,
+  extractFrustumPlanes,
   filesToPakSources,
+  findLeafForPoint,
+  gatherVisibleFaces,
   groupMd2Animations,
   ingestPakFiles,
   ingestPaks,
+  interpolateVec3,
   parseMd2,
+  parseMd3,
+  parsePcx,
+  parseWal,
+  parseWalTexture,
+  parseWav,
+  pcxToRgba,
+  pickChannel,
+  preparePcxTexture,
+  removeViewTranslation,
+  resolveLightStyles,
+  spatializeOrigin,
+  walToRgba,
   wireDropTarget,
   wireFileInput
 };