webgl2 1.2.8 → 1.3.1

package/coverage.md

@@ -4,50 +4,52 @@
 
 | File | Lines Covered | Lines Missed | Total Lines | Coverage |
 |---|---|---|---|---:|
-| src/coverage.rs | 5 | 3 | 8 | 62.50% 🟡 |
-| src/decompiler/ast.rs | 5 | 0 | 5 | 100.00% 🟢 |
-| src/decompiler/emitter.rs | 28 | 6 | 34 | 82.35% 🟢 |
-| src/decompiler/lifter.rs | 6 | 3 | 9 | 66.67% 🟡 |
-| src/decompiler/mod.rs | 4 | 0 | 4 | 100.00% 🟢 |
-| src/decompiler/module.rs | 0 | 1 | 1 | 0.00% 🟡 |
-| src/decompiler/parser.rs | 21 | 12 | 33 | 63.64% 🟡 |
-| src/decompiler/simplifier.rs | 42 | 2 | 44 | 95.45% 🟢 |
-| src/error.rs | 41 | 3 | 44 | 93.18% 🟢 |
-| src/lib.rs | 94 | 313 | 407 | 23.10% 🟠 |
-| src/naga_wasm_backend/backend.rs | 151 | 44 | 195 | 77.44% 🟡 |
-| src/naga_wasm_backend/call_lowering.rs | 30 | 3 | 33 | 90.91% 🟢 |
-| src/naga_wasm_backend/control_flow.rs | 42 | 41 | 83 | 50.60% 🟡 |
-| src/naga_wasm_backend/debug/stub.rs | 10 | 0 | 10 | 100.00% 🟢 |
-| src/naga_wasm_backend/expressions.rs | 212 | 134 | 346 | 61.27% 🟡 |
-| src/naga_wasm_backend/function_abi.rs | 25 | 3 | 28 | 89.29% 🟢 |
-| src/naga_wasm_backend/functions/prep.rs | 8 | 0 | 8 | 100.00% 🟢 |
-| src/naga_wasm_backend/functions/registry.rs | 1 | 0 | 1 | 100.00% 🟢 |
-| src/naga_wasm_backend/mod.rs | 6 | 2 | 8 | 75.00% 🟡 |
-| src/naga_wasm_backend/output_layout.rs | 10 | 1 | 11 | 90.91% 🟢 |
-| src/naga_wasm_backend/types.rs | 15 | 7 | 22 | 68.18% 🟡 |
-| src/wasm_gl_emu/device.rs | 1 | 0 | 1 | 100.00% 🟢 |
-| src/wasm_gl_emu/framebuffer.rs | 2 | 1 | 3 | 66.67% 🟡 |
-| src/wasm_gl_emu/rasterizer.rs | 32 | 40 | 72 | 44.44% 🟠 |
-| src/wasm_gl_emu/transfer.rs | 10 | 12 | 22 | 45.45% 🟠 |
-| src/webgl2_context/blend.rs | 9 | 1 | 10 | 90.00% 🟢 |
-| src/webgl2_context/buffers.rs | 15 | 0 | 15 | 100.00% 🟢 |
-| src/webgl2_context/drawing.rs | 31 | 1 | 32 | 96.88% 🟢 |
-| src/webgl2_context/registry.rs | 13 | 0 | 13 | 100.00% 🟢 |
-| src/webgl2_context/shaders.rs | 149 | 16 | 165 | 90.30% 🟢 |
-| src/webgl2_context/state.rs | 60 | 4 | 64 | 93.75% 🟢 |
-| src/webgl2_context/textures.rs | 56 | 0 | 56 | 100.00% 🟢 |
-| src/webgl2_context/types.rs | 4 | 0 | 4 | 100.00% 🟢 |
+| src/coverage.rs | 9 | 5 | 14 | 64.29% 🟡 |
+| src/decompiler/ast.rs | 6 | 0 | 6 | 100.00% 🟢 |
+| src/decompiler/emitter.rs | 24 | 3 | 27 | 88.89% 🟢 |
+| src/decompiler/lifter.rs | 6 | 2 | 8 | 75.00% 🟡 |
+| src/decompiler/parser.rs | 12 | 3 | 15 | 80.00% 🟢 |
+| src/decompiler/simplifier.rs | 36 | 2 | 38 | 94.74% 🟢 |
+| src/error.rs | 33 | 8 | 41 | 80.49% 🟢 |
+| src/lib.rs | 155 | 298 | 453 | 34.22% 🟠 |
+| src/naga_wasm_backend/backend.rs | 151 | 24 | 175 | 86.29% 🟢 |
+| src/naga_wasm_backend/call_lowering.rs | 9 | 3 | 12 | 75.00% 🟡 |
+| src/naga_wasm_backend/control_flow.rs | 38 | 30 | 68 | 55.88% 🟡 |
+| src/naga_wasm_backend/debug/stub.rs | 11 | 16 | 27 | 40.74% 🟠 |
+| src/naga_wasm_backend/expressions.rs | 270 | 155 | 425 | 63.53% 🟡 |
+| src/naga_wasm_backend/function_abi.rs | 15 | 8 | 23 | 65.22% 🟡 |
+| src/naga_wasm_backend/functions/prep.rs | 5 | 0 | 5 | 100.00% 🟢 |
+| src/naga_wasm_backend/functions/registry.rs | 6 | 0 | 6 | 100.00% 🟢 |
+| src/naga_wasm_backend/memory_layout.rs | 15 | 1 | 16 | 93.75% 🟢 |
+| src/naga_wasm_backend/mod.rs | 6 | 0 | 6 | 100.00% 🟢 |
+| src/naga_wasm_backend/output_layout.rs | 7 | 1 | 8 | 87.50% 🟢 |
+| src/naga_wasm_backend/types.rs | 22 | 6 | 28 | 78.57% 🟡 |
+| src/wasm_gl_emu/device.rs | 3 | 0 | 3 | 100.00% 🟢 |
+| src/wasm_gl_emu/framebuffer.rs | 1 | 0 | 1 | 100.00% 🟢 |
+| src/wasm_gl_emu/rasterizer.rs | 16 | 41 | 57 | 28.07% 🟠 |
+| src/wasm_gl_emu/transfer.rs | 3 | 0 | 3 | 100.00% 🟢 |
+| src/webgl2_context/blend.rs | 14 | 1 | 15 | 93.33% 🟢 |
+| src/webgl2_context/buffers.rs | 12 | 0 | 12 | 100.00% 🟢 |
+| src/webgl2_context/drawing.rs | 33 | 0 | 33 | 100.00% 🟢 |
+| src/webgl2_context/ephemeral.rs | 0 | 1 | 1 | 0.00% 🟡 |
+| src/webgl2_context/framebuffers.rs | 8 | 6 | 14 | 57.14% 🟡 |
+| src/webgl2_context/registry.rs | 11 | 0 | 11 | 100.00% 🟢 |
+| src/webgl2_context/shaders.rs | 137 | 29 | 166 | 82.53% 🟢 |
+| src/webgl2_context/state.rs | 33 | 9 | 42 | 78.57% 🟡 |
+| src/webgl2_context/textures.rs | 60 | 0 | 60 | 100.00% 🟢 |
+| src/webgl2_context/types.rs | 45 | 21 | 66 | 68.18% 🟡 |
 | src/webgpu/adapter.rs | 3 | 0 | 3 | 100.00% 🟢 |
