@woosh/meep-engine 3.14.6 → 3.16.0

package/src/shade/device/graph/BufferResourceDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BufferResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/graph/BufferResourceDescriptor.js"],"names":[],"mappings":"AASA;IA0FI;;;;OAIG;IACH,0CAFa,wBAAwB,CAWpC;IAED;;;;;;;;OAQG;IACH,mBAJW,MAAM,SACN,iBAAe,MAAM,GACnB,wBAAwB,CASpC;IAED;;;;;;;OAOG;IACH,kBANW,MAAM,SACN,iBAAe,MAAM,iBACrB,MAAM,eACN,MAAM,GACJ,wBAAwB,CAsCpC;IAvKD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,4BAAoC;IAUpC;;;OAGG;IACH,YAFW,wBAAwB,QAOlC;IAED;;;OAGG;IACH,SAFY,wBAAwB,CAQnC;IAMD,4BAMC;IAED;;;;OAIG;IACH,eAHW,wBAAwB,GACvB,MAAM,CAoBjB;IAmFL;;;OAGG;IACH,4BAFU,OAAO,CAE4C;CAN5D;mCA7KM,4EAA4E"}
+{"version":3,"file":"BufferResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/graph/BufferResourceDescriptor.js"],"names":[],"mappings":"AAUA;IAkGI;;;;OAIG;IACH,0CAFa,wBAAwB,CAWpC;IAED;;;;;;;;OAQG;IACH,mBAJW,MAAM,SACN,iBAAe,MAAM,GACnB,wBAAwB,CASpC;IAED;;;;;;;OAOG;IACH,kBANW,MAAM,SACN,iBAAe,MAAM,iBACrB,MAAM,eACN,MAAM,GACJ,wBAAwB,CAsCpC;IA/KD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,4BAAoC;IAUpC;;;OAGG;IACH,YAFW,wBAAwB,QAOlC;IAED;;;OAGG;IACH,SAFY,wBAAwB,CAQnC;IAcD,4BAMC;IAED;;;;OAIG;IACH,eAHW,wBAAwB,GACvB,MAAM,CAoBjB;IAmFL;;;OAGG;IACH,4BAFU,OAAO,CAE4C;CAN5D;mCArLM,4EAA4E"}

package/src/shade/device/graph/BufferResourceDescriptor.js

