@plasius/gpu-worker 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -20,6 +20,25 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
 - **Security**
   - (placeholder)
 
+## [0.1.1] - 2026-01-23
+
+- **Added**
+  - `assembleWorkerWgsl` now accepts optional queue WGSL overrides for local demos.
+
+- **Changed**
+  - Demo now simulates millions of instanced objects with range checks, bounding spheres/AABBs, and face contact stats.
+  - **Breaking:** Queue bindings updated to remove the payload arena and use payload offsets into caller-managed buffers.
+  - Demo updated to match the new payload-handle layout.
+  - **Breaking:** Queue bindings now use job metadata and a variable-size payload arena.
+  - Worker job payloads are read from the output payload buffer using `output_stride`.
+  - Demo updated to emit job metadata and payload buffers.
+
+- **Fixed**
+  - Demo can load a local queue WGSL to avoid mismatched dependency versions.
+
+- **Security**
+  - (placeholder)
+
 ## [0.1.0] - 2026-01-22
 
 - **Added**
@@ -69,6 +88,9 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
 
 ---
 
-[Unreleased]: https://github.com/Plasius-LTD/gpu-worker/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/Plasius-LTD/gpu-worker/compare/v0.1.1...HEAD
 [0.1.0-beta.1]: https://github.com/Plasius-LTD/gpu-worker/releases/tag/v0.1.0-beta.1
 [0.1.0]: https://github.com/Plasius-LTD/gpu-worker/releases/tag/v0.1.0
+[0.2.0]: https://github.com/Plasius-LTD/gpu-worker/releases/tag/v0.2.0
+[0.3.0]: https://github.com/Plasius-LTD/gpu-worker/releases/tag/v0.3.0
+[0.1.1]: https://github.com/Plasius-LTD/gpu-worker/releases/tag/v0.1.1

package/README.md

@@ -22,6 +22,9 @@ const shaderCode = await assembleWorkerWgsl(workerWgsl);
 // Pass shaderCode to device.createShaderModule({ code: shaderCode })
 ```
 
+`assembleWorkerWgsl` also accepts an optional second argument to override the queue WGSL source:
+`assembleWorkerWgsl(workerWgsl, { queueWgsl, queueUrl, fetcher })`.
+
 ## What this is
 - A minimal GPU worker layer that combines a lock-free queue with user WGSL jobs.
 - A helper to assemble WGSL modules with queue helpers included.
@@ -33,11 +36,26 @@ dependencies first so the lock-free queue package is available for the browser i
 
 ```
 npm install
-python3 -m http.server
+npm run demo
 ```
 
 Then open `http://localhost:8000/demo/`.
 
+### HTTPS demo
+WebGPU requires a secure context. For non-localhost access, run the HTTPS demo server.
+
+```
+mkdir -p demo/certs
+mkcert -key-file demo/certs/localhost-key.pem -cert-file demo/certs/localhost.pem localhost 127.0.0.1 ::1
+# or
+openssl req -x509 -newkey rsa:2048 -nodes -keyout demo/certs/localhost-key.pem -out demo/certs/localhost.pem -days 365 -subj "/CN=localhost" -addext "subjectAltName=DNS:localhost,IP:127.0.0.1"
+npm run demo:https
+```
+
+Then open `https://localhost:8443/demo/`. If you use a different hostname/IP, generate a
+certificate for that name and set `DEMO_HOST`, `DEMO_PORT`, `DEMO_TLS_CERT`, and
+`DEMO_TLS_KEY` as needed.
+
 ## Build Outputs
 
 `npm run build` emits `dist/index.js`, `dist/index.cjs`, and `dist/worker.wgsl`.
@@ -49,4 +67,6 @@ Then open `http://localhost:8000/demo/`.
 - `src/index.js`: Helper functions to load/assemble WGSL.
 
 ## Job shape
-Jobs are `u32` indices into a fixed workload array (tiles, particles, etc). Keep job data fixed-size; use indices into a separate payload buffer for variable payloads.
+Jobs are variable-length payloads stored in a caller-managed buffer. Each job supplies `job_type`, `payload_offset`, and `payload_words` metadata plus a payload stored in the input payload buffer. For simple cases, use a single-word payload containing an index into your workload array.
+
+Set `output_stride` in queue params to the maximum payload size you want copied out for a job; `job_type` can be used by schedulers to route work to different kernels. The queue mirrors input metadata into `output_jobs` and optionally copies payloads into `output_payloads`.

package/dist/index.cjs

@@ -40,10 +40,11 @@ async function loadWorkerWgsl() {
   const response = await fetch(workerWgslUrl);
   return response.text();
 }