-| src/webgpu/backend.rs | 79 | 16 | 95 | 83.16% 🟢 |
-| src/webgpu/buffer.rs | 2 | 0 | 2 | 100.00% 🟢 |
-| src/webgpu/command.rs | 7 | 3 | 10 | 70.00% 🟡 |
-| **Total** | **1229** | **672** | **1901** | **64.65% 🟡** |
+| src/webgpu/backend.rs | 52 | 17 | 69 | 75.36% 🟡 |
+| src/webgpu/bind_group.rs | 6 | 1 | 7 | 85.71% 🟢 |
+| src/webgpu/buffer.rs | 8 | 2 | 10 | 80.00% 🟢 |
+| src/webgpu/command.rs | 12 | 5 | 17 | 70.59% 🟡 |
+| **Total** | **1293** | **698** | **1991** | **64.94% 🟡** |
 
 ## Top Missed Files
 
 | File | Lines Missed | Illustrative Line | Coverage |
 |---|---|---|---:|
-| src/lib.rs | 313/407 | [1994] `}` | 23.10% 🟠 |
-| src/naga_wasm_backend/expressions.rs | 134/346 | [805] `let offset = (*index * element_size) + (component_idx * 4);` | 61.27% 🟡 |
-| src/naga_wasm_backend/backend.rs | 44/195 | [110] `code: CodeSection::new(),` | 77.44% 🟡 |
-| src/naga_wasm_backend/control_flow.rs | 41/83 | [30] `if let Some(layout) = ctx.private_memory_layout {` | 50.60% 🟡 |
+| src/lib.rs | 298/453 | [1994] `vertex_module_handle: u32,` | 34.22% 🟠 |
+| src/naga_wasm_backend/expressions.rs | 155/425 | [910] `if let Some(handle) = found_global {` | 63.53% 🟡 |
+| src/wasm_gl_emu/rasterizer.rs | 41/57 | [370] `match eq {` | 28.07% 🟠 |
+| src/naga_wasm_backend/control_flow.rs | 30/68 | [489] `let types = super::types::naga_to_wasm_types(` | 55.88% 🟡 |