@@ -1,185 +1,194 @@
-import { assert } from "../../../core/assert.js";
-import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
-import { number_format_by_thousands } from "../../../core/primitives/numbers/number_format_by_thousands.js";
-import {
-    ResourceDescriptor
-} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
-import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
-
-
-export class BufferResourceDescriptor extends ResourceDescriptor {
-    /**
-     * In bytes
-     * @type {number}
-     */
-    size = 0;
-
-    /**
-     * Minimize the number of usage flags per-resource.
-     * The fewer flags you use - the more efficient the access will be.
-     * The driver can happily allow you the full set of flags - but the memory access will typically be much slower compared to just a few needed flags.
-     * @see GPUBufferUsage
-     * @type {number}
-     */
-    usage = 0;
-
-    /**
-     * Range of the buffer that needs to be cleared (reset to 0)
-     * Make sure to have a `GPUBufferUsage.COPY_DST` usage flag set if you want to clear the buffer
-     */
-    ensure_cleared = new Uint32Array(2);
-
-    toString() {
-        return `Buffer{ size = ${number_format_by_thousands(this.size)}, usage = ${decode_bitmask_enum(this.usage, GPUBufferUsage).join(" | ")} }`
-    }
-
-    get type() {
-        return "buffer";
-    }
-
-    /**
-     *
-     * @param {BufferResourceDescriptor} other
-     */
-    copy(other) {
-        this.size = other.size;
-        this.usage = other.usage;
-        this.ensure_cleared[0] = other.ensure_cleared[0];
-        this.ensure_cleared[1] = other.ensure_cleared[1];
-    }
-
-    /**
-     *
-     * @return {BufferResourceDescriptor}
-     */
-    clone() {
-        const r = new BufferResourceDescriptor();
-
-        r.copy(this);
-
-        return r;
-    }
-
-    hash() {
-        return this.size ^ this.usage;
-    }
-
-    equals(other) {
-        return super.equals(other)
-            && this.size === other.size
-            && this.usage === other.usage
-            && isArrayEqualStrict(this.ensure_cleared, other.ensure_cleared)
-            ;
-    }
-
-    /**
-     *
-     * @param {BufferResourceDescriptor} other
-     * @return {number}
-     */
-    compare(other) {
-        if (other.type !== this.type) {
-            return super.compare(other);
-        }
-
-        const d_size = this.size - other.size;
-
-        if (d_size !== 0) {
-            return d_size;
-        }
-
-        const d_usage = this.usage - other.usage;
-
-        if (d_usage !== 0) {
-            return d_usage;
-        }
-
-        return 0;
-    }
-
-    /**
-     *
-     * @param {GPUBuffer} gpu_buffer
-     * @returns {BufferResourceDescriptor}
-     */
-    static fromBuffer(gpu_buffer) {
-        assert.defined(gpu_buffer, 'gpu_buffer');
-
-        const r = new BufferResourceDescriptor();
-
-        r.usage = gpu_buffer.usage;
-        r.size = gpu_buffer.size;
-
-        return r;
-    }
-
-    /**
-     * Shortcut to create a buffer that is cleared to 0 for the entire size.
-     * If you don't need the buffer to be cleared, use {@link BufferResourceDescriptor.from} instead.
-     *
-     *
-     * @param {number} size
-     * @param {GPUBufferUsage|number} usage
-     * @returns {BufferResourceDescriptor}
-     */
-    static empty(size, usage) {
-        return BufferResourceDescriptor.from(
-            size,
-            usage,
-            0,
-            size
-        );
-    }
-
-    /**
-     *
-     * @param {number} size
-     * @param {GPUBufferUsage|number} usage will automatically add `GPUBufferUsage.COPY_DST` if `clear_size > 0`
-     * @param {number} [clear_offset]
-     * @param {number} [clear_size]
-     * @returns {BufferResourceDescriptor}
-     */
-    static from(
-        size,
-        usage,
-        clear_offset = 0,
-        clear_size = 0
-    ) {
-
-        assert.isNonNegativeInteger(size, 'size');
-        assert.isNonNegativeInteger(usage, 'usage');
-        assert.notEqual(usage, 0, 'usage may not be 0');
-        assert.isNonNegativeInteger(clear_offset, 'clear_offset');
-        assert.isNonNegativeInteger(clear_size, 'clear_size');
-
-        assert.lessThanOrEqual(clear_offset + clear_size, size, 'clear region is out of bounds');
-
-        // spec requires 4 byte alignment: https://www.w3.org/TR/webgpu/#dom-gpucommandencoder-clearbuffer
-        assert.equal(clear_offset % 4, 0, 'offset must be a multiple of 4');
-        assert.equal(clear_size % 4, 0, 'size must be a multiple of 4');
-
-        const r = new BufferResourceDescriptor();
-
-        r.size = size;
-        r.usage = usage;
-
-        r.ensure_cleared[0] = clear_offset;
-        r.ensure_cleared[1] = clear_size;
-
-        if (clear_size > 0) {
-            // requesting buffer to be cleared, this requires COPY_DST to actually fulfill
-            // automatically add it in case it was missing
-            // "buffer.usage contains COPY_DST", spec https://www.w3.org/TR/webgpu/#dom-gpucommandencoder-clearbuffer
-            r.usage |= GPUBufferUsage.COPY_DST;
-        }
-
-
-        return r;
-    }
-}
-
-/**
- * Type check shortcut
- * @type {boolean}
- */
+import { assert } from "../../../core/assert.js";
+import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { number_format_by_thousands } from "../../../core/primitives/numbers/number_format_by_thousands.js";
+import {
+    ResourceDescriptor
+} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
+import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
+
+
+export class BufferResourceDescriptor extends ResourceDescriptor {
+    /**
+     * In bytes
+     * @type {number}
+     */
+    size = 0;
+
+    /**
+     * Minimize the number of usage flags per-resource.
+     * The fewer flags you use - the more efficient the access will be.
+     * The driver can happily allow you the full set of flags - but the memory access will typically be much slower compared to just a few needed flags.
+     * @see GPUBufferUsage
+     * @type {number}
+     */
+    usage = 0;
+
+    /**
+     * Range of the buffer that needs to be cleared (reset to 0)
+     * Make sure to have a `GPUBufferUsage.COPY_DST` usage flag set if you want to clear the buffer
+     */
+    ensure_cleared = new Uint32Array(2);
+
+    toString() {
+        return `Buffer{ size = ${number_format_by_thousands(this.size)}, usage = ${decode_bitmask_enum(this.usage, GPUBufferUsage).join(" | ")} }`
+    }
+
+    get type() {
+        return "buffer";
+    }
+
+    /**
+     *
+     * @param {BufferResourceDescriptor} other
+     */
+    copy(other) {
+        this.size = other.size;
+        this.usage = other.usage;
+        this.ensure_cleared[0] = other.ensure_cleared[0];
+        this.ensure_cleared[1] = other.ensure_cleared[1];
+    }
+
+    /**
+     *
+     * @return {BufferResourceDescriptor}
+     */
+    clone() {
+        const r = new BufferResourceDescriptor();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    hash() {
+        // XOR is symmetric, so it maps (size, usage) and (usage, size) onto one value, and it left
+        // `ensure_cleared` out entirely although `equals` compares it — two descriptors that are
+        // not equal sharing a bucket, which is how a texture ends up being probed with a buffer.
+        return combine_hash(
+            this.size,
+            this.usage,
+            this.ensure_cleared[0],
+            this.ensure_cleared[1]
+        );
+    }
+
+    equals(other) {
+        return super.equals(other)
+            && this.size === other.size
+            && this.usage === other.usage
+            && isArrayEqualStrict(this.ensure_cleared, other.ensure_cleared)
+            ;
+    }
+
+    /**
+     *
+     * @param {BufferResourceDescriptor} other
+     * @return {number}
+     */
+    compare(other) {
+        if (other.type !== this.type) {
+            return super.compare(other);
+        }
+
+        const d_size = this.size - other.size;
+
+        if (d_size !== 0) {
+            return d_size;
+        }
+
+        const d_usage = this.usage - other.usage;
+
+        if (d_usage !== 0) {
+            return d_usage;
+        }
+
+        return 0;
+    }
+
+    /**
+     *
+     * @param {GPUBuffer} gpu_buffer
+     * @returns {BufferResourceDescriptor}
+     */
+    static fromBuffer(gpu_buffer) {
+        assert.defined(gpu_buffer, 'gpu_buffer');
+
+        const r = new BufferResourceDescriptor();
+
+        r.usage = gpu_buffer.usage;
+        r.size = gpu_buffer.size;
+
+        return r;
+    }
+
+    /**
+     * Shortcut to create a buffer that is cleared to 0 for the entire size.
+     * If you don't need the buffer to be cleared, use {@link BufferResourceDescriptor.from} instead.
+     *
+     *
+     * @param {number} size
+     * @param {GPUBufferUsage|number} usage
+     * @returns {BufferResourceDescriptor}
+     */
+    static empty(size, usage) {
+        return BufferResourceDescriptor.from(
+            size,
+            usage,
+            0,
+            size
+        );
+    }
+
+    /**
+     *
+     * @param {number} size
+     * @param {GPUBufferUsage|number} usage will automatically add `GPUBufferUsage.COPY_DST` if `clear_size > 0`
+     * @param {number} [clear_offset]
+     * @param {number} [clear_size]
+     * @returns {BufferResourceDescriptor}
+     */
+    static from(
+        size,
+        usage,
+        clear_offset = 0,
+        clear_size = 0
+    ) {
+
+        assert.isNonNegativeInteger(size, 'size');
+        assert.isNonNegativeInteger(usage, 'usage');
+        assert.notEqual(usage, 0, 'usage may not be 0');
+        assert.isNonNegativeInteger(clear_offset, 'clear_offset');
+        assert.isNonNegativeInteger(clear_size, 'clear_size');
+
+        assert.lessThanOrEqual(clear_offset + clear_size, size, 'clear region is out of bounds');
+
+        // spec requires 4 byte alignment: https://www.w3.org/TR/webgpu/#dom-gpucommandencoder-clearbuffer
+        assert.equal(clear_offset % 4, 0, 'offset must be a multiple of 4');
+        assert.equal(clear_size % 4, 0, 'size must be a multiple of 4');
+
+        const r = new BufferResourceDescriptor();
+
+        r.size = size;
+        r.usage = usage;
+
+        r.ensure_cleared[0] = clear_offset;
+        r.ensure_cleared[1] = clear_size;
+
+        if (clear_size > 0) {
+            // requesting buffer to be cleared, this requires COPY_DST to actually fulfill
+            // automatically add it in case it was missing
+            // "buffer.usage contains COPY_DST", spec https://www.w3.org/TR/webgpu/#dom-gpucommandencoder-clearbuffer
+            r.usage |= GPUBufferUsage.COPY_DST;
+        }
+
+
+        return r;
+    }
+}
+
+/**
+ * Type check shortcut
+ * @type {boolean}
+ */
 BufferResourceDescriptor.prototype.isBufferResourceDescriptor = true;

package/src/shade/device/graph/TextureResourceDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextureResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/graph/TextureResourceDescriptor.js"],"names":[],"mappings":";;;sCAgBU,MAAM;;;;;AAOhB;IAmCI;;;;;;;;OAQG;IACH,kEAPW,MAAM,EAAE,GAKN,yBAAyB,CAkCrC;IAED;;;;OAIG;IACH,yCAFa,yBAAyB,CAoBrC;IApGD;;;;;;;;;OASG;IACH,mBAFU,uBAAuB,GAAC,MAAM,CAEyB;IAGjE,yBAAyC;IACzC,oBAAgB;IAEhB,sBAAkB;IAElB;;;OAGG;IACH,WAFU,sBAAoB,MAAM,CAEpB;IAEhB;;OAEG;IACH,QAFU,MAAM,mBAAiB,CAEX;IAEtB;;OAEG;IACH,OAFU,MAAM,uBAAqB,CAEG;IAqFxC;;;;OAIG;IACH,cAHW,yBAAyB,GACvB,OAAO,CAWnB;CAKJ;mCAxJM,4EAA4E"}
+{"version":3,"file":"TextureResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/graph/TextureResourceDescriptor.js"],"names":[],"mappings":";;;sCAgBU,MAAM;;;;;AAOhB;IAmCI;;;;;;;;OAQG;IACH,kEAPW,MAAM,EAAE,GAKN,yBAAyB,CAkCrC;IAED;;;;OAIG;IACH,yCAFa,yBAAyB,CAoBrC;IApGD;;;;;;;;;OASG;IACH,mBAFU,uBAAuB,GAAC,MAAM,CAEyB;IAGjE,yBAAyC;IACzC,oBAAgB;IAEhB,sBAAkB;IAElB;;;OAGG;IACH,WAFU,sBAAoB,MAAM,CAEpB;IAEhB;;OAEG;IACH,QAFU,MAAM,mBAAiB,CAEX;IAEtB;;OAEG;IACH,OAFU,MAAM,uBAAqB,CAEG;IAqFxC;;;;OAIG;IACH,cAHW,yBAAyB,GACvB,OAAO,CAuBnB;CAKJ;mCApKM,4EAA4E"}

