avbd-babylon 0.2.0 → 0.4.0

package/docs/HPLOC.md

@@ -1,116 +1,120 @@
-# GPU tree collision detection
-
-`GpuHploc` in `gpuHploc.js` builds and traverses a GPU bounding-volume hierarchy.
-Its pairs feed the existing narrowphase and AVBD solver. Shapes, friction,
-rotation, solving rounds and contact equations stay the same; pinned upstream
-sources remain unchanged.
-
-This is a portable hierarchical PLOC treelet variant, based on the clustering
-family described in [H-PLOC](https://gpuopen.com/download/HPLOC.pdf), **not** the
-paper's single-launch wave implementation. `hplocpp.wgsl` builds the tree;
-`hplocSort.wgsl` sorts keys.
-
-## Algorithm
-
-1. Compute world AABBs from live GPU positions, quaternions and collider sizes.
-2. Reduce scene bounds on the GPU, generate 30-bit Morton keys and sort them
-   with stable radix passes. No fixed scene coordinates or lost duplicate keys.
-3. Merge mutual nearest neighbours by surface-area cost in 16-cluster treelets.
-   Construct hierarchy levels until one root remains. Dispatch boundaries
-   publish global writes; barriers publish local merges. There are no
-   cross-workgroup spin waits or relaxed-atomic publication assumptions.
-4. Build escape links for stackless traversal. Dynamic queries find static and
-   kinematic leaves; giant ground slabs do not traverse the whole tree.
-5. Refit **every leaf and internal bound every step**. Rebuild ordering and
-   clustering every 64 steps by default. Refitting preserves coverage after
-   teleports; rebuilding improves traversal quality.
-
-Pair acceptance reuses the grid's masks, disabled-joint handling, bounding
-spheres, world AABBs, face-axis rejection and overflow accounting. Dynamic
-pairs are emitted once; dynamic/static pairs are emitted from the dynamic
-body. Hulls retain the canonical hull narrowphase.
-
-## Selection and limits
-
-`AppGpuSolver3D` and `AvbdPhysics.create` accept `broadphase: "auto"`, `"grid"`
-or `"hploc"`, and `bvh: { rebuildInterval: 64 }`. The lab and browser benchmark
-have the same choices. Explicit selections let you compare on your GPU.
-
-Automatic selection uses a tree for at least 10,000 bodies when either:
-
-- Grid cells are at least four times a typical body's bounding-sphere diameter.
-- At least a quarter of dynamic bodies are thin plates, and there is at least
-  one active constraint per body. This covers the rigid ragdoll net.
-
-For this policy, a thin plate has a shortest dimension no more than 40% of its
-middle dimension, with the middle dimension at least half the longest. Rods,
-spheres and convex hulls do not qualify as plates. Shape metadata is checked
-when bodies or active constraint counts change; positions are not downloaded.
-
-Body count alone does not select a tree. Adapter dispatch/storage limits are checked; automatic mode
-keeps the grid when unsupported. Explicit unsupported requests fail clearly.
-
-This is a conservative policy based on the measured 1K, 10K and 50K mixed-size workloads and the 24K ragdoll net,
-not a universal crossover point. Scene layout, size distribution and GPU matter.
-
-Extra buffers store nodes, links, sorting and clustering. JSON records primary
-buffer bytes, rebuild/refit counts and the first GPU step. Startup GPU time
-excludes CPU scene creation and shader compilation. Warm timing includes
-periodic rebuilds, but excludes the first build; inspect both. Grid buffers
-remain available for selection changes. This path adds no sleeping.
-Reported primary bytes exclude prefix-scan scratch, small uniforms and pipelines.
-
-## Replication and checks
-
-Open `/tests/performance.html` and close other GPU workloads. Paired comparison
-alternates execution order every step and preserves each scene's settings.
-Every step checks overflow and solve-group conflicts.
-
-```js
-try {
-  const result = await __PERFORMANCE__.runPaired(
-    "3d-mixed-sizes-50k",
-    ["grid", "hploc"],
-    60,
-    60,
-  );
-  console.table(
-    result.results.map((r) => ({
-      method: r.broadphase,
-      collisionMs: r.summary.collision.mean,
-      physicsMs: r.summary.total.mean,
-      extraBytes: r.bvh?.extraBytes ?? 0,
-    })),
-  );
-} finally {
-  await __BENCHMARK_VIEW__.preview.load(document.querySelector("#scene").value);
-}
-```
-
-Use `grid-detail` / `hploc-detail` to separate build/refit, pair search,
-narrowphase, body solving and contact-force updates. Extra pass boundaries
-affect timing, so compare matching detailed modes. Raw data retains rebuild
-spikes and noisy samples. An unchanged solve-stage difference over 10% is flagged.
-
-For the ragdoll net, compare `"showcase-ragdolls-on-cloth-24k"` with
-`["grid", "hploc"]`, 1440 warmup steps and 60 samples. This measures the scene
-after six simulated seconds at its full 240 Hz collision rate. Saved paired
-results on the RTX 4070 Laptop GPU use the same timestep and five AVBD iterations;
-see `test-results/solver-ragdoll-settled.json`. The separate
-`node scripts/check-ragdoll-net.mjs` regression checks every quarter-second
-through 30 simulated seconds with automatic selection. It checks whole limbs
-below the sheet and partial capsule/triangle intersections deeper than 5 mm.
-The net uses overlapping plates and excludes its eight immediate neighbors
-from self-collisions; distant folds still collide.
-
-Tests compare unique, complete pair sets against the grid for empty and partial
-treelets, duplicate keys, rotated hulls and boxes, spheres, giant statics,
-ignored and released joints, filters, teleports and added bodies. Physical regressions cover floor support,
-joints, sleeping and support removal; browser checks exercise motion and drawing.
-
-`node scripts/check-hploc-motion.mjs` checks 360 steps of the 10K/50K mixed-size
-scenes, 110K ring, 100K columns and half-million walls with the tree forced.
-It checks every step's capacity and scheduling counters, measures floor support
-and rotation, and captures four screenshots per scene. `npm run test:web`
-includes this check alongside all scene and benchmark views.
+# GPU tree collision detection
 
+[`GpuHploc`](../src/gpu/gpuHploc.js) in `src/gpu/` builds and traverses a GPU bounding-volume hierarchy.
+Its pairs feed the existing narrowphase and AVBD solver. Shapes, friction,
+rotation, solving rounds and contact equations stay the same; pinned upstream
+sources remain unchanged.
+
+This portable hierarchical PLOC treelet variant builds on the clustering family
+described in [H-PLOC](https://gpuopen.com/download/HPLOC.pdf). It uses multiple
+GPU dispatches to coordinate tree levels. `hplocpp.wgsl` builds the tree;
+`hplocSort.wgsl` sorts keys.
+
+## Algorithm
+
+1. Compute world AABBs from live GPU positions, quaternions and collider sizes.
+2. Reduce scene bounds on the GPU, generate 30-bit Morton keys and sort them
+   with stable radix passes. No fixed scene coordinates or lost duplicate keys.
+3. Merge mutual nearest neighbours by surface-area cost in 16-cluster treelets.
+   Construct hierarchy levels until one root remains. Dispatch boundaries
+   publish global writes; barriers publish local merges. There are no
+   cross-workgroup spin waits or relaxed-atomic publication assumptions.
+4. Build escape links for stackless traversal. Dynamic queries find static and
+   kinematic leaves; giant ground slabs do not traverse the whole tree.
+5. Refit **every leaf and internal bound every step**. Rebuild ordering and
+   clustering every 64 steps by default. Refitting preserves coverage after
+   teleports; rebuilding improves traversal quality.
+
+Refit steps update leaf boxes directly without the scene-bound reductions used
+for Morton sorting. Every leaf and internal box still follows the current GPU
+pose, including moved static bodies and teleports.
+
+Pair acceptance reuses the grid's masks, disabled-joint handling, bounding
+spheres, world AABBs, face-axis rejection and overflow accounting. Dynamic
+pairs are emitted once; dynamic/static pairs are emitted from the dynamic
+body. Hulls retain the canonical hull narrowphase.
+
+## Selection and limits
+
+`AppGpuSolver3D` and `AvbdPhysics.create` accept `broadphase: "auto"`, `"grid"`
+or `"hploc"`, and `bvh: { rebuildInterval: 64 }`. The lab and browser benchmark
+have the same choices. Explicit selections let you compare on your GPU.
+
+Automatic selection uses a tree for at least 10,000 bodies when either:
+
+- Grid cells are at least four times a typical body's bounding-sphere diameter.
+- At least a quarter of dynamic bodies are thin plates, and there is at least
+  one active constraint per body. This covers the rigid ragdoll net.
+
+For this policy, a thin plate has a shortest dimension no more than 40% of its
+middle dimension, with the middle dimension at least half the longest. Rods,
+spheres and convex hulls do not qualify as plates. Shape metadata is checked
+when bodies or active constraint counts change; positions are not downloaded.
+
+Body count alone does not select a tree. Adapter dispatch/storage limits are checked; automatic mode
+keeps the grid when unsupported. Explicit unsupported requests fail clearly.
+
+The selection policy uses measurements from 1K, 10K and 50K mixed-size workloads
+and the 24K ragdoll net. The crossover depends on scene layout, object sizes and
+the GPU.
+
+Extra buffers store nodes, links, sorting and clustering. JSON records primary
+buffer bytes, rebuild/refit counts and the first GPU step. Startup GPU time
+excludes CPU scene creation and shader compilation. Warm timing includes
+periodic rebuilds, but excludes the first build; inspect both. Grid buffers
+remain available for selection changes. Sleeping is configured separately from collision search.
+Reported primary bytes exclude prefix-scan scratch, small uniforms and pipelines.
+
+## Replication and checks
+
+Open `/tests/performance.html` and close other GPU workloads. Paired comparison
+alternates execution order every step and preserves each scene's settings.
+Every step checks overflow and solve-group conflicts.
+
+```js
+try {
+  const result = await __PERFORMANCE__.runPaired(
+    "3d-mixed-sizes-50k",
+    ["grid", "hploc"],
+    60,
+    60,
+  );
+  console.table(
+    result.results.map((r) => ({
+      method: r.broadphase,
+      collisionMs: r.summary.collision.mean,
+      physicsMs: r.summary.total.mean,
+      extraBytes: r.bvh?.extraBytes ?? 0,
+    })),
+  );
+} finally {
+  await __BENCHMARK_VIEW__.preview.load(document.querySelector("#scene").value);
+}
+```
+
+Use `grid-detail` / `hploc-detail` to separate build/refit, pair search,
+narrowphase, body solving and contact-force updates. Extra pass boundaries
+affect timing, so compare matching detailed modes. Raw data retains rebuild
+spikes and noisy samples. An unchanged solve-stage difference over 10% is flagged.
+
+For the ragdoll net, compare `"showcase-ragdolls-on-cloth-24k"` with
+`["grid", "hploc"]`, 1440 warmup steps and 60 samples. This measures the scene
+after six simulated seconds at its full 240 Hz collision rate. Saved paired
+results on the RTX 4070 Laptop GPU use the same timestep and five AVBD iterations;
+see `test-results/solver-ragdoll-settled.json`. The separate
+`node scripts/check-ragdoll-net.mjs` regression checks every quarter-second
+through 30 simulated seconds with automatic selection. It checks whole limbs
+below the sheet and partial capsule/triangle intersections deeper than 5 mm.
+The net uses overlapping plates and excludes its eight immediate neighbors
+from self-collisions; distant folds still collide.
+
+Tests compare unique, complete pair sets against the grid for empty and partial
+treelets, duplicate keys, rotated hulls and boxes, spheres, giant statics,
+ignored and released joints, filters, teleports and added bodies. Physical regressions cover floor support,
+joints, sleeping and support removal; browser checks exercise motion and drawing.
+
+`node scripts/check-hploc-motion.mjs` checks 360 steps of the 10K/50K mixed-size
+scenes, 110K ring, 100K columns and half-million walls with the tree forced.
+It checks every step's capacity and scheduling counters, measures floor support
+and rotation, and captures four screenshots per scene. `npm run test:web`
+includes this check alongside all scene and benchmark views.

package/docs/README.md

@@ -11,6 +11,7 @@ Physics V2 plugin interface or install through `scene.enablePhysics()`.
 
 - [Install the library](#install-the-library)
 - [A complete small scene](#a-complete-small-scene)
+- [Everyday body commands](#everyday-body-commands)
 - [Move, launch and reuse bodies](#move-launch-and-reuse-bodies)
 - [Choose a rendering path](#choose-a-rendering-path)
 - [Reproduce the collision and solver benchmarks](#reproduce-the-collision-and-solver-benchmarks)
@@ -19,10 +20,15 @@ Physics V2 plugin interface or install through `scene.enablePhysics()`.
 
 ## Install the library
 
-The package is named `avbd-babylon`. For a local build, run `npm install` and
-`npm run build` in this repository. From your
-Babylon project, run `npm install /absolute/path/to/avbd` or install the archive
-created by `npm pack`. Import from `avbd-babylon` using your normal bundler.
+Install AVBD and Babylon in your project:
+
+```sh
+npm install avbd-babylon @babylonjs/core
+```
+
+Import from `avbd-babylon` using your normal bundler. For a local development
+build, run `npm install` and `npm run build` in this repository, then install
+its directory or the archive created by `npm pack` into your project.
 The ESM output already contains the solver and shader strings. No TypeScript
 source compilation or WGSL loader is needed in your project. The package has
 no Babylon runtime imports; it uses the mesh objects your project provides.
@@ -32,13 +38,21 @@ browser tests. `npm start` builds the library and serves the lab together.
 `npm run build:cdn` creates `dist/avbd.global.js`, which exposes `globalThis.AVBD`.
 Host that file yourself and load it with a normal script tag; use
 `const { AvbdPhysics, AvbdPhysicsAggregate, AvbdShapeType } = AVBD`.
-There is no public CDN release URL yet.
 
-WebGPU
-needs a supported browser and localhost or HTTPS. The default world requests
-9 storage bindings, a 512 MiB storage binding limit and a 1 GiB buffer limit;
-unsupported adapters fail during creation. Babylon drawing can use either its
-WebGL or WebGPU engine when using the small-scene mesh bridge.
+WebGPU needs a supported browser and localhost or HTTPS. The world prefers up to
+9 storage bindings, a 512 MiB storage binding limit and a 1 GiB buffer limit,
+and adapts these requests to the adapter's available limits. Custom convex mesh
+shapes require 9 storage bindings. Creation checks 3D floor contacts once and
+selects a compatible GPU path when needed, including on supported mobile devices.
+Babylon drawing can use either its WebGL or WebGPU engine with the small-scene
+mesh bridge.
+
+For CPU physics, use the [native pipeline examples](../README.md#choose-a-solver-backend-once).
+Select the backend once; 2D and 3D scene builders, body commands, joints, triggers,
+restitution, collision masks and state reads keep the same API. The package
+supports WebGPU and CPU. The repository demos retain an experimental WebGL2
+solver for comparisons; its measured performance was too poor to include in
+the package. See the [backend benchmark](../README.md#backend-differences-and-benchmarks).
 
 ## A complete small scene
 
@@ -120,6 +134,36 @@ custom simulation loop, pass `autoAttach: false` and call `step()` yourself.
 `attachToScene()` is also available and does not attach a second observer when
 called again for the same scene.
 
+## Everyday body commands
+
+Keep the aggregate and use its `body` handle for movement. Babylon `Vector3`
+values work for velocity, impulses and forces; those calls also accept arrays.
+Teleporting accepts a `Vector3` and an optional `Quaternion`.
+
+| Task                           | Call                                                                              |
+| ------------------------------ | --------------------------------------------------------------------------------- |
+| Set movement or spin           | `body.setLinearVelocity(v)` / `body.setAngularVelocity(v)`                        |
+| Give a sudden push             | `body.applyImpulse(impulse, worldPoint)`; omit the point for a central push       |
+| Apply force for one fixed step | `body.applyForce(force, worldPoint)` / `body.applyTorque(torque)`                 |
+| Move instantly                 | `body.teleport(position, rotation)`; omit rotation to retain the live orientation |
+| Set bounce                     | `body.setRestitution(0.5)`                                                        |
+| Set collision masks            | `body.setCollisionGroups(group, collidesWith)`                                    |
+| Make an overlap sensor         | `body.setTrigger(true)`                                                           |
+| Allow sleeping or wake a body  | `body.setSleepEnabled(true)` / `body.wakeUp()`                                    |
+| Read live physics state        | `await body.readState()`                                                          |
+| Remove physics participation   | `aggregate.dispose()`; the mesh stays caller-owned                                |
+
+Commands made before the next fixed step are batched automatically. Ordinary
+per-body calls do not require a manual flush or pose download. State reads and
+queries are asynchronous because they return current GPU results. Create the
+world with `{ scene }` to attach stepping and disposal to Babylon's scene.
+
+For another renderer or CPU compatibility, use the
+[native 2D/3D examples](../README.md#native-physics-with-any-renderer). They use the
+same movement, impulse, bounce, trigger, mask and sleep method names, with
+two- or three-component coordinates. Native bulk edits and reusable packed
+batches are shown in [bulk edits](../README.md#bulk-edits-and-gpu-dispatches).
+
 ## Move, launch and reuse bodies
 
 ```js
@@ -227,7 +271,7 @@ device stays alive when the world is disposed.
 Thin instances do not automatically create colliders. The aggregate API takes
 one mesh per physics body, which has a startup cost for very large scenes.
 For 100K bodies, the laboratory's native body/scene builders avoid creating
-100K Babylon mesh objects; see [canonicalScenes.js](../demo/canonicalScenes.js).
+100K Babylon mesh objects; see [scene registry](../demo/lab/scenes.js).
 Import `AvbdScene2D` or `AvbdScene3D` from `avbd-babylon/native` for the same
 renderer-independent integration. Both expose live body handles, bulk commands,
 packed velocity uploads, selected pose reads, triggers, masks, restitution,
@@ -236,9 +280,9 @@ sleeping and contact events. See the package README's
 The direct-buffer renderer and small-scene aggregate bridge are separate
 integration paths.
 
-See [canonicalRenderer.js](../demo/canonicalRenderer.js) and
-[canonicalRender.wgsl](../demo/canonicalRender.wgsl) for the direct rendering path,
-and [mixedColliderDemo.js](../demo/mixedColliderDemo.js) for the Babylon mesh bridge.
+See [canonicalRenderer.js](../demo/shared/rendering/canonicalRenderer.js) and
+[canonicalRender.wgsl](../demo/shared/rendering/canonicalRender.wgsl) for the direct rendering path,
+and [mixed collider demo](../demo/mixed-colliders/index.js) for the Babylon mesh bridge.
 The laboratory scene builders use z up; the Babylon adapter uses y up by
 default. Match your renderer's coordinates to the world you create.
 

package/docs/RELEASE.md

@@ -5,6 +5,20 @@ portable scene builders and the browser demos. The package ships ESM, the `AVBD`
 browser global, declarations, documentation and license notices. It has no runtime
 dependencies; Babylon 9 is an optional peer for the integration API.
 
+`avbd-babylon/utils` exposes the GPU timers, buffer recycler, surface particles,
+contact sampling, startup coloring, custom GPU step passes and worker input/canvas
+helpers used by the demos. These helpers are also available from the main entry.
+`npm run benchmark:particles` measures visible D20 particle capacity and updates
+the public report; its results are separate from AVBD rigid-body benchmarks.
+
+Native 2D and 3D worlds select WebGPU or CPU at initialization and share
+the scene and body APIs. The Babylon aggregate API uses WebGPU; native CPU
+worlds can use Babylon drawing with synchronized poses. The experimental
+WebGL2 implementation remains in the repository demos and benchmarks; it is
+excluded from package exports, declarations and both production bundles.
+Build and package checks enforce that separation. Its measured performance
+was too poor for production; the README preserves the comparison.
+
 ## Validate the package
 
 ```sh
@@ -12,6 +26,7 @@ npm ci
 npm run build:all
 npm run test:complete
 npm run test:web
+npm run test:compatibility
 npm run clean:results
 npm run clean:dist
 npm pack
@@ -49,6 +64,14 @@ collision searches. It uses only the existing local demo tab and saves
 `test-results/connected-phone-contacts.json`. Mobile viewport tests and physical
 phone tests have separate reports.
 
+Run `npm run test:connected-demos` on the same connection for ten production
+scene checks, screenshots and short physics/rendering measurements on the phone.
+This includes 2D/3D hinges and sensors, terrain, tearable cloth and the 40,000-marble
+Galton board. The saved `connected-phone-demos.json` distinguishes GPU physics
+time from completion time. These short checks verify startup and motion; they
+do not replace long settling tests or the complete Galton distribution test.
+Sequential measurements can warm the phone and change its clock speeds.
+
 To compare PC performance with a saved package build, run
 `node scripts/check-contact-performance.mjs --baseline=/path/to/avbd.js`.
 It runs 10K and 100K native 3D bodies with five iterations, three alternating
@@ -143,8 +166,9 @@ See the [feature table](../README.md#feature-coverage) for exact coverage.
 
 These remain useful follow-up work rather than supported 0.2 features:
 
-- **Concave mesh collisions:** custom hulls fill cavities. Terrain and hollow
-  objects need suitable convex pieces.
+- **Dynamic concave bodies:** moving hollow objects need convex pieces. Static
+  triangle meshes and heightfields are supported through terrain cooking, which
+  preserves caves and overhangs. A single convex hull fills its cavities.
 - **Continuous collision detection:** contacts are discrete. Use smaller
   timesteps for fast objects; sphere/circle casts are queries, not automatic CCD.
 - **Full Babylon Physics V2 integration:** use AVBD aggregates, not

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avbd-babylon",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "GPU AVBD rigid-body physics with a Babylon.js aggregate API",
   "main": "./dist/avbd.js",
   "types": "./dist/avbd.d.ts",
@@ -35,11 +35,36 @@
     "test:published": "node scripts/check-published.mjs",
     "test:mobile-contacts": "node scripts/build.mjs && node scripts/check-contact-portability.mjs && node scripts/check-contact-compatibility-features.mjs",
     "test:types": "tsc --noEmit --strict --skipLibCheck --module nodenext --target es2022 tests/package-api-types.ts",
+    "test:cpu": "node scripts/build.mjs && node scripts/check-cpu-demos.mjs && node scripts/check-cpu-features.mjs && node scripts/check-cpu-slingshot.mjs",
+    "test:webgl-collisions": "node scripts/check-webgl-broadphase.mjs && node --experimental-transform-types scripts/check-webgl-contacts.mjs",
+    "test:webgl": "npm run test:webgl-collisions && node scripts/check-webgl-coloring.mjs && node --experimental-transform-types scripts/check-webgl-solve.mjs && node --experimental-transform-types scripts/check-webgl-world.mjs && node --experimental-transform-types scripts/check-webgl-edits.mjs && node --experimental-transform-types scripts/check-webgl-bounce.mjs && node --experimental-transform-types scripts/check-webgl-sleeping.mjs && node scripts/check-webgl-scene-behavior.mjs && node scripts/check-backend-contract.mjs --webgl2",
+    "test:compatibility": "npm run build:all && node scripts/check-backend-contract.mjs --package && npm run test:cpu && npm run test:webgl && npm run test:webgl-scenes && npm run test:compatibility-performance",
+    "test:pipelines": "node scripts/check-backend-contract.mjs",
+    "benchmark:backends": "node scripts/build.mjs && node scripts/benchmark-backends.mjs",
     "benchmark:native": "node scripts/benchmark-package.mjs",
     "benchmark:sleeping": "node scripts/benchmark-package.mjs",
+    "benchmark:connected-sleep": "node scripts/benchmark-connected-sleep.mjs",
+    "benchmark:small-groups": "node scripts/benchmark-small-groups.mjs",
     "benchmark:native-edits": "node scripts/check-native-performance.mjs",
     "benchmark:renderers": "node scripts/build.mjs && node scripts/benchmark-renderers.mjs",
-    "test:connected-phone": "node scripts/check-connected-contacts.mjs"
+    "benchmark:particles": "node scripts/build.mjs && node scripts/benchmark-particles.mjs && node scripts/report-particles.mjs",
+    "test:connected-phone": "node scripts/check-connected-contacts.mjs",
+    "test:connected-demos": "node scripts/check-connected-demos.mjs",
+    "test:webgl-scenes": "node scripts/build.mjs && node scripts/check-webgl-demos.mjs",
+    "test:compatibility-performance": "node scripts/build.mjs && node scripts/check-compatibility-performance.mjs",
+    "test:workers": "node scripts/build.mjs && node scripts/check-runtime-efficiency.mjs && node scripts/check-workers.mjs",
+    "benchmark:workers": "node scripts/build.mjs && node scripts/benchmark-workers.mjs && node scripts/report-workers.mjs && node scripts/report-solver.mjs",
+    "test:execution": "node scripts/build.mjs && node scripts/check-execution-ui.mjs",
+    "test:naval": "node scripts/build.mjs && node scripts/check-naval.mjs",
+    "benchmark:naval": "node scripts/build.mjs && node scripts/benchmark-naval.mjs",
+    "test:terrain": "node scripts/check-terrain-cooking.mjs && node scripts/build-library.mjs && node scripts/build.mjs && node scripts/check-terrain.mjs && node scripts/check-terrain-import.mjs",
+    "benchmark:hploc-refit": "node scripts/benchmark-hploc-refit.mjs",
+    "benchmark:gpu-uploads": "node scripts/benchmark-webgpu-uploads.mjs",
+    "benchmark:gpu-scheduling": "node scripts/benchmark-color-buckets.mjs",
+    "benchmark:movement": "node scripts/benchmark-movement-solve.mjs",
+    "benchmark:gpu-encoding": "node scripts/benchmark-command-encoding.mjs",
+    "test:playgrounds": "node scripts/build.mjs && node scripts/check-siege-damage.mjs && node scripts/check-galton-statistics.mjs && node scripts/check-galton-startup.mjs && node scripts/check-galton-pegs.mjs && node scripts/check-lab-timing.mjs && node scripts/check-lab-step-rate.mjs && node scripts/check-lab-sleep.mjs && node scripts/check-playgrounds.mjs && node scripts/check-slingshot-input.mjs && node scripts/check-slingshot-game.mjs",
+    "test:demo-startup": "node scripts/build.mjs && node scripts/check-demo-startup.mjs --all"
   },
   "license": "MIT",
   "repository": {
@@ -65,11 +90,12 @@
     "babylonjs"
   ],
   "devDependencies": {
+    "@babylonjs/core": "^9.13.0",
     "esbuild": "^0.28.2",
     "prettier": "^3.9.9",
     "tinybuild": "^1.0.6",
-    "@babylonjs/core": "^9.13.0",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "wgsl_reflect": "^1.6.0"
   },
   "module": "./dist/avbd.js",
   "exports": {
@@ -83,6 +109,11 @@
       "import": "./dist/native.js",
       "default": "./dist/native.js"
     },
+    "./utils": {
+      "types": "./dist/utilities.d.ts",
+      "import": "./dist/utilities.js",
+      "default": "./dist/utilities.js"
+    },
     "./global": {
       "types": "./dist/avbd.global.d.ts",
       "default": "./dist/avbd.global.js"
@@ -99,6 +130,9 @@
     "dist/native.js",
     "dist/native.d.ts",
     "dist/gpuDevice.d.ts",
+    "dist/solverPipeline.d.ts",
+    "dist/utilities.js",
+    "dist/utilities.d.ts",
     "dist/NOTICE",
     "LICENSE",
     "README.md",