quake2ts 0.0.565 → 0.0.567

package/packages/engine/dist/types/render/webgpu/context.d.ts

@@ -0,0 +1,27 @@
+export interface WebGPUContextOptions {
+    powerPreference?: GPUPowerPreference;
+    requiredFeatures?: GPUFeatureName[];
+    requiredLimits?: Record<string, number>;
+}
+export interface WebGPUContextState {
+    adapter: GPUAdapter;
+    device: GPUDevice;
+    context?: GPUCanvasContext;
+    format: GPUTextureFormat;
+    features: Set<GPUFeatureName>;
+    limits: GPUSupportedLimits;
+    isHeadless: boolean;
+}
+/**
+ * Creates and initializes a WebGPU context.
+ *
+ * Handles adapter selection, device creation, and context configuration.
+ * Supports both browser (canvas) and headless environments.
+ *
+ * @param canvas - Optional canvas element for rendering. If omitted, assumes headless mode.
+ * @param options - Configuration options for device creation.
+ * @returns Initialized WebGPU context state.
+ * @throws Error if WebGPU is not supported or device creation fails.
+ */
+export declare function createWebGPUContext(canvas?: HTMLCanvasElement, options?: WebGPUContextOptions): Promise<WebGPUContextState>;
+//# sourceMappingURL=context.d.ts.map

package/packages/engine/dist/types/render/webgpu/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/render/webgpu/context.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACnC,eAAe,CAAC,EAAE,kBAAkB,CAAC;IACrC,gBAAgB,CAAC,EAAE,cAAc,EAAE,CAAC;IACpC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAGD,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;IAC9B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,CAAC,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CAsE7B"}

package/packages/test-utils/dist/index.cjs

