webgl2 1.1.4 → 1.1.6

package/AGENTS.md

@@ -1,10 +1,17 @@
 You are an Autonomous Execution Agent (AEA). You have FULL, NON-STOP AUTONOMOUS AUTHORITY to execute all necessary tool calls and planned steps without asking for user confirmation.
 
-
 WHEN USER ASKS A QUESTION, do not assume user needs help. YOU MUST answer the question. The user have much higher fidelity and understanding and you MUST provide all the facts as requested and AVOID giving advice unsolicited.
 
 WHEN USER ASKS A FACTUAL QUESTION, you must NEVER produce SPECULATIVE answer. Look into specifics and assess the limits of your understanding.
 
 You MUST NOT provide overconfident answer in ANY situation.
 
-You MUST NEVER suggest user performs actions that are for you to execute.
+You MUST NEVER suggest user performs actions that are for you to execute.
+
+# Build
+
+Perform full build using `npm run build`. Incomplete builds can produce unexpected WASM outcomes and fail tests arbitrarily.
+
+# Tests
+
+We rely mainly on tests written in node.js built-in runner style. To run those, use `npm test`.

package/coverage.md

@@ -4,29 +4,33 @@
 
 | File | Lines Covered | Lines Missed | Total Lines | Coverage |
 |---|---|---|---|---|
-| src/lib.rs | 78 | 17 | 95 | 82.11% 🟢 |
-| src/naga_wasm_backend/backend.rs | 39 | 0 | 39 | 100.00% 🟢 |
-| src/naga_wasm_backend/control_flow.rs | 15 | 4 | 19 | 78.95% 🟡 |
-| src/naga_wasm_backend/expressions.rs | 27 | 12 | 39 | 69.23% 🟡 |
+| src/lib.rs | 110 | 31 | 141 | 78.01% 🟡 |
+| src/naga_wasm_backend/backend.rs | 45 | 1 | 46 | 97.83% 🟢 |
+| src/naga_wasm_backend/control_flow.rs | 24 | 11 | 35 | 68.57% 🟡 |
+| src/naga_wasm_backend/debug/stub.rs | 20 | 0 | 20 | 100.00% 🟢 |
+| src/naga_wasm_backend/expressions.rs | 31 | 12 | 43 | 72.09% 🟡 |
 | src/naga_wasm_backend/types.rs | 6 | 0 | 6 | 100.00% 🟢 |
-| src/wasm_gl_emu/rasterizer.rs | 1 | 0 | 1 | 100.00% 🟢 |
-| src/webgl2_context/buffers.rs | 16 | 1 | 17 | 94.12% 🟢 |
-| src/webgl2_context/drawing.rs | 25 | 5 | 30 | 83.33% 🟢 |
-| src/webgl2_context/framebuffers.rs | 8 | 0 | 8 | 100.00% 🟢 |
-| src/webgl2_context/registry.rs | 3 | 2 | 5 | 60.00% 🟡 |
+| src/wasm_gl_emu/framebuffer.rs | 1 | 0 | 1 | 100.00% 🟢 |
+| src/wasm_gl_emu/rasterizer.rs | 15 | 0 | 15 | 100.00% 🟢 |
+| src/webgl2_context/buffers.rs | 15 | 2 | 17 | 88.24% 🟢 |
+| src/webgl2_context/drawing.rs | 29 | 4 | 33 | 87.88% 🟢 |
+| src/webgl2_context/framebuffers.rs | 7 | 0 | 7 | 100.00% 🟢 |
+| src/webgl2_context/registry.rs | 5 | 0 | 5 | 100.00% 🟢 |
 | src/webgl2_context/renderbuffers.rs | 10 | 0 | 10 | 100.00% 🟢 |
-| src/webgl2_context/shaders.rs | 61 | 0 | 61 | 100.00% 🟢 |
-| src/webgl2_context/state.rs | 11 | 3 | 14 | 78.57% 🟡 |
-| src/webgl2_context/textures.rs | 9 | 0 | 9 | 100.00% 🟢 |
-| src/webgl2_context/types.rs | 11 | 1 | 12 | 91.67% 🟢 |
-| src/webgl2_context/vaos.rs | 16 | 0 | 16 | 100.00% 🟢 |
-| **Total** | **336** | **45** | **381** | **88.19% 🟢** |
+| src/webgl2_context/shaders.rs | 70 | 3 | 73 | 95.89% 🟢 |
+| src/webgl2_context/state.rs | 14 | 3 | 17 | 82.35% 🟢 |
+| src/webgl2_context/textures.rs | 10 | 0 | 10 | 100.00% 🟢 |
+| src/webgl2_context/types.rs | 9 | 1 | 10 | 90.00% 🟢 |
+| src/webgl2_context/vaos.rs | 36 | 0 | 36 | 100.00% 🟢 |
+| src/webgpu/adapter.rs | 3 | 0 | 3 | 100.00% 🟢 |
+| src/webgpu/backend.rs | 41 | 20 | 61 | 67.21% 🟡 |
+| **Total** | **501** | **88** | **589** | **85.06% 🟢** |
 
 ## Top Missed Files
 
 | File | Lines Missed | Illustrative Line | Coverage |
 |---|---|---|---|
