@woosh/meep-engine 3.69.0 → 3.70.0

package/src/shade/renderer/gpu_primitive/bvh8/bvh8_encode_from_bvh2.js

@@ -0,0 +1,348 @@
+import { assert } from "../../../../core/assert.js";
+import { bitCount } from "../../../../core/binary/operations/bitCount.js";
+import { BVH8_SLOT_UNASSIGNED, bvh8_assign_slots_greedy } from "../../../../core/bvh8/build/bvh8_assign_slots_greedy.js";
+import { bvh8_node_fit_slots } from "../../../../core/bvh8/build/bvh8_node_fit_slots.js";
+import { BVH8 } from "../../../../core/bvh8/BVH8.js";
+import {
+    BVH_HEADER_WORDS,
+    BVH_NODE_BOUNDS_WORD,
+    BVH_NODE_CHILD_1_WORD,
+    BVH_NODE_CHILD_2_WORD,
+    BVH_NODE_STRIDE_WORDS
+} from "../bvh/BVH_BUFFER_LAYOUT.js";
+import {
+    BVH8_TREE_BOUNDS_HIGH_WORD,
+    BVH8_TREE_BOUNDS_LOW_WORD,
+    BVH8_TREE_HEADER_WORDS,
+    BVH8_TREE_LEAF_COUNT_WORD,
+    BVH8_TREE_NODE_STRIDE_WORDS,
+    BVH8_TREE_ORDER_OFFSET_WORD,
+    bvh8_tree_buffer_size
+} from "./BVH8_TREE_BUFFER_LAYOUT.js";
+
+const BVH_NULL_NODE = 0xFFFFFFFF;
+
+const fround = Math.fround;
+
+/**
+ * Binary levels a node of the wide tree stands for.
+ * @type {number}
+ */
+export const BVH8_ENCODE_LEVELS = 3;
+
+/**
+ * Encode a binary BVH as a BVH8, three binary levels to a node. The reference for the passes that do
+ * it on the GPU: they are held to this, word for word.
+ *
+ * **Which nodes.** An internal node of the binary tree whose depth is a multiple of three becomes a
+ * node of the wide tree; the root is at depth 0. Its children are what lies three levels below it,
+ * and the leaves met sooner: at most eight, taken child 1 before child 2 all the way down. One of
+ * them that is internal is itself at a depth that is a multiple of three, so it is a node too; one
+ * that is a leaf fills a leaf slot. A binary tree that is a single leaf is one node with that leaf
+ * in a slot.
+ *
+ * **Which slots.** A node's children are given its slots by {@link bvh8_assign_slots_greedy}: a
+ * child costs a slot the distance its box's centre lies from the node's centre, taken with the
+ * slot's signs — the bit of an axis set where the child should lie high on it. The cost is worked
+ * in single precision as `(±x + ±y) + ±z`, where an axis's term is the child's `low + high` less the
+ * node's. A child whose box is not a number costs nothing a comparison can rank: it takes the lowest
+ * slot left once the others have theirs, so that a tree's shape never depends on what its boxes hold.
+ *
+ * **Where.** Counting a node's child nodes and its leaves, in the order of the binary tree's own
+ * node indices: a node's child nodes are the block that starts at one more than the child nodes of
+ * every node before it, in slot order; its leaves' payloads are the run that starts at the leaves
+ * of every node before it, in slot order. The root is node 0. So a node finds its own place from
+ * its parent's block and the slot it has there, with no word from the parent.
+ *
+ * **Boxes.** A node's box is the binary node's, and its slots are fitted to it by
+ * {@link bvh8_node_fit_slots}.
+ *
+ * @param {Uint32Array} out the BVH8, in the layout of {@link BVH8_TREE_BUFFER_LAYOUT}; at least
+ * `bvh8_tree_buffer_size(leaf_count) / 4` words. Words past the tree written are left as they are.
+ * @param {Uint32Array} tree the binary tree as u32 words, `[root][node 0][node 1] ...`, in the layout
+ * of {@link BVH_BUFFER_LAYOUT}: `2 * leaf_count - 1` nodes, fitted
+ * @param {number} leaf_count
+ * @returns {number} nodes in the BVH8
+ */
+export function bvh8_encode_from_bvh2(out, tree, leaf_count) {
+    assert.isNonNegativeInteger(leaf_count, 'leaf_count');
+    assert.greaterThanOrEqual(out.length * Uint32Array.BYTES_PER_ELEMENT, bvh8_tree_buffer_size(leaf_count), 'out is too small for a tree of this many leaves');
+
+    const out_floats = new Float32Array(out.buffer, out.byteOffset, out.length);
+
+    if (leaf_count === 0) {
+        out.fill(0, 0, BVH8_TREE_HEADER_WORDS + BVH8_TREE_NODE_STRIDE_WORDS);
+
+        out[BVH8_TREE_ORDER_OFFSET_WORD] = BVH8_TREE_HEADER_WORDS + BVH8_TREE_NODE_STRIDE_WORDS;
+
+        return 1;
+    }
+
+    const binary_count = 2 * leaf_count - 1;
+
+    assert.greaterThanOrEqual(tree.length, BVH_HEADER_WORDS + binary_count * BVH_NODE_STRIDE_WORDS, 'tree is too short for this many leaves');
+
+    const tree_floats = new Float32Array(tree.buffer, tree.byteOffset, tree.length);
+
+    const root = tree[0];
+
+    const child_1 = node => tree[BVH_HEADER_WORDS + node * BVH_NODE_STRIDE_WORDS + BVH_NODE_CHILD_1_WORD];
+    const child_2 = node => tree[BVH_HEADER_WORDS + node * BVH_NODE_STRIDE_WORDS + BVH_NODE_CHILD_2_WORD];
+    const is_leaf = node => child_1(node) === BVH_NULL_NODE;
+    const bounds_word = node => BVH_HEADER_WORDS + node * BVH_NODE_STRIDE_WORDS + BVH_NODE_BOUNDS_WORD;
+
+    // ===========
+    // Parents, and from them each node's depth
+    // ===========
+    const parents = new Uint32Array(binary_count).fill(BVH_NULL_NODE);
+
+    for (let node = 0; node < binary_count; node++) {
+        if (!is_leaf(node)) {
+            parents[child_1(node)] = node;
+            parents[child_2(node)] = node;
+        }
+    }
+
+    const depth_of = node => {
+        let depth = 0;
+
+        for (let at = parents[node]; at !== BVH_NULL_NODE; at = parents[at]) {
+            depth++;
+        }
+
+        return depth;
+    };
+
+    // an internal node at a depth that is a multiple of three, or a root that is the tree's only leaf
+    const is_wide = node => node === root
+        || (!is_leaf(node) && depth_of(node) % BVH8_ENCODE_LEVELS === 0);
+
+    /**
+     * The children of a wide node, child 1 before child 2 all the way down.
+     *
+     * @param {number} node
+     * @param {number[]} children output
+     * @returns {number} how many
+     */
+    function gather(node, children) {
+        let count = 0;
+
+        if (is_leaf(node)) {
+            // the tree is this one leaf
+            children[count++] = node;
+
+            return count;
+        }
+
+        const visit = (at, level) => {
+            if (is_leaf(at) || level === BVH8_ENCODE_LEVELS) {
+                children[count++] = at;
+
+                return;
+            }
+
+            visit(child_1(at), level + 1);
+            visit(child_2(at), level + 1);
+        };
+
+        visit(child_1(node), 1);
+        visit(child_2(node), 1);
+
+        return count;
+    }
+
+    const cost = new Float32Array(64);
+
+    /**
+     * The slot each child of a wide node is given.
+     *
+     * @param {number} node
+     * @param {number[]} children
+     * @param {number} child_count
+     * @param {Uint32Array} slots output, a slot a child
+     */
+    function assign(node, children, child_count, slots) {
+        const n = bounds_word(node);
+
+        for (let c = 0; c < child_count; c++) {
+            const b = bounds_word(children[c]);
+
+            const x = fround(fround(tree_floats[b] + tree_floats[b + 3]) - fround(tree_floats[n] + tree_floats[n + 3]));
+            const y = fround(fround(tree_floats[b + 1] + tree_floats[b + 4]) - fround(tree_floats[n + 1] + tree_floats[n + 4]));
+            const z = fround(fround(tree_floats[b + 2] + tree_floats[b + 5]) - fround(tree_floats[n + 2] + tree_floats[n + 5]));
+
+            for (let s = 0; s < 8; s++) {
+                cost[c * 8 + s] = fround(fround(((s & 4) !== 0 ? -x : x) + ((s & 2) !== 0 ? -y : y)) + ((s & 1) !== 0 ? -z : z));
+            }
+        }
+
+        let filled = bvh8_assign_slots_greedy(slots, cost, child_count);
+
+        // whoever no cost could rank, in order, into the lowest slots left
+        for (let c = 0; c < child_count; c++) {
+            if (slots[c] !== BVH8_SLOT_UNASSIGNED) {
+                continue;
+            }
+
+            let slot = 0;
+
+            while ((filled & (1 << slot)) !== 0) {
+                slot++;
+            }
+
+            slots[c] = slot;
+            filled |= 1 << slot;
+        }
+    }
+
+    // ===========
+    // Count each wide node's child nodes and leaves, and lay the blocks and runs end to end in the
+    // order of the binary tree's node indices
+    // ===========
+    const child_base = new Uint32Array(binary_count);
+    const leaf_base = new Uint32Array(binary_count);
+
+    const children = new Array(8);
+    const slots = new Uint32Array(8);
+
+    let node_count = 1;
+    let leaves_placed = 0;
+
+    for (let node = 0; node < binary_count; node++) {
+        child_base[node] = node_count;
+        leaf_base[node] = leaves_placed;
+
+        if (!is_wide(node)) {
+            continue;
+        }
+
+        const child_count = gather(node, children);
+
+        for (let c = 0; c < child_count; c++) {
+            if (is_leaf(children[c])) {
+                leaves_placed++;
+            } else {
+                node_count++;
+            }
+        }
+    }
+
+    assert.equal(leaves_placed, leaf_count, 'every leaf is the child of one wide node');
+
+    const order_offset = BVH8_TREE_HEADER_WORDS + node_count * BVH8_TREE_NODE_STRIDE_WORDS;
+
+    // ===========
+    // Write each wide node at the place its parent's block gives it
+    // ===========
+    const bvh8 = new BVH8();
+
+    bvh8.allocate_nodes(node_count);
+
+    const parent_children = new Array(8);
+    const parent_slots = new Uint32Array(8);
+
+    const slot_boxes = new Float32Array(48);
+
+    for (let node = 0; node < binary_count; node++) {
+        if (!is_wide(node)) {
+            continue;
+        }
+
+        let index = 0;
+
+        if (node !== root) {
+            // three levels up is the wide node this one is a child of; its place there is the block's
+            // start and the child nodes in the slots below its own
+            const parent = parents[parents[parents[node]]];
+
+            const sibling_count = gather(parent, parent_children);
+
+            assign(parent, parent_children, sibling_count, parent_slots);
+
+            let slot = 0;
+            let internal = 0;
+
+            for (let c = 0; c < sibling_count; c++) {
+                if (parent_children[c] === node) {
+                    slot = parent_slots[c];
+                }
+
+                if (!is_leaf(parent_children[c])) {
+                    internal |= 1 << parent_slots[c];
+                }
+            }
+
+            index = child_base[parent] + bitCount(internal & ((1 << slot) - 1));
+        }
+
+        const child_count = gather(node, children);
+
+        assign(node, children, child_count, slots);
+
+        let occupied = 0;
+        let internal = 0;
+
+        // which child sits in a slot
+        const child_in_slot = new Array(8).fill(BVH_NULL_NODE);
+
+        for (let c = 0; c < child_count; c++) {
+            const slot = slots[c];
+
+            occupied |= 1 << slot;
+            child_in_slot[slot] = children[c];
+
+            if (!is_leaf(children[c])) {
+                internal |= 1 << slot;
+            }
+
+            const b = bounds_word(children[c]);
+
+            for (let i = 0; i < 6; i++) {
+                slot_boxes[slot * 6 + i] = tree_floats[b + i];
+            }
+        }
+
+        const n = bounds_word(node);
+
+        bvh8_node_fit_slots(bvh8, index, tree_floats.subarray(n, n + 6), slot_boxes, occupied);
+
+        bvh8.node_set_imask(index, internal);
+        bvh8.node_set_base_index_child(index, child_base[node]);
+        bvh8.node_set_base_index_triangle(index, leaf_base[node]);
+
+        let leaves_before = 0;
+
+        for (let slot = 0; slot < 8; slot++) {
+            if ((occupied & (1 << slot)) === 0) {
+                bvh8.node_set_meta(index, slot, 0);
+            } else if ((internal & (1 << slot)) !== 0) {
+                bvh8.node_set_meta(index, slot, 0b00100000 | (24 + slot));
+            } else {
+                // a run of one leaf
+                bvh8.node_set_meta(index, slot, 0b00100000 | leaves_before);
+
+                // a binary leaf's second child word is its payload
+                out[order_offset + leaf_base[node] + leaves_before] = child_2(child_in_slot[slot]);
+
+                leaves_before++;
+            }
+        }
+    }
+
+    // ===========
+    // The header, and the nodes behind it
+    // ===========
+    const r = bounds_word(root);
+
+    for (let axis = 0; axis < 3; axis++) {
+        out_floats[BVH8_TREE_BOUNDS_LOW_WORD + axis] = tree_floats[r + axis];
+        out_floats[BVH8_TREE_BOUNDS_HIGH_WORD + axis] = tree_floats[r + 3 + axis];
+    }
+
+    out[BVH8_TREE_LEAF_COUNT_WORD] = leaf_count;
+    out[BVH8_TREE_ORDER_OFFSET_WORD] = order_offset;
+
+    out.set(new Uint32Array(bvh8.data_buffer, 0, node_count * BVH8_TREE_NODE_STRIDE_WORDS), BVH8_TREE_HEADER_WORDS);
+
+    return node_count;
+}