-async function assembleWorkerWgsl(workerWgsl) {
-  const queueWgsl = await (0, import_gpu_lock_free_queue.loadQueueWgsl)();
+async function assembleWorkerWgsl(workerWgsl, options = {}) {
+  const { queueWgsl, queueUrl, fetcher } = options ?? {};
+  const queueSource = queueWgsl ?? await (0, import_gpu_lock_free_queue.loadQueueWgsl)({ url: queueUrl, fetcher });
   const body = workerWgsl ?? await loadWorkerWgsl();
-  return `${queueWgsl}
+  return `${queueSource}
 
 ${body}`;
 }

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.js"],"sourcesContent":["import { loadQueueWgsl } from \"@plasius/gpu-lock-free-queue\";\n\nexport const workerWgslUrl = (() => {\n  if (typeof __IMPORT_META_URL__ !== \"undefined\") {\n    return new URL(\"./worker.wgsl\", __IMPORT_META_URL__);\n  }\n  if (typeof __filename !== \"undefined\" && typeof require !== \"undefined\") {\n    const { pathToFileURL } = require(\"node:url\");\n    return new URL(\"./worker.wgsl\", pathToFileURL(__filename));\n  }\n  const base =\n    typeof process !== \"undefined\" && process.cwd\n      ? `file://${process.cwd()}/`\n      : \"file:///\";\n  return new URL(\"./worker.wgsl\", base);\n})();\n\nexport async function loadWorkerWgsl() {\n  const response = await fetch(workerWgslUrl);\n  return response.text();\n}\n\nexport async function assembleWorkerWgsl(workerWgsl) {\n  const queueWgsl = await loadQueueWgsl();\n  const body = workerWgsl ?? (await loadWorkerWgsl());\n  return `${queueWgsl}\\n\\n${body}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAA8B;AAEvB,IAAM,iBAAiB,MAAM;AAClC,MAAI,OAA4C;AAC9C,WAAO,IAAI,IAAI,iBAAiB,MAAmB;AAAA,EACrD;AACA,MAAI,OAAO,eAAe,eAAe,OAAO,YAAY,aAAa;AACvE,UAAM,EAAE,cAAc,IAAI,QAAQ,KAAU;AAC5C,WAAO,IAAI,IAAI,iBAAiB,cAAc,UAAU,CAAC;AAAA,EAC3D;AACA,QAAM,OACJ,OAAO,YAAY,eAAe,QAAQ,MACtC,UAAU,QAAQ,IAAI,CAAC,MACvB;AACN,SAAO,IAAI,IAAI,iBAAiB,IAAI;AACtC,GAAG;AAEH,eAAsB,iBAAiB;AACrC,QAAM,WAAW,MAAM,MAAM,aAAa;AAC1C,SAAO,SAAS,KAAK;AACvB;AAEA,eAAsB,mBAAmB,YAAY;AACnD,QAAM,YAAY,UAAM,0CAAc;AACtC,QAAM,OAAO,cAAe,MAAM,eAAe;AACjD,SAAO,GAAG,SAAS;AAAA;AAAA,EAAO,IAAI;AAChC;","names":[]}
+{"version":3,"sources":["../src/index.js"],"sourcesContent":["import { loadQueueWgsl } from \"@plasius/gpu-lock-free-queue\";\n\nexport const workerWgslUrl = (() => {\n  if (typeof __IMPORT_META_URL__ !== \"undefined\") {\n    return new URL(\"./worker.wgsl\", __IMPORT_META_URL__);\n  }\n  if (typeof __filename !== \"undefined\" && typeof require !== \"undefined\") {\n    const { pathToFileURL } = require(\"node:url\");\n    return new URL(\"./worker.wgsl\", pathToFileURL(__filename));\n  }\n  const base =\n    typeof process !== \"undefined\" && process.cwd\n      ? `file://${process.cwd()}/`\n      : \"file:///\";\n  return new URL(\"./worker.wgsl\", base);\n})();\n\nexport async function loadWorkerWgsl() {\n  const response = await fetch(workerWgslUrl);\n  return response.text();\n}\n\nexport async function assembleWorkerWgsl(workerWgsl, options = {}) {\n  const { queueWgsl, queueUrl, fetcher } = options ?? {};\n  const queueSource =\n    queueWgsl ?? (await loadQueueWgsl({ url: queueUrl, fetcher }));\n  const body = workerWgsl ?? (await loadWorkerWgsl());\n  return `${queueSource}\\n\\n${body}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAA8B;AAEvB,IAAM,iBAAiB,MAAM;AAClC,MAAI,OAA4C;AAC9C,WAAO,IAAI,IAAI,iBAAiB,MAAmB;AAAA,EACrD;AACA,MAAI,OAAO,eAAe,eAAe,OAAO,YAAY,aAAa;AACvE,UAAM,EAAE,cAAc,IAAI,QAAQ,KAAU;AAC5C,WAAO,IAAI,IAAI,iBAAiB,cAAc,UAAU,CAAC;AAAA,EAC3D;AACA,QAAM,OACJ,OAAO,YAAY,eAAe,QAAQ,MACtC,UAAU,QAAQ,IAAI,CAAC,MACvB;AACN,SAAO,IAAI,IAAI,iBAAiB,IAAI;AACtC,GAAG;AAEH,eAAsB,iBAAiB;AACrC,QAAM,WAAW,MAAM,MAAM,aAAa;AAC1C,SAAO,SAAS,KAAK;AACvB;AAEA,eAAsB,mBAAmB,YAAY,UAAU,CAAC,GAAG;AACjE,QAAM,EAAE,WAAW,UAAU,QAAQ,IAAI,WAAW,CAAC;AACrD,QAAM,cACJ,aAAc,UAAM,0CAAc,EAAE,KAAK,UAAU,QAAQ,CAAC;AAC9D,QAAM,OAAO,cAAe,MAAM,eAAe;AACjD,SAAO,GAAG,WAAW;AAAA;AAAA,EAAO,IAAI;AAClC;","names":[]}

package/dist/index.js

@@ -22,10 +22,11 @@ async function loadWorkerWgsl() {
   const response = await fetch(workerWgslUrl);
   return response.text();
 }
-async function assembleWorkerWgsl(workerWgsl) {
-  const queueWgsl = await loadQueueWgsl();
+async function assembleWorkerWgsl(workerWgsl, options = {}) {
+  const { queueWgsl, queueUrl, fetcher } = options ?? {};
+  const queueSource = queueWgsl ?? await loadQueueWgsl({ url: queueUrl, fetcher });
   const body = workerWgsl ?? await loadWorkerWgsl();
-  return `${queueWgsl}
+  return `${queueSource}
 
 ${body}`;
 }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.js"],"sourcesContent":["import { loadQueueWgsl } from \"@plasius/gpu-lock-free-queue\";\n\nexport const workerWgslUrl = (() => {\n  if (typeof __IMPORT_META_URL__ !== \"undefined\") {\n    return new URL(\"./worker.wgsl\", __IMPORT_META_URL__);\n  }\n  if (typeof __filename !== \"undefined\" && typeof require !== \"undefined\") {\n    const { pathToFileURL } = require(\"node:url\");\n    return new URL(\"./worker.wgsl\", pathToFileURL(__filename));\n  }\n  const base =\n    typeof process !== \"undefined\" && process.cwd\n      ? `file://${process.cwd()}/`\n      : \"file:///\";\n  return new URL(\"./worker.wgsl\", base);\n})();\n\nexport async function loadWorkerWgsl() {\n  const response = await fetch(workerWgslUrl);\n  return response.text();\n}\n\nexport async function assembleWorkerWgsl(workerWgsl) {\n  const queueWgsl = await loadQueueWgsl();\n  const body = workerWgsl ?? (await loadWorkerWgsl());\n  return `${queueWgsl}\\n\\n${body}`;\n}\n"],"mappings":";;;;;;;;AAAA,SAAS,qBAAqB;AAEvB,IAAM,iBAAiB,MAAM;AAClC,MAAI,OAAO,oBAAwB,aAAa;AAC9C,WAAO,IAAI,IAAI,iBAAiB,eAAmB;AAAA,EACrD;AACA,MAAI,OAAO,eAAe,eAAe,OAAO,cAAY,aAAa;AACvE,UAAM,EAAE,cAAc,IAAI,UAAQ,KAAU;AAC5C,WAAO,IAAI,IAAI,iBAAiB,cAAc,UAAU,CAAC;AAAA,EAC3D;AACA,QAAM,OACJ,OAAO,YAAY,eAAe,QAAQ,MACtC,UAAU,QAAQ,IAAI,CAAC,MACvB;AACN,SAAO,IAAI,IAAI,iBAAiB,IAAI;AACtC,GAAG;AAEH,eAAsB,iBAAiB;AACrC,QAAM,WAAW,MAAM,MAAM,aAAa;AAC1C,SAAO,SAAS,KAAK;AACvB;AAEA,eAAsB,mBAAmB,YAAY;AACnD,QAAM,YAAY,MAAM,cAAc;AACtC,QAAM,OAAO,cAAe,MAAM,eAAe;AACjD,SAAO,GAAG,SAAS;AAAA;AAAA,EAAO,IAAI;AAChC;","names":[]}
+{"version":3,"sources":["../src/index.js"],"sourcesContent":["import { loadQueueWgsl } from \"@plasius/gpu-lock-free-queue\";\n\nexport const workerWgslUrl = (() => {\n  if (typeof __IMPORT_META_URL__ !== \"undefined\") {\n    return new URL(\"./worker.wgsl\", __IMPORT_META_URL__);\n  }\n  if (typeof __filename !== \"undefined\" && typeof require !== \"undefined\") {\n    const { pathToFileURL } = require(\"node:url\");\n    return new URL(\"./worker.wgsl\", pathToFileURL(__filename));\n  }\n  const base =\n    typeof process !== \"undefined\" && process.cwd\n      ? `file://${process.cwd()}/`\n      : \"file:///\";\n  return new URL(\"./worker.wgsl\", base);\n})();\n\nexport async function loadWorkerWgsl() {\n  const response = await fetch(workerWgslUrl);\n  return response.text();\n}\n\nexport async function assembleWorkerWgsl(workerWgsl, options = {}) {\n  const { queueWgsl, queueUrl, fetcher } = options ?? {};\n  const queueSource =\n    queueWgsl ?? (await loadQueueWgsl({ url: queueUrl, fetcher }));\n  const body = workerWgsl ?? (await loadWorkerWgsl());\n  return `${queueSource}\\n\\n${body}`;\n}\n"],"mappings":";;;;;;;;AAAA,SAAS,qBAAqB;AAEvB,IAAM,iBAAiB,MAAM;AAClC,MAAI,OAAO,oBAAwB,aAAa;AAC9C,WAAO,IAAI,IAAI,iBAAiB,eAAmB;AAAA,EACrD;AACA,MAAI,OAAO,eAAe,eAAe,OAAO,cAAY,aAAa;AACvE,UAAM,EAAE,cAAc,IAAI,UAAQ,KAAU;AAC5C,WAAO,IAAI,IAAI,iBAAiB,cAAc,UAAU,CAAC;AAAA,EAC3D;AACA,QAAM,OACJ,OAAO,YAAY,eAAe,QAAQ,MACtC,UAAU,QAAQ,IAAI,CAAC,MACvB;AACN,SAAO,IAAI,IAAI,iBAAiB,IAAI;AACtC,GAAG;AAEH,eAAsB,iBAAiB;AACrC,QAAM,WAAW,MAAM,MAAM,aAAa;AAC1C,SAAO,SAAS,KAAK;AACvB;AAEA,eAAsB,mBAAmB,YAAY,UAAU,CAAC,GAAG;AACjE,QAAM,EAAE,WAAW,UAAU,QAAQ,IAAI,WAAW,CAAC;AACrD,QAAM,cACJ,aAAc,MAAM,cAAc,EAAE,KAAK,UAAU,QAAQ,CAAC;AAC9D,QAAM,OAAO,cAAe,MAAM,eAAe;AACjD,SAAO,GAAG,WAAW;AAAA;AAAA,EAAO,IAAI;AAClC;","names":[]}

package/dist/worker.wgsl

@@ -1,62 +1,113 @@
-struct RenderParams {
-  width: u32,
-  height: u32,
-  tile_size: u32,
-  _pad0: u32,
-  camera_pos: vec4<f32>,
-  camera_target: vec4<f32>,
-  fov_y: f32,
-  aspect: f32,
-  time: f32,
-  _pad1: f32,
+struct SimParams {
+  count: u32,
+  steps: u32,
+  _pad0: vec2<u32>,
+  dt: f32,
+  range: f32,
+  _pad1: vec2<f32>,
+  bounds_min: vec4<f32>,
+  bounds_max: vec4<f32>,
+  sensor: vec4<f32>,
 };
 
-@group(1) @binding(0) var<storage, read_write> framebuffer: array<u32>;
-@group(1) @binding(1) var<uniform> render: RenderParams;
+struct Instance {
+  pos: vec4<f32>,
+  half: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct Result {
+  aabb_min: vec4<f32>,
+  aabb_max: vec4<f32>,
+  sphere: vec4<f32>,
+  metrics: vec4<f32>,
+};
+
+struct BounceResult {
+  pos: vec3<f32>,
+  vel: vec3<f32>,
+  mask: u32,
+};
+
+@group(1) @binding(0) var<storage, read_write> instances: array<Instance>;
+@group(1) @binding(1) var<storage, read_write> results: array<Result>;
+@group(1) @binding(2) var<uniform> sim: SimParams;
+@group(1) @binding(3) var<storage, read_write> stats: array<atomic<u32>>;
 
-fn hit_sphere(center: vec3<f32>, radius: f32, origin: vec3<f32>, dir: vec3<f32>) -> f32 {
-  let oc = origin - center;
-  let a = dot(dir, dir);
-  let b = 2.0 * dot(oc, dir);
-  let c = dot(oc, oc) - radius * radius;
-  let disc = b * b - 4.0 * a * c;
-  if (disc < 0.0) {
-    return -1.0;
+const STAT_IN_RANGE: u32 = 0u;
+const STAT_FACE_CONTACTS: u32 = 1u;
+const STAT_FACE_X_NEG: u32 = 2u;
+const STAT_FACE_X_POS: u32 = 3u;
+const STAT_FACE_Y_NEG: u32 = 4u;
+const STAT_FACE_Y_POS: u32 = 5u;
+const STAT_FACE_Z_NEG: u32 = 6u;
+const STAT_FACE_Z_POS: u32 = 7u;
+const STAT_BODY_CONTACTS: u32 = 8u;
+
+const BODY_CONTACT_FLAG: u32 = 64u;
+const COLLISION_SAMPLES: u32 = 24u;
+const COLLISION_BRUTE_FORCE_MAX: u32 = 2048u;
+const COLLISION_RESTITUTION: f32 = 0.65;
+const COLLISION_PUSH: f32 = 0.5;
+const COLLISION_EPSILON: f32 = 1e-5;
+
+fn apply_bounds(pos: vec3<f32>, vel: vec3<f32>, half: vec3<f32>) -> BounceResult {
+  let min_bound = sim.bounds_min.xyz + half;
+  let max_bound = sim.bounds_max.xyz - half;
+  var p = pos;
+  var v = vel;
+  var mask: u32 = 0u;
+
+  if (p.x < min_bound.x) {
+    p.x = min_bound.x;
+    v.x = abs(v.x);
+    mask = mask | 1u;
   }
-  let sq = sqrt(disc);
-  let t0 = (-b - sq) / (2.0 * a);
-  if (t0 > 0.001) {
-    return t0;
+  if (p.x > max_bound.x) {
+    p.x = max_bound.x;
+    v.x = -abs(v.x);
+    mask = mask | 2u;
   }
-  let t1 = (-b + sq) / (2.0 * a);
-  if (t1 > 0.001) {
-    return t1;
+  if (p.y < min_bound.y) {
+    p.y = min_bound.y;
+    v.y = abs(v.y);
+    mask = mask | 4u;
+  }
+  if (p.y > max_bound.y) {
+    p.y = max_bound.y;
+    v.y = -abs(v.y);
+    mask = mask | 8u;
+  }
+  if (p.z < min_bound.z) {
+    p.z = min_bound.z;
+    v.z = abs(v.z);
+    mask = mask | 16u;
+  }
+  if (p.z > max_bound.z) {
+    p.z = max_bound.z;
+    v.z = -abs(v.z);
+    mask = mask | 32u;
   }
-  return -1.0;
-}
 
-fn background(dir: vec3<f32>) -> vec3<f32> {
-  let t = 0.5 * (dir.y + 1.0);
-  return mix(vec3<f32>(0.04, 0.05, 0.08), vec3<f32>(0.65, 0.78, 0.92), t);
+  return BounceResult(p, v, mask);
 }
 
-fn shade_point(pos: vec3<f32>, normal: vec3<f32>, base: vec3<f32>) -> vec3<f32> {
-  let light_dir = normalize(vec3<f32>(0.6 + 0.2 * sin(render.time), 0.9, 0.3));
-  let diff = max(dot(normal, light_dir), 0.0);
-  let ambient = 0.2;
-  return base * (ambient + diff * 0.8);
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
 }
 
-fn pack_color(color: vec3<f32>) -> u32 {
-  let c = clamp(color, vec3<f32>(0.0), vec3<f32>(1.0));
-  let r = u32(round(c.x * 255.0));
-  let g = u32(round(c.y * 255.0));
-  let b = u32(round(c.z * 255.0));
-  return (255u << 24) | (b << 16) | (g << 8) | r;
+fn neighbor_index(seed: u32, salt: u32, count: u32) -> u32 {
+  return hash_u32(seed ^ salt) % count;
 }
 
 @compute @workgroup_size(64)
-fn raytrace_main(@builtin(global_invocation_id) gid: vec3<u32>) {
+fn simulate_main(@builtin(global_invocation_id) gid: vec3<u32>) {
   let idx = gid.x;
   if (idx >= params.job_count) {
     return;
@@ -67,68 +118,148 @@ fn raytrace_main(@builtin(global_invocation_id) gid: vec3<u32>) {
     return;
   }
 
-  let job = output_jobs[idx];
-  let tiles_x = (render.width + render.tile_size - 1u) / render.tile_size;
-  let tile_x = job % tiles_x;
-  let tile_y = job / tiles_x;
-  let start_x = tile_x * render.tile_size;
-  let start_y = tile_y * render.tile_size;
+  let payload_words = output_jobs[idx].payload_words;
+  if (payload_words == 0u) {
+    return;
+  }
+  let payload_offset = output_jobs[idx].payload_offset;
+  if (payload_offset + payload_words > arrayLength(&input_payloads)) {
+    return;
+  }
+  let job = input_payloads[payload_offset];
+  if (job >= sim.count) {
+    return;
+  }
 
-  let forward = normalize(render.camera_target.xyz - render.camera_pos.xyz);
-  let right = normalize(cross(forward, vec3<f32>(0.0, 1.0, 0.0)));
-  let up = normalize(cross(right, forward));
-  let tan_half = tan(0.5 * render.fov_y);
+  var inst = instances[job];
+  var pos = inst.pos.xyz;
+  var vel = inst.vel.xyz;
+  let half = inst.half.xyz;
+  var face_mask: u32 = 0u;
+  var body_hits: u32 = 0u;
+  let self_radius = length(half);
 
-  for (var y: u32 = 0u; y < render.tile_size; y = y + 1u) {
-    let py = start_y + y;
-    if (py >= render.height) {
-      continue;
-    }
-    for (var x: u32 = 0u; x < render.tile_size; x = x + 1u) {
-      let px = start_x + x;
-      if (px >= render.width) {
-        continue;
-      }
+  for (var step: u32 = 0u; step < sim.steps; step = step + 1u) {
+    pos = pos + vel * sim.dt;
+    let bounce = apply_bounds(pos, vel, half);
+    pos = bounce.pos;
+    vel = bounce.vel;
+    face_mask = face_mask | bounce.mask;
 
-      let u = (f32(px) + 0.5) / f32(render.width);
-      let v = (f32(py) + 0.5) / f32(render.height);
-      let ndc = vec2<f32>(u * 2.0 - 1.0, 1.0 - v * 2.0);
-      let dir = normalize(forward + ndc.x * render.aspect * tan_half * right + ndc.y * tan_half * up);
-
-      let origin = render.camera_pos.xyz;
-      var color = background(dir);
-
-      let t1 = hit_sphere(vec3<f32>(0.0, 1.0, 0.0), 1.0, origin, dir);
-      let t2 = hit_sphere(vec3<f32>(-1.6, 0.6, -0.5), 0.6, origin, dir);
-      let t3 = hit_sphere(vec3<f32>(0.0, -1000.0, 0.0), 999.0, origin, dir);
-
-      var t_hit = -1.0;
-      var base = vec3<f32>(0.0);
-      var center = vec3<f32>(0.0);
-      if (t1 > 0.0) {
-        t_hit = t1;
-        base = vec3<f32>(0.86, 0.42, 0.32);
-        center = vec3<f32>(0.0, 1.0, 0.0);
-      }
-      if (t2 > 0.0 && (t_hit < 0.0 || t2 < t_hit)) {
-        t_hit = t2;
-        base = vec3<f32>(0.2, 0.7, 0.9);
-        center = vec3<f32>(-1.6, 0.6, -0.5);
-      }
-      if (t3 > 0.0 && (t_hit < 0.0 || t3 < t_hit)) {
-        t_hit = t3;
-        base = vec3<f32>(0.32, 0.3, 0.26);
-        center = vec3<f32>(0.0, -1000.0, 0.0);
-      }
+    if (sim.count <= COLLISION_BRUTE_FORCE_MAX) {
+      for (var other_idx: u32 = 0u; other_idx < sim.count; other_idx = other_idx + 1u) {
+        if (other_idx == job) {
+          continue;
+        }
+        let other = instances[other_idx];
+        let other_pos = other.pos.xyz;
+        let other_vel = other.vel.xyz;
+        let other_radius = length(other.half.xyz);
+        let delta = pos - other_pos;
+        let dist_sq = dot(delta, delta);
+        let min_dist = self_radius + other_radius;
 
-      if (t_hit > 0.0) {
-        let pos = origin + t_hit * dir;
-        let normal = normalize(pos - center);
-        color = shade_point(pos, normal, base);
+        if (dist_sq < min_dist * min_dist && dist_sq > COLLISION_EPSILON) {
+          let dist = sqrt(dist_sq);
+          let normal = delta / dist;
+          let overlap = min_dist - dist;
+          pos = pos + normal * (overlap * COLLISION_PUSH);
+          let rel_vel = vel - other_vel;
+          let approach = dot(rel_vel, normal);
+          if (approach < 0.0) {
+            vel = vel - normal * (approach * (1.0 + COLLISION_RESTITUTION)) * 0.5;
+          }
+          body_hits = body_hits + 1u;
+        }
       }
+    } else {
+      let step_seed = job ^ (step * 0x9e3779b9u);
+      for (var sample: u32 = 0u; sample < COLLISION_SAMPLES; sample = sample + 1u) {
+        let neighbor = neighbor_index(
+          step_seed,
+          sample * 0x85ebca6bu + 0x27d4eb2du,
+          sim.count,
+        );
+        if (neighbor == job) {
+          continue;
+        }
 
-      let pixel_index = py * render.width + px;
-      framebuffer[pixel_index] = pack_color(color);
+        let other = instances[neighbor];
+        let other_pos = other.pos.xyz;
+        let other_vel = other.vel.xyz;
+        let other_radius = length(other.half.xyz);
+        let delta = pos - other_pos;
+        let dist_sq = dot(delta, delta);
+        let min_dist = self_radius + other_radius;
+
+        if (dist_sq < min_dist * min_dist && dist_sq > COLLISION_EPSILON) {
+          let dist = sqrt(dist_sq);
+          let normal = delta / dist;
+          let overlap = min_dist - dist;
+          pos = pos + normal * (overlap * COLLISION_PUSH);
+          let rel_vel = vel - other_vel;
+          let approach = dot(rel_vel, normal);
+          if (approach < 0.0) {
+            vel = vel - normal * (approach * (1.0 + COLLISION_RESTITUTION)) * 0.5;
+          }
+          body_hits = body_hits + 1u;
+        }
+      }
     }
+
+    let bounce2 = apply_bounds(pos, vel, half);
+    pos = bounce2.pos;
+    vel = bounce2.vel;
+    face_mask = face_mask | bounce2.mask;
+  }
+
+  let aabb_min = pos - half;
+  let aabb_max = pos + half;
+  let radius = length(half);
+  let dist = length(pos - sim.sensor.xyz);
+  var in_range: f32 = 0.0;
+  if (dist <= sim.range + radius) {
+    in_range = 1.0;
+  }
+  let speed = length(vel);
+
+  let boundary_mask = face_mask;
+  let face_hits = countOneBits(boundary_mask);
+  if (in_range > 0.0) {
+    atomicAdd(&stats[STAT_IN_RANGE], 1u);
   }
+  if (face_hits > 0u) {
+    atomicAdd(&stats[STAT_FACE_CONTACTS], face_hits);
+  }
+  if ((boundary_mask & 1u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_X_NEG], 1u);
+  }
+  if ((boundary_mask & 2u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_X_POS], 1u);
+  }
+  if ((boundary_mask & 4u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_Y_NEG], 1u);
+  }
+  if ((boundary_mask & 8u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_Y_POS], 1u);
+  }
+  if ((boundary_mask & 16u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_Z_NEG], 1u);
+  }
+  if ((boundary_mask & 32u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_Z_POS], 1u);
+  }
+  if (body_hits > 0u) {
+    atomicAdd(&stats[STAT_BODY_CONTACTS], body_hits);
+    face_mask = boundary_mask | BODY_CONTACT_FLAG;
+  }
+
+  inst.pos = vec4<f32>(pos, 1.0);
+  inst.vel = vec4<f32>(vel, 0.0);
+  instances[job] = inst;
+
+  results[job].aabb_min = vec4<f32>(aabb_min, 0.0);
+  results[job].aabb_max = vec4<f32>(aabb_max, 0.0);
+  results[job].sphere = vec4<f32>(pos, radius);
+  results[job].metrics = vec4<f32>(dist, speed, in_range, f32(face_mask));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasius/gpu-worker",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "WebGPU worker runtime with a lock-free job queue for WGSL workloads.",
   "type": "module",
   "sideEffects": false,
@@ -26,6 +26,7 @@
   "scripts": {
     "build": "tsup && cp src/worker.wgsl dist/worker.wgsl",
     "demo": "python3 -m http.server",
+    "demo:https": "node demo/serve-https.js",
     "test": "npm run test:unit",
     "test:unit": "node --test",
     "test:e2e": "npx playwright install chromium && playwright test",
@@ -46,7 +47,7 @@
   "author": "Plasius LTD <development@plasius.co.uk>",
   "license": "Apache-2.0",
   "dependencies": {
-    "@plasius/gpu-lock-free-queue": "^0.1.1-beta.1"
+    "@plasius/gpu-lock-free-queue": "^0.2.1"
   },
   "devDependencies": {
     "@playwright/test": "^1.57.0",

package/src/index.js

@@ -20,8 +20,10 @@ export async function loadWorkerWgsl() {
   return response.text();
 }
 
-export async function assembleWorkerWgsl(workerWgsl) {
-  const queueWgsl = await loadQueueWgsl();
+export async function assembleWorkerWgsl(workerWgsl, options = {}) {
+  const { queueWgsl, queueUrl, fetcher } = options ?? {};
+  const queueSource =
+    queueWgsl ?? (await loadQueueWgsl({ url: queueUrl, fetcher }));
   const body = workerWgsl ?? (await loadWorkerWgsl());
-  return `${queueWgsl}\n\n${body}`;
+  return `${queueSource}\n\n${body}`;
 }

package/src/worker.wgsl

@@ -1,62 +1,113 @@
-struct RenderParams {
-  width: u32,
-  height: u32,
-  tile_size: u32,
-  _pad0: u32,
-  camera_pos: vec4<f32>,
-  camera_target: vec4<f32>,
-  fov_y: f32,
-  aspect: f32,
-  time: f32,
-  _pad1: f32,
+struct SimParams {
+  count: u32,
+  steps: u32,
+  _pad0: vec2<u32>,
+  dt: f32,
+  range: f32,
+  _pad1: vec2<f32>,
+  bounds_min: vec4<f32>,
+  bounds_max: vec4<f32>,
+  sensor: vec4<f32>,
 };
 
-@group(1) @binding(0) var<storage, read_write> framebuffer: array<u32>;
-@group(1) @binding(1) var<uniform> render: RenderParams;
+struct Instance {
+  pos: vec4<f32>,
+  half: vec4<f32>,
+  vel: vec4<f32>,
+};
+
+struct Result {
+  aabb_min: vec4<f32>,
+  aabb_max: vec4<f32>,
+  sphere: vec4<f32>,
+  metrics: vec4<f32>,
+};
+
+struct BounceResult {
+  pos: vec3<f32>,
+  vel: vec3<f32>,
+  mask: u32,
+};
+
+@group(1) @binding(0) var<storage, read_write> instances: array<Instance>;
+@group(1) @binding(1) var<storage, read_write> results: array<Result>;
+@group(1) @binding(2) var<uniform> sim: SimParams;
+@group(1) @binding(3) var<storage, read_write> stats: array<atomic<u32>>;
 
-fn hit_sphere(center: vec3<f32>, radius: f32, origin: vec3<f32>, dir: vec3<f32>) -> f32 {
-  let oc = origin - center;
-  let a = dot(dir, dir);
-  let b = 2.0 * dot(oc, dir);
-  let c = dot(oc, oc) - radius * radius;
-  let disc = b * b - 4.0 * a * c;
-  if (disc < 0.0) {
-    return -1.0;
+const STAT_IN_RANGE: u32 = 0u;
+const STAT_FACE_CONTACTS: u32 = 1u;
+const STAT_FACE_X_NEG: u32 = 2u;
+const STAT_FACE_X_POS: u32 = 3u;
+const STAT_FACE_Y_NEG: u32 = 4u;
+const STAT_FACE_Y_POS: u32 = 5u;
+const STAT_FACE_Z_NEG: u32 = 6u;
+const STAT_FACE_Z_POS: u32 = 7u;
+const STAT_BODY_CONTACTS: u32 = 8u;
+
+const BODY_CONTACT_FLAG: u32 = 64u;
+const COLLISION_SAMPLES: u32 = 24u;
+const COLLISION_BRUTE_FORCE_MAX: u32 = 2048u;
+const COLLISION_RESTITUTION: f32 = 0.65;
+const COLLISION_PUSH: f32 = 0.5;
+const COLLISION_EPSILON: f32 = 1e-5;
+
+fn apply_bounds(pos: vec3<f32>, vel: vec3<f32>, half: vec3<f32>) -> BounceResult {
+  let min_bound = sim.bounds_min.xyz + half;
+  let max_bound = sim.bounds_max.xyz - half;
+  var p = pos;
+  var v = vel;
+  var mask: u32 = 0u;
+
+  if (p.x < min_bound.x) {
+    p.x = min_bound.x;
+    v.x = abs(v.x);
+    mask = mask | 1u;
   }
-  let sq = sqrt(disc);
-  let t0 = (-b - sq) / (2.0 * a);
-  if (t0 > 0.001) {
-    return t0;
+  if (p.x > max_bound.x) {
+    p.x = max_bound.x;
+    v.x = -abs(v.x);
+    mask = mask | 2u;
   }
-  let t1 = (-b + sq) / (2.0 * a);
-  if (t1 > 0.001) {
-    return t1;
+  if (p.y < min_bound.y) {
+    p.y = min_bound.y;
+    v.y = abs(v.y);
+    mask = mask | 4u;
+  }
+  if (p.y > max_bound.y) {
+    p.y = max_bound.y;
+    v.y = -abs(v.y);
+    mask = mask | 8u;
+  }
+  if (p.z < min_bound.z) {
+    p.z = min_bound.z;
+    v.z = abs(v.z);
+    mask = mask | 16u;
+  }
+  if (p.z > max_bound.z) {
+    p.z = max_bound.z;
+    v.z = -abs(v.z);
+    mask = mask | 32u;
   }
-  return -1.0;
-}
 
-fn background(dir: vec3<f32>) -> vec3<f32> {
-  let t = 0.5 * (dir.y + 1.0);
-  return mix(vec3<f32>(0.04, 0.05, 0.08), vec3<f32>(0.65, 0.78, 0.92), t);
+  return BounceResult(p, v, mask);
 }
 
-fn shade_point(pos: vec3<f32>, normal: vec3<f32>, base: vec3<f32>) -> vec3<f32> {
-  let light_dir = normalize(vec3<f32>(0.6 + 0.2 * sin(render.time), 0.9, 0.3));
-  let diff = max(dot(normal, light_dir), 0.0);
-  let ambient = 0.2;
-  return base * (ambient + diff * 0.8);
+fn hash_u32(x: u32) -> u32 {
+  var v = x;
+  v = v ^ (v >> 16u);
+  v = v * 0x7feb352du;
+  v = v ^ (v >> 15u);
+  v = v * 0x846ca68bu;
+  v = v ^ (v >> 16u);
+  return v;
 }
 
-fn pack_color(color: vec3<f32>) -> u32 {
-  let c = clamp(color, vec3<f32>(0.0), vec3<f32>(1.0));
-  let r = u32(round(c.x * 255.0));
-  let g = u32(round(c.y * 255.0));
-  let b = u32(round(c.z * 255.0));
-  return (255u << 24) | (b << 16) | (g << 8) | r;
+fn neighbor_index(seed: u32, salt: u32, count: u32) -> u32 {
+  return hash_u32(seed ^ salt) % count;
 }
 
 @compute @workgroup_size(64)
-fn raytrace_main(@builtin(global_invocation_id) gid: vec3<u32>) {
+fn simulate_main(@builtin(global_invocation_id) gid: vec3<u32>) {
   let idx = gid.x;
   if (idx >= params.job_count) {
     return;
@@ -67,68 +118,148 @@ fn raytrace_main(@builtin(global_invocation_id) gid: vec3<u32>) {
     return;
   }
 
-  let job = output_jobs[idx];
-  let tiles_x = (render.width + render.tile_size - 1u) / render.tile_size;
-  let tile_x = job % tiles_x;
-  let tile_y = job / tiles_x;
-  let start_x = tile_x * render.tile_size;
-  let start_y = tile_y * render.tile_size;
+  let payload_words = output_jobs[idx].payload_words;
+  if (payload_words == 0u) {
+    return;
+  }
+  let payload_offset = output_jobs[idx].payload_offset;
+  if (payload_offset + payload_words > arrayLength(&input_payloads)) {
+    return;
+  }
+  let job = input_payloads[payload_offset];
+  if (job >= sim.count) {
+    return;
+  }
 
-  let forward = normalize(render.camera_target.xyz - render.camera_pos.xyz);
-  let right = normalize(cross(forward, vec3<f32>(0.0, 1.0, 0.0)));
-  let up = normalize(cross(right, forward));
-  let tan_half = tan(0.5 * render.fov_y);
+  var inst = instances[job];
+  var pos = inst.pos.xyz;
+  var vel = inst.vel.xyz;
+  let half = inst.half.xyz;
+  var face_mask: u32 = 0u;
+  var body_hits: u32 = 0u;
+  let self_radius = length(half);
 
-  for (var y: u32 = 0u; y < render.tile_size; y = y + 1u) {
-    let py = start_y + y;
-    if (py >= render.height) {
-      continue;
-    }
-    for (var x: u32 = 0u; x < render.tile_size; x = x + 1u) {
-      let px = start_x + x;
-      if (px >= render.width) {
-        continue;
-      }
+  for (var step: u32 = 0u; step < sim.steps; step = step + 1u) {
+    pos = pos + vel * sim.dt;
+    let bounce = apply_bounds(pos, vel, half);
+    pos = bounce.pos;
+    vel = bounce.vel;
+    face_mask = face_mask | bounce.mask;
 
-      let u = (f32(px) + 0.5) / f32(render.width);
-      let v = (f32(py) + 0.5) / f32(render.height);
-      let ndc = vec2<f32>(u * 2.0 - 1.0, 1.0 - v * 2.0);
-      let dir = normalize(forward + ndc.x * render.aspect * tan_half * right + ndc.y * tan_half * up);
-
-      let origin = render.camera_pos.xyz;
-      var color = background(dir);
-
-      let t1 = hit_sphere(vec3<f32>(0.0, 1.0, 0.0), 1.0, origin, dir);
-      let t2 = hit_sphere(vec3<f32>(-1.6, 0.6, -0.5), 0.6, origin, dir);
-      let t3 = hit_sphere(vec3<f32>(0.0, -1000.0, 0.0), 999.0, origin, dir);
-
-      var t_hit = -1.0;
-      var base = vec3<f32>(0.0);
-      var center = vec3<f32>(0.0);
-      if (t1 > 0.0) {
-        t_hit = t1;
-        base = vec3<f32>(0.86, 0.42, 0.32);
-        center = vec3<f32>(0.0, 1.0, 0.0);
-      }
-      if (t2 > 0.0 && (t_hit < 0.0 || t2 < t_hit)) {
-        t_hit = t2;
-        base = vec3<f32>(0.2, 0.7, 0.9);
-        center = vec3<f32>(-1.6, 0.6, -0.5);
-      }
-      if (t3 > 0.0 && (t_hit < 0.0 || t3 < t_hit)) {
-        t_hit = t3;
-        base = vec3<f32>(0.32, 0.3, 0.26);
-        center = vec3<f32>(0.0, -1000.0, 0.0);
-      }
+    if (sim.count <= COLLISION_BRUTE_FORCE_MAX) {
+      for (var other_idx: u32 = 0u; other_idx < sim.count; other_idx = other_idx + 1u) {
+        if (other_idx == job) {
+          continue;
+        }
+        let other = instances[other_idx];
+        let other_pos = other.pos.xyz;
+        let other_vel = other.vel.xyz;
+        let other_radius = length(other.half.xyz);
+        let delta = pos - other_pos;
+        let dist_sq = dot(delta, delta);
+        let min_dist = self_radius + other_radius;
 
-      if (t_hit > 0.0) {
-        let pos = origin + t_hit * dir;
-        let normal = normalize(pos - center);
-        color = shade_point(pos, normal, base);
+        if (dist_sq < min_dist * min_dist && dist_sq > COLLISION_EPSILON) {
+          let dist = sqrt(dist_sq);
+          let normal = delta / dist;
+          let overlap = min_dist - dist;
+          pos = pos + normal * (overlap * COLLISION_PUSH);
+          let rel_vel = vel - other_vel;
+          let approach = dot(rel_vel, normal);
+          if (approach < 0.0) {
+            vel = vel - normal * (approach * (1.0 + COLLISION_RESTITUTION)) * 0.5;
+          }
+          body_hits = body_hits + 1u;
+        }
       }
+    } else {
+      let step_seed = job ^ (step * 0x9e3779b9u);
+      for (var sample: u32 = 0u; sample < COLLISION_SAMPLES; sample = sample + 1u) {
+        let neighbor = neighbor_index(
+          step_seed,
+          sample * 0x85ebca6bu + 0x27d4eb2du,
+          sim.count,
+        );
+        if (neighbor == job) {
+          continue;
+        }
 
-      let pixel_index = py * render.width + px;
-      framebuffer[pixel_index] = pack_color(color);
+        let other = instances[neighbor];
+        let other_pos = other.pos.xyz;
+        let other_vel = other.vel.xyz;
+        let other_radius = length(other.half.xyz);
+        let delta = pos - other_pos;
+        let dist_sq = dot(delta, delta);
+        let min_dist = self_radius + other_radius;
+
+        if (dist_sq < min_dist * min_dist && dist_sq > COLLISION_EPSILON) {
+          let dist = sqrt(dist_sq);
+          let normal = delta / dist;
+          let overlap = min_dist - dist;
+          pos = pos + normal * (overlap * COLLISION_PUSH);
+          let rel_vel = vel - other_vel;
+          let approach = dot(rel_vel, normal);
+          if (approach < 0.0) {
+            vel = vel - normal * (approach * (1.0 + COLLISION_RESTITUTION)) * 0.5;
+          }
+          body_hits = body_hits + 1u;
+        }
+      }
     }
+
+    let bounce2 = apply_bounds(pos, vel, half);
+    pos = bounce2.pos;
+    vel = bounce2.vel;
+    face_mask = face_mask | bounce2.mask;
+  }
+
+  let aabb_min = pos - half;
+  let aabb_max = pos + half;
+  let radius = length(half);
+  let dist = length(pos - sim.sensor.xyz);
+  var in_range: f32 = 0.0;
+  if (dist <= sim.range + radius) {
+    in_range = 1.0;
+  }
+  let speed = length(vel);
+
+  let boundary_mask = face_mask;
+  let face_hits = countOneBits(boundary_mask);
+  if (in_range > 0.0) {
+    atomicAdd(&stats[STAT_IN_RANGE], 1u);
   }
+  if (face_hits > 0u) {
+    atomicAdd(&stats[STAT_FACE_CONTACTS], face_hits);
+  }
+  if ((boundary_mask & 1u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_X_NEG], 1u);
+  }
+  if ((boundary_mask & 2u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_X_POS], 1u);
+  }
+  if ((boundary_mask & 4u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_Y_NEG], 1u);
+  }
+  if ((boundary_mask & 8u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_Y_POS], 1u);
+  }
+  if ((boundary_mask & 16u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_Z_NEG], 1u);
+  }
+  if ((boundary_mask & 32u) != 0u) {
+    atomicAdd(&stats[STAT_FACE_Z_POS], 1u);
+  }
+  if (body_hits > 0u) {
+    atomicAdd(&stats[STAT_BODY_CONTACTS], body_hits);
+    face_mask = boundary_mask | BODY_CONTACT_FLAG;
+  }
+
+  inst.pos = vec4<f32>(pos, 1.0);
+  inst.vel = vec4<f32>(vel, 0.0);
+  instances[job] = inst;
+
+  results[job].aabb_min = vec4<f32>(aabb_min, 0.0);
+  results[job].aabb_max = vec4<f32>(aabb_max, 0.0);
+  results[job].sphere = vec4<f32>(pos, radius);
+  results[job].metrics = vec4<f32>(dist, speed, in_range, f32(face_mask));
 }