@woosh/meep-engine 3.57.0 → 3.58.0

package/src/shade/renderer/water/query/WATER_QUERY_DATABASE_SPEC.d.ts

@@ -0,0 +1,58 @@
+/**
+ * One request of the GPU water surface read API: the `water_bodies` row to sample, where its run of
+ * samples starts in `water_query_sample`, how many samples the run has, and the spatial filter
+ * footprint in metres (wavelengths below `2·footprint` are attenuated by `water_surface_sample`).
+ *
+ * @type {WebGPUStruct}
+ */
+export const WATER_QUERY_STRUCT: WebGPUStruct;
+/**
+ * One sample slot (8 bytes) in `water_query_sample`, written by `shader_water_surface_query` and
+ * read back by `GPUDatabaseReadback#request_run`:
+ * - `height`: the displaced world-space surface height `y` (metres).
+ * - `normal`: the world-space unit surface normal packed via `encode_vertex_normal` (2×16-bit
+ *   octahedral unorm in a single `u32`).
+ *
+ * @type {WebGPUStruct}
+ */
+export const WATER_QUERY_SAMPLE_STRUCT: WebGPUStruct;
+/** Name of the request table within {@link WATER_QUERY_DATABASE_SPEC}. */
+export const WATER_QUERY_TABLE: "water_query";
+/** Name of the sample table within {@link WATER_QUERY_DATABASE_SPEC}. */
+export const WATER_QUERY_SAMPLE_TABLE: "water_query_sample";
+/**
+ * A 16 KB page holds ~2,000 8-byte samples or ~1,000 16-byte requests, growing a page at a time
+ * past that.
+ *
+ * @type {number}
+ */
+export const WATER_QUERY_DATABASE_PAGE_SIZE: number;
+/**
+ * The page address table (two tables of `GPU_DATABASE_PAGE_LIMIT` u32 slots, 32 KB) and a page of
+ * each table, before the database grows itself.
+ *
+ * @type {number}
+ */
+export const WATER_QUERY_DATABASE_INITIAL_SIZE: number;
+/**
+ * # The GPU water surface read API's database
+ *
+ * | Table | Row | Lifecycle |
+ * |---|---|---|
+ * | `water_query` | one {@link WATER_QUERY_STRUCT} per request | added when the request is recorded; freed after its run is delivered or dropped |
+ * | `water_query_sample` | one {@link WATER_QUERY_SAMPLE_STRUCT} per query point, a run per request | allocated on record, written with `(world_height, packed_world_normal)` by `shader_water_surface_query`, read back as one run (`GPUDatabaseReadback#request_run`), freed with its request |
+ *
+ * @type {GPUDatabaseDefinition}
+ */
+export const WATER_QUERY_DATABASE_SPEC: GPUDatabaseDefinition;
+/**
+ * @type {import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor}
+ */
+export const WATER_QUERY_DESCRIPTOR: import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+/**
+ * @type {import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor}
+ */
+export const WATER_QUERY_SAMPLE_DESCRIPTOR: import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { GPUDatabaseDefinition } from "../../buffer/table/GPUDatabaseDefinition.js";
+//# sourceMappingURL=WATER_QUERY_DATABASE_SPEC.d.ts.map

package/src/shade/renderer/water/query/WATER_QUERY_DATABASE_SPEC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WATER_QUERY_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/query/WATER_QUERY_DATABASE_SPEC.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,iCAFU,YAAY,CAOL;AAEjB;;;;;;;;GAQG;AACH,wCAFU,YAAY,CAKC;AAEvB,0EAA0E;AAC1E,8CAA+C;AAE/C,yEAAyE;AACzE,4DAA6D;AAE7D;;;;;GAKG;AACH,6CAFU,MAAM,CAE4C;AAE5D;;;;;GAKG;AACH,gDAFU,MAAM,CAE+C;AAE/D;;;;;;;;;GASG;AACH,wCAFU,qBAAqB,CAKI;AAEnC;;GAEG;AACH,qCAFU,OAAO,+CAA+C,EAAE,uBAAuB,CAEF;AAEvF;;GAEG;AACH,4CAFU,OAAO,+CAA+C,EAAE,uBAAuB,CAEY;6BA3ExE,mCAAmC;sCAF1B,6CAA6C"}