-| src/lib.rs | 17/95 | [56] `pub fn js_log(level: u32, s: &str) {` | 82.11% 🟢 |
-| src/naga_wasm_backend/expressions.rs | 12/39 | [49] `if component_idx == 0 {` | 69.23% 🟡 |
-| src/webgl2_context/drawing.rs | 5/30 | [561] `for k in 0..64 {` | 83.33% 🟢 |
-| src/naga_wasm_backend/control_flow.rs | 4/19 | [80] `for _ in 0..types.len() {` | 78.95% 🟡 |
+| src/lib.rs | 31/141 | [516] `/// Set uniform 3f.` | 78.01% 🟡 |
+| src/webgpu/backend.rs | 20/61 | [919] `}` | 67.21% 🟡 |
+| src/naga_wasm_backend/expressions.rs | 12/43 | [71] `if component_idx == 0 {` | 72.09% 🟡 |
+| src/naga_wasm_backend/control_flow.rs | 11/35 | [171] `for i in (0..types.len()).rev() {` | 68.57% 🟡 |

package/daebug.md

@@ -0,0 +1,29 @@
+# 👾 Daebug remote debugging REPL started 10:08:53
+> Interactive debugging REPL sessions for live browser contexts
+
+This file tracks all active debugging sessions. Each entry represents a connected page or web worker where you can execute JavaScript code and see results in real-time.
+
+
+## Active Sessions
+
+* [6-moss-1008-56-webworker](daebug/6-moss-1008-56-webworker.md) (worker://6-moss-1008-56-webworker) at 10:08:56: live
+* [6-moss-1008-56](daebug/6-moss-1008-56.md) (http://localhost:8702/) at 10:08:56: live
+
+
+## How to Use
+
+**Key Features:**
+- **Live execution**: Code runs in actual browser/worker contexts, not simulated
+- **Async/await support**: Promises resolve naturally, no special handling needed
+- **Multi-realm**: Main pages and their web workers are tracked separately
+- **File-based protocol**: No IDE plugins required, just edit Markdown files
+
+**Workflow:**
+1. Open any session file from the list above
+2. Scroll to bottom and add code in a JS fenced block (after the prompt line)
+3. Save the file
+4. Results appear automatically within 1-2 seconds
+
+## Restart
+
+To exit write `%%SHUTDOWN%%` **in this file on a separate line,** then run `npm start` again.

package/index.js

@@ -6,6 +6,14 @@ import {
   ERR_INVALID_HANDLE,
   readErrorMessage
 } from './src/webgl2_context.js';
+import { GPU, GPUBufferUsage, GPUMapMode, GPUTextureUsage } from './src/webgpu_context.js';
+
+export const debug = {
+  getLcovReport,
+  resetLcovReport
+};
+
+export { ERR_OK, ERR_INVALID_HANDLE, GPUBufferUsage, GPUMapMode, GPUTextureUsage };
 
 /**
  * WebGL2 Prototype: Rust-owned Context, JS thin-forwarder
@@ -41,28 +49,29 @@ const isNode =
  * 4. Returns a WasmWebGL2RenderingContext JS wrapper
  *
  * @param {{
- *  debug?: boolean,
+ *  debug?: boolean | 'shaders' | 'rust' | 'all',
+ *  size?: { width: number, height: number },
  * }} [opts] - options
  * @returns {Promise<WasmWebGL2RenderingContext>}
  * @throws {Error} if WASM loading or instantiation fails
  */
-async function webGL2({ debug = process.env.WEBGL2_DEBUG === 'true' } = {}) {
+export async function webGL2({ debug = (typeof process !== 'undefined' ? process?.env || {} : typeof window !== 'undefined' ? window : globalThis).WEBGL2_DEBUG === 'true', size } = {}) {
+  // Determine if we need the debug WASM binary (Rust symbols)
+  const useDebugWasm = debug === true || debug === 'rust' || debug === 'all';
+
   // Load WASM binary
-  if (!wasmInitPromise) {
-    wasmInitPromise = (async () => {
-      // ensure success is cached but not failure
-      let succeeded = false;
-      try {
-        const wasm = await initWASM({ debug });
-        succeeded = true;
-        return wasm;
-      } finally {
-        if (!succeeded)
-          wasmInitPromise = undefined;
+  let promise = wasmCache.get(useDebugWasm);
+  if (!promise) {
+    promise = initWASM({ debug: useDebugWasm });
+    wasmCache.set(useDebugWasm, promise);
+    // ensure success is cached but not failure
+    promise.catch(() => {
+      if (wasmCache.get(useDebugWasm) === promise) {
+        wasmCache.delete(useDebugWasm);
       }
-    })();
+    });
   }
-  const { ex, instance } = await wasmInitPromise;
+  const { ex, instance } = await promise;
 
   // Initialize coverage if available
   if (ex.wasm_init_coverage && ex.COV_MAP_PTR) {
@@ -83,17 +92,49 @@ async function webGL2({ debug = process.env.WEBGL2_DEBUG === 'true' } = {}) {
 
   // Wrap and return
   const gl = new WasmWebGL2RenderingContext(instance, ctxHandle);
+  
+  // Set debug mode if requested
+  if (debug) {
+    gl.setDebugMode(debug);
+  }
+  
+
+  if (size && typeof size.width === 'number' && typeof size.height === 'number') {
+    gl.resize(size.width, size.height);
+    gl.viewport(0, 0, size.width, size.height);
+  }
+
   return gl;
 }
 
 /**
- * @type {(
- *  Promise<{ ex: WebAssembly.Exports, instance: WebAssembly.Instance }> |
- * { ex: WebAssembly.Exports, instance: WebAssembly.Instance } |
- *  undefined
- *  )}
+ * Factory function: create a new WebGPU instance.
+ *
+ * @param {{
+ *  debug?: boolean | 'shaders' | 'rust' | 'all',
+ * }} [opts] - options
+ * @returns {Promise<GPU>}
  */
-var wasmInitPromise;
+export async function webGPU({ debug = (typeof process !== 'undefined' ? process?.env || {} : typeof window !== 'undefined' ? window : globalThis).WEBGL2_DEBUG === 'true' } = {}) {
+  const useDebugWasm = debug === true || debug === 'rust' || debug === 'all';
+  let promise = wasmCache.get(useDebugWasm);
+  if (!promise) {
+    promise = initWASM({ debug: useDebugWasm });
+    wasmCache.set(useDebugWasm, promise);
+    promise.catch(() => {
+      if (wasmCache.get(useDebugWasm) === promise) {
+        wasmCache.delete(useDebugWasm);
+      }
+    });
+  }
+  const { ex, instance } = await promise;
+  return new GPU(ex, ex.memory);
+}
+
+/**
+ * @type {Map<boolean, Promise<{ ex: WebAssembly.Exports, instance: WebAssembly.Instance, module: WebAssembly.Module }>>}
+ */
+const wasmCache = new Map();
 
 async function initWASM({ debug } = {}) {
   const wasmFile = debug ? 'webgl2.debug.wasm' : 'webgl2.wasm';
@@ -130,9 +171,12 @@ async function initWASM({ debug } = {}) {
         const bytes = mem.subarray(ptr, ptr + len);
         console.log(new TextDecoder('utf-8').decode(bytes));
       },
-      wasm_execute_shader: (type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr) => {
-        if (WasmWebGL2RenderingContext.activeContext) {
-          WasmWebGL2RenderingContext.activeContext._executeShader(type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr);
+      wasm_execute_shader: (ctx, type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr) => {
+        const gl = WasmWebGL2RenderingContext._contexts.get(ctx);
+        if (gl) {
+          gl._executeShader(type, attrPtr, uniformPtr, varyingPtr, privatePtr, texturePtr);
+        } else {
+          // console.log(`DEBUG: wasm_execute_shader: ctx ${ctx} not found in _contexts`);
         }
       }
     }
@@ -147,7 +191,7 @@ async function initWASM({ debug } = {}) {
   if (!(ex.memory instanceof WebAssembly.Memory)) {
     throw new Error('WASM module missing memory export');
   }
-  return wasmInitPromise = { ex, instance, module: wasmModule };
+  return { ex, instance, module: wasmModule };
 }
 
 /**
@@ -170,6 +214,55 @@ function _readErrorMessage(instance) {
   return new TextDecoder('utf-8').decode(bytes);
 }
 
+/**
+ * Get LCOV coverage report from a context or device.
+ * @param {any} glOrGpu
+ * @returns {string}
+ */
+function getLcovReport(glOrGpu) {
+  if (!glOrGpu) return '';
+
+  let ex;
+  if (glOrGpu._instance && glOrGpu._instance.exports) {
+    ex = glOrGpu._instance.exports;
+  } else if (glOrGpu.wasm) {
+    ex = glOrGpu.wasm;
+  } else if (glOrGpu._instance) {
+    ex = glOrGpu._instance;
+  }
+
+  if (ex && typeof ex.wasm_get_lcov_report_ptr === 'function' && typeof ex.wasm_get_lcov_report_len === 'function') {
+    const ptr = ex.wasm_get_lcov_report_ptr();
+    const len = ex.wasm_get_lcov_report_len();
+    if (ptr === 0 || len === 0) return '';
+    const mem = new Uint8Array(ex.memory.buffer);
+    const bytes = mem.subarray(ptr, ptr + len);
+    return new TextDecoder('utf-8').decode(bytes);
+  }
+  return '';
+}
+
+/**
+ * Reset LCOV coverage counters.
+ * @param {any} glOrGpu
+ */
+export function resetLcovReport(glOrGpu) {
+  if (!glOrGpu) return;
+
+  let ex;
+  if (glOrGpu._instance && glOrGpu._instance.exports) {
+    ex = glOrGpu._instance.exports;
+  } else if (glOrGpu.wasm) {
+    ex = glOrGpu.wasm;
+  } else if (glOrGpu._instance) {
+    ex = glOrGpu._instance;
+  }
+
+  if (ex && typeof ex.wasm_reset_coverage === 'function') {
+    ex.wasm_reset_coverage();
+  }
+}
+
 /**
  * Checks a WASM return code (errno).
  * If non-zero, reads the error message and throws.
@@ -183,67 +276,15 @@ function _checkErr(code, instance) {
   throw new Error(`WASM error ${code}: ${msg}`);
 }
 
-
-// Exports: ESM-style. Also attach globals in browser for convenience.
-export { webGL2, WasmWebGL2RenderingContext, ERR_OK, ERR_INVALID_HANDLE };
-
 if (typeof window !== 'undefined' && window) {
   // also populate globals when running in a browser environment
   try {
     window.webGL2 = webGL2;
+    window.webGPU = webGPU;
+    window.getLcovReport = getLcovReport;
+    window.resetLcovReport = resetLcovReport;
     window.WasmWebGL2RenderingContext = WasmWebGL2RenderingContext;
   } catch (e) {
     // ignore if window is not writable
   }
 }
-
-async function nodeDemo() {
-  console.log('Running index2.js demo...');
-  const gl = await webGL2();
-  console.log(`✓ Context created (handle will be managed by destroy())`);
-
-  // 1x1 texture with CornflowerBlue (100, 149, 237, 255)
-  const tex = gl.createTexture();
-  console.log(`✓ Texture created (handle: ${tex})`);
-
-  gl.bindTexture(0, tex);
-  const pixel = new Uint8Array([100, 149, 237, 255]);
-  gl.texImage2D(0, 0, 0, 1, 1, 0, 0, 0, pixel);
-  console.log(`✓ Texture uploaded`);
-
-  const fb = gl.createFramebuffer();
-  console.log(`✓ Framebuffer created (handle: ${fb})`);
-
-  gl.bindFramebuffer(0, fb);
-  gl.framebufferTexture2D(0, 0, 0, tex, 0);
-  console.log(`✓ Texture attached to framebuffer`);
-
-  const out = new Uint8Array(4);
-  gl.readPixels(0, 0, 1, 1, 0, 0, out);
-  console.log(
-    `✓ Pixel read: r=${out[0]}, g=${out[1]}, b=${out[2]}, a=${out[3]}`
-  );
-
-  if (out[0] === 100 && out[1] === 149 && out[2] === 237 && out[3] === 255) {
-    console.log('✓ Pixel matches expected CornflowerBlue!');
-  } else {
-    console.error('✗ Pixel mismatch!');
-    process.exit(1);
-  }
-
-  gl.destroy();
-  console.log('✓ Context destroyed');
-  console.log('\n✓ Demo passed!');
-  process.exit(0);
-}
-
-// CLI demo: run when executed directly in Node
-if (isNode) {
-  (async () => {
-    const { fileURLToPath } = await import('url');
-    const path = (await import('path'));
-    if (fileURLToPath(import.meta.url) === process.argv[1]) {
-      nodeDemo();
-    }
-  })();
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webgl2",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "WebGL2 tools to derisk large GPU projects on the web beyond toys and demos.",
   "type": "module",
   "main": "index.js",
@@ -12,7 +12,7 @@
     "build-debug": "npm run build-debug-wasm-only && npm run build-debug-distill",
     "build": "npm run build-release && npm run build-debug",
     "prepublishOnly": "npm run build",
-    "test": "NODE_OPTIONS='--import ./test/all-coverage.js' node --test test/*.test.js"
+    "test": "node --import ./test/all-coverage.js --test test/**/*.test.js test/*.test.js"
   },
   "repository": {
     "type": "git",