package/src/shade/renderer/gpu_primitive/bvh8/check_bvh8_tree.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Check a BVH8 in the layout of {@link BVH8_TREE_BUFFER_LAYOUT} for what every walk of it relies on,
+ * whoever built it:
+ *
+ * - the header counts the leaves and says where their payloads start, straight behind the nodes;
+ * - from node 0 every node is reached, and reached once;
+ * - a slot is empty, a child node or one leaf, and its meta and the node's child mask agree which;
+ * - a node's child nodes are the block its base names, in slot order;
+ * - every payload expected is a leaf's, once, and no leaf carries another;
+ * - a slot's box holds every leaf under it, to within the node's grid: no leaf sticks out, and the
+ *   box is no looser than two steps of the grid a side;
+ * - the header's box is the box of every leaf.
+ *
+ * A tree of no leaves is a header that counts none and one node with every slot empty.
+ *
+ * @param {ArrayLike<number>} tree the buffer's words
+ * @param {number} leaf_count how many leaves the tree should hold
+ * @param {ArrayLike<number>} expected_payloads the payload of every leaf, in any order
+ * @param {function(number): ArrayLike<number>} [box_of] the box of the leaf carrying a payload,
+ * `[min.xyz, max.xyz]` in float32 values; without it no box is checked
+ * @returns {{problems: string[], warnings: string[], node_count: number, max_depth: number, depth_histogram: number[], low: number[], high: number[]}}
+ * what is wrong, the first three of a kind; then the tree's nodes, the levels of nodes a walk goes
+ * down, its leaves by the level of the node that holds them, and the header's box
+ */
+export function check_bvh8_tree(tree: ArrayLike<number>, leaf_count: number, expected_payloads: ArrayLike<number>, box_of?: (arg0: number) => ArrayLike<number>): {
+    problems: string[];
+    warnings: string[];
+    node_count: number;
+    max_depth: number;
+    depth_histogram: number[];
+    low: number[];
+    high: number[];
+};
+//# sourceMappingURL=check_bvh8_tree.d.ts.map