package/src/shade/renderer/water/query/WATER_QUERY_DATABASE_SPEC.js

@@ -0,0 +1,79 @@
+import { KILOBYTE } from "../../../../core/science/units/memory/KILOBYTE.js";
+import { GPUDatabaseDefinition } from "../../buffer/table/GPUDatabaseDefinition.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * One request of the GPU water surface read API: the `water_bodies` row to sample, where its run of
+ * samples starts in `water_query_sample`, how many samples the run has, and the spatial filter
+ * footprint in metres (wavelengths below `2·footprint` are attenuated by `water_surface_sample`).
+ *
+ * @type {WebGPUStruct}
+ */
+export const WATER_QUERY_STRUCT = WebGPUStruct.from({
+    body: u32,
+    first_sample: u32,
+    sample_count: u32,
+    footprint: f32,
+}, 'WaterQuery');
+
+/**
+ * One sample slot (8 bytes) in `water_query_sample`, written by `shader_water_surface_query` and
+ * read back by `GPUDatabaseReadback#request_run`:
+ * - `height`: the displaced world-space surface height `y` (metres).
+ * - `normal`: the world-space unit surface normal packed via `encode_vertex_normal` (2×16-bit
+ *   octahedral unorm in a single `u32`).
+ *
+ * @type {WebGPUStruct}
+ */
+export const WATER_QUERY_SAMPLE_STRUCT = WebGPUStruct.from({
+    height: f32,
+    normal: u32,
+}, 'WaterQuerySample');
+
+/** Name of the request table within {@link WATER_QUERY_DATABASE_SPEC}. */
+export const WATER_QUERY_TABLE = "water_query";
+
+/** Name of the sample table within {@link WATER_QUERY_DATABASE_SPEC}. */
+export const WATER_QUERY_SAMPLE_TABLE = "water_query_sample";
+
+/**
+ * A 16 KB page holds ~2,000 8-byte samples or ~1,000 16-byte requests, growing a page at a time
+ * past that.
+ *
+ * @type {number}
+ */
+export const WATER_QUERY_DATABASE_PAGE_SIZE = 16 * KILOBYTE;
+
+/**
+ * The page address table (two tables of `GPU_DATABASE_PAGE_LIMIT` u32 slots, 32 KB) and a page of
+ * each table, before the database grows itself.
+ *
+ * @type {number}
+ */
+export const WATER_QUERY_DATABASE_INITIAL_SIZE = 64 * KILOBYTE;
+
+/**
+ * # The GPU water surface read API's database
+ *
+ * | Table | Row | Lifecycle |
+ * |---|---|---|
+ * | `water_query` | one {@link WATER_QUERY_STRUCT} per request | added when the request is recorded; freed after its run is delivered or dropped |
+ * | `water_query_sample` | one {@link WATER_QUERY_SAMPLE_STRUCT} per query point, a run per request | allocated on record, written with `(world_height, packed_world_normal)` by `shader_water_surface_query`, read back as one run (`GPUDatabaseReadback#request_run`), freed with its request |
+ *
+ * @type {GPUDatabaseDefinition}
+ */
+export const WATER_QUERY_DATABASE_SPEC = GPUDatabaseDefinition.from({
+    [WATER_QUERY_TABLE]: WATER_QUERY_STRUCT,
+    [WATER_QUERY_SAMPLE_TABLE]: WATER_QUERY_SAMPLE_STRUCT,
+}, WATER_QUERY_DATABASE_PAGE_SIZE);
+
+/**
+ * @type {import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor}
+ */
+export const WATER_QUERY_DESCRIPTOR = WATER_QUERY_DATABASE_SPEC.get(WATER_QUERY_TABLE);
+
+/**
+ * @type {import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor}
+ */
+export const WATER_QUERY_SAMPLE_DESCRIPTOR = WATER_QUERY_DATABASE_SPEC.get(WATER_QUERY_SAMPLE_TABLE);

package/src/shade/renderer/water/query/shader_water_surface_query.d.ts