package/src/shade/device/graph/TextureResourceDescriptor.js

@@ -145,6 +145,18 @@ export class TextureResourceDescriptor extends ResourceDescriptor {
      * @returns {boolean}
      */
     equals(other) {
+        if (this === other) {
+            return true;
+        }
+
+        // A texture and a buffer descriptor share one `ImmutableObjectPool` in
+        // `RenderResourceManager`, so a hash collision puts a buffer in front of this method. The
+        // type check has to come first: without it the very next line reads `other.resolution.length`
+        // on undefined and the probe throws instead of missing the cache.
+        if (!super.equals(other)) {
+            return false;
+        }
+
         return isArrayEqualStrict(this.resolution, other.resolution)
             && this.mipLevelCount === other.mipLevelCount
             && this.resolution_domain === other.resolution_domain

package/src/shade/device/mock/SoftwareGPUDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AA4PA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;;;OAUG;IACH;QAT+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAyBrC;IAzDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAmCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAwID;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;OAGG;IACH,kEAEC;IAED;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WAxpBa,mBAAiB,IAAI;;sCA3PG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}
+{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AAoQA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;;;OAUG;IACH;QAT+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAyBrC;IAzDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAmCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAwID;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;OAGG;IACH,kEAEC;IAED;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WAxpBa,mBAAiB,IAAI;;sCAnQG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}

package/src/shade/device/mock/SoftwareGPUDevice.js

@@ -195,6 +195,14 @@ const CORE_FEATURE = "core-features-and-limits";
 const SUPPORTED_OPTIONAL_FEATURES = [
     "timestamp-query",
     "subgroups",
+    /*
+     `indirect-first-instance` is the `subgroups` argument once more: all it permits is a non-zero
+     `firstInstance` inside an indirect draw's arguments, which live in a buffer this device never
+     reads and issue a draw it never runs. Refusing it would leave every pass that draws meshlets
+     indirectly — the whole transparency orchestration, which asserts the feature before it records
+     anything — untestable at this tier, again for a reason unrelated to what the tier asserts.
+    */
+    "indirect-first-instance",
     /*
      The three compression families are the same argument as `subgroups` again, with one thing this
      device *can* honour: `createTexture` of a block format is a validation error without the family's

package/src/shade/playground/avboit/README.md

@@ -0,0 +1,117 @@
+# avboit
+
+AVBOIT against MBOIT on the deck's own test case: a stack of near-opaque cards at a chosen depth
+separation, a tinted glass pane, an opaque surface pushed through the transparency pipeline, an
+opaque backdrop. `npm run dev`, then `/src/shade/playground/avboit/`.
+
+The pipeline itself is documented in
+[`AVBOIT_PLAN_2026_09_03.md`](../../renderer/rasterize/native/avboit/AVBOIT_PLAN_2026_09_03.md); this
+page is its device tier — the real compile, the look, and the timings.
+
+## What to look for
+
+- **Depth-complexity invariance.** Four cards at alpha 0.85 and spacing 1.5. Under MBOIT the cards
+  behind the front one show through more than their alpha allows and the black bar behind the stack
+  is visible through all four (deck slides 35–38). Under AVBOIT the front card hides what is behind
+  it by its alpha and no more. Seen on 2026-09-03 (ledger entry 12).
+- **The slice floor.** Drop the spacing under AVBOIT. When the cards land in one slice the stack
+  degrades to weighted blending — the deck's fail case (slides 86–92). With 4096 virtual slices the
+  floor at this camera is about 1.6 cm, and the two-slice bias means cards need more than 3.2 cm to
+  occlude each other cleanly; 0.05 should still resolve, 0.02 should not.
+- **RGB transmittance.** With **tint transmitted light by base colour** on
+  (`renderer.avboit.transmission_tint_from_base_color`, off by default), the glass pane filters the
+  backdrop by its base colour under AVBOIT — glTF's transmission semantics — and never under MBOIT
+  or the tracer, which have no per-channel transmission. Off, all three modes render the pane as
+  the same clear glass. Switch the tint to `none` for a control.
+- **An opaque surface through the transparency pipeline.** The small pale quad one unit behind the
+  last card is alpha 1 on a `Transparent` material — the deck's "0 % transmittance card" (slides
+  35–38). Both pipelines clamp its coverage at 0.997, so it should read as solid with a hard edge
+  against the backdrop and the dark bar. Under MBOIT the moment reconstruction cannot hold a step
+  that steep: the quad leaks what is behind it, and where its depth jumps against the background the
+  reconstruction tears along the edge. Under AVBOIT the quad occupies a slice of its own and the
+  edge is only as soft as the 1/8-resolution volume's trilinear filter.
+- **Slopes.** Orbit until a card or the pane is at a grazing angle. A splat fragment carries the
+  depth of its 1/8-resolution pixel centre, which on a slope can differ from the full-resolution
+  fragment's depth by more than the two-slice bias; self-occlusion along the slope would show as the
+  surface darkening or striping toward the grazing edge. Copy the camera when you find one.
+- **Brick4.** The indirect-lighting select runs the Brick4 draw variant. The scene has no probes, so
+  the indirect term is black either way; what it proves is that the variant compiles and draws.
+- **Nothing else changes.** TAA, shadows and exposure are pinned across the switch; auto exposure
+  is off by default because it keeps drifting for seconds after any change.
+
+## The reference
+
+The third mode, **path traced (reference)**, hands the frame to `renderer.path_tracer`, the
+accumulating path tracer. It rolls every transparent hit against the surface's alpha
+(`chunk_render_trace_path.js`, the opacity roll) and continues the ray, so over many samples it
+converges to the exact order-independent composite of the card stack — what both OIT modes are
+approximating. The report shows the sample count of the slowest tile; judge nothing under a few
+hundred. TAA is forced off while tracing (two temporal filters over one image), the running-mean
+floor is lowered from the tracer's default so the image keeps settling, and any camera move or
+**Reset accumulation** starts over.
+
+Two things the reference does *not* settle:
+
+- **The glass tint.** The tracer's thin-walled transmission carries the `(1 - F)` Fresnel split and
+  no per-channel colour (`chunk_render_trace_path.js`, the substrate slot), so for the pane it is a
+  reference for the Fresnel coverage only. Compare the pane with the tint switch off.
+- **Shadow rays through transparency.** The tracer's occlusion query treats geometry as opaque
+  (its own `TODO`), so cards cast full shadows in the reference where the rasterized modes cast
+  none. Look at the stack, not at its shadow on the floor.
+
+## Camera
+
+Drag to orbit, wheel to zoom, right-drag to pan, W/A/S/D to move (the `OrbitalCameraController`, on
+`document.body`, so dragging across the panel moves the camera too and the keys need the page
+focused — click it once). The camera and its controls are wired before the device is requested, so
+they work even where the renderer cannot start; a control whose handler fails says so in the report
+panel rather than only in the console. **Copy camera** puts
+`{"position":[…],"target":[…],"fov_degrees":…}` on the clipboard and in the box; **Apply camera**
+reads the box back. From the console: `camera_state()`, `apply_camera(state)`, or
+`configure({ camera: state })` alongside the other controls.
+
+## Timings
+
+**Profile** starts a `GPUProfileSession` at `WORKLOAD` level (pass spans, the frame graph, dispatch
+and draw counts); pressing it again drains the in-flight frames, stops, and downloads
+`avboit-<mode>-<timestamp>.sgpt`. Record a few seconds in one mode, switch, record again with the
+same settings, and open both in the inspector:
+
+```bash
+npm run dev --workspace @woosh/gpu-inspector-tool
+```
+
+The passes to compare are under the `transparencies` scope: `AVBOIT/occupancy`, `AVBOIT/build warp`,
+`AVBOIT/splat`, `AVBOIT / integrate`, `AVBOIT/draw`, `AVBOIT / resolve` against `MBOIT/generate
+moments`, `MBOIT/resolve moments`, `OIT Blend`. Without `timestamp-query` the capture has the
+structure and no durations; the report says so when it starts. `start_profile()` / `stop_profile()`
+from the console do the same.
+
+## One scripted session
+
+The in-app browser pane has no WebGPU adapter in this environment, so the device-tier checks are
+run by hand. One session, in order, results pasted back into the ledger:
+
+1. Open the page. The report should say `mode AVBOIT, IBL indirect, 4 cards, …` and the scene should render.
+2. Press **Compile check**. Expect `10/10 AVBOIT modules compiled`. Anything else: paste the block.
+3. Switch **indirect lighting** to Brick4. The frame should still render (black indirect is expected).
+4. Compare the stack: AVBOIT vs MBOIT at the defaults. Does the black bar show through under AVBOIT?
+5. `configure({ spacing: 0.05 })` then `configure({ spacing: 0.02 })` under AVBOIT: the first should
+   still occlude, the second should blend.
+6. `configure({ spacing: 1.5, tint_from_base_color: true, tint: 'none' })` then `tint: 'red'`: the
+   backdrop behind the pane should go red under AVBOIT only. With the switch off the pane is the
+   same clear glass in every mode.
+7. `configure({ mode: 'REFERENCE', tint: 'none' })`, wait for the report to pass ~300 samples, and
+   compare the stack against AVBOIT at the same settings: which of the two OIT modes is closer to
+   it, and where do they differ (the bar behind the stack is the sharpest test).
+8. With the opaque quad on, zoom on its edges against the backdrop and against the dark bar under
+   MBOIT, AVBOIT and the reference: is the edge a clean step, and does anything behind the quad show
+   through its interior?
+9. Orbit to a grazing view of a card or the pane; if the surface darkens or stripes toward the
+   grazing edge under AVBOIT and not under MBOIT, **Copy camera** and paste the state with the note.
+10. **Profile** a few seconds in AVBOIT, then in MBOIT at the same settings; open both captures in
+    the inspector and read the `transparencies` scope.
+
+Everything the page does is reachable from the console: `renderer`, `scene`, `camera`, `controller`,
+`configure({...})`, `camera_state()`, `apply_camera(state)`, `compile_check()` (its last result is
+on `globalThis.__last_compile`), `start_profile()`, `stop_profile()`.