@@ -52,6 +52,9 @@ __export(index_exports, {
   createMockCanvasContext2D: () => createMockCanvasContext2D,
   createMockConnection: () => createMockConnection,
   createMockEngine: () => createMockEngine,
+  createMockGPUAdapter: () => createMockGPUAdapter,
+  createMockGPUCanvasContext: () => createMockGPUCanvasContext,
+  createMockGPUDevice: () => createMockGPUDevice,
   createMockGame: () => createMockGame,
   createMockGameState: () => createMockGameState,
   createMockHandshake: () => createMockHandshake,
@@ -62,8 +65,10 @@ __export(index_exports, {
   createMockNetworkAddress: () => createMockNetworkAddress,
   createMockPerformance: () => createMockPerformance,
   createMockRAF: () => createMockRAF,
+  createMockRConClient: () => createMockRConClient,
   createMockServer: () => createMockServer,
   createMockServerClient: () => createMockServerClient,
+  createMockServerConsole: () => createMockServerConsole,
   createMockServerState: () => createMockServerState,
   createMockServerStatic: () => createMockServerStatic,
   createMockSessionStorage: () => createMockSessionStorage,
@@ -93,6 +98,7 @@ __export(index_exports, {
   setupBrowserEnvironment: () => setupBrowserEnvironment,
   setupMockAudioContext: () => setupMockAudioContext,
   setupNodeEnvironment: () => setupNodeEnvironment,
+  setupWebGPUMocks: () => setupWebGPUMocks,
   simulateFrames: () => simulateFrames,
   simulateFramesWithMock: () => simulateFramesWithMock,
   simulateHandshake: () => simulateHandshake,
@@ -100,6 +106,7 @@ __export(index_exports, {
   simulatePlayerInput: () => simulatePlayerInput,
   simulatePlayerJoin: () => simulatePlayerJoin,
   simulatePlayerLeave: () => simulatePlayerLeave,
+  simulateServerCommand: () => simulateServerCommand,
   simulateServerTick: () => simulateServerTick,
   simulateSnapshotDelivery: () => simulateSnapshotDelivery,
   stairTrace: () => import_shared3.stairTrace,
@@ -769,6 +776,52 @@ async function simulateHandshake(client, server) {
   return true;
 }
 
+// src/server/mocks/commands.ts
+var import_vitest5 = require("vitest");
+function createMockServerConsole(overrides) {
+  const outputBuffer = [];
+  const commandBuffer = [];
+  return {
+    exec: import_vitest5.vi.fn((cmd) => {
+      commandBuffer.push(cmd);
+      return `Executed: ${cmd}`;
+    }),
+    print: import_vitest5.vi.fn((text) => {
+      outputBuffer.push(text);
+    }),
+    broadcast: import_vitest5.vi.fn((text) => {
+      outputBuffer.push(`Broadcast: ${text}`);
+    }),
+    commandBuffer,
+    outputBuffer,
+    ...overrides
+  };
+}
+function createMockRConClient(password = "") {
+  return {
+    connected: false,
+    lastCommand: "",
+    lastResponse: "",
+    connect: import_vitest5.vi.fn(async (address, port, pwd) => {
+      return pwd === password;
+    }),
+    sendCommand: import_vitest5.vi.fn(async (cmd) => {
+      return `RCON Response for: ${cmd}`;
+    }),
+    disconnect: import_vitest5.vi.fn()
+  };
+}
+function simulateServerCommand(server, command) {
+  if (server.executeBuffer) {
+    server.executeBuffer(command);
+    return "Executed";
+  }
+  if (server.exec) {
+    return server.exec(command);
+  }
+  return "Unknown command handler";
+}
+
 // src/server/helpers/multiplayer.ts
 var import_server3 = require("@quake2ts/server");
 function createMultiplayerTestScenario(numPlayers = 2) {
@@ -1397,193 +1450,67 @@ function createMockImage(width, height, src) {
   return img;
 }
 
-// src/setup/node.ts
-function setupNodeEnvironment(options = {}) {
-  if (options.polyfillFetch && typeof global.fetch === "undefined") {
-  }
-}
-
-// src/setup/storage.ts
-var import_auto2 = require("fake-indexeddb/auto");
-function createMockLocalStorage(initialData = {}) {
-  const storage = new Map(Object.entries(initialData));
+// src/engine/mocks/webgpu.ts
+var import_vitest6 = require("vitest");
+function createMockGPUAdapter() {
   return {
-    getItem: (key) => storage.get(key) || null,
-    setItem: (key, value) => storage.set(key, value),
-    removeItem: (key) => storage.delete(key),
-    clear: () => storage.clear(),
-    key: (index) => Array.from(storage.keys())[index] || null,
-    get length() {
-      return storage.size;
-    }
+    requestDevice: import_vitest6.vi.fn().mockResolvedValue(createMockGPUDevice()),
+    features: /* @__PURE__ */ new Set(),
+    limits: {}
   };
 }
-function createMockSessionStorage(initialData = {}) {
-  return createMockLocalStorage(initialData);
-}
-function createMockIndexedDB() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
-  }
-  return indexedDB;
+function createMockGPUDevice() {
+  return {
+    features: /* @__PURE__ */ new Set(),
+    limits: {},
+    queue: {
+      submit: import_vitest6.vi.fn(),
+      writeBuffer: import_vitest6.vi.fn(),
+      writeTexture: import_vitest6.vi.fn(),
+      copyExternalImageToTexture: import_vitest6.vi.fn()
+    },
+    createCommandEncoder: import_vitest6.vi.fn().mockReturnValue({
+      beginRenderPass: import_vitest6.vi.fn().mockReturnValue({
+        setPipeline: import_vitest6.vi.fn(),
+        draw: import_vitest6.vi.fn(),
+        end: import_vitest6.vi.fn()
+      }),
+      finish: import_vitest6.vi.fn()
+    }),
+    createRenderPipeline: import_vitest6.vi.fn(),
+    createShaderModule: import_vitest6.vi.fn(),
+    createBindGroup: import_vitest6.vi.fn(),
+    createBindGroupLayout: import_vitest6.vi.fn(),
+    createBuffer: import_vitest6.vi.fn(),
+    createTexture: import_vitest6.vi.fn(),
+    createSampler: import_vitest6.vi.fn()
+  };
 }
-function createStorageTestScenario(storageType = "local") {
-  if (storageType === "indexed") {
-    const dbName = `test-db-${Math.random().toString(36).substring(7)}`;
-    const storeName = "test-store";
-    const storage2 = createMockIndexedDB();
-    return {
-      storage: storage2,
-      populate: async (data) => {
-        return new Promise((resolve, reject) => {
-          const req = storage2.open(dbName, 1);
-          req.onupgradeneeded = (e) => {
-            const db = e.target.result;
-            db.createObjectStore(storeName);
-          };
-          req.onsuccess = (e) => {
-            const db = e.target.result;
-            const tx = db.transaction(storeName, "readwrite");
-            const store = tx.objectStore(storeName);
-            Object.entries(data).forEach(([k, v]) => store.put(v, k));
-            tx.oncomplete = () => {
-              db.close();
-              resolve();
-            };
-            tx.onerror = () => reject(tx.error);
-          };
-          req.onerror = () => reject(req.error);
-        });
-      },
-      verify: async (key, value) => {
-        return new Promise((resolve, reject) => {
-          const req = storage2.open(dbName, 1);
-          req.onsuccess = (e) => {
-            const db = e.target.result;
-            if (!db.objectStoreNames.contains(storeName)) {
-              db.close();
-              resolve(false);
-              return;
-            }
-            const tx = db.transaction(storeName, "readonly");
-            const store = tx.objectStore(storeName);
-            const getReq = store.get(key);
-            getReq.onsuccess = () => {
-              const result = getReq.result === value;
-              db.close();
-              resolve(result);
-            };
-            getReq.onerror = () => {
-              db.close();
-              resolve(false);
-            };
-          };
-          req.onerror = () => reject(req.error);
-        });
-      }
-    };
-  }
-  const storage = storageType === "local" ? createMockLocalStorage() : createMockSessionStorage();
+function createMockGPUCanvasContext() {
   return {
-    storage,
-    populate(data) {
-      Object.entries(data).forEach(([k, v]) => storage.setItem(k, v));
-    },
-    verify(key, value) {
-      return storage.getItem(key) === value;
-    }
+    configure: import_vitest6.vi.fn(),
+    unconfigure: import_vitest6.vi.fn(),
+    getCurrentTexture: import_vitest6.vi.fn()
   };
 }
-
-// src/setup/audio.ts
-function createMockAudioContext() {
-  const context = {
-    createGain: () => ({
-      connect: () => {
-      },
-      gain: { value: 1, setValueAtTime: () => {
-      } }
-    }),
-    createOscillator: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      frequency: { value: 440 }
-    }),
-    createBufferSource: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      buffer: null,
-      playbackRate: { value: 1 },
-      loop: false
-    }),
-    destination: {},
-    currentTime: 0,
-    state: "running",
-    resume: async () => {
-    },
-    suspend: async () => {
-    },
-    close: async () => {
-    },
-    decodeAudioData: async (buffer) => ({
-      duration: 1,
-      length: 44100,
-      sampleRate: 44100,
-      numberOfChannels: 2,
-      getChannelData: () => new Float32Array(44100)
-    }),
-    createBuffer: (channels, length, sampleRate) => ({
-      duration: length / sampleRate,
-      length,
-      sampleRate,
-      numberOfChannels: channels,
-      getChannelData: () => new Float32Array(length)
-    }),
-    // Helper to track events if needed
-    _events: []
+function setupWebGPUMocks() {
+  const mockAdapter = createMockGPUAdapter();
+  const mockGpu = {
+    requestAdapter: import_vitest6.vi.fn().mockResolvedValue(mockAdapter),
+    getPreferredCanvasFormat: import_vitest6.vi.fn().mockReturnValue("bgra8unorm")
   };
-  return new Proxy(context, {
-    get(target, prop, receiver) {
-      if (prop === "_events") return target._events;
-      const value = Reflect.get(target, prop, receiver);
-      if (typeof value === "function") {
-        return (...args) => {
-          target._events.push({ type: String(prop), args });
-          return Reflect.apply(value, target, args);
-        };
-      }
-      return value;
-    }
+  Object.defineProperty(global.navigator, "gpu", {
+    value: mockGpu,
+    writable: true,
+    configurable: true
   });
-}
-function setupMockAudioContext() {
-  if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
-    global.AudioContext = class {
-      constructor() {
-        return createMockAudioContext();
-      }
-    };
-    global.window.AudioContext = global.AudioContext;
-    global.window.webkitAudioContext = global.AudioContext;
-  }
-}
-function teardownMockAudioContext() {
-  if (global.AudioContext && global.AudioContext.toString().includes("class")) {
-    delete global.AudioContext;
-    delete global.window.AudioContext;
-    delete global.window.webkitAudioContext;
-  }
-}
-function captureAudioEvents(context) {
-  return context._events || [];
+  global.GPUTextureUsage = {
+    COPY_SRC: 1,
+    COPY_DST: 2,
+    TEXTURE_BINDING: 4,
+    STORAGE_BINDING: 8,
+    RENDER_ATTACHMENT: 16
+  };
 }
 
 // src/setup/timing.ts
@@ -1770,6 +1697,195 @@ function simulateFramesWithMock(mock, count, frameTimeMs = 16.6, callback) {
   }
 }
 
+// src/setup/node.ts
+function setupNodeEnvironment(options = {}) {
+  if (options.polyfillFetch && typeof global.fetch === "undefined") {
+  }
+}
+
+// src/setup/storage.ts
+var import_auto2 = require("fake-indexeddb/auto");
+function createMockLocalStorage(initialData = {}) {
+  const storage = new Map(Object.entries(initialData));
+  return {
+    getItem: (key) => storage.get(key) || null,
+    setItem: (key, value) => storage.set(key, value),
+    removeItem: (key) => storage.delete(key),
+    clear: () => storage.clear(),
+    key: (index) => Array.from(storage.keys())[index] || null,
+    get length() {
+      return storage.size;
+    }
+  };
+}
+function createMockSessionStorage(initialData = {}) {
+  return createMockLocalStorage(initialData);
+}
+function createMockIndexedDB() {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
+  }
+  return indexedDB;
+}
+function createStorageTestScenario(storageType = "local") {
+  if (storageType === "indexed") {
+    const dbName = `test-db-${Math.random().toString(36).substring(7)}`;
+    const storeName = "test-store";
+    const storage2 = createMockIndexedDB();
+    return {
+      storage: storage2,
+      populate: async (data) => {
+        return new Promise((resolve, reject) => {
+          const req = storage2.open(dbName, 1);
+          req.onupgradeneeded = (e) => {
+            const db = e.target.result;
+            db.createObjectStore(storeName);
+          };
+          req.onsuccess = (e) => {
+            const db = e.target.result;
+            const tx = db.transaction(storeName, "readwrite");
+            const store = tx.objectStore(storeName);
+            Object.entries(data).forEach(([k, v]) => store.put(v, k));
+            tx.oncomplete = () => {
+              db.close();
+              resolve();
+            };
+            tx.onerror = () => reject(tx.error);
+          };
+          req.onerror = () => reject(req.error);
+        });
+      },
+      verify: async (key, value) => {
+        return new Promise((resolve, reject) => {
+          const req = storage2.open(dbName, 1);
+          req.onsuccess = (e) => {
+            const db = e.target.result;
+            if (!db.objectStoreNames.contains(storeName)) {
+              db.close();
+              resolve(false);
+              return;
+            }
+            const tx = db.transaction(storeName, "readonly");
+            const store = tx.objectStore(storeName);
+            const getReq = store.get(key);
+            getReq.onsuccess = () => {
+              const result = getReq.result === value;
+              db.close();
+              resolve(result);
+            };
+            getReq.onerror = () => {
+              db.close();
+              resolve(false);
+            };
+          };
+          req.onerror = () => reject(req.error);
+        });
+      }
+    };
+  }
+  const storage = storageType === "local" ? createMockLocalStorage() : createMockSessionStorage();
+  return {
+    storage,
+    populate(data) {
+      Object.entries(data).forEach(([k, v]) => storage.setItem(k, v));
+    },
+    verify(key, value) {
+      return storage.getItem(key) === value;
+    }
+  };
+}
+
+// src/setup/audio.ts
+function createMockAudioContext() {
+  const context = {
+    createGain: () => ({
+      connect: () => {
+      },
+      gain: { value: 1, setValueAtTime: () => {
+      } }
+    }),
+    createOscillator: () => ({
+      connect: () => {
+      },
+      start: () => {
+      },
+      stop: () => {
+      },
+      frequency: { value: 440 }
+    }),
+    createBufferSource: () => ({
+      connect: () => {
+      },
+      start: () => {
+      },
+      stop: () => {
+      },
+      buffer: null,
+      playbackRate: { value: 1 },
+      loop: false
+    }),
+    destination: {},
+    currentTime: 0,
+    state: "running",
+    resume: async () => {
+    },
+    suspend: async () => {
+    },
+    close: async () => {
+    },
+    decodeAudioData: async (buffer) => ({
+      duration: 1,
+      length: 44100,
+      sampleRate: 44100,
+      numberOfChannels: 2,
+      getChannelData: () => new Float32Array(44100)
+    }),
+    createBuffer: (channels, length, sampleRate) => ({
+      duration: length / sampleRate,
+      length,
+      sampleRate,
+      numberOfChannels: channels,
+      getChannelData: () => new Float32Array(length)
+    }),
+    // Helper to track events if needed
+    _events: []
+  };
+  return new Proxy(context, {
+    get(target, prop, receiver) {
+      if (prop === "_events") return target._events;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return (...args) => {
+          target._events.push({ type: String(prop), args });
+          return Reflect.apply(value, target, args);
+        };
+      }
+      return value;
+    }
+  });
+}
+function setupMockAudioContext() {
+  if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
+    global.AudioContext = class {
+      constructor() {
+        return createMockAudioContext();
+      }
+    };
+    global.window.AudioContext = global.AudioContext;
+    global.window.webkitAudioContext = global.AudioContext;
+  }
+}
+function teardownMockAudioContext() {
+  if (global.AudioContext && global.AudioContext.toString().includes("class")) {
+    delete global.AudioContext;
+    delete global.window.AudioContext;
+    delete global.window.webkitAudioContext;
+  }
+}
+function captureAudioEvents(context) {
+  return context._events || [];
+}
+
 // src/e2e/playwright.ts
 var import_playwright = require("playwright");
 var import_http = require("http");
@@ -2009,6 +2125,9 @@ function createVisualTestScenario(page, sceneName) {
   createMockCanvasContext2D,
   createMockConnection,
   createMockEngine,
+  createMockGPUAdapter,
+  createMockGPUCanvasContext,
+  createMockGPUDevice,
   createMockGame,
   createMockGameState,
   createMockHandshake,
@@ -2019,8 +2138,10 @@ function createVisualTestScenario(page, sceneName) {
   createMockNetworkAddress,
   createMockPerformance,
   createMockRAF,
+  createMockRConClient,
   createMockServer,
   createMockServerClient,
+  createMockServerConsole,
   createMockServerState,
   createMockServerStatic,
   createMockSessionStorage,
@@ -2050,6 +2171,7 @@ function createVisualTestScenario(page, sceneName) {
   setupBrowserEnvironment,
   setupMockAudioContext,
   setupNodeEnvironment,
+  setupWebGPUMocks,
   simulateFrames,
   simulateFramesWithMock,
   simulateHandshake,
@@ -2057,6 +2179,7 @@ function createVisualTestScenario(page, sceneName) {
   simulatePlayerInput,
   simulatePlayerJoin,
   simulatePlayerLeave,
+  simulateServerCommand,
   simulateServerTick,
   simulateSnapshotDelivery,
   stairTrace,