@@ -0,0 +1,32 @@
+/** Invocations of a gather workgroup, one query sample each. */
+export const WATER_QUERY_GATHER_WORKGROUP_SIZE: 64;
+/**
+ * Words of one entry of the gather's list: the request's row in `water_query`, then the flat index
+ * of its first sample among the dispatch's.
+ * @type {number}
+ */
+export const WATER_QUERY_GATHER_ENTRY_WORDS: number;
+/**
+ * Per dispatch, 12 bytes, as immediate data.
+ *
+ * - `query_count`: entries of the list;
+ * - `sample_count`: samples of every entry together, one invocation each;
+ * - `row_width`: invocations a row of the dispatch holds, its x extent, so sample
+ *   `id.y · row_width + id.x` lands past the guaranteed workgroup count along x without
+ *   `num_workgroups`.
+ *
+ * @type {WebGPUStruct}
+ */
+export const WATER_QUERY_GATHER_SETTINGS_STRUCT: WebGPUStruct;
+/**
+ * The GPU water surface read API's gather: evaluates the displaced world-space surface height and
+ * world-space normal (packed as a single `u32` via `encode_vertex_normal`) at every query point
+ * requested this frame, clamping off-outline or island-hole points continuously to the nearest
+ * point on the body's authored mesh via `point_query_blas_nearest`.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_water_surface_query: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_surface_query.d.ts.map

package/src/shade/renderer/water/query/shader_water_surface_query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_surface_query.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/query/shader_water_surface_query.js"],"names":[],"mappings":"AA8BA,gEAAgE;AAChE,mDAAoD;AAEpD;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;GAUG;AACH,iDAFU,YAAY,CAMS;AA+J/B;;;;;;;GAOG;AACH,yCAFU,aAAa,CAMpB;6BApN0B,mCAAmC;8BAVlC,+BAA+B"}

package/src/shade/renderer/water/query/shader_water_surface_query.js

@@ -0,0 +1,227 @@
+import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
+import { BVH_TRAVERSAL_STACK_SIZE } from "../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
+import { chunk_encode_vertex_normal } from "../../shader/chunk/geometry/normal/chunk_encode_vertex_normal.js";
+import { chunk_ray_query_blas_nearest } from "../../shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js";
+import { chunk_point_query_blas_nearest } from "../../shader/chunk/sdf/chunk_point_query_blas_nearest.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { WATER_BODIES_TABLE } from "../medium/chunk_water_bodies.js";
+import { chunk_water_surface_sample } from "../surface/chunk_water_surface_sample.js";
+import {
+    WATER_BAND_DERIVATIVES_RESOURCE,
+    WATER_BAND_DISPLACEMENT_RESOURCE,
+    WATER_BAND_SAMPLER_RESOURCE,
+    WATER_PARTICLE_ENTRIES_RESOURCE,
+    WATER_PARTICLE_OFFSETS_RESOURCE
+} from "../surface/WATER_SURFACE_RESOURCES.js";
+import {
+    WATER_QUERY_DESCRIPTOR,
+    WATER_QUERY_SAMPLE_DESCRIPTOR,
+    WATER_QUERY_SAMPLE_STRUCT
+} from "./WATER_QUERY_DATABASE_SPEC.js";
+
+/** Invocations of a gather workgroup, one query sample each. */
+export const WATER_QUERY_GATHER_WORKGROUP_SIZE = 64;
+
+/**
+ * Words of one entry of the gather's list: the request's row in `water_query`, then the flat index
+ * of its first sample among the dispatch's.
+ * @type {number}
+ */
+export const WATER_QUERY_GATHER_ENTRY_WORDS = 2;
+
+/**
+ * Per dispatch, 12 bytes, as immediate data.
+ *
+ * - `query_count`: entries of the list;
+ * - `sample_count`: samples of every entry together, one invocation each;
+ * - `row_width`: invocations a row of the dispatch holds, its x extent, so sample
+ *   `id.y · row_width + id.x` lands past the guaranteed workgroup count along x without
+ *   `num_workgroups`.
+ *
+ * @type {WebGPUStruct}
+ */
+export const WATER_QUERY_GATHER_SETTINGS_STRUCT = WebGPUStruct.from({
+    query_count: u32,
+    sample_count: u32,
+    row_width: u32,
+}, 'WaterQueryGatherSettings');
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate('settings', WATER_QUERY_GATHER_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addStorageBuffer("database", WebGPUArray.from(u32), true)
+    .addStorageBuffer("list", WebGPUArray.from(u32), false)
+    .add(SCENE_DATABASE_RESOURCE)
+    .add(WATER_BAND_DISPLACEMENT_RESOURCE)
+    .add(WATER_BAND_DERIVATIVES_RESOURCE)
+    .add(WATER_BAND_SAMPLER_RESOURCE)
+    .add(WATER_PARTICLE_OFFSETS_RESOURCE)
+    .add(WATER_PARTICLE_ENTRIES_RESOURCE)
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer("blas_lookup", WebGPUArray.u32)
+    .addStorageBuffer("blas_data", WebGPUArray.from(BVH2_NODE_STRUCT))
+    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
+    .addStorageBuffer("meshlet_data", WebGPUArray.from(f32));
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const ENTRY_WORDS = ${WATER_QUERY_GATHER_ENTRY_WORDS}u;
+
+// the entry a flat sample belongs to: the last one whose first sample is at or before it. The first
+// entry starts at 0, so one always is; 32 halvings cover any u32 count.
+fn water_query_gather_entry(sample: u32) -> u32 {
+    var low = 0u;
+    var high = settings.query_count;
+
+    for (var step = 0u; step < 32u && high - low > 1u; step++) {
+        let middle = low + ((high - low) >> 1u);
+
+        if (list[middle * ENTRY_WORDS + 1u] <= sample) {
+            low = middle;
+        } else {
+            high = middle;
+        }
+    }
+
+    return low;
+}
+
+@compute @workgroup_size(${WATER_QUERY_GATHER_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let sample = id.y * settings.row_width + id.x;
+
+    if (sample >= settings.sample_count) {
+        return;
+    }
+
+    let entry = water_query_gather_entry(sample);
+
+    let row = list[entry * ENTRY_WORDS];
+    let local = sample - list[entry * ENTRY_WORDS + 1u];
+
+    let query = ${WATER_QUERY_DESCRIPTOR.marshalling_method_read_rw}(&database, row);
+    let sample_row = query.first_sample + local;
+
+    // Input (local_x, local_z) is packed in the transient list buffer right after the query entries.
+    let point_word = (settings.query_count + sample) * ENTRY_WORDS;
+    let input_xz = vec2<f32>(bitcast<f32>(list[point_word]), bitcast<f32>(list[point_word + 1u]));
+
+    let body = ${WATER_BODIES_TABLE.marshalling_method_read}(&scene_database, query.body);
+    if (body.node == 0u || body.node == ~0u) {
+        ${WATER_QUERY_SAMPLE_DESCRIPTOR.marshalling_method_write}(&database, sample_row,
+            ${WATER_QUERY_SAMPLE_STRUCT.wgsl_ref}(0.0, encode_vertex_normal(vec3<f32>(0.0, 1.0, 0.0))));
+        return;
+    }
+
+    let global = scene_read_node(&scene_database, body.node).global;
+    let c0 = global[0].xyz;
+    let c1 = global[1].xyz;
+    let c2 = global[2].xyz;
+    let cof0 = cross(c1, c2);
+    let cof1 = cross(c2, c0);
+    let cof2 = cross(c0, c1);
+    let det = dot(c0, cof0);
+
+    if (abs(det) < 1e-20) {
+        ${WATER_QUERY_SAMPLE_DESCRIPTOR.marshalling_method_write}(&database, sample_row,
+            ${WATER_QUERY_SAMPLE_STRUCT.wgsl_ref}(global[3].y, encode_vertex_normal(vec3<f32>(0.0, 1.0, 0.0))));
+        return;
+    }
+
+    let scale = max(vec3<f32>(length(c0), length(c1), length(c2)), vec3<f32>(1e-20));
+    let geometry_index = body.geometry;
+    let box = geometries[geometry_index].bounding_box;
+    let clamped_box_xz = clamp(input_xz, vec2<f32>(box[0], box[2]), vec2<f32>(box[3], box[5]));
+
+    var stack: array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
+    var rest_position: vec3<f32>;
+    var inside = false;
+
+    // 1. Inside-outline check via down-ray into the body's BLAS (skipped when already outside the XZ AABB).
+    if (all(input_xz == clamped_box_xz)) {
+        let margin = max(1e-3, (box[4] - box[1]) * 1e-4);
+        let top = box[4] + margin;
+        let hit = ray_query_blas_nearest(
+            Ray(vec3<f32>(input_xz.x, top, input_xz.y), vec3<f32>(0.0, -1.0, 0.0), top - box[1] + margin),
+            geometry_index,
+            &stack,
+            0u
+        );
+        if (hit.t >= 0.0) {
+            rest_position = vec3<f32>(input_xz.x, top - hit.t, input_xz.y);
+            inside = true;
+        }
+    }
+
+    // 2. Outside the shoreline or inside an island hole: clamp continuously to the nearest point on the mesh.
+    if (!inside) {
+        let mid_y = 0.5 * (box[1] + box[4]);
+        let box_diag = length(vec3<f32>(box[3] - box[0], box[4] - box[1], box[5] - box[2]));
+        let max_reach = min(1e18, distance(input_xz, clamped_box_xz) + box_diag + 1.0);
+        let nearest = point_query_blas_nearest(vec3<f32>(input_xz.x, mid_y, input_xz.y), max_reach, geometry_index, &stack, 0u);
+        if (nearest.primitive != 0xFFFFFFFFu) {
+            rest_position = nearest.position;
+        } else {
+            rest_position = vec3<f32>(clamped_box_xz.x, mid_y, clamped_box_xz.y);
+        }
+    }
+
+    // 3. Evaluate water_surface_sample at the clamped metric rest position, with 2 fixed-point steps
+    //    to invert horizontal choppiness (Gerstner / particle horizontal displacement).
+    let target_metric = rest_position.xz * scale.xz;
+    let footprint = max(query.footprint, 1e-6);
+    var sample_p = target_metric;
+    for (var iter = 0u; iter < 2u; iter++) {
+        let step_sample = water_surface_sample(body.wave, sample_p, footprint, 1.0);
+        sample_p = target_metric - step_sample.offset.xz;
+    }
+    let surface = water_surface_sample(body.wave, sample_p, footprint, 1.0);
+
+    // 4. Transform displaced height and normal to world space, and pack normal into u32.
+    let displaced_local = vec3<f32>(rest_position.x, rest_position.y + surface.offset.y / scale.y, rest_position.z);
+    let world_height = (global * vec4<f32>(displaced_local, 1.0)).y;
+
+    let local_normal = normalize(surface.normal * scale);
+    let world_normal = normalize((cof0 * local_normal.x + cof1 * local_normal.y + cof2 * local_normal.z) * (1.0 / det));
+    let packed_normal = encode_vertex_normal(world_normal);
+
+    ${WATER_QUERY_SAMPLE_DESCRIPTOR.marshalling_method_write}(&database, sample_row,
+        ${WATER_QUERY_SAMPLE_STRUCT.wgsl_ref}(world_height, packed_normal));
+}
+`, [
+        WATER_QUERY_DESCRIPTOR.chunk_read_rw,
+        WATER_QUERY_SAMPLE_DESCRIPTOR.chunk_write,
+        WATER_BODIES_TABLE.chunk_read,
+        chunk_scene_database_access,
+        chunk_water_surface_sample,
+        chunk_ray_query_blas_nearest,
+        chunk_point_query_blas_nearest,
+        chunk_encode_vertex_normal,
+    ]
+);
+
+/**
+ * The GPU water surface read API's gather: evaluates the displaced world-space surface height and
+ * world-space normal (packed as a single `u32` via `encode_vertex_normal`) at every query point
+ * requested this frame, clamping off-outline or island-hole points continuously to the nearest
+ * point on the body's authored mesh via `point_query_blas_nearest`.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_water_surface_query = ComputeShader.from({
+    label: "Water / surface query",
+    resources,
+    body,
+});

package/src/shade/renderer/wind/GPUSceneWind.d.ts

@@ -42,7 +42,7 @@ export class GPUSceneWind {
      * @param {number} capacity
      * @returns {GPUTileAtlas3D}
      */
-    static "__#172@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
+    static "__#173@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
     /**
      * @param {GPUDevice} device
      */

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -963,9 +963,10 @@ function defaultValueForType(type) {
                     const ctor = arrayCtorForScalar(type.element.name);
                     return `new ${ctor}(${length})`;
                 }
-                // For non-primitive elements (vec / mat / struct / nested array) build the
-                // array eagerly so `out[i]` is a fresh, mutable element rather than `undefined`.
-                return `Array.from({ length: ${length} }, () => ${defaultValueForType(type.element)})`;
+                // For non-primitive elements (vec / mat / struct / atomic / nested array) build the
+                // array eagerly so `out[i]` is a fresh, mutable element rather than `undefined`. The
+                // parentheses keep an atomic's `{ value: 0 }` an object, not the arrow's block.
+                return `Array.from({ length: ${length} }, () => (${defaultValueForType(type.element)}))`;
             }
             return '[]';
         }
@@ -3010,6 +3011,10 @@ function compileCallPhraseTyped(c, node) {
         if ((type.kind !== 'array' || type.element === T_UNKNOWN) && arg_results.length > 0 && !isAbstractType(arg_results[0].type)) {
             type = { kind: 'array', element: arg_results[0].type, count: arg_results.length };
         }
+        // `array<T, N>()`, the zero-value constructor: N of T's zero, as a `var` of the type starts
+        if (arg_results.length === 0 && type.kind === 'array') {
+            return { code: defaultValueForType(type), type };
+        }
         return { code: `[${stored_args.join(', ')}]`, type };
     }
 
@@ -3120,12 +3125,13 @@ function compileCallPhraseTyped(c, node) {
  *
  * `abs` wraps at the most negative i32 and is the identity on u32; `firstLeadingBit` scans for the
  * most significant bit unlike the sign bit on i32 and for the most significant set bit on u32, which
- * are different functions rather than the same one read differently. Taking the JS meaning for both
- * made the emulator answer things no device does, on the oracle the chunk specs are checked against.
+ * are different functions rather than the same one read differently; `extractBits` sign-extends the
+ * field it reads on i32 and zero-extends it on u32. Taking the JS meaning for both made the emulator
+ * answer things no device does, on the oracle the chunk specs are checked against.
  *
  * @type {Set<string>}
  */
-const INTEGER_TYPED_BUILTIN = new Set(['abs', 'firstLeadingBit', 'firstTrailingBit']);
+const INTEGER_TYPED_BUILTIN = new Set(['abs', 'firstLeadingBit', 'firstTrailingBit', 'extractBits']);
 
 /**
  * Element-wise builtins: the result has the type of the arguments. Most are vector-preserving

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IA+yDA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAk0DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -690,6 +690,24 @@ export const WGSLLanguageCore = {
         });
     },
 
+    /** `extractBits` on u32: the field zero-extended. */
+    extractBits_u32(e, offset, count) {
+        return this.extractBits(e, offset, count);
+    },
+
+    /** `extractBits` on i32: the field sign-extended, its top bit copied up (WGSL §17.9). */
+    extractBits_i32(e, offset, count) {
+        const o = Math.min(offset >>> 0, 32);
+        const c = Math.min(count >>> 0, 32 - o);
+        return unop(e, (x) => {
+            if (c === 0) {
+                return 0;
+            }
+            // the field's top bit to bit 31, then an arithmetic shift back down
+            return ((x << (32 - o - c)) >> (32 - c)) | 0;
+        });
+    },
+
     // Bit counting (WGSL §17.9). Component-wise over vectors. All of these read their operand as
     // 32 bits regardless of whether the WGSL type was u32 or i32 — which is what the spec says and
     // what makes `countLeadingZeros` the exact counterpart of JS's `Math.clz32`.
@@ -1188,7 +1206,8 @@ export const WGSLLanguageCore = {
      */
     textureLoad(t, coords, _level_or_index = 0, _array_level = undefined) {
         assert.defined(t, 'texture');
-        const out = new Float32Array(4);
+        // an integer texture's texel in its own type: past 2^24 an f32 no longer holds every integer
+        const out = t.data instanceof Uint32Array || t.data instanceof Int32Array ? new t.data.constructor(4) : new Float32Array(4);
         // textureLoad on texture_1d takes a scalar i32 in WGSL (not vec1).
         const dim = coordinate_axis_count(coords);
         const x = (dim === 1 ? coords : coords[0]) | 0;

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":"AAmNA;;;;;;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,CAkQ7D"}
+{"version":3,"file":"validate_wgsl_source.d.ts","sourceRoot":"","sources":["../../../../src/shade/wgsl/validate_wgsl_source.js"],"names":[],"mappings":"AAqOA;;;;;;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,CA0Q7D"}

package/src/shade/wgsl/validate_wgsl_source.js

@@ -19,6 +19,11 @@ import { WGSLLanguageCore } from "./emulator/WGSLLanguageCore.js";
  *  - reserved-keyword: an identifier that is a WGSL reserved word (`target`, `filter`,
  *    `set`, `type`, …). The parser reads these as ordinary identifiers, so they pass the
  *    emulator and only fail at `createShaderModule` on a device. Lexical, whole-word.
+ *  - keyword-identifier: a WGSL keyword (`alias`, `loop`, `override`, …) named as a struct member
+ *    or a parameter (`alias: u32`), or read as a member (`h.alias`). Keywords have places in the
+ *    grammar, so the reserved-word scan leaves them out, but the parser takes one as a name in
+ *    these two places and Tint refuses the module. Lexical: in WGSL a keyword is never followed by
+ *    `:` nor preceded by `.`, but for a switch's `default:`.
  *  - undeclared-call: a call to a function that is neither user-defined nor a known WGSL
  *    builtin / type constructor (catches missing chunk dependencies).
  *  - const-initializer: a function-scope `const` whose initializer reads a runtime value — a
@@ -140,6 +145,19 @@ const WGSL_RESERVED_WORDS = [
 
 const RESERVED_WORD_RE = new RegExp(`\\b(?:${WGSL_RESERVED_WORDS.join('|')})\\b`, 'g');
 
+// WGSL keywords (spec §"Keyword Summary"), but `default`, which a switch case names with a colon.
+const WGSL_KEYWORDS_NAMED = [
+    'alias', 'break', 'case', 'const', 'const_assert', 'continue', 'continuing',
+    'diagnostic', 'discard', 'else', 'enable', 'false', 'fn', 'for', 'if', 'let', 'loop',
+    'override', 'requires', 'return', 'struct', 'switch', 'true', 'var', 'while',
+];
+
+// a keyword declared as a name (`alias: u32`) or read as a member (`h.alias`)
+const KEYWORD_AS_NAME_RE = new RegExp(
+    `\\.\\s*(?:${WGSL_KEYWORDS_NAMED.join('|')})\\b|\\b(?:${WGSL_KEYWORDS_NAMED.join('|')})\\s*:`,
+    'g'
+);
+
 // Half-precision (`f16`) enable directive and tokens (WGSL §14.1.1, §3.4.3, §6.2.4–6.2.6).
 // Matches `enable f16;`, `enable subgroups, f16;`, etc.
 const F16_ENABLE_DIRECTIVE_RE = /\benable\s+[^;]*\bf16\b/;
@@ -459,6 +477,14 @@ export function validate_wgsl_source(source, parser) {
             });
         }
 
+        for (const m of lines[i].matchAll(KEYWORD_AS_NAME_RE)) {
+            diagnostics.push({
+                rule: 'keyword-identifier',
+                message: `'${m[0].replace(/[.:\s]/g, '')}' is a WGSL keyword and cannot name a member or a parameter`,
+                line: i + 1,
+            });
+        }
+
         if (!f16_enabled) {
             const f16_match = lines[i].match(F16_TOKEN_RE);
             if (f16_match !== null) {

package/src/view/common/LabelView.js

@@ -13,7 +13,7 @@ import { number_pretty_print } from "../../core/primitives/numbers/number_pretty
 import { isInstanceOf } from "../../core/process/matcher/isInstanceOf.js";
 import { isTypeOf } from "../../core/process/matcher/isTypeOf.js";
 import { or } from "../../core/process/matcher/or.js";
-import { frameThrottle } from "../../engine/graphics/FrameThrottle.js";
+import { frameThrottle } from "../../core/function/frameThrottle.js";
 import View from "../View.js";
 
 

package/src/view/common/VirtualListView.js

@@ -4,7 +4,7 @@ import Signal from "../../core/events/signal/Signal.js";
 import { passThrough } from "../../core/function/passThrough.js";
 import { strictEquals } from "../../core/function/strictEquals.js";
 import { max2 } from "../../core/math/max2.js";
-import { frameThrottle } from '../../engine/graphics/FrameThrottle.js';
+import { frameThrottle } from '../../core/function/frameThrottle.js';
 import dom from '../DOM.js';
 import View from '../View.js';
 

package/src/view/elements/progress/SmoothProgressBar.js

@@ -2,7 +2,7 @@ import { passThrough } from "../../../core/function/passThrough.js";
 import { clamp01 } from "../../../core/math/clamp01.js";
 
 import BoundedValue from "../../../core/model/BoundedValue.js";
-import { frameThrottle } from "../../../engine/graphics/FrameThrottle.js";
+import { frameThrottle } from "../../../core/function/frameThrottle.js";
 import dom from "../../DOM.js";
 import View from "../../View.js";
 

package/src/view/tooltip/TooltipManager.js

@@ -4,7 +4,7 @@ import AABB2 from "../../core/geom/2d/aabb/AABB2.js";
 import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor.js";
 import Task from "../../core/process/task/Task.js";
 import { TaskSignal } from "../../core/process/task/TaskSignal.js";
-import { frameThrottle } from "../../engine/graphics/FrameThrottle.js";
+import { frameThrottle } from "../../core/function/frameThrottle.js";
 import { PointerDevice } from "../../engine/input/devices/PointerDevice.js";
 import EmptyView from "../elements/EmptyView.js";
 import { GMLEngine } from "./gml/GMLEngine.js";

package/editor/view/ecs/components/DatGuiController.d.ts

@@ -1,2 +0,0 @@
-export { default } from "../../../../src/view/controller/dat/DatGuiController.js";
-//# sourceMappingURL=DatGuiController.d.ts.map

package/editor/view/ecs/components/DatGuiController.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DatGuiController.d.ts","sourceRoot":"","sources":["../../../../../editor/view/ecs/components/DatGuiController.js"],"names":[],"mappings":""}

package/editor/view/ecs/components/DatGuiController.js

@@ -1,2 +0,0 @@
-// relocated to the dat.gui vendor boundary
-export { default } from "../../../../src/view/controller/dat/DatGuiController.js";

package/editor/view/v2/SplitView.d.ts

@@ -1,2 +0,0 @@
-export { SplitView } from "../../../src/view/layout/SplitView.js";
-//# sourceMappingURL=SplitView.d.ts.map

package/editor/view/v2/SplitView.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SplitView.d.ts","sourceRoot":"","sources":["../../../../editor/view/v2/SplitView.js"],"names":[],"mappings":""}

package/editor/view/v2/SplitView.js

@@ -1,2 +0,0 @@
-// relocated into the view framework's layout module
-export { SplitView } from "../../../src/view/layout/SplitView.js";

package/src/core/binary/hash/XXH128Hash.d.ts

@@ -1,2 +0,0 @@
-export { XXH128Hash } from "../../math/hash/XXH128Hash.js";
-//# sourceMappingURL=XXH128Hash.d.ts.map

package/src/core/binary/hash/XXH128Hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XXH128Hash.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/hash/XXH128Hash.js"],"names":[],"mappings":""}

package/src/core/binary/hash/XXH128Hash.js

@@ -1,4 +0,0 @@
-export {
-    /** @deprecated moved to core/math/hash/XXH128Hash.js; import it from there */
-    XXH128Hash
-} from "../../math/hash/XXH128Hash.js";

package/src/core/binary/hash/XXH3_SECRET.d.ts

@@ -1,2 +0,0 @@
-export { XXH3_SECRET } from "../../math/hash/XXH3_SECRET.js";
-//# sourceMappingURL=XXH3_SECRET.d.ts.map

package/src/core/binary/hash/XXH3_SECRET.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XXH3_SECRET.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/hash/XXH3_SECRET.js"],"names":[],"mappings":""}

package/src/core/binary/hash/XXH3_SECRET.js

@@ -1,4 +0,0 @@
-export {
-    /** @deprecated moved to core/math/hash/XXH3_SECRET.js; import it from there */
-    XXH3_SECRET
-} from "../../math/hash/XXH3_SECRET.js";