package/src/shade/renderer/gpu_primitive/bvh8/check_bvh8_tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check_bvh8_tree.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh8/check_bvh8_tree.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sCATW,UAAU,MAAM,CAAC,cACjB,MAAM,qBACN,UAAU,MAAM,CAAC,kBACR,MAAM,KAAG,UAAU,MAAM,CAAC,GAEjC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAC,CAmQrJ"}

package/src/shade/renderer/gpu_primitive/bvh8/check_bvh8_tree.js

@@ -0,0 +1,291 @@
+import { bitCount } from "../../../../core/binary/operations/bitCount.js";
+import { reinterpret_uint32_as_float32 } from "../../../../core/binary/reinterpret_uint32_as_float32.js";
+import {
+    BVH8_TREE_BOUNDS_HIGH_WORD,
+    BVH8_TREE_BOUNDS_LOW_WORD,
+    BVH8_TREE_HEADER_WORDS,
+    BVH8_TREE_LEAF_COUNT_WORD,
+    BVH8_TREE_NODE_STRIDE_WORDS,
+    BVH8_TREE_ORDER_OFFSET_WORD
+} from "./BVH8_TREE_BUFFER_LAYOUT.js";
+
+/**
+ * Check a BVH8 in the layout of {@link BVH8_TREE_BUFFER_LAYOUT} for what every walk of it relies on,
+ * whoever built it:
+ *
+ * - the header counts the leaves and says where their payloads start, straight behind the nodes;
+ * - from node 0 every node is reached, and reached once;
+ * - a slot is empty, a child node or one leaf, and its meta and the node's child mask agree which;
+ * - a node's child nodes are the block its base names, in slot order;
+ * - every payload expected is a leaf's, once, and no leaf carries another;
+ * - a slot's box holds every leaf under it, to within the node's grid: no leaf sticks out, and the
+ *   box is no looser than two steps of the grid a side;
+ * - the header's box is the box of every leaf.
+ *
+ * A tree of no leaves is a header that counts none and one node with every slot empty.
+ *
+ * @param {ArrayLike<number>} tree the buffer's words
+ * @param {number} leaf_count how many leaves the tree should hold
+ * @param {ArrayLike<number>} expected_payloads the payload of every leaf, in any order
+ * @param {function(number): ArrayLike<number>} [box_of] the box of the leaf carrying a payload,
+ * `[min.xyz, max.xyz]` in float32 values; without it no box is checked
+ * @returns {{problems: string[], warnings: string[], node_count: number, max_depth: number, depth_histogram: number[], low: number[], high: number[]}}
+ * what is wrong, the first three of a kind; then the tree's nodes, the levels of nodes a walk goes
+ * down, its leaves by the level of the node that holds them, and the header's box
+ */
+export function check_bvh8_tree(tree, leaf_count, expected_payloads, box_of) {
+    const words = tree instanceof Uint32Array ? tree : Uint32Array.from(tree);
+    const floats = new Float32Array(words.buffer, words.byteOffset, words.length);
+
+    /** @type {string[]} */
+    const problems = [];
+
+    const result = {
+        problems,
+        warnings: [],
+        node_count: 0,
+        max_depth: 0,
+        depth_histogram: [],
+        low: Array.from(floats.subarray(BVH8_TREE_BOUNDS_LOW_WORD, BVH8_TREE_BOUNDS_LOW_WORD + 3)),
+        high: Array.from(floats.subarray(BVH8_TREE_BOUNDS_HIGH_WORD, BVH8_TREE_BOUNDS_HIGH_WORD + 3)),
+    };
+
+    // how many problems of each kind have been met
+    const met = new Map();
+
+    // of a kind of problem, the first few say it; a tree wrong at the root is wrong everywhere below
+    function problem(kind, text) {
+        const count = (met.get(kind) ?? 0) + 1;
+
+        met.set(kind, count);
+
+        if (count <= 3) {
+            problems.push(text);
+        }
+    }
+
+    if (words[BVH8_TREE_LEAF_COUNT_WORD] !== leaf_count) {
+        problem('header', `the header counts ${words[BVH8_TREE_LEAF_COUNT_WORD]} leaves, expected ${leaf_count}`);
+    }
+
+    const order_offset = words[BVH8_TREE_ORDER_OFFSET_WORD];
+
+    const node_words = order_offset - BVH8_TREE_HEADER_WORDS;
+
+    if (order_offset < BVH8_TREE_HEADER_WORDS + BVH8_TREE_NODE_STRIDE_WORDS || node_words % BVH8_TREE_NODE_STRIDE_WORDS !== 0) {
+        problem('header', `the payloads start at word ${order_offset}, which is not behind a whole number of nodes`);
+
+        return result;
+    }
+
+    if (order_offset + leaf_count > words.length) {
+        problem('header', `the payloads start at word ${order_offset} and ${leaf_count} of them run past the buffer's ${words.length} words`);
+
+        return result;
+    }
+
+    const node_count = node_words / BVH8_TREE_NODE_STRIDE_WORDS;
+
+    result.node_count = node_count;
+
+    if (leaf_count === 0) {
+        if (node_count !== 1) {
+            problem('empty', `a tree of no leaves has ${node_count} nodes, expected the one empty node`);
+        }
+
+        for (let word = 0; word < BVH8_TREE_NODE_STRIDE_WORDS; word++) {
+            if (words[BVH8_TREE_HEADER_WORDS + word] !== 0) {
+                problem('empty', `the empty node's word ${word} is 0x${words[BVH8_TREE_HEADER_WORDS + word].toString(16)}, expected zero`);
+            }
+        }
+
+        return result;
+    }
+
+    const visited = new Uint8Array(node_count);
+
+    // how many leaves carry each payload
+    const carried = new Map();
+
+    /**
+     * @param {number} node
+     * @param {number} depth levels of nodes down to and including this one
+     * @returns {number[]|null} the box of every leaf under the node, if boxes are known
+     */
+    function walk(node, depth) {
+        if (visited[node] === 1) {
+            problem('reached twice', `node ${node} is reached twice`);
+
+            return null;
+        }
+
+        visited[node] = 1;
+
+        result.max_depth = Math.max(result.max_depth, depth);
+
+        const at = BVH8_TREE_HEADER_WORDS + node * BVH8_TREE_NODE_STRIDE_WORDS;
+
+        const origin = [floats[at], floats[at + 1], floats[at + 2]];
+
+        const packed = words[at + 3];
+
+        // the step of the node's grid an axis; an exponent of zero is a step of nothing
+        const steps = [packed & 0xFF, (packed >>> 8) & 0xFF, (packed >>> 16) & 0xFF]
+            .map(exponent => exponent === 0 ? 0 : reinterpret_uint32_as_float32(exponent << 23));
+
+        const child_mask = packed >>> 24;
+
+        const child_base = words[at + 4];
+        const leaf_base = words[at + 5];
+
+        /** @type {number[]|null} */
+        let under_node = null;
+
+        let child_rank = 0;
+        let held = 0;
+
+        for (let slot = 0; slot < 8; slot++) {
+            const slot_meta = (words[at + 6 + (slot >> 2)] >>> ((slot & 3) * 8)) & 0xFF;
+
+            const is_child = (child_mask & (1 << slot)) !== 0;
+
+            if (slot_meta === 0) {
+                if (is_child) {
+                    problem('meta', `node ${node} slot ${slot} is empty and in the child mask`);
+                }
+
+                continue;
+            }
+
+            held++;
+
+            /** @type {number[]|null} */
+            let under = null;
+
+            if (is_child) {
+                if (slot_meta !== (0b00100000 | (24 + slot))) {
+                    problem('meta', `node ${node} slot ${slot} is in the child mask with meta 0x${slot_meta.toString(16)}`);
+                }
+
+                const child = child_base + child_rank;
+
+                child_rank++;
+
+                if (child >= node_count) {
+                    problem('child', `node ${node} slot ${slot} names child node ${child} of ${node_count}`);
+
+                    continue;
+                }
+
+                under = walk(child, depth + 1);
+            } else {
+                if (bitCount(slot_meta >>> 5) !== 1) {
+                    problem('meta', `node ${node} slot ${slot} has meta 0x${slot_meta.toString(16)}, which is not one leaf`);
+
+                    continue;
+                }
+
+                const leaf = leaf_base + (slot_meta & 31);
+
+                if (leaf >= leaf_count) {
+                    problem('leaf', `node ${node} slot ${slot} names leaf ${leaf} of ${leaf_count}`);
+
+                    continue;
+                }
+
+                const payload = words[order_offset + leaf];
+
+                carried.set(payload, (carried.get(payload) ?? 0) + 1);
+
+                result.depth_histogram[depth] = (result.depth_histogram[depth] ?? 0) + 1;
+
+                if (box_of !== undefined) {
+                    under = Array.from(box_of(payload));
+                }
+            }
+
+            if (under === null) {
+                continue;
+            }
+
+            for (let axis = 0; axis < 3; axis++) {
+                const byte_shift = (slot & 3) * 8;
+
+                const q_low = (words[at + 8 + axis * 4 + (slot >> 2)] >>> byte_shift) & 0xFF;
+                const q_high = (words[at + 10 + axis * 4 + (slot >> 2)] >>> byte_shift) & 0xFF;
+
+                const low = origin[axis] + q_low * steps[axis];
+                const high = origin[axis] + q_high * steps[axis];
+
+                if (!(low <= under[axis] && high >= under[axis + 3])) {
+                    problem('holds', `node ${node} slot ${slot} axis ${axis}: the box [${low}, ${high}] does not hold what is under it, [${under[axis]}, ${under[axis + 3]}]`);
+                } else if (under[axis] - low > 2 * steps[axis] || high - under[axis + 3] > 2 * steps[axis]) {
+                    problem('loose', `node ${node} slot ${slot} axis ${axis}: the box [${low}, ${high}] is more than two steps of ${steps[axis]} looser than what is under it, [${under[axis]}, ${under[axis + 3]}]`);
+                }
+            }
+
+            if (under_node === null) {
+                under_node = under.slice();
+            } else {
+                for (let axis = 0; axis < 3; axis++) {
+                    under_node[axis] = Math.min(under_node[axis], under[axis]);
+                    under_node[axis + 3] = Math.max(under_node[axis + 3], under[axis + 3]);
+                }
+            }
+        }
+
+        if (held === 0) {
+            problem('nothing', `node ${node} holds nothing`);
+        }
+
+        return under_node;
+    }
+
+    const under_root = walk(0, 1);
+
+    let unreached = 0;
+
+    for (let node = 0; node < node_count; node++) {
+        if (visited[node] === 0) {
+            unreached++;
+        }
+    }
+
+    if (unreached > 0) {
+        problem('unreached', `${unreached} of ${node_count} nodes are never reached from the root`);
+    }
+
+    let leaves_expected = 0;
+
+    for (let i = 0; i < expected_payloads.length; i++) {
+        const payload = expected_payloads[i];
+
+        leaves_expected++;
+
+        const times = carried.get(payload) ?? 0;
+
+        if (times !== 1) {
+            problem('payload', `payload ${payload} is carried by ${times} leaves, expected one`);
+        }
+
+        carried.delete(payload);
+    }
+
+    for (const [payload, times] of carried) {
+        problem('stray payload', `payload ${payload}, which no leaf should carry, is carried by ${times}`);
+    }
+
+    if (leaves_expected !== leaf_count) {
+        problem('header', `${leaves_expected} payloads were expected of a tree of ${leaf_count} leaves`);
+    }
+
+    if (under_root !== null) {
+        for (let axis = 0; axis < 3; axis++) {
+            if (result.low[axis] !== under_root[axis] || result.high[axis] !== under_root[axis + 3]) {
+                problem('bounds', `the header's box on axis ${axis} is [${result.low[axis]}, ${result.high[axis]}], and the leaves span [${under_root[axis]}, ${under_root[axis + 3]}]`);
+            }
+        }
+    }
+
+    return result;
+}