package/index.js

@@ -269,26 +269,30 @@ async function initWASM({ debug } = {}) {
           ACTIVE_FRAME_SP: turboGlobals.ACTIVE_FRAME_SP,
         };
         
-        // Map transcendental functions to JS Math equivalents for maximum accuracy
-        env.gl_sin = Math.sin;
-        env.gl_cos = Math.cos;
-        env.gl_tan = Math.tan;
-        env.gl_asin = Math.asin;
-        env.gl_acos = Math.acos;
-        env.gl_atan = Math.atan;
-        env.gl_atan2 = Math.atan2;
-        env.gl_exp = Math.exp;
-        env.gl_exp2 = (x) => Math.pow(2, x);
-        env.gl_log = Math.log;
-        env.gl_log2 = Math.log2;
-        env.gl_pow = Math.pow;
-        env.gl_ldexp = (mant, exp) => mant * Math.pow(2, exp);
-        env.gl_sinh = Math.sinh;
-        env.gl_cosh = Math.cosh;
-        env.gl_tanh = Math.tanh;
-        env.gl_asinh = Math.asinh;
-        env.gl_acosh = Math.acosh;
-        env.gl_atanh = Math.atanh;
+        env.gl_sin = instance.exports.gl_sin;
+        env.gl_cos = instance.exports.gl_cos;
+        env.gl_tan = instance.exports.gl_tan;
+        env.gl_asin = instance.exports.gl_asin;
+        env.gl_acos = instance.exports.gl_acos;
+        env.gl_atan = instance.exports.gl_atan;
+        env.gl_atan2 = instance.exports.gl_atan2;
+        env.gl_exp = instance.exports.gl_exp;
+        env.gl_exp2 = instance.exports.gl_exp2;
+        env.gl_log = instance.exports.gl_log;
+        env.gl_log2 = instance.exports.gl_log2;
+        env.gl_pow = instance.exports.gl_pow;
+        env.gl_ldexp = instance.exports.gl_ldexp;
+        env.gl_sinh = instance.exports.gl_sinh;
+        env.gl_cosh = instance.exports.gl_cosh;
+        env.gl_tanh = instance.exports.gl_tanh;
+        env.gl_asinh = instance.exports.gl_asinh;
+        env.gl_acosh = instance.exports.gl_acosh;
+        env.gl_atanh = instance.exports.gl_atanh;
+
+        // Link diagnostic and math helpers from the main module
+        env.gl_debug4 = instance.exports.gl_debug4;
+        env.gl_inverse_mat2 = instance.exports.gl_inverse_mat2;
+        env.gl_inverse_mat3 = instance.exports.gl_inverse_mat3;
 
         const shaderInstance = new WebAssembly.Instance(shaderModule, { env });
         if (shaderInstance.exports.main) {
@@ -362,16 +366,23 @@ async function initWASM({ debug } = {}) {
  */
 function _readErrorMessage(instance) {
   const ex = instance.exports;
-  if (!ex || typeof ex.wasm_last_error_ptr !== 'function' || typeof ex.wasm_last_error_len !== 'function') {
+  if (!ex || typeof ex.wasm_last_error !== 'function') {
+    if (typeof ex.wasm_last_error_ptr === 'function') {
+      const ptr = ex.wasm_last_error_ptr();
+      const len = ex.wasm_last_error_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 '(no error message available)';
   }
-  const ptr = ex.wasm_last_error_ptr();
-  const len = ex.wasm_last_error_len();
-  if (ptr === 0 || len === 0) {
-    return '';
-  }
+  const ptr = ex.wasm_last_error();
+  if (ptr === 0) return '';
+  const dv = new DataView(ex.memory.buffer);
+  const len = dv.getUint32(ptr - 16, true);
   const mem = new Uint8Array(ex.memory.buffer);
-  const bytes = mem.subarray(ptr, ptr + len);
+  const bytes = mem.slice(ptr, ptr + len);
   return new TextDecoder('utf-8').decode(bytes);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webgl2",
-  "version": "1.2.8",
+  "version": "1.3.1",
   "description": "WebGL2 tools to derisk large GPU projects on the web beyond toys and demos.",
   "type": "module",
   "main": "index.js",

package/src/webgl2_context.js

@@ -709,48 +709,31 @@ export class WasmWebGL2RenderingContext {
       throw new Error('wasm_ctx_read_pixels not found');
     }
 
-    let bpp = 4;
-    if (type_ === 0x1406) { // GL_FLOAT
-      if (format === 0x1908) bpp = 16;      // GL_RGBA
-      else if (format === 0x8227) bpp = 8;  // GL_RG
-      else if (format === 0x1903) bpp = 4;  // GL_RED
-    } else if (type_ === 0x1405 || type_ === 0x1404) { // GL_UNSIGNED_INT or GL_INT
-      if (format === 0x8D9E) bpp = 16;      // GL_RGBA_INTEGER
-      else if (format === 0x8228) bpp = 8;  // GL_RG_INTEGER
-      else if (format === 0x8D94) bpp = 4;  // GL_RED_INTEGER
-    } else if (type_ === 0x1401) { // GL_UNSIGNED_BYTE
-      if (format === 0x1908) bpp = 4;
-    }
-
-    const len = width * height * bpp;
-    if (!out || out.byteLength < len) {
-      throw new Error(`output buffer too small (need ${len} bytes, have ${out ? out.byteLength : 0})`);
+    const ptr = ex.wasm_ctx_read_pixels(
+      this._ctxHandle,
+      x | 0,
+      y | 0,
+      width >>> 0,
+      height >>> 0,
+      format >>> 0,
+      type_ >>> 0
+    );
+
+    if (ptr === 0) {
+      const msg = readErrorMessage(this._instance);
+      throw new Error(`readPixels failed: ${msg}`);
     }
 
-    const ptr = ex.wasm_alloc(len);
-    if (ptr === 0) throw new Error('Failed to allocate memory for readPixels output');
+    const dv = new DataView(ex.memory.buffer);
+    const len = dv.getUint32(ptr - 16, true);
 
-    try {
-      const code = ex.wasm_ctx_read_pixels(
-        this._ctxHandle,
-        x | 0,
-        y | 0,
-        width >>> 0,
-        height >>> 0,
-        format >>> 0,
-        type_ >>> 0,
-        ptr >>> 0,
-        len >>> 0
-      );
-      _checkErr(code, this._instance);
-
-      const mem = new Uint8Array(ex.memory.buffer);
-      const src = mem.subarray(ptr, ptr + len);
-      const out_bytes = new Uint8Array(out.buffer, out.byteOffset, len);
-      out_bytes.set(src);
-    } finally {
-      ex.wasm_free(ptr);
+    if (!out || out.byteLength < len) {
+      throw new Error(`output buffer too small (need ${len} bytes, have ${out ? out.byteLength : 0})`);
     }
+
+    const src = new Uint8Array(ex.memory.buffer, ptr, len);
+    const out_bytes = new Uint8Array(out.buffer, out.byteOffset, len);
+    out_bytes.set(src);
   }
 
   // --- Stubs for unimplemented WebGL2 methods (forwarding API surface) ---
@@ -856,43 +839,18 @@ export class WasmWebGL2RenderingContext {
     }
     const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
 
-    // Allocate buffers: size(4) + type(4) + name(256)
-    const sizePtr = ex.wasm_alloc(4);
-    const typePtr = ex.wasm_alloc(4);
-    const nameMaxLen = 256;
-    const namePtr = ex.wasm_alloc(nameMaxLen);
-
-    try {
-      const nameLen = ex.wasm_ctx_get_active_uniform(
-        this._ctxHandle,
-        programHandle,
-        index >>> 0,
-        sizePtr,
-        typePtr,
-        namePtr,
-        nameMaxLen
-      );
-
-      if (nameLen === 0) {
-        return null;
-      }
-
-      const mem32SizeIdx = sizePtr >>> 2;
-      const mem32TypeIdx = typePtr >>> 2;
-
-      const size = new Int32Array(ex.memory.buffer)[mem32SizeIdx];
-      const type_ = new Uint32Array(ex.memory.buffer)[mem32TypeIdx];
-
-      const nameBytes = new Uint8Array(ex.memory.buffer, namePtr, nameLen);
-      const name = new TextDecoder().decode(nameBytes);
+    const ptr = ex.wasm_ctx_get_active_uniform(this._ctxHandle, programHandle, index >>> 0);
+    if (ptr === 0) return null;
 
-      return { name, size, type: type_ };
+    const dv = new DataView(ex.memory.buffer);
+    const totalLen = dv.getUint32(ptr - 16, true);
+    const size = dv.getInt32(ptr, true);
+    const type_ = dv.getUint32(ptr + 4, true);
+    const nameLen = totalLen - 8;
+    const nameBytes = new Uint8Array(ex.memory.buffer, ptr + 8, nameLen);
+    const name = new TextDecoder('utf-8').decode(nameBytes);
 
-    } finally {
-      ex.wasm_free(sizePtr);
-      ex.wasm_free(typePtr);
-      ex.wasm_free(namePtr);
-    }
+    return { name, size, type: type_ };
   }
 
   getActiveAttrib(program, index) {
@@ -903,43 +861,18 @@ export class WasmWebGL2RenderingContext {
     }
     const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
 
-    // Allocate buffers: size(4) + type(4) + name(256)
-    const sizePtr = ex.wasm_alloc(4);
-    const typePtr = ex.wasm_alloc(4);
-    const nameMaxLen = 256;
-    const namePtr = ex.wasm_alloc(nameMaxLen);
-
-    try {
-      const nameLen = ex.wasm_ctx_get_active_attrib(
-        this._ctxHandle,
-        programHandle,
-        index >>> 0,
-        sizePtr,
-        typePtr,
-        namePtr,
-        nameMaxLen
-      );
-
-      if (nameLen === 0) {
-        return null;
-      }
-
-      const mem32SizeIdx = sizePtr >>> 2;
-      const mem32TypeIdx = typePtr >>> 2;
-
-      const size = new Int32Array(ex.memory.buffer)[mem32SizeIdx];
-      const type_ = new Uint32Array(ex.memory.buffer)[mem32TypeIdx];
-
-      const nameBytes = new Uint8Array(ex.memory.buffer, namePtr, nameLen);
-      const name = new TextDecoder().decode(nameBytes);
+    const ptr = ex.wasm_ctx_get_active_attrib(this._ctxHandle, programHandle, index >>> 0);
+    if (ptr === 0) return null;
 
-      return { name, size, type: type_ };
+    const dv = new DataView(ex.memory.buffer);
+    const totalLen = dv.getUint32(ptr - 16, true);
+    const size = dv.getInt32(ptr, true);
+    const type_ = dv.getUint32(ptr + 4, true);
+    const nameLen = totalLen - 8;
+    const nameBytes = new Uint8Array(ex.memory.buffer, ptr + 8, nameLen);
+    const name = new TextDecoder('utf-8').decode(nameBytes);
 
-    } finally {
-      ex.wasm_free(sizePtr);
-      ex.wasm_free(typePtr);
-      ex.wasm_free(namePtr);
-    }
+    return { name, size, type: type_ };
   }
 
   linkProgram(program) {
@@ -1036,7 +969,10 @@ export class WasmWebGL2RenderingContext {
     const mathFuncs = [
       'gl_sin', 'gl_cos', 'gl_tan', 'gl_asin', 'gl_acos', 'gl_atan', 'gl_atan2',
       'gl_exp', 'gl_exp2', 'gl_log', 'gl_log2', 'gl_pow',
-      'gl_sinh', 'gl_cosh', 'gl_tanh', 'gl_asinh', 'gl_acosh', 'gl_atanh'
+      'gl_sinh', 'gl_cosh', 'gl_tanh', 'gl_asinh', 'gl_acosh', 'gl_atanh',
+      'gl_inverse_mat2', 'gl_inverse_mat3',
+      'gl_debug4'
+
     ];
     for (const name of mathFuncs) {
       if (this._instance.exports[name]) {
@@ -1056,7 +992,19 @@ export class WasmWebGL2RenderingContext {
     }
 
     let fsModule;
+    // Dump WASM to disk when debug_shaders is enabled to aid diagnostics
+    if (this._debugShaders) {
+      try {
+        require('fs').writeFileSync('test_debug/failing_fragment.wasm', Buffer.from(fsWasm));
+      } catch (e) {
+        // Best-effort; ignore write failures in constrained environments
+      }
+    }
+    if (this._debug) {
+        console.log("Compiling FS Module...");
+    }
     fsModule = new WebAssembly.Module(fsWasm);
+
     const fsInstanceRef = { current: null };
     const fsDebugEnv = createDebugEnv(this.FRAGMENT_SHADER, fsInstanceRef);
 
@@ -1078,6 +1026,10 @@ export class WasmWebGL2RenderingContext {
       }
     }
 
+    if (!fsEnv.gl_debug4) fsEnv.gl_debug4 = (a, b, c, d) => {};
+    if (!fsEnv.gl_inverse_mat2) fsEnv.gl_inverse_mat2 = (in_ptr, out_ptr) => {};
+    if (!fsEnv.gl_inverse_mat3) fsEnv.gl_inverse_mat3 = (in_ptr, out_ptr) => {};
+
     program._fsInstance = new WebAssembly.Instance(fsModule, {
       env: fsEnv
     });
@@ -1197,18 +1149,14 @@ export class WasmWebGL2RenderingContext {
     }
     const shaderHandle = shader && typeof shader === 'object' && typeof shader._handle === 'number' ? shader._handle : (shader >>> 0);
 
-    const maxLen = 1024;
-    const ptr = ex.wasm_alloc(maxLen);
-    if (ptr === 0) throw new Error('Failed to allocate memory for getShaderInfoLog');
+    const ptr = ex.wasm_ctx_get_shader_info_log(this._ctxHandle, shaderHandle);
+    if (ptr === 0) return "";
 
-    try {
-      const len = ex.wasm_ctx_get_shader_info_log(this._ctxHandle, shaderHandle, ptr, maxLen);
-      const mem = new Uint8Array(ex.memory.buffer);
-      const bytes = mem.subarray(ptr, ptr + len);
-      return new TextDecoder().decode(bytes);
-    } finally {
-      ex.wasm_free(ptr);
-    }
+    const dv = new DataView(ex.memory.buffer);
+    const len = dv.getUint32(ptr - 16, true);
+    const mem = new Uint8Array(ex.memory.buffer);
+    const bytes = mem.slice(ptr, ptr + len);
+    return new TextDecoder().decode(bytes);
   }
 
   getProgramInfoLog(program) {
@@ -1219,18 +1167,14 @@ export class WasmWebGL2RenderingContext {
     }
     const programHandle = program && typeof program === 'object' && typeof program._handle === 'number' ? program._handle : (program >>> 0);
 
-    const maxLen = 1024;
-    const ptr = ex.wasm_alloc(maxLen);
-    if (ptr === 0) throw new Error('Failed to allocate memory for getProgramInfoLog');
+    const ptr = ex.wasm_ctx_get_program_info_log(this._ctxHandle, programHandle);
+    if (ptr === 0) return "";
 
-    try {
-      const len = ex.wasm_ctx_get_program_info_log(this._ctxHandle, programHandle, ptr, maxLen);
-      const mem = new Uint8Array(ex.memory.buffer);
-      const bytes = mem.subarray(ptr, ptr + len);
-      return new TextDecoder().decode(bytes);
-    } finally {
-      ex.wasm_free(ptr);
-    }
+    const dv = new DataView(ex.memory.buffer);
+    const len = dv.getUint32(ptr - 16, true);
+    const mem = new Uint8Array(ex.memory.buffer);
+    const bytes = mem.slice(ptr, ptr + len);
+    return new TextDecoder().decode(bytes);
   }
 
   getProgramWasm(program, shaderType) {
@@ -1899,45 +1843,18 @@ export class WasmWebGL2RenderingContext {
     }
     const programHandle = program && typeof program === "object" && typeof program._handle === "number" ? program._handle : (program >>> 0);
 
-    const sizePtr = ex.wasm_alloc(4);
-    const typePtr = ex.wasm_alloc(4);
-    const nameCapacity = 256;
-    const namePtr = ex.wasm_alloc(nameCapacity);
-
-    if (sizePtr === 0 || typePtr === 0 || namePtr === 0) {
-      if (sizePtr) ex.wasm_free(sizePtr);
-      if (typePtr) ex.wasm_free(typePtr);
-      if (namePtr) ex.wasm_free(namePtr);
-      throw new Error("Failed to allocate memory for getTransformFeedbackVarying");
-    }
-
-    try {
-      const code = ex.wasm_ctx_get_transform_feedback_varying(
-        this._ctxHandle,
-        programHandle,
-        index >>> 0,
-        sizePtr,
-        typePtr,
-        namePtr,
-        nameCapacity
-      );
-      _checkErr(code, this._instance);
-
-      const mem = new DataView(ex.memory.buffer);
-      const size = mem.getInt32(sizePtr, true);
-      const type = mem.getUint32(typePtr, true);
+    const ptr = ex.wasm_ctx_get_transform_feedback_varying(this._ctxHandle, programHandle, index >>> 0);
+    if (ptr === 0) return null;
 
-      const nameBytes = new Uint8Array(ex.memory.buffer, namePtr, nameCapacity);
-      let nameLen = 0;
-      while (nameLen < nameCapacity && nameBytes[nameLen] !== 0) nameLen++;
-      const name = new TextDecoder().decode(nameBytes.subarray(0, nameLen));
+    const dv = new DataView(ex.memory.buffer);
+    const totalLen = dv.getUint32(ptr - 16, true);
+    const size = dv.getInt32(ptr, true);
+    const type = dv.getUint32(ptr + 4, true);
+    const nameLen = totalLen - 8;
+    const nameBytes = new Uint8Array(ex.memory.buffer, ptr + 8, nameLen);
+    const name = new TextDecoder('utf-8').decode(nameBytes);
 
-      return { name, size, type };
-    } finally {
-      ex.wasm_free(sizePtr);
-      ex.wasm_free(typePtr);
-      ex.wasm_free(namePtr);
-    }
+    return { name, size, type };
   }
 
   createQuery() { this._assertNotDestroyed(); throw new Error('not implemented'); }
@@ -2298,116 +2215,66 @@ export class WasmWebGL2RenderingContext {
   getParameter(pname) {
     this._assertNotDestroyed();
     const ex = this._instance.exports;
-    if (!ex || typeof ex.wasm_ctx_get_parameter_v !== 'function') {
-      throw new Error('wasm_ctx_get_parameter_v not found');
+    if (!ex || typeof ex.wasm_ctx_get_parameter !== 'function') {
+      throw new Error('wasm_ctx_get_parameter not found');
+    }
+
+    if (pname === 0x8869 /* MAX_VERTEX_ATTRIBS */) {
+      return 16;
+    }
+
+    const ptr = ex.wasm_ctx_get_parameter(this._ctxHandle, pname);
+    if (ptr === 0) {
+      return null;
+    }
+
+    const dv = new DataView(ex.memory.buffer);
+
+    if (pname === 0x1F00 || pname === 0x1F01 || pname === 0x1F02 || pname === 0x8B8C) {
+      const len = dv.getUint32(ptr - 16, true);
+      const bytes = new Uint8Array(ex.memory.buffer, ptr, len);
+      return new TextDecoder().decode(bytes);
     }
 
     if (pname === 0x0BA2 /* VIEWPORT */) {
-      const ptr = ex.wasm_alloc(16);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 16);
-        _checkErr(code, this._instance);
-        const mem = new Int32Array(ex.memory.buffer, ptr, 4);
-        return new Int32Array(mem);
-      } finally {
-        ex.wasm_free(ptr, 16);
-      }
+      return new Int32Array(ex.memory.buffer.slice(ptr, ptr + 16));
     }
 
     if (pname === 0x0C22 /* COLOR_CLEAR_VALUE */) {
-      const ptr = ex.wasm_alloc(16);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 16);
-        _checkErr(code, this._instance);
-        const mem = new Float32Array(ex.memory.buffer, ptr, 4);
-        return new Float32Array(mem);
-      } finally {
-        ex.wasm_free(ptr, 16);
-      }
+      return new Float32Array(ex.memory.buffer.slice(ptr, ptr + 16));
     }
 
     if (pname === 0x0C23 /* COLOR_WRITEMASK */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const mem = new Uint8Array(ex.memory.buffer, ptr, 4);
-        return [mem[0] !== 0, mem[1] !== 0, mem[2] !== 0, mem[3] !== 0];
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
+      const mem = new Uint8Array(ex.memory.buffer, ptr, 4);
+      return [mem[0] !== 0, mem[1] !== 0, mem[2] !== 0, mem[3] !== 0];
     }
 
     if (pname === 0x8CA6 /* DRAW_FRAMEBUFFER_BINDING */ || pname === 0x8CAA /* READ_FRAMEBUFFER_BINDING */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const handle = new Int32Array(ex.memory.buffer, ptr, 1)[0];
-        if (handle === 0) return null;
-        return this._fbHandles.get(handle) || null;
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
+      const handle = dv.getInt32(ptr, true);
+      if (handle === 0) return null;
+      return this._fbHandles.get(handle) || null;
     }
 
     if (pname === 0x8CA7 /* RENDERBUFFER_BINDING */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const handle = new Int32Array(ex.memory.buffer, ptr, 1)[0];
-        if (handle === 0) return null;
-        return this._rbHandles.get(handle) || null;
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
+      const handle = dv.getInt32(ptr, true);
+      if (handle === 0) return null;
+      return this._rbHandles.get(handle) || null;
     }
 
     if (pname === 0x8824 /* MAX_DRAW_BUFFERS */ || pname === 0x8CDF /* MAX_COLOR_ATTACHMENTS */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        return new Int32Array(ex.memory.buffer, ptr, 1)[0];
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
+      return dv.getInt32(ptr, true);
     }
 
     if (pname >= 0x8825 /* DRAW_BUFFER0 */ && pname <= 0x882C /* DRAW_BUFFER7 */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        return new Int32Array(ex.memory.buffer, ptr, 1)[0];
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
+      return dv.getInt32(ptr, true);
     }
 
     if (pname === 0x0B72 /* DEPTH_WRITEMASK */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const mem = new Uint8Array(ex.memory.buffer, ptr, 1);
-        return mem[0] !== 0;
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
+      return dv.getUint8(ptr) !== 0;
     }
 
     if (pname === 0x0B98 /* STENCIL_WRITEMASK */ || pname === 0x8CA5 /* STENCIL_BACK_WRITEMASK */) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const mem = new Int32Array(ex.memory.buffer, ptr, 1);
-        return mem[0];
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
+      return dv.getInt32(ptr, true);
     }
 
     const singleIntParams = [
@@ -2427,19 +2294,7 @@ export class WasmWebGL2RenderingContext {
     ];
 
     if (singleIntParams.includes(pname)) {
-      const ptr = ex.wasm_alloc(4);
-      try {
-        const code = ex.wasm_ctx_get_parameter_v(this._ctxHandle, pname, ptr, 4);
-        _checkErr(code, this._instance);
-        const mem = new Int32Array(ex.memory.buffer, ptr, 1);
-        return mem[0];
-      } finally {
-        ex.wasm_free(ptr, 4);
-      }
-    }
-
-    if (pname === 0x8869 /* MAX_VERTEX_ATTRIBS */) {
-      return 16;
+      return dv.getInt32(ptr, true);
     }
 
     throw new Error(`getParameter for ${pname} not implemented`);
@@ -2721,16 +2576,24 @@ export class WasmWebGL2RenderingContext {
  */
 export function readErrorMessage(instance) {
   const ex = instance.exports;
-  if (!ex || typeof ex.wasm_last_error_ptr !== 'function' || typeof ex.wasm_last_error_len !== 'function') {
+  if (!ex || typeof ex.wasm_last_error !== 'function') {
+    // Fallback to old ptr/len if exists, otherwise return unknown
+    if (typeof ex.wasm_last_error_ptr === 'function') {
+      const ptr = ex.wasm_last_error_ptr();
+      const len = ex.wasm_last_error_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 '(no error message available)';
   }
-  const ptr = ex.wasm_last_error_ptr();
-  const len = ex.wasm_last_error_len();
-  if (ptr === 0 || len === 0) {
-    return '';
-  }
+  const ptr = ex.wasm_last_error();
+  if (ptr === 0) return '';
+  const dv = new DataView(ex.memory.buffer);
+  const len = dv.getUint32(ptr - 16, true);
   const mem = new Uint8Array(ex.memory.buffer);
-  const bytes = mem.subarray(ptr, ptr + len);
+  const bytes = mem.slice(ptr, ptr + len);
   return new TextDecoder('utf-8').decode(bytes);
 }
 
@@ -2878,24 +2741,18 @@ export function getShaderGlsl(ctxHandle, programHandle, shaderType) {
     mem.set(wasmBytes, wasmBytesPtr);
 
     // Call the decompiler
-    const resultLen = ex.wasm_decompile_to_glsl(wasmBytesPtr, wasmBytesLen);
+    const glslPtr = ex.wasm_decompile_to_glsl(wasmBytesPtr, wasmBytesLen);
 
-    if (resultLen === 0) {
+    if (glslPtr === 0) {
       return null;
     }
 
-    // Get the decompiled GLSL
-    const glslPtr = ex.wasm_get_decompiled_glsl_ptr();
-    const glslLen = ex.wasm_get_decompiled_glsl_len();
-
-    if (glslPtr === 0 || glslLen === 0) {
-      return null;
-    }
+    const dv = new DataView(ex.memory.buffer);
+    const glslLen = dv.getUint32(glslPtr - 16, true);
 
     // Read the GLSL string
-    const glslBytes = new Uint8Array(ex.memory.buffer).subarray(glslPtr, glslPtr + glslLen);
-    const decoder = new TextDecoder('utf-8');
-    return decoder.decode(glslBytes);
+    const glslBytes = new Uint8Array(ex.memory.buffer).slice(glslPtr, glslPtr + glslLen);
+    return new TextDecoder('utf-8').decode(glslBytes);
   } finally {
     // Free the allocated memory
     ex.wasm_free(wasmBytesPtr);
@@ -2934,24 +2791,18 @@ export function decompileWasmToGlsl(gl, wasmBytes) {
     mem.set(wasmBytes, wasmBytesPtr);
 
     // Call the decompiler
-    const resultLen = ex.wasm_decompile_to_glsl(wasmBytesPtr, wasmBytesLen);
+    const glslPtr = ex.wasm_decompile_to_glsl(wasmBytesPtr, wasmBytesLen);
 
-    if (resultLen === 0) {
+    if (glslPtr === 0) {
       return null;
     }
 
-    // Get the decompiled GLSL
-    const glslPtr = ex.wasm_get_decompiled_glsl_ptr();
-    const glslLen = ex.wasm_get_decompiled_glsl_len();
-
-    if (glslPtr === 0 || glslLen === 0) {
-      return null;
-    }
+    const dv = new DataView(ex.memory.buffer);
+    const glslLen = dv.getUint32(glslPtr - 16, true);
 
     // Read the GLSL string
-    const glslBytes = new Uint8Array(ex.memory.buffer).subarray(glslPtr, glslPtr + glslLen);
-    const decoder = new TextDecoder('utf-8');
-    return decoder.decode(glslBytes);
+    const glslBytes = new Uint8Array(ex.memory.buffer).slice(glslPtr, glslPtr + glslLen);
+    return new TextDecoder('utf-8').decode(glslBytes);
   } finally {
     // Free the allocated memory
     ex.wasm_free(wasmBytesPtr);