@simulatte/webgpu 0.2.1 → 0.2.4

package/layering-plan.md

@@ -0,0 +1,259 @@
+# Proposed layering plan for core and full
+
+Plan status: `draft`
+
+Scope:
+
+- future Doe runtime/package sharding for headless WebGPU
+- architecture and refactor sequencing only
+- no current runtime behavior changes
+
+This plan exists to keep the future `core` and `full` split honest before any
+Zig source moves begin.
+
+It answers four questions:
+
+1. what boundary is being enforced
+2. how that boundary is enforced in code review and CI
+3. how capability coverage and gates split once the boundary exists
+4. what order the refactor should happen in
+
+Use this together with:
+
+- `support-contracts.md` for product/support scope
+- `api-contract.md` for the current package contract (`full` default, `compute` subpath)
+- `compat-scope.md` for current package non-goals
+- `zig-source-inventory.md` for the current `zig/src` file map
+
+## Current state
+
+The repo is now partially physically split into `core` and `full`, but the public façade boundary is still being reduced.
+
+Current reality:
+
+1. `zig/src/core/` and `zig/src/full/` are now real source subtrees with canonical implementations for the first runtime split slices.
+2. The old root ABI shims (`zig/src/wgpu_types.zig`, `zig/src/wgpu_loader.zig`) have now been retired; the remaining root compatibility façades are narrower command/resource surfaces kept only while callers finish retargeting.
+3. Canonical command partition and command dispatch now live in `zig/src/core/{command_partition.zig,command_dispatch.zig}` and `zig/src/full/{command_partition.zig,command_dispatch.zig}`.
+4. Canonical texture command handling now lives in `zig/src/core/resource/wgpu_texture_commands.zig`; canonical sampler and surface command handling now lives in `zig/src/full/render/wgpu_sampler_commands.zig` and `zig/src/full/surface/wgpu_surface_commands.zig`.
+5. `zig/src/wgpu_commands.zig`, `zig/src/wgpu_resources.zig`, and `zig/src/wgpu_extended_commands.zig` are now compatibility façades over the canonical subtrees, while `zig/src/webgpu_ffi.zig` remains the public façade and owner of `WebGPUBackend`.
+6. Dedicated Zig test lanes now exist as `zig build test-core` and `zig build test-full`, but split coverage remains thin and capability tracking is still represented by one shared coverage ledger.
+7. The JS package now exposes a default `full` surface plus an explicit `compute` subpath, while the underlying JS implementation is still shared.
+
+That means this plan is now materially physicalized in the tree, and the remaining semantic split is concentrated in the public façade files and backend roots.
+
+## Boundary definition
+
+The target architecture is:
+
+```text
+Doe core
+  ^
+  |
+Doe full
+  ^
+  |
+Chromium Track A runtime artifact lane
+```
+
+Rules:
+
+1. `full` composes `core`; it does not toggle `core`.
+2. `core` must never import `full`.
+3. `full` may depend on `core` Zig modules, Lean modules, build outputs, and JS
+   helpers.
+4. Chromium Track A depends on the full runtime artifact and browser-specific
+   gates, not on npm package layout.
+
+The anti-bleed rule is the core of the design:
+
+- no `if full_enabled` branches inside `core`
+- no `full` fields added to `core` structs
+- no browser-policy logic added to `full`
+
+## Import fence rule
+
+This is the primary long-term enforcement rule.
+
+### Contract
+
+1. `zig/src/core/**` may not import any file under `zig/src/full/**`
+2. `lean/Fawn/Core/**` may not import any file under `lean/Fawn/Full/**`
+3. package-level `core` entrypoints may not import `full` entrypoints
+4. any exception requires redesign, not a one-off waiver
+
+### CI enforcement
+
+The dedicated import-fence check should fail if:
+
+1. a Zig file under `core` references `full/`
+2. a Lean file under `Core` references `Full`
+3. a package `core` entrypoint reaches into a `full`-only module
+
+The check should be a simple, explicit path-dependency audit. This is not a
+lint preference; it is a release-blocking architectural boundary.
+
+## Struct wrapping rule
+
+`full` must extend `core` by composition, never by mutating `core` types in
+place.
+
+### Contract
+
+1. if `full` needs shared state, it holds a `core` value or handle
+2. if `full` needs extra state, that state lives in a `full` wrapper type
+3. `core` structs may not gain render/surface/full-only fields just because
+   `full` needs them
+4. `core` APIs may expose stable extension points, but not latent `full`
+   payload slots
+
+### Example direction
+
+Good shape:
+
+```text
+full.RenderPipeline
+  - core_pipeline_layout: core.PipelineLayout
+  - full_render_state: ...
+```
+
+Bad shape:
+
+```text
+core.PipelineLayout
+  - maybe_render_state_if_full_enabled: ...
+```
+
+The intent is to keep `core` independently understandable, buildable, and
+benchmarked.
+
+## Coverage split rule
+
+The current shared capability ledger is not enough once `core` and `full`
+become separate release surfaces.
+
+### Target split
+
+1. `config/webgpu-core-coverage.json`
+   - only `core` contractual capabilities
+2. `config/webgpu-full-coverage.json`
+   - `core` plus `full` contractual capabilities
+3. Chromium Track A keeps its own browser/drop-in evidence and must not be
+   represented as mere package coverage
+
+### Gate split
+
+`core` gates should validate:
+
+1. core package contract
+2. core CTS subset
+3. core package-surface benchmark cells
+4. explicit unsupported taxonomy outside core scope
+
+`full` gates should validate:
+
+1. all core gates
+2. full package contract
+3. expanded CTS subset for render/lifecycle/query coverage
+4. full package-surface benchmark cells
+5. explicit unsupported taxonomy outside full scope
+
+Track A gates remain separate:
+
+1. drop-in symbol completeness
+2. drop-in behavior suite
+3. browser replay and trace parity
+4. browser performance claimability
+
+## Proposed source layout
+
+Target layout:
+
+```text
+zig/src/core/
+  mod.zig
+  trace/
+  replay/
+  abi/
+  resource/
+  queue/
+  compute/
+  backend/common/
+  backend/{metal,vulkan,d3d12}/core/
+
+zig/src/full/
+  mod.zig
+  render/
+  surface/
+  lifecycle/
+  backend/{metal,vulkan,d3d12}/full/
+```
+
+Matching Lean layout:
+
+```text
+lean/Fawn/Core/
+lean/Fawn/Full/
+```
+
+Matching package layout is currently:
+
+1. one package with scoped exports
+   - `@simulatte/webgpu` => `full`
+   - `@simulatte/webgpu/compute` => compute-first subset
+
+Separate packages remain optional later, but they are not the current shape.
+The source boundary still comes first.
+
+## Refactor order
+
+Do not start by renaming packages.
+
+Recommended order:
+
+1. freeze support contracts
+   - define what `core` and `full` promise
+2. add import-fence CI checks
+   - enforce the one-way dependency before extraction starts
+3. add split coverage ledgers and split gate entrypoints
+   - even if both initially point at the current shared runtime
+4. identify shared runtime modules that are genuinely `core`
+   - trace, replay, buffers, queue, compute, shared resource model
+5. identify `full`-only modules
+   - render, surface, broader lifecycle/parity layers
+6. extract `full` wrappers around `core` types
+   - composition only
+7. move render/surface code out of the shared tree
+   - no behavior change intended during extraction
+8. split package/API contracts
+   - only after the runtime boundary is real
+9. retarget Chromium Track A to the full runtime artifact contract
+   - no npm package dependency in architecture docs
+
+## Review checklist for future changes
+
+Any future patch touching this split should answer:
+
+1. does `core` now depend on `full` anywhere
+2. did a `core` struct gain a `full`-only field
+3. did a coverage or gate responsibility move without contract updates
+4. did a browser-owned behavior get assigned to `core` or `full`
+5. did packaging get ahead of the runtime boundary
+
+If any answer is yes, the patch should be treated as architecture drift until
+the contract is updated or the design is corrected.
+
+## Immediate next artifacts
+
+The earliest structural groundwork now exists: the inventory and import-fence check are in place, the first canonical `core/` and `full/` subtrees exist, and the legacy root command/resource files are compatibility façades.
+
+The next technical artifacts should focus on the remaining semantic boundary:
+
+1. split coverage contracts for `core` and `full`
+2. classify tests and Lean proofs against the new `core`/`full` boundary
+3. shrink the remaining public façade files:
+   - `model.zig`
+   - `webgpu_ffi.zig`
+   - backend root modules
+4. retire root compatibility façades once callers stop importing them
+
+The extraction work should now spend its effort on the remaining public boundary, not on re-moving files that already have canonical homes.

package/native/doe_napi.c

@@ -15,6 +15,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
+#include <stdio.h>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -884,6 +885,30 @@ static napi_value doe_buffer_get_mapped_range(napi_env env, napi_callback_info i
     return ab;
 }
 
+/* bufferAssertMappedPrefixF32(buffer, expected, count) */
+static napi_value doe_buffer_assert_mapped_prefix_f32(napi_env env, napi_callback_info info) {
+    NAPI_ASSERT_ARGC(env, info, 3);
+    CHECK_LIB_LOADED(env);
+    WGPUBuffer buf = unwrap_ptr(env, _args[0]);
+    double expected = 0.0;
+    uint32_t count = 0;
+    napi_get_value_double(env, _args[1], &expected);
+    napi_get_value_uint32(env, _args[2], &count);
+    if (!buf) NAPI_THROW(env, "bufferAssertMappedPrefixF32 requires buffer");
+    const float* mapped = (const float*)pfn_wgpuBufferGetConstMappedRange(buf, 0, count * sizeof(float));
+    if (!mapped) NAPI_THROW(env, "bufferAssertMappedPrefixF32: mapped range unavailable");
+    for (uint32_t i = 0; i < count; i++) {
+        if ((double)mapped[i] != expected) {
+            char msg[128];
+            snprintf(msg, sizeof(msg), "expected readback[%u] === %.0f, got %.9g", i, expected, (double)mapped[i]);
+            NAPI_THROW(env, msg);
+        }
+    }
+    napi_value ok;
+    napi_get_boolean(env, true, &ok);
+    return ok;
+}
+
 /* ================================================================
  * Shader Module
  * ================================================================ */
@@ -1376,8 +1401,8 @@ static napi_value doe_queue_flush(napi_env env, napi_callback_info info) {
 }
 
 /* submitBatched(device, queue, commandsArray)
- * Fast path: single dispatch + optional copy → doeNativeComputeDispatchFlush (direct Metal, no Zig command recording).
- * Fallback: standard wgpu path for multi-dispatch or unsupported patterns. */
+ * Fast path: single dispatch or dispatch+copy → doeNativeComputeDispatchFlush.
+ * Larger or mixed batches stay on the standard wgpu path. */
 #define BATCH_MAX_BIND_GROUPS 4
 static napi_value doe_submit_batched(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 3);
@@ -1391,12 +1416,18 @@ static napi_value doe_submit_batched(napi_env env, napi_callback_info info) {
     napi_get_array_length(env, commands, &cmd_count);
     if (cmd_count == 0) return NULL;
 
-    /* Fast path: exactly 1 dispatch + 0-1 copy, and direct dispatch function available. */
-    if (pfn_doeNativeComputeDispatchFlush && cmd_count >= 1 && cmd_count <= 2) {
+    /* Fast path: exactly one dispatch, or dispatch followed by copy. */
+    if (pfn_doeNativeComputeDispatchFlush && (cmd_count == 1 || cmd_count == 2)) {
         napi_value cmd0;
         napi_get_element(env, commands, 0, &cmd0);
         uint32_t t0 = get_uint32_prop(env, cmd0, "t");
-        if (t0 == 0) {
+        uint32_t t1 = UINT32_MAX;
+        napi_value cmd1 = NULL;
+        if (cmd_count == 2) {
+            napi_get_element(env, commands, 1, &cmd1);
+            t1 = get_uint32_prop(env, cmd1, "t");
+        }
+        if (t0 == 0 && (cmd_count == 1 || t1 == 1)) {
             void* pipeline = unwrap_ptr(env, get_prop(env, cmd0, "p"));
             napi_value bgs = get_prop(env, cmd0, "bg");
             uint32_t bg_count = 0;
@@ -1411,20 +1442,17 @@ static napi_value doe_submit_batched(napi_env env, napi_callback_info info) {
             uint32_t dx = get_uint32_prop(env, cmd0, "x");
             uint32_t dy = get_uint32_prop(env, cmd0, "y");
             uint32_t dz = get_uint32_prop(env, cmd0, "z");
-
-            void* copy_src = NULL; uint64_t copy_src_off = 0;
-            void* copy_dst = NULL; uint64_t copy_dst_off = 0;
+            void* copy_src = NULL;
+            uint64_t copy_src_off = 0;
+            void* copy_dst = NULL;
+            uint64_t copy_dst_off = 0;
             uint64_t copy_size = 0;
             if (cmd_count == 2) {
-                napi_value cmd1;
-                napi_get_element(env, commands, 1, &cmd1);
-                if (get_uint32_prop(env, cmd1, "t") == 1) {
-                    copy_src = unwrap_ptr(env, get_prop(env, cmd1, "s"));
-                    copy_src_off = (uint64_t)get_int64_prop(env, cmd1, "so");
-                    copy_dst = unwrap_ptr(env, get_prop(env, cmd1, "d"));
-                    copy_dst_off = (uint64_t)get_int64_prop(env, cmd1, "do");
-                    copy_size = (uint64_t)get_int64_prop(env, cmd1, "sz");
-                }
+                copy_src = unwrap_ptr(env, get_prop(env, cmd1, "s"));
+                copy_dst = unwrap_ptr(env, get_prop(env, cmd1, "d"));
+                copy_src_off = (uint64_t)get_int64_prop(env, cmd1, "so");
+                copy_dst_off = (uint64_t)get_int64_prop(env, cmd1, "do");
+                copy_size = (uint64_t)get_int64_prop(env, cmd1, "sz");
             }
             pfn_doeNativeComputeDispatchFlush(
                 queue, pipeline, (void**)bg_ptrs, bg_count,
@@ -1435,6 +1463,16 @@ static napi_value doe_submit_batched(napi_env env, napi_callback_info info) {
     }
 
     /* Fallback: standard wgpu path. */
+    int flush_after_submit = 0;
+    if (cmd_count == 2) {
+        napi_value cmd0;
+        napi_value cmd1;
+        napi_get_element(env, commands, 0, &cmd0);
+        napi_get_element(env, commands, 1, &cmd1);
+        if (get_uint32_prop(env, cmd0, "t") == 0 && get_uint32_prop(env, cmd1, "t") == 1) {
+            flush_after_submit = 1;
+        }
+    }
     WGPUCommandEncoder encoder = pfn_wgpuDeviceCreateCommandEncoder(device, NULL);
     if (!encoder) NAPI_THROW(env, "submitBatched: createCommandEncoder failed");
     for (uint32_t i = 0; i < cmd_count; i++) {
@@ -1470,11 +1508,64 @@ static napi_value doe_submit_batched(napi_env env, napi_callback_info info) {
     }
     WGPUCommandBuffer cmd_buf = pfn_wgpuCommandEncoderFinish(encoder, NULL);
     pfn_wgpuQueueSubmit(queue, 1, &cmd_buf);
+    if (flush_after_submit && pfn_doeNativeQueueFlush) {
+        pfn_doeNativeQueueFlush(queue);
+    }
     pfn_wgpuCommandBufferRelease(cmd_buf);
     pfn_wgpuCommandEncoderRelease(encoder);
     return NULL;
 }
 
+/* submitComputeDispatchCopy(device, queue, pipeline, bindGroups, x, y, z, src, srcOff, dst, dstOff, size)
+ * Direct addon surface for the exact package compute_e2e shape so JS runtimes
+ * do not pay generic command-array parsing on every timed sample. */
+static napi_value doe_submit_compute_dispatch_copy(napi_env env, napi_callback_info info) {
+    size_t argc = 12;
+    napi_value args[12];
+    napi_status status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+    if (status != napi_ok || argc != 12) NAPI_THROW(env, "submitComputeDispatchCopy requires 12 arguments");
+    CHECK_LIB_LOADED(env);
+    WGPUDevice device = unwrap_ptr(env, args[0]);
+    WGPUQueue queue = unwrap_ptr(env, args[1]);
+    void* pipeline = unwrap_ptr(env, args[2]);
+    napi_value bgs = args[3];
+    uint32_t dx = 0;
+    uint32_t dy = 0;
+    uint32_t dz = 0;
+    int64_t copy_src_off_i = 0;
+    int64_t copy_dst_off_i = 0;
+    int64_t copy_size_i = 0;
+    napi_get_value_uint32(env, args[4], &dx);
+    napi_get_value_uint32(env, args[5], &dy);
+    napi_get_value_uint32(env, args[6], &dz);
+    void* copy_src = unwrap_ptr(env, args[7]);
+    napi_get_value_int64(env, args[8], &copy_src_off_i);
+    void* copy_dst = unwrap_ptr(env, args[9]);
+    napi_get_value_int64(env, args[10], &copy_dst_off_i);
+    napi_get_value_int64(env, args[11], &copy_size_i);
+    uint64_t copy_src_off = (uint64_t)copy_src_off_i;
+    uint64_t copy_dst_off = (uint64_t)copy_dst_off_i;
+    uint64_t copy_size = (uint64_t)copy_size_i;
+    if (!device || !queue || !pipeline) NAPI_THROW(env, "submitComputeDispatchCopy requires device, queue, and pipeline");
+    if (!pfn_doeNativeComputeDispatchFlush) NAPI_THROW(env, "submitComputeDispatchCopy: doeNativeComputeDispatchFlush not available");
+
+    uint32_t bg_count = 0;
+    napi_get_array_length(env, bgs, &bg_count);
+    if (bg_count > BATCH_MAX_BIND_GROUPS) bg_count = BATCH_MAX_BIND_GROUPS;
+    void* bg_ptrs[BATCH_MAX_BIND_GROUPS] = {NULL};
+    for (uint32_t j = 0; j < bg_count; j++) {
+        napi_value bg_val;
+        napi_get_element(env, bgs, j, &bg_val);
+        bg_ptrs[j] = unwrap_ptr(env, bg_val);
+    }
+
+    pfn_doeNativeComputeDispatchFlush(
+        queue, pipeline, (void**)bg_ptrs, bg_count,
+        dx, dy, dz,
+        copy_src, copy_src_off, copy_dst, copy_dst_off, copy_size);
+    return NULL;
+}
+
 /* flushAndMapSync(instance, queue, buffer, mode, offset, size) — flush + map in one N-API call. */
 static napi_value doe_flush_and_map_sync(napi_env env, napi_callback_info info) {
     NAPI_ASSERT_ARGC(env, info, 6);
@@ -1868,6 +1959,7 @@ static napi_value doe_module_init(napi_env env, napi_value exports) {
         EXPORT_FN("bufferUnmap", doe_buffer_unmap),
         EXPORT_FN("bufferMapSync", doe_buffer_map_sync),
         EXPORT_FN("bufferGetMappedRange", doe_buffer_get_mapped_range),
+        EXPORT_FN("bufferAssertMappedPrefixF32", doe_buffer_assert_mapped_prefix_f32),
         EXPORT_FN("createShaderModule", doe_create_shader_module),
         EXPORT_FN("shaderModuleRelease", doe_shader_module_release),
         EXPORT_FN("createComputePipeline", doe_create_compute_pipeline),
@@ -1895,6 +1987,7 @@ static napi_value doe_module_init(napi_env env, napi_value exports) {
         EXPORT_FN("queueWriteBuffer", doe_queue_write_buffer),
         EXPORT_FN("queueFlush", doe_queue_flush),
         EXPORT_FN("submitBatched", doe_submit_batched),
+        EXPORT_FN("submitComputeDispatchCopy", doe_submit_compute_dispatch_copy),
         EXPORT_FN("flushAndMapSync", doe_flush_and_map_sync),
         EXPORT_FN("queueRelease", doe_queue_release),
         EXPORT_FN("createTexture", doe_create_texture),

package/package.json

@@ -1,16 +1,32 @@
 {
   "name": "@simulatte/webgpu",
-  "version": "0.2.1",
-  "description": "Doe WebGPU bridge for browserless AI/ML benchmarking and CI",
+  "version": "0.2.4",
+  "description": "Headless WebGPU runtime for Node.js and Bun, powered by Doe",
   "type": "module",
   "main": "./src/node-runtime.js",
+  "types": "./src/full.d.ts",
   "exports": {
     ".": {
+      "types": "./src/full.d.ts",
       "bun": "./src/bun.js",
       "default": "./src/node-runtime.js"
     },
-    "./bun": "./src/bun.js",
-    "./node": "./src/node-runtime.js"
+    "./bun": {
+      "types": "./src/full.d.ts",
+      "default": "./src/bun.js"
+    },
+    "./node": {
+      "types": "./src/full.d.ts",
+      "default": "./src/node-runtime.js"
+    },
+    "./compute": {
+      "types": "./src/compute.d.ts",
+      "default": "./src/compute.js"
+    },
+    "./full": {
+      "types": "./src/full.d.ts",
+      "default": "./src/full.js"
+    }
   },
   "bin": {
     "fawn-webgpu-bench": "./bin/fawn-webgpu-bench.js",
@@ -25,8 +41,12 @@
     "prebuilds/",
     "binding.gyp",
     "README.md",
-    "API_CONTRACT.md",
-    "COMPAT_SCOPE.md",
+    "CHANGELOG.md",
+    "api-contract.md",
+    "compat-scope.md",
+    "support-contracts.md",
+    "layering-plan.md",
+    "zig-source-inventory.md",
     "headless-webgpu-comparison.md",
     "doe-build-metadata.schema.json",
     "prebuild-metadata.schema.json"
@@ -36,7 +56,7 @@
     "build:addon": "node-gyp rebuild",
     "build:readme-assets": "node scripts/generate-readme-assets.js",
     "prebuild": "node scripts/prebuild.js",
-    "test": "node ./test-node.js",
+    "test": "node ./test-node.js && node ./test-package-exports.js",
     "test:bun": "bun ./test-bun.js",
     "smoke": "node scripts/smoke-test.js"
   },
@@ -60,5 +80,5 @@
     "url": "https://github.com/clocksmith/fawn/issues"
   },
   "author": "Fawn",
-  "license": "ISC"
+  "license": "Apache-2.0"
 }

package/prebuilds/darwin-arm64/metadata.json

@@ -1,11 +1,11 @@
 {
   "schemaVersion": 1,
   "package": "@simulatte/webgpu",
-  "packageVersion": "0.2.0",
+  "packageVersion": "0.2.3",
   "platform": "darwin",
   "arch": "arm64",
   "nodeNapiVersion": 8,
-  "doeVersion": "22613a9b0",
+  "doeVersion": "68a193c88",
   "doeBuild": {
     "artifact": "libwebgpu_doe",
     "leanVerifiedBuild": false,
@@ -13,14 +13,14 @@
   },
   "files": {
     "doe_napi.node": {
-      "sha256": "ccd350506359a770d286f7f3893dd0c6d81582dbcc04524461c9fa81cae4573e"
+      "sha256": "472c753c5c5bd82b60444bfcc1d3837bdbd40d1fce1b8281e6c706043bb64a84"
     },
     "libwebgpu_doe.dylib": {
-      "sha256": "30be9ca300c53c0ba02eb76dfa94b683585c20f7a4caaa1f8eeea2cfb17d1f5f"
+      "sha256": "d9a66fa8fad7a8e50736778329ea5c011457c814238f96ecf230eb8eb97bcc64"
     },
     "libwebgpu_dawn.dylib": {
       "sha256": "22751faeb459e7a2ec778c0410ca122e23c23366eb3da145c651d1d43e26707d"
     }
   },
-  "builtAt": "2026-03-07T03:39:41.504Z"
+  "builtAt": "2026-03-10T17:19:18.720Z"
 }

package/prebuilds/linux-x64/metadata.json

@@ -0,0 +1,26 @@
+{
+  "schemaVersion": 1,
+  "package": "@simulatte/webgpu",
+  "packageVersion": "0.2.3",
+  "platform": "linux",
+  "arch": "x64",
+  "nodeNapiVersion": 8,
+  "doeVersion": "b09d34586",
+  "doeBuild": {
+    "artifact": "libwebgpu_doe",
+    "leanVerifiedBuild": false,
+    "proofArtifactSha256": null
+  },
+  "files": {
+    "doe_napi.node": {
+      "sha256": "21475bcd04b499e1a0ed6e75d8af2a7bead08d365ddfb09708d509d0de62bf28"
+    },
+    "libwebgpu_doe.so": {
+      "sha256": "28c5da84da65a5d6f4a3a74b9757279cddee738aaa93fe8ece6e358d4d94cdb1"
+    },
+    "libwebgpu_dawn.so": {
+      "sha256": "9d329301f59fbe85a190cee4faacde97f9c991b07264a18a6750b890899cc417"
+    }
+  },
+  "builtAt": "2026-03-10T21:30:16.241Z"
+}

package/scripts/generate-readme-assets.js

@@ -26,8 +26,8 @@ const SURFACE_SPECS = [
   {
     surface: 'bun_package',
     title: 'Bun package lane',
-    supportLabel: 'Prototype support',
-    preferredHostProfile: 'linux_x64',
+    supportLabel: 'Validated support',
+    preferredHostProfile: 'mac_apple_silicon',
     focusSets: ['compute_e2e', 'uploads'],
     tone: 'right',
   },

package/src/bun-ffi.js

@@ -157,6 +157,7 @@ function openLibrary(path) {
         wgpuDeviceCreateComputePipeline: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
         wgpuComputePipelineRelease: { args: [FFIType.ptr], returns: FFIType.void },
         wgpuComputePipelineGetBindGroupLayout: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.ptr },
+        doeNativeComputePipelineGetBindGroupLayout: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.ptr },
 
         // Bind group layout / bind group / pipeline layout
         wgpuDeviceCreateBindGroupLayout: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
@@ -804,7 +805,7 @@ class DoeGPUComputePipeline {
     constructor(native) { this._native = native; }
 
     getBindGroupLayout(index) {
-        const layout = wgpu.symbols.wgpuComputePipelineGetBindGroupLayout(this._native, index);
+        const layout = wgpu.symbols.doeNativeComputePipelineGetBindGroupLayout(this._native, index);
         return new DoeGPUBindGroupLayout(layout);
     }
 }
@@ -961,7 +962,7 @@ function ensureLibrary() {
     if (libraryLoaded) return;
     if (!DOE_LIB_PATH) {
         throw new Error(
-            "@simulatte/webgpu: libwebgpu_doe not found. Build it with `cd fawn/zig && zig build dropin` or set DOE_WEBGPU_LIB."
+            "@simulatte/webgpu: libwebgpu_doe not found. Build it with `cd zig && zig build dropin` or set DOE_WEBGPU_LIB."
         );
     }
     wgpu = openLibrary(DOE_LIB_PATH);

package/src/bun.js

@@ -1,2 +1,2 @@
-export * from "./bun-ffi.js";
-export { default } from "./bun-ffi.js";
+export * from "./full.js";
+export { default } from "./full.js";