@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/texture/virtual/build_shader_vt_feedback.js

@@ -1,231 +1,233 @@
-import { atomic_u32, f32, u32, vec2u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
-import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
-import { MATERIAL_METADATA_STRUCT } from "../../material/MATERIAL_METADATA_STRUCT.js";
-import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
-import { RENDER_GLOBAL_MIP_BIAS } from "../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
-import { chunk_barycentric_full } from "../../shader/chunk/geometry/triangle/chunk_barycentric_full.js";
-import { chunk_barycentric_interpolate_uv } from "../../shader/chunk/geometry/triangle/chunk_barycentric_interpolate_uv.js";
-import { chunk_decode_meshlet_element } from "../../shader/chunk/geometry/meshlet/chunk_decode_meshlet_element.js";
-import {
-    chunk_read_meshlet_triangle_vertices
-} from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_triangle_vertices.js";
-import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
-import { chunk_vt_request_key } from "./chunk_vt_request_key.js";
-import { VT_STACK_ID_INVALID } from "./VT_CONSTANTS.js";
-import { VT_STACK_INFO_STRUCT } from "./VT_STACK_INFO_STRUCT.js";
-
-/**
- * Uniform parameters of the feedback pass.
- *
- * `stride` — the pass samples one pixel per stride×stride block;
- * `jitter` — which pixel of the block this frame (cycled by the manager so
- * coverage integrates to every pixel over stride² frames);
- * `mip_bias` — added to the requested LOD; carries the residency
- * (over-subscription) bias so pressure degrades to blur instead of thrash.
- */
-export const VT_FEEDBACK_PARAMS_STRUCT = WebGPUStruct.from({
-    stride: u32,
-    jitter: vec2u,
-    mip_bias: f32,
-}, "VTFeedbackParams").pack();
-
-/**
- * Matches the fragment_gbuffer derivative bias so feedback requests the mips
- * the material pass actually samples.
- * @type {number}
- */
-const MIP_DERIVATIVE_BIAS = 1 / (1 - RENDER_GLOBAL_MIP_BIAS);
-
-export const VT_FEEDBACK_WORKGROUP_SIZE = 8;
-
-/**
- * Builds the feedback compute shader: one thread per sampled pixel, reading
- * the visibility buffer and reproducing the material pass's UV + analytic
- * gradient math (vertex pulling + perspective-correct barycentric
- * derivatives), then inserting the touched (stack, mip, page) key into a
- * global hash set of unique requests.
- *
- * This is the "no second geometry pass" property: the viz buffer already
- * identifies the triangle per pixel, so usage detection is a bounded-cost
- * screen-space compute pass regardless of scene complexity, shared by every
- * virtual texture in the frame.
- *
- * The hash set is insert-only and cleared each frame; the CPU reads the raw
- * table back and treats presence as "touched this frame" — both residency
- * touches (LRU) and misses (load requests) fall out of the same data.
- *
- * @param {Object} config
- * @param {CodeChunk} config.chunk_vt_lookup from {@link build_chunk_vt_lookup}
- * @param {number} config.hash_capacity power of two
- * @returns {ComputeShader}
- */
-export function build_shader_vt_feedback({ chunk_vt_lookup, hash_capacity }) {
-
-    const resources = new ShaderResourceSetDescriptor();
-
-    resources.createGroup()
-        .addTexture("viz_buffer_triangle", "uint")
-        .addTexture("viz_buffer_mesh", "uint")
-        .addUniform("view", VIEW_UNIFORM_STRUCT)
-        .addUniform("vt_params", VT_FEEDBACK_PARAMS_STRUCT)
-        .addStorageBuffer("scene_database", WebGPUArray.from(u32))
-        .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
-        .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
-        .addStorageBuffer("material_metadata", WebGPUArray.from(MATERIAL_METADATA_STRUCT))
-        .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
-        .addStorageBuffer("vt_requests", WebGPUArray.from(atomic_u32), true);
-
-    const body = CodeChunk.from(
-        //language=WGSL
-        `
-const VT_HASH_CAPACITY_MASK: u32 = ${hash_capacity - 1}u;
-const VT_HASH_MAX_PROBES: u32 = 32u;
-
-const MIP_BIAS: f32 = ${MIP_DERIVATIVE_BIAS.toFixed(8)};
-
-// Insert-only open-addressing hash set. Values are stored as key+1 so a
-// zero-cleared buffer means "all empty" (same conventions as
-// common/hash_table, which is the CPU-build/GPU-read counterpart of this
-// GPU-insert/CPU-read set; see also the SHARC hash map for the bucketed
-// key->index variant).
-//
-// Forward-progress note: this loop never waits on another invocation's
-// progress. The atomicCompareExchangeWeak retry only re-tests a *local*
-// spurious failure, every iteration consumes the shared probe budget, and
-// the loop is hard-bounded at VT_HASH_MAX_PROBES regardless of what other
-// threads do. On exhaustion the fallback is to DROP the request — benign,
-// feedback re-emits it next frame. Contrast with the decoupled-lookback
-// spin in common/prefix_sum/v1/shader_prefix_scan_csdldf.js, where the
-// awaited value is required for correctness and the bounded spin
-// (MAX_SPIN_COUNT) must therefore pair with a local recompute fallback.
-fn vt_request_insert(key: u32) {
-    let stored = key + 1u;
-
-    var h = hash_lowbias32(key) & VT_HASH_CAPACITY_MASK;
-
-    for (var i = 0u; i < VT_HASH_MAX_PROBES; i++) {
-        let existing = atomicLoad(&vt_requests[h]);
-
-        if (existing == stored) {
-            return;
-        }
-
-        if (existing == 0u) {
-            let r = atomicCompareExchangeWeak(&vt_requests[h], 0u, stored);
-
-            if (r.exchanged || r.old_value == stored) {
-                return;
-            }
-
-            if (r.old_value == 0u) {
-                // spurious weak failure — retry the same slot
-                continue;
-            }
-        }
-
-        h = (h + 1u) & VT_HASH_CAPACITY_MASK;
-    }
-}
-
-@compute @workgroup_size(${VT_FEEDBACK_WORKGROUP_SIZE}, ${VT_FEEDBACK_WORKGROUP_SIZE}, 1)
-fn main(
-    @builtin(global_invocation_id) gid: vec3<u32>,
-) {
-    let pixel = gid.xy * vt_params.stride + vt_params.jitter;
-
-    if (pixel.x >= view.width || pixel.y >= view.height) {
-        return;
-    }
-
-    let mesh_index = textureLoad(viz_buffer_mesh, vec2<i32>(pixel), 0).r;
-
-    if (mesh_index == ${VIZ_BUFFER_INVALID_MESH_VALUE}u) {
-        return;
-    }
-
-    let mesh = scene_read_mesh(&scene_database, mesh_index);
-
-    let stack_id = material_metadata[mesh.material].vt_stack;
-
-    if (stack_id == ${VT_STACK_ID_INVALID}u) {
-        return;
-    }
-
-    let info = vt_stacks[stack_id];
-
-    // ── UV + gradients, mirroring fragment_gbuffer ──────────────────
-    let encoded_meshlet_triangle = textureLoad(viz_buffer_triangle, vec2<i32>(pixel), 0).r;
-
-    let decoded = decode_meshlet_element(encoded_meshlet_triangle);
-    let meshlet_id = decoded[0];
-    let meshlet_triangle_id = decoded[1];
-
-    let node = scene_read_node(&scene_database, mesh.node);
-
-    let triangle = read_meshlet_triangle_vertices(meshlet_id, meshlet_triangle_id);
-
-    let mesh_transform = node.global;
-
-    let p0 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.a.position, 1.0));
-    let p1 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.b.position, 1.0));
-    let p2 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.c.position, 1.0));
-
-    let pixel_center = vec2<f32>(pixel) + 0.5;
-
-    let barycentric = barycentric_full(p0, p1, p2, pixel_center);
-
-    var uv0 = triangle.a.uv;
-    var uv1 = triangle.b.uv;
-    var uv2 = triangle.c.uv;
-
-    if ((info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
-        uv0 = triangle.a.uv1;
-        uv1 = triangle.b.uv1;
-        uv2 = triangle.c.uv1;
-    }
-
-    var uv_info = barycentric_interpolate_uv(barycentric, uv0, uv1, uv2);
-
-    let uv_derivative_bias = MIP_BIAS / view.upscale_ratio;
-
-    uv_info.ddx *= uv_derivative_bias.x;
-    uv_info.ddy *= uv_derivative_bias.y;
-
-    // ── request ─────────────────────────────────────────────────────
-    let uv_wrapped = vt_stack_wrap_uv(uv_info.uv, info.flags);
-
-    let mip = vt_mip_select(info, uv_info.ddx, uv_info.ddy, vt_params.mip_bias);
-
-    let page = vt_page_coord(info, uv_wrapped, mip);
-
-    vt_request_insert(vt_request_key_pack(stack_id, mip, page));
-}
-`,
-        [
-            chunk_vt_lookup,
-            chunk_vt_request_key,
-            chunk_hash_lowbias32,
-            chunk_scene_database_access,
-            chunk_decode_meshlet_element,
-            chunk_read_meshlet_triangle_vertices,
-            chunk_barycentric_full,
-            chunk_barycentric_interpolate_uv,
-        ]
-    );
-
-    return ComputeShader.from({
-        label: 'vt/feedback',
-        body,
-        resources,
-    });
-}
+import { atomic_u32, f32, u32, vec2u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
+import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import {
+    VIZ_BUFFER_INVALID_MESH_VALUE
+} from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import { MATERIAL_METADATA_STRUCT } from "../../material/MATERIAL_METADATA_STRUCT.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { RENDER_GLOBAL_MIP_BIAS } from "../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
+import { chunk_barycentric_full } from "../../shader/chunk/geometry/triangle/chunk_barycentric_full.js";
+import { chunk_barycentric_interpolate_uv } from "../../shader/chunk/geometry/triangle/chunk_barycentric_interpolate_uv.js";
+import { chunk_decode_meshlet_element } from "../../shader/chunk/geometry/meshlet/chunk_decode_meshlet_element.js";
+import {
+    chunk_read_meshlet_triangle_vertices
+} from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_triangle_vertices.js";
+import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_vt_request_key } from "./chunk_vt_request_key.js";
+import { VT_STACK_ID_INVALID } from "./VT_CONSTANTS.js";
+import { VT_STACK_INFO_STRUCT } from "./VT_STACK_INFO_STRUCT.js";
+
+/**
+ * Uniform parameters of the feedback pass.
+ *
+ * `stride` — the pass samples one pixel per stride×stride block;
+ * `jitter` — which pixel of the block this frame (cycled by the manager so
+ * coverage integrates to every pixel over stride² frames);
+ * `mip_bias` — added to the requested LOD; carries the residency
+ * (over-subscription) bias so pressure degrades to blur instead of thrash.
+ */
+export const VT_FEEDBACK_PARAMS_STRUCT = WebGPUStruct.from({
+    stride: u32,
+    jitter: vec2u,
+    mip_bias: f32,
+}, "VTFeedbackParams").pack();
+
+/**
+ * Matches the fragment_gbuffer derivative bias so feedback requests the mips
+ * the material pass actually samples.
+ * @type {number}
+ */
+const MIP_DERIVATIVE_BIAS = 1 / (1 - RENDER_GLOBAL_MIP_BIAS);
+
+export const VT_FEEDBACK_WORKGROUP_SIZE = 8;
+
+/**
+ * Builds the feedback compute shader: one thread per sampled pixel, reading
+ * the visibility buffer and reproducing the material pass's UV + analytic
+ * gradient math (vertex pulling + perspective-correct barycentric
+ * derivatives), then inserting the touched (stack, mip, page) key into a
+ * global hash set of unique requests.
+ *
+ * This is the "no second geometry pass" property: the viz buffer already
+ * identifies the triangle per pixel, so usage detection is a bounded-cost
+ * screen-space compute pass regardless of scene complexity, shared by every
+ * virtual texture in the frame.
+ *
+ * The hash set is insert-only and cleared each frame; the CPU reads the raw
+ * table back and treats presence as "touched this frame" — both residency
+ * touches (LRU) and misses (load requests) fall out of the same data.
+ *
+ * @param {Object} config
+ * @param {CodeChunk} config.chunk_vt_lookup from {@link build_chunk_vt_lookup}
+ * @param {number} config.hash_capacity power of two
+ * @returns {ComputeShader}
+ */
+export function build_shader_vt_feedback({ chunk_vt_lookup, hash_capacity }) {
+
+    const resources = new ShaderResourceSetDescriptor();
+
+    // per-dispatch, 16 bytes, read-only: immediate data rather than a uniform buffer
+    resources.setImmediate("vt_params", VT_FEEDBACK_PARAMS_STRUCT);
+
+    resources.createGroup()
+        .addTexture("viz_buffer_triangle", "uint")
+        .addTexture("viz_buffer_mesh", "uint")
+        .addUniform("view", VIEW_UNIFORM_STRUCT)
+        .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+        .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
+        .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
+        .addStorageBuffer("material_metadata", WebGPUArray.from(MATERIAL_METADATA_STRUCT))
+        .addStorageBuffer("vt_stacks", WebGPUArray.from(VT_STACK_INFO_STRUCT))
+        .addStorageBuffer("vt_requests", WebGPUArray.from(atomic_u32), true);
+
+    const body = CodeChunk.from(
+        //language=WGSL
+        `
+const VT_HASH_CAPACITY_MASK: u32 = ${hash_capacity - 1}u;
+const VT_HASH_MAX_PROBES: u32 = 32u;
+
+const MIP_BIAS: f32 = ${MIP_DERIVATIVE_BIAS.toFixed(8)};
+
+// Insert-only open-addressing hash set. Values are stored as key+1 so a
+// zero-cleared buffer means "all empty" (same conventions as
+// common/hash_table, which is the CPU-build/GPU-read counterpart of this
+// GPU-insert/CPU-read set; see also the SHARC hash map for the bucketed
+// key->index variant).
+//
+// Forward-progress note: this loop never waits on another invocation's
+// progress. The atomicCompareExchangeWeak retry only re-tests a *local*
+// spurious failure, every iteration consumes the shared probe budget, and
+// the loop is hard-bounded at VT_HASH_MAX_PROBES regardless of what other
+// threads do. On exhaustion the fallback is to DROP the request — benign,
+// feedback re-emits it next frame. Contrast with the decoupled-lookback
+// spin in common/prefix_sum/v1/shader_prefix_scan_csdldf.js, where the
+// awaited value is required for correctness and the bounded spin
+// (MAX_SPIN_COUNT) must therefore pair with a local recompute fallback.
+fn vt_request_insert(key: u32) {
+    let stored = key + 1u;
+
+    var h = hash_lowbias32(key) & VT_HASH_CAPACITY_MASK;
+
+    for (var i = 0u; i < VT_HASH_MAX_PROBES; i++) {
+        let existing = atomicLoad(&vt_requests[h]);
+
+        if (existing == stored) {
+            return;
+        }
+
+        if (existing == 0u) {
+            let r = atomicCompareExchangeWeak(&vt_requests[h], 0u, stored);
+
+            if (r.exchanged || r.old_value == stored) {
+                return;
+            }
+
+            if (r.old_value == 0u) {
+                // spurious weak failure — retry the same slot
+                continue;
+            }
+        }
+
+        h = (h + 1u) & VT_HASH_CAPACITY_MASK;
+    }
+}
+
+@compute @workgroup_size(${VT_FEEDBACK_WORKGROUP_SIZE}, ${VT_FEEDBACK_WORKGROUP_SIZE}, 1)
+fn main(
+    @builtin(global_invocation_id) gid: vec3<u32>,
+) {
+    let pixel = gid.xy * vt_params.stride + vt_params.jitter;
+
+    if (pixel.x >= view.width || pixel.y >= view.height) {
+        return;
+    }
+
+    let mesh_index = textureLoad(viz_buffer_mesh, vec2<i32>(pixel), 0).r;
+
+    if (mesh_index == ${VIZ_BUFFER_INVALID_MESH_VALUE}u) {
+        return;
+    }
+
+    let mesh = scene_read_mesh(&scene_database, mesh_index);
+
+    let stack_id = material_metadata[mesh.material].vt_stack;
+
+    if (stack_id == ${VT_STACK_ID_INVALID}u) {
+        return;
+    }
+
+    let info = vt_stacks[stack_id];
+
+    // ── UV + gradients, mirroring fragment_gbuffer ──────────────────
+    let encoded_meshlet_triangle = textureLoad(viz_buffer_triangle, vec2<i32>(pixel), 0).r;
+
+    let decoded = decode_meshlet_element(encoded_meshlet_triangle);
+    let meshlet_id = decoded[0];
+    let meshlet_triangle_id = decoded[1];
+
+    let node = scene_read_node(&scene_database, mesh.node);
+
+    let triangle = read_meshlet_triangle_vertices(meshlet_id, meshlet_triangle_id);
+
+    let mesh_transform = node.global;
+
+    let p0 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.a.position, 1.0));
+    let p1 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.b.position, 1.0));
+    let p2 = view.projection_matrix * (mesh_transform * vec4<f32>(triangle.c.position, 1.0));
+
+    let pixel_center = vec2<f32>(pixel) + 0.5;
+
+    let barycentric = barycentric_full(p0, p1, p2, pixel_center);
+
+    var uv0 = triangle.a.uv;
+    var uv1 = triangle.b.uv;
+    var uv2 = triangle.c.uv;
+
+    if ((info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
+        uv0 = triangle.a.uv1;
+        uv1 = triangle.b.uv1;
+        uv2 = triangle.c.uv1;
+    }
+
+    var uv_info = barycentric_interpolate_uv(barycentric, uv0, uv1, uv2);
+
+    let uv_derivative_bias = MIP_BIAS / view.upscale_ratio;
+
+    uv_info.ddx *= uv_derivative_bias.x;
+    uv_info.ddy *= uv_derivative_bias.y;
+
+    // ── request ─────────────────────────────────────────────────────
+    let uv_wrapped = vt_stack_wrap_uv(uv_info.uv, info.flags);
+
+    let mip = vt_mip_select(info, uv_info.ddx, uv_info.ddy, vt_params.mip_bias);
+
+    let page = vt_page_coord(info, uv_wrapped, mip);
+
+    vt_request_insert(vt_request_key_pack(stack_id, mip, page));
+}
+`,
+        [
+            chunk_vt_lookup,
+            chunk_vt_request_key,
+            chunk_hash_lowbias32,
+            chunk_scene_database_access,
+            chunk_decode_meshlet_element,
+            chunk_read_meshlet_triangle_vertices,
+            chunk_barycentric_full,
+            chunk_barycentric_interpolate_uv,
+        ]
+    );
+
+    return ComputeShader.from({
+        label: 'vt/feedback',
+        body,
+        resources,
+    });
+}

package/src/shade/renderer/volumetrics/graph_build_volumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,4DAFa;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CAgEjE;AAqTD;;;;;;;;;;;;;;;;;;GAkBG;AACH;;;;;EAwKC"}
+{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,4DAFa;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CA8DjE;AAqTD;;;;;;;;;;;;;;;;;;GAkBG;AACH;;;;;EAwKC"}

package/src/shade/renderer/volumetrics/graph_build_volumetrics.js

@@ -43,14 +43,12 @@ export function graph_integrate_sky({ graph }) {
 
         const encoder = context.encoder;
 
-        const settings_type = shader_transmittance_lut.descriptor.resources.getResourceByName("settings").buffer_type;
-
-        const settings = encoder.allocateTransientValueBuffer(settings_type, {
+        const settings = {
             steps: 40,
             // taken off the target being drawn into, so the generator cannot be told a size
             // the texture does not have
             resolution: [output.width, output.height],
-        });
+        };
 
         shader_transmittance_lut.draw({
             encoder: encoder,

package/src/shade/wgsl/validate_wgsl_source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate_wgsl_source.d.ts","sourceRoot":"","sources":["../../../../src/shade/wgsl/validate_wgsl_source.js"],"names":[],"mappings":"AA8JA;;;;;;GAMG;AACH,6CAJW,MAAM,UACN,OAAO,iBAAiB,EAAE,UAAU,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CAwJ7D"}
+{"version":3,"file":"validate_wgsl_source.d.ts","sourceRoot":"","sources":["../../../../src/shade/wgsl/validate_wgsl_source.js"],"names":[],"mappings":"AAmKA;;;;;;GAMG;AACH,6CAJW,MAAM,UACN,OAAO,iBAAiB,EAAE,UAAU,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CAwJ7D"}

package/src/shade/wgsl/validate_wgsl_source.js

@@ -37,7 +37,10 @@ const WGSL_BUILTIN_NAMES = new Set([
     'vec2f', 'vec3f', 'vec4f', 'vec2h', 'vec3h', 'vec4h',
     'mat2x2', 'mat2x3', 'mat2x4', 'mat3x2', 'mat3x3', 'mat3x4', 'mat4x2', 'mat4x3', 'mat4x4',
     'mat2x2f', 'mat2x3f', 'mat2x4f', 'mat3x2f', 'mat3x3f', 'mat3x4f', 'mat4x2f', 'mat4x3f', 'mat4x4f',
+    'mat2x2h', 'mat2x3h', 'mat2x4h', 'mat3x2h', 'mat3x3h', 'mat3x4h', 'mat4x2h', 'mat4x3h', 'mat4x4h',
     'array', 'bitcast',
+    // array
+    'arrayLength',
     // numeric
     'abs', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'atan2', 'ceil', 'clamp',
     'cos', 'cosh', 'countLeadingZeros', 'countOneBits', 'countTrailingZeros', 'cross',
@@ -71,9 +74,11 @@ const WGSL_BUILTIN_NAMES = new Set([
     'subgroupAdd', 'subgroupExclusiveAdd', 'subgroupInclusiveAdd', 'subgroupAll',
     'subgroupAnd', 'subgroupAny', 'subgroupBallot', 'subgroupBroadcast',
     'subgroupBroadcastFirst', 'subgroupElect', 'subgroupMax', 'subgroupMin', 'subgroupMul',
-    'subgroupOr', 'subgroupShuffle', 'subgroupShuffleDown', 'subgroupShuffleUp',
-    'subgroupShuffleXor', 'subgroupXor', 'quadBroadcast', 'quadSwapDiagonal', 'quadSwapX',
-    'quadSwapY',
+    'subgroupExclusiveMul', 'subgroupInclusiveMul', 'subgroupOr', 'subgroupShuffle',
+    'subgroupShuffleDown', 'subgroupShuffleUp', 'subgroupShuffleXor', 'subgroupXor',
+    'quadBroadcast', 'quadSwapDiagonal', 'quadSwapX', 'quadSwapY',
+    // buffer views
+    'bufferView', 'bufferArrayView', 'bufferLength',
 ]);
 
 const SWIZZLE_COMPONENTS = /^[xyzwrgba]+$/;

package/src/shade/device/timing/profile/make_profiling_pass_encoder.d.ts

@@ -1,21 +0,0 @@
-/**
- * Wrap a pass encoder so that the work encoded into it is recorded.
- *
- * **A `Proxy` rather than a hand-written forwarder.** A pass encoder has around twenty methods and
- * WebGPU keeps adding them; a forwarding class that misses one does not fail loudly, it silently
- * drops a call that the renderer needed, and only while profiling — the worst possible shape for a
- * bug. Everything not named below is forwarded untouched, including anything added later.
- *
- * The cost is a `Proxy` on the hot encoding path, which is why this exists only while a capture is
- * running at {@link GPUProfileLevel.WORKLOAD} or above. Bound methods are cached per encoder so the
- * `get` trap does not allocate a new closure on every `setBindGroup`.
- *
- * @param {GPUComputePassEncoder|GPURenderPassEncoder} encoder
- * @param {GPUProfileWork} work accumulated into
- * @returns {GPUComputePassEncoder|GPURenderPassEncoder}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function make_profiling_pass_encoder(encoder: GPUComputePassEncoder | GPURenderPassEncoder, work: GPUProfileWork): GPUComputePassEncoder | GPURenderPassEncoder;
-//# sourceMappingURL=make_profiling_pass_encoder.d.ts.map

package/src/shade/device/timing/profile/make_profiling_pass_encoder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"make_profiling_pass_encoder.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/make_profiling_pass_encoder.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qDAPW,4CAA0C,yBAExC,4CAA0C,CAiGtD"}