quake2ts 0.0.512 → 0.0.513

package/packages/engine/dist/cjs/index.cjs

@@ -49,6 +49,7 @@ __export(index_exports, {
   CvarRegistry: () => CvarRegistry,
   DemoAnalyzer: () => DemoAnalyzer,
   DemoCameraMode: () => DemoCameraMode,
+  DemoClipper: () => DemoClipper,
   DemoEventType: () => DemoEventType,
   DemoPlaybackController: () => DemoPlaybackController,
   DemoReader: () => DemoReader,
@@ -88,10 +89,13 @@ __export(index_exports, {
   PakParseError: () => PakParseError,
   PakValidationError: () => PakValidationError,
   PakValidator: () => PakValidator,
+  PakWriter: () => PakWriter,
   ParticleRenderer: () => ParticleRenderer,
   ParticleSystem: () => ParticleSystem,
   PlaybackState: () => PlaybackState,
   RERELEASE_KNOWN_PAKS: () => RERELEASE_KNOWN_PAKS,
+  ResourceLoadTracker: () => ResourceLoadTracker,
+  ResourceType: () => ResourceType,
   SKYBOX_FRAGMENT_SHADER: () => SKYBOX_FRAGMENT_SHADER,
   SKYBOX_VERTEX_SHADER: () => SKYBOX_VERTEX_SHADER,
   SOUND_FULLVOLUME: () => SOUND_FULLVOLUME,
@@ -141,6 +145,7 @@ __export(index_exports, {
   VertexBuffer: () => VertexBuffer,
   VirtualFileSystem: () => VirtualFileSystem,
   advanceAnimation: () => advanceAnimation,
+  applyEntityDelta: () => applyEntityDelta,
   applySurfaceState: () => applySurfaceState,
   attenuationToDistanceMultiplier: () => attenuationToDistanceMultiplier,
   boxIntersectsFrustum: () => boxIntersectsFrustum,
@@ -2012,7 +2017,7 @@ var PakArchive = class _PakArchive {
     if (dirOffset < HEADER_SIZE) {
       throw new PakParseError(`Invalid directory offset: ${dirOffset}`);
     }
-    if (dirLength <= 0 || dirLength % DIRECTORY_ENTRY_SIZE !== 0) {
+    if (dirLength < 0 || dirLength % DIRECTORY_ENTRY_SIZE !== 0) {
       throw new PakParseError(`Invalid directory length: ${dirLength}`);
     }
     const dirEnd = dirOffset + dirLength;
@@ -2066,6 +2071,136 @@ function calculatePakChecksum(buffer) {
   return crc32(new Uint8Array(buffer));
 }
 
+// src/assets/pakWriter.ts
+var HEADER_SIZE2 = 12;
+var DIRECTORY_ENTRY_SIZE2 = 64;
+var PakWriter = class _PakWriter {
+  constructor() {
+    this.files = /* @__PURE__ */ new Map();
+  }
+  addFile(path, data) {
+    const normalized = normalizePath(path);
+    if (!normalized) {
+      throw new Error(`Invalid path: ${path}`);
+    }
+    if (normalized.length > 56) {
+      throw new Error(`Path too long: ${path} (max 56 chars)`);
+    }
+    this.files.set(normalized, data);
+  }
+  removeFile(path) {
+    const normalized = normalizePath(path);
+    return this.files.delete(normalized);
+  }
+  build() {
+    let currentOffset = HEADER_SIZE2;
+    const sortedPaths = Array.from(this.files.keys()).sort();
+    const directorySize = sortedPaths.length * DIRECTORY_ENTRY_SIZE2;
+    let fileDataSize = 0;
+    for (const path of sortedPaths) {
+      fileDataSize += this.files.get(path).byteLength;
+    }
+    const totalSize = HEADER_SIZE2 + fileDataSize + directorySize;
+    const buffer = new Uint8Array(totalSize);
+    const view = new DataView(buffer.buffer);
+    view.setUint8(0, "P".charCodeAt(0));
+    view.setUint8(1, "A".charCodeAt(0));
+    view.setUint8(2, "C".charCodeAt(0));
+    view.setUint8(3, "K".charCodeAt(0));
+    const directoryOffset = HEADER_SIZE2 + fileDataSize;
+    view.setInt32(4, directoryOffset, true);
+    view.setInt32(8, directorySize, true);
+    let fileOffset = HEADER_SIZE2;
+    let dirEntryOffset = directoryOffset;
+    for (const path of sortedPaths) {
+      const data = this.files.get(path);
+      buffer.set(data, fileOffset);
+      for (let i = 0; i < 56; i++) {
+        if (i < path.length) {
+          view.setUint8(dirEntryOffset + i, path.charCodeAt(i));
+        } else {
+          view.setUint8(dirEntryOffset + i, 0);
+        }
+      }
+      view.setInt32(dirEntryOffset + 56, fileOffset, true);
+      view.setInt32(dirEntryOffset + 60, data.byteLength, true);
+      fileOffset += data.byteLength;
+      dirEntryOffset += DIRECTORY_ENTRY_SIZE2;
+    }
+    return buffer;
+  }
+  static buildFromEntries(entries) {
+    const writer = new _PakWriter();
+    for (const [path, data] of entries) {
+      writer.addFile(path, data);
+    }
+    return writer.build();
+  }
+};
+
+// src/assets/resourceTracker.ts
+var ResourceType = /* @__PURE__ */ ((ResourceType2) => {
+  ResourceType2["Texture"] = "texture";
+  ResourceType2["Sound"] = "sound";
+  ResourceType2["Model"] = "model";
+  ResourceType2["Map"] = "map";
+  ResourceType2["Sprite"] = "sprite";
+  ResourceType2["ConfigString"] = "configString";
+  return ResourceType2;
+})(ResourceType || {});
+var ResourceLoadTracker = class {
+  constructor() {
+    this.tracking = false;
+    this.entries = [];
+    this.currentFrame = 0;
+    this.currentTime = 0;
+  }
+  startTracking() {
+    this.tracking = true;
+    this.entries = [];
+  }
+  stopTracking() {
+    this.tracking = false;
+    const log = {
+      byFrame: /* @__PURE__ */ new Map(),
+      byTime: /* @__PURE__ */ new Map(),
+      uniqueResources: /* @__PURE__ */ new Map()
+    };
+    for (const entry of this.entries) {
+      if (!log.byFrame.has(entry.frame)) {
+        log.byFrame.set(entry.frame, []);
+      }
+      log.byFrame.get(entry.frame).push(entry);
+      if (!log.byTime.has(entry.timestamp)) {
+        log.byTime.set(entry.timestamp, []);
+      }
+      log.byTime.get(entry.timestamp).push(entry);
+      const key = `${entry.type}:${entry.path}`;
+      if (!log.uniqueResources.has(key)) {
+        log.uniqueResources.set(key, entry);
+      }
+    }
+    return log;
+  }
+  recordLoad(type, path, size, pakSource) {
+    if (!this.tracking) return;
+    this.entries.push({
+      type,
+      path,
+      timestamp: this.currentTime,
+      frame: this.currentFrame,
+      size,
+      pakSource
+    });
+  }
+  setCurrentFrame(frame) {
+    this.currentFrame = frame;
+  }
+  setCurrentTime(time) {
+    this.currentTime = time;
+  }
+};
+
 // src/assets/vfs.ts
 var VirtualFileSystem = class {
   constructor(archives = []) {
@@ -2590,7 +2725,7 @@ function wireFileInput(input, handler) {
 var BSP_MAGIC = "IBSP";
 var BSP_VERSION = 38;
 var HEADER_LUMPS = 19;
-var HEADER_SIZE2 = 4 + 4 + HEADER_LUMPS * 8;
+var HEADER_SIZE3 = 4 + 4 + HEADER_LUMPS * 8;
 var BspParseError = class extends Error {
 };
 var BspLoader = class {
@@ -2605,7 +2740,7 @@ var BspLoader = class {
   }
 };
 function parseBsp(buffer) {
-  if (buffer.byteLength < HEADER_SIZE2) {
+  if (buffer.byteLength < HEADER_SIZE3) {
     throw new BspParseError("BSP too small to contain header");
   }
   const view = new DataView(buffer);
@@ -3058,7 +3193,7 @@ function createFaceLightmap(face, lightMaps, info) {
 // src/assets/md2.ts
 var MD2_MAGIC = 844121161;
 var MD2_VERSION = 8;
-var HEADER_SIZE3 = 17 * 4;
+var HEADER_SIZE4 = 17 * 4;
 var MD2_NORMALS = [
   { x: -0.525731, y: 0, z: 0.850651 },
   { x: -0.442863, y: 0.238856, z: 0.864188 },
@@ -3256,12 +3391,12 @@ function readCString2(view, offset, maxLength) {
 }
 function validateSection(buffer, offset, length, label) {
   if (length === 0) return;
-  if (offset < HEADER_SIZE3 || offset + length > buffer.byteLength) {
+  if (offset < HEADER_SIZE4 || offset + length > buffer.byteLength) {
     throw new Md2ParseError(`${label} section is out of bounds`);
   }
 }
 function parseHeader(buffer) {
-  if (buffer.byteLength < HEADER_SIZE3) {
+  if (buffer.byteLength < HEADER_SIZE4) {
     throw new Md2ParseError("MD2 buffer too small to contain header");
   }
   const view = new DataView(buffer);
@@ -3698,7 +3833,7 @@ var Md3Loader = class {
 var IDSPRITEHEADER = 844317769;
 var SPRITE_VERSION = 2;
 var MAX_SKINNAME = 64;
-var HEADER_SIZE4 = 12;
+var HEADER_SIZE5 = 12;
 var SpriteParseError = class extends Error {
 };
 function readCString3(view, offset, maxLength) {
@@ -3711,7 +3846,7 @@ function readCString3(view, offset, maxLength) {
   return String.fromCharCode(...chars);
 }
 function parseSprite(buffer) {
-  if (buffer.byteLength < HEADER_SIZE4) {
+  if (buffer.byteLength < HEADER_SIZE5) {
     throw new SpriteParseError("Sprite buffer too small to contain header");
   }
   const view = new DataView(buffer);
@@ -3726,7 +3861,7 @@ function parseSprite(buffer) {
   }
   const frames = [];
   const frameSize = 16 + MAX_SKINNAME;
-  let offset = HEADER_SIZE4;
+  let offset = HEADER_SIZE5;
   for (let i = 0; i < numFrames; i += 1) {
     if (offset + frameSize > buffer.byteLength) {
       throw new SpriteParseError("Sprite frame data exceeds buffer length");
@@ -4442,6 +4577,7 @@ var AssetManager = class {
     this.textures = new TextureCache({ capacity: options.textureCacheCapacity ?? 128 });
     this.audio = new AudioRegistry(vfs, { cacheSize: options.audioCacheSize ?? 64 });
     this.dependencyTracker = options.dependencyTracker ?? new AssetDependencyTracker();
+    this.resourceTracker = options.resourceTracker;
     this.md2 = new Md2Loader(vfs);
     this.md3 = new Md3Loader(vfs);
     this.sprite = new SpriteLoader(vfs);
@@ -4478,6 +4614,9 @@ var AssetManager = class {
     this.dependencyTracker.markLoaded(key);
   }
   async loadTexture(path) {
+    if (this.resourceTracker) {
+      this.resourceTracker.recordLoad("texture" /* Texture */, path);
+    }
     const cached = this.textures.get(path);
     if (cached) return cached;
     const buffer = await this.vfs.readFile(path);
@@ -4496,6 +4635,9 @@ var AssetManager = class {
     return texture;
   }
   async loadSound(path) {
+    if (this.resourceTracker) {
+      this.resourceTracker.recordLoad("sound" /* Sound */, path);
+    }
     const audio = await this.audio.load(path);
     const key = this.makeKey("sound", path);
     this.dependencyTracker.register(key);
@@ -4503,6 +4645,9 @@ var AssetManager = class {
     return audio;
   }
   async loadMd2Model(path, textureDependencies = []) {
+    if (this.resourceTracker) {
+      this.resourceTracker.recordLoad("model" /* Model */, path);
+    }
     const modelKey = this.makeKey("model", path);
     const dependencyKeys = textureDependencies.map((dep) => this.makeKey("texture", dep));
     this.dependencyTracker.register(modelKey, dependencyKeys);
@@ -4515,9 +4660,15 @@ var AssetManager = class {
     return model;
   }
   getMd2Model(path) {
+    if (this.resourceTracker) {
+      this.resourceTracker.recordLoad("model" /* Model */, path);
+    }
     return this.md2.get(path);
   }
   async loadMd3Model(path, textureDependencies = []) {
+    if (this.resourceTracker) {
+      this.resourceTracker.recordLoad("model" /* Model */, path);
+    }
     const modelKey = this.makeKey("model", path);
     const dependencyKeys = textureDependencies.map((dep) => this.makeKey("texture", dep));
     this.dependencyTracker.register(modelKey, dependencyKeys);
@@ -4530,9 +4681,15 @@ var AssetManager = class {
     return model;
   }
   getMd3Model(path) {
+    if (this.resourceTracker) {
+      this.resourceTracker.recordLoad("model" /* Model */, path);
+    }
     return this.md3.get(path);
   }
   async loadSprite(path) {
+    if (this.resourceTracker) {
+      this.resourceTracker.recordLoad("sprite" /* Sprite */, path);
+    }
     const spriteKey = this.makeKey("sprite", path);
     this.dependencyTracker.register(spriteKey);
     const sprite = await this.sprite.load(path);
@@ -4540,6 +4697,9 @@ var AssetManager = class {
     return sprite;
   }
   async loadMap(path) {
+    if (this.resourceTracker) {
+      this.resourceTracker.recordLoad("map" /* Map */, path);
+    }
     const mapKey = this.makeKey("map", path);
     if (this.maps.has(path)) {
       return this.maps.get(path);
@@ -13607,6 +13767,8 @@ var DemoPlaybackController = class {
     this.cachedStatistics = null;
     this.cachedPlayerStats = null;
     this.cachedWeaponStats = null;
+    // Resource Tracking
+    this.tracker = null;
     // Camera State
     this.cameraMode = 0 /* FirstPerson */;
     this.thirdPersonDistance = 80;
@@ -13720,6 +13882,41 @@ var DemoPlaybackController = class {
   seekToFrame(frameIndex) {
     this.seek(frameIndex);
   }
+  frameToTime(frame) {
+    return frame * this.frameDuration / 1e3;
+  }
+  timeToFrame(seconds) {
+    return Math.floor(seconds * 1e3 / this.frameDuration);
+  }
+  playFrom(offset) {
+    if (offset.type === "frame") {
+      this.seek(offset.frame);
+    } else {
+      this.seekToTime(offset.seconds);
+    }
+    this.play();
+  }
+  playRange(start, end) {
+    this.playFrom(start);
+    const endFrame = end.type === "frame" ? end.frame : this.timeToFrame(end.seconds);
+    const originalOnFrameUpdate = this.callbacks?.onFrameUpdate;
+    const rangeCallback = {
+      ...this.callbacks,
+      onFrameUpdate: (frame) => {
+        if (originalOnFrameUpdate) originalOnFrameUpdate(frame);
+        if (this.currentFrameIndex >= endFrame) {
+          this.pause();
+          if (this.callbacks === rangeCallback) {
+            this.setCallbacks({ ...this.callbacks, onFrameUpdate: originalOnFrameUpdate });
+          }
+          if (this.callbacks?.onPlaybackComplete) {
+            this.callbacks.onPlaybackComplete();
+          }
+        }
+      }
+    };
+    this.setCallbacks(rangeCallback);
+  }
   /**
    * Seeks to a specific frame number.
    */
@@ -13797,6 +13994,10 @@ var DemoPlaybackController = class {
       return false;
     }
     this.currentFrameIndex++;
+    if (this.tracker) {
+      this.tracker.setCurrentFrame(this.currentFrameIndex);
+      this.tracker.setCurrentTime(this.getCurrentTime());
+    }
     try {
       const proxyHandler = {
         ...this.handler,
@@ -14031,6 +14232,93 @@ var DemoPlaybackController = class {
   setThirdPersonOffset(offset) {
     this.thirdPersonOffset = offset;
   }
+  async playWithTracking(tracker, options = {}) {
+    this.tracker = tracker;
+    tracker.startTracking();
+    if (options.fastForward) {
+      try {
+        if (this.state === 0 /* Stopped */ && this.reader) {
+        }
+        this.transitionState(1 /* Playing */);
+        const CHUNK_SIZE = 100;
+        const processChunk = async () => {
+          if (this.state !== 1 /* Playing */) {
+            throw new Error("Playback stopped unexpectedly during fast forward");
+          }
+          let count = 0;
+          while (count < CHUNK_SIZE) {
+            if (!this.processNextFrame()) {
+              const log = tracker.stopTracking();
+              this.tracker = null;
+              if (this.callbacks?.onPlaybackComplete) this.callbacks.onPlaybackComplete();
+              return log;
+            }
+            count++;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 0));
+          return processChunk();
+        };
+        return await processChunk();
+      } catch (e) {
+        tracker.stopTracking();
+        this.tracker = null;
+        throw e;
+      }
+    } else {
+      return new Promise((resolve, reject) => {
+        const originalComplete = this.callbacks?.onPlaybackComplete;
+        const originalError = this.callbacks?.onPlaybackError;
+        const cleanup = () => {
+          this.setCallbacks({ ...this.callbacks, onPlaybackComplete: originalComplete, onPlaybackError: originalError });
+          this.tracker = null;
+        };
+        this.setCallbacks({
+          ...this.callbacks,
+          onPlaybackComplete: () => {
+            const log = tracker.stopTracking();
+            if (originalComplete) originalComplete();
+            cleanup();
+            resolve(log);
+          },
+          onPlaybackError: (err2) => {
+            tracker.stopTracking();
+            if (originalError) originalError(err2);
+            cleanup();
+            reject(err2);
+          }
+        });
+        this.play();
+      });
+    }
+  }
+  async playRangeWithTracking(start, end, tracker) {
+    this.tracker = tracker;
+    tracker.startTracking();
+    return new Promise((resolve, reject) => {
+      const originalComplete = this.callbacks?.onPlaybackComplete;
+      const originalError = this.callbacks?.onPlaybackError;
+      const cleanup = () => {
+        this.setCallbacks({ ...this.callbacks, onPlaybackComplete: originalComplete, onPlaybackError: originalError });
+        this.tracker = null;
+      };
+      this.setCallbacks({
+        ...this.callbacks,
+        onPlaybackComplete: () => {
+          const log = tracker.stopTracking();
+          if (originalComplete) originalComplete();
+          cleanup();
+          resolve(log);
+        },
+        onPlaybackError: (err2) => {
+          tracker.stopTracking();
+          if (originalError) originalError(err2);
+          cleanup();
+          reject(err2);
+        }
+      });
+      this.playRange(start, end);
+    });
+  }
 };
 
 // src/demo/recorder.ts
@@ -14106,6 +14394,165 @@ var DemoValidator = class {
   }
 };
 
+// src/demo/delta.ts
+function applyEntityDelta(to, from) {
+  const bits = from.bits;
+  const bitsHigh = from.bitsHigh;
+  to.number = from.number;
+  if (bits & U_MODEL5) to.modelindex = from.modelindex;
+  if (bits & U_MODEL22) to.modelindex2 = from.modelindex2;
+  if (bits & U_MODEL32) to.modelindex3 = from.modelindex3;
+  if (bits & U_MODEL42) to.modelindex4 = from.modelindex4;
+  if (bits & U_FRAME8) to.frame = from.frame;
+  if (bits & U_FRAME16) to.frame = from.frame;
+  if (bits & U_SKIN8 || bits & U_SKIN16) to.skinnum = from.skinnum;
+  if (bits & U_EFFECTS8 || bits & U_EFFECTS16) to.effects = from.effects;
+  if (bits & U_RENDERFX8 || bits & U_RENDERFX16) to.renderfx = from.renderfx;
+  if (bits & U_ORIGIN12) to.origin.x = from.origin.x;
+  if (bits & U_ORIGIN22) to.origin.y = from.origin.y;
+  if (bits & U_ORIGIN32) to.origin.z = from.origin.z;
+  if (bits & U_ANGLE12) to.angles.x = from.angles.x;
+  if (bits & U_ANGLE22) to.angles.y = from.angles.y;
+  if (bits & U_ANGLE32) to.angles.z = from.angles.z;
+  if (bits & U_OLDORIGIN) {
+    to.old_origin.x = from.old_origin.x;
+    to.old_origin.y = from.old_origin.y;
+    to.old_origin.z = from.old_origin.z;
+  }
+  if (bits & U_SOUND2) to.sound = from.sound;
+  if (bits & U_EVENT2) to.event = from.event;
+  if (bits & U_SOLID2) to.solid = from.solid;
+  if (bits & U_ALPHA) to.alpha = from.alpha;
+  if (bits & U_SCALE) to.scale = from.scale;
+  if (bits & U_INSTANCE_BITS) to.instanceBits = from.instanceBits;
+  if (bits & U_LOOP_VOLUME) to.loopVolume = from.loopVolume;
+  if (bitsHigh & U_LOOP_ATTENUATION_HIGH) to.loopAttenuation = from.loopAttenuation;
+  if (bitsHigh & U_OWNER_HIGH) to.owner = from.owner;
+  if (bitsHigh & U_OLD_FRAME_HIGH) to.oldFrame = from.oldFrame;
+}
+
+// src/demo/clipper.ts
+var DemoClipper = class {
+  static extractClip(demoData, startFrame, endFrame) {
+    const reader = new DemoReader(demoData);
+    if (!reader.seekToMessage(startFrame)) {
+      throw new Error(`Start frame ${startFrame} out of bounds`);
+    }
+    const startOffset = reader.getOffset();
+    let endOffset = demoData.byteLength;
+    if (endFrame < reader.getMessageCount()) {
+      if (reader.seekToMessage(endFrame)) {
+        endOffset = reader.getOffset();
+      }
+    }
+    const length = endOffset - startOffset;
+    const result = new Uint8Array(length + 4);
+    const sourceView = new Uint8Array(demoData);
+    result.set(sourceView.subarray(startOffset, endOffset), 0);
+    const view = new DataView(result.buffer);
+    view.setInt32(length, -1, true);
+    return result;
+  }
+  static async captureWorldState(demoData, atFrame) {
+    const reader = new DemoReader(demoData);
+    const configStrings = /* @__PURE__ */ new Map();
+    const entityBaselines = /* @__PURE__ */ new Map();
+    let serverData = null;
+    let playerState = createEmptyProtocolPlayerState();
+    const entities = /* @__PURE__ */ new Map();
+    let currentFrame = -1;
+    const handler = {
+      onServerData: (protocol, serverCount, attractLoop, gameDir, playerNum, levelName, tickRate, demoType) => {
+        serverData = {
+          protocolVersion: protocol,
+          serverCount,
+          attractLoop: attractLoop !== 0,
+          gameDirectory: gameDir,
+          levelName
+        };
+      },
+      onConfigString: (index, str) => {
+        configStrings.set(index, str);
+      },
+      onSpawnBaseline: (entity) => {
+        entityBaselines.set(entity.number, entity);
+      },
+      onFrame: (frameData) => {
+        playerState = frameData.playerState;
+        const packetEntities = frameData.packetEntities;
+        if (!packetEntities.delta) {
+          entities.clear();
+        }
+        for (const partial of packetEntities.entities) {
+          if (partial.bits & U_REMOVE2) {
+            entities.delete(partial.number);
+            continue;
+          }
+          const number = partial.number;
+          let source;
+          if (packetEntities.delta && entities.has(number)) {
+            source = entities.get(number);
+          } else if (entityBaselines.has(number)) {
+            source = entityBaselines.get(number);
+          } else {
+            source = createEmptyEntityState();
+          }
+          const final = structuredClone(source);
+          applyEntityDelta(final, partial);
+          entities.set(number, final);
+        }
+      },
+      onCenterPrint: () => {
+      },
+      onStuffText: () => {
+      },
+      onSound: () => {
+      },
+      onPrint: () => {
+      },
+      onMuzzleFlash: () => {
+      },
+      onMuzzleFlash2: () => {
+      },
+      onTempEntity: () => {
+      },
+      onLayout: () => {
+      },
+      onInventory: () => {
+      },
+      onDisconnect: () => {
+      },
+      onReconnect: () => {
+      },
+      onDownload: () => {
+      }
+    };
+    while (reader.hasMore()) {
+      if (currentFrame >= atFrame) {
+        break;
+      }
+      const block = reader.readNextBlock();
+      if (!block) break;
+      currentFrame++;
+      const parser = new NetworkMessageParser(block.data, handler);
+      const currentProtocol = serverData ? serverData.protocolVersion : 34;
+      parser.setProtocolVersion(currentProtocol);
+      parser.parseMessage();
+    }
+    return {
+      serverData,
+      configStrings,
+      entityBaselines,
+      playerState,
+      entities,
+      gameTime: 0
+    };
+  }
+  static extractStandaloneClip(demoData, startFrame, endFrame, worldState) {
+    throw new Error("extractStandaloneClip not fully implemented: requires NetworkMessageWriter");
+  }
+};
+
 // src/assets/fileType.ts
 var FileType = /* @__PURE__ */ ((FileType2) => {
   FileType2["Unknown"] = "unknown";
@@ -14484,6 +14931,7 @@ function createEngine(imports) {
   CvarRegistry,
   DemoAnalyzer,
   DemoCameraMode,
+  DemoClipper,
   DemoEventType,
   DemoPlaybackController,
   DemoReader,
@@ -14523,10 +14971,13 @@ function createEngine(imports) {
   PakParseError,
   PakValidationError,
   PakValidator,
+  PakWriter,
   ParticleRenderer,
   ParticleSystem,
   PlaybackState,
   RERELEASE_KNOWN_PAKS,
+  ResourceLoadTracker,
+  ResourceType,
   SKYBOX_FRAGMENT_SHADER,
   SKYBOX_VERTEX_SHADER,
   SOUND_FULLVOLUME,
@@ -14576,6 +15027,7 @@ function createEngine(imports) {
   VertexBuffer,
   VirtualFileSystem,
   advanceAnimation,
+  applyEntityDelta,
   applySurfaceState,
   attenuationToDistanceMultiplier,
   boxIntersectsFrustum,