@manycore/aholo-splat-transform 1.2.7 → 1.2.9

package/dist/utils/voxel/gpu-dilation.js

@@ -1,665 +1,677 @@
-import { getOrCreateDevice } from '../webgpu.js';
-import { BLOCK_EMPTY, BLOCK_MIXED, BLOCK_SOLID, SparseVoxelGrid, readBlockType } from './common.js';
-const GPU_BUFFER_USAGE_STORAGE = 128;
-const GPU_BUFFER_USAGE_COPY_DST = 8;
-const GPU_BUFFER_USAGE_COPY_SRC = 4;
-const GPU_BUFFER_USAGE_UNIFORM = 64;
-const GPU_BUFFER_USAGE_MAP_READ = 1;
-const GPU_MAP_MODE_READ = 1;
-const CHUNK_INNER = 512;
-const SOLID_WORD = 0x55555555 >>> 0;
-const extractWgsl = () => /* wgsl */ `
-struct ExtractUniforms {
-    minBx: i32,
-    minBy: i32,
-    minBz: i32,
-    outerBx: u32,
-    outerBy: u32,
-    outerBz: u32,
-    numXWords: u32,
-    srcNbx: u32,
-    srcNby: u32,
-    srcNbz: u32,
-    srcBStride: u32,
-    srcCapMinusOne: u32
-}
-
-@group(0) @binding(0) var<uniform> u: ExtractUniforms;
-@group(0) @binding(1) var<storage, read> srcTypes: array<u32>;
-@group(0) @binding(2) var<storage, read> srcKeys: array<u32>;
-@group(0) @binding(3) var<storage, read> srcLo: array<u32>;
-@group(0) @binding(4) var<storage, read> srcHi: array<u32>;
-@group(0) @binding(5) var<storage, read_write> dstDense: array<atomic<u32>>;
-
-@compute @workgroup_size(8, 4, 8)
-fn main(@builtin(global_invocation_id) gid: vec3u) {
-    if (gid.x >= u.outerBx || gid.y >= u.outerBy || gid.z >= u.outerBz) { return; }
-
-    let chunkBx = i32(gid.x);
-    let chunkBy = i32(gid.y);
-    let chunkBz = i32(gid.z);
-    let globalBx = u.minBx + chunkBx;
-    let globalBy = u.minBy + chunkBy;
-    let globalBz = u.minBz + chunkBz;
-    if (globalBx < 0 || globalBy < 0 || globalBz < 0) { return; }
-    if (globalBx >= i32(u.srcNbx) || globalBy >= i32(u.srcNby) || globalBz >= i32(u.srcNbz)) { return; }
-
-    let blockIdx = u32(globalBx) + u32(globalBy) * u.srcNbx + u32(globalBz) * u.srcBStride;
-    let typeWord = srcTypes[blockIdx >> 4u];
-    let bt = (typeWord >> ((blockIdx & 15u) * 2u)) & 3u;
-    if (bt == 0u) { return; }
-
-    var lo: u32;
-    var hi: u32;
-    if (bt == 1u) {
-        lo = 0xFFFFFFFFu;
-        hi = 0xFFFFFFFFu;
-    } else {
-        var i = (blockIdx * 0x9E3779B9u) & u.srcCapMinusOne;
-        loop {
-            let k = srcKeys[i];
-            if (k == blockIdx) {
-                lo = srcLo[i];
-                hi = srcHi[i];
-                break;
-            }
-            if (k == 0xFFFFFFFFu) { return; }
-            i = (i + 1u) & u.srcCapMinusOne;
-        }
-    }
-
-    let dx0 = u32(chunkBx) * 4u;
-    let wordOffsetX = dx0 / 32u;
-    let bitShiftX = dx0 & 31u;
-    let outerNy = u.outerBy * 4u;
-    let planeWords = u.numXWords * outerNy;
-
-    for (var lz = 0u; lz < 4u; lz = lz + 1u) {
-        let dz = u32(chunkBz) * 4u + lz;
-        let zBitBase = (lz & 1u) * 16u;
-        let word = select(lo, hi, lz >= 2u);
-        for (var ly = 0u; ly < 4u; ly = ly + 1u) {
-            let dy = u32(chunkBy) * 4u + ly;
-            let bitBase = zBitBase + ly * 4u;
-            let pattern = (word >> bitBase) & 0xFu;
-            if (pattern == 0u) { continue; }
-            let wordIdx = wordOffsetX + dy * u.numXWords + dz * planeWords;
-            atomicOr(&dstDense[wordIdx], pattern << bitShiftX);
-        }
-    }
-}
-`;
-const compactWgsl = () => /* wgsl */ `
-struct CompactUniforms {
-    haloBx: u32,
-    haloBy: u32,
-    haloBz: u32,
-    numXWords: u32,
-    innerBx: u32,
-    innerBy: u32,
-    innerBz: u32,
-    outerBy: u32
-}
-
-@group(0) @binding(0) var<uniform> u: CompactUniforms;
-@group(0) @binding(1) var<storage, read> dilatedDense: array<u32>;
-@group(0) @binding(2) var<storage, read_write> typesOut: array<atomic<u32>>;
-@group(0) @binding(3) var<storage, read_write> masksOut: array<u32>;
-
-@compute @workgroup_size(8, 4, 8)
-fn main(@builtin(global_invocation_id) gid: vec3u) {
-    if (gid.x >= u.innerBx || gid.y >= u.innerBy || gid.z >= u.innerBz) { return; }
-
-    let innerBlockIdx = gid.x + gid.y * u.innerBx + gid.z * u.innerBx * u.innerBy;
-    let outerBx = gid.x + u.haloBx;
-    let outerBy = gid.y + u.haloBy;
-    let outerBz = gid.z + u.haloBz;
-    let dx0 = outerBx * 4u;
-    let wordOffsetX = dx0 / 32u;
-    let bitShiftX = dx0 & 31u;
-    let outerNy = u.outerBy * 4u;
-    let planeWords = u.numXWords * outerNy;
-
-    var lo = 0u;
-    var hi = 0u;
-    for (var lz = 0u; lz < 4u; lz = lz + 1u) {
-        let dz = outerBz * 4u + lz;
-        let zBitBase = (lz & 1u) * 16u;
-        let inHi = lz >= 2u;
-        let planeBase = dz * planeWords;
-        for (var ly = 0u; ly < 4u; ly = ly + 1u) {
-            let dy = outerBy * 4u + ly;
-            let bitBase = zBitBase + ly * 4u;
-            let wordIdx = wordOffsetX + dy * u.numXWords + planeBase;
-            let pattern = (dilatedDense[wordIdx] >> bitShiftX) & 0xFu;
-            let bits = pattern << bitBase;
-            if (inHi) { hi = hi | bits; } else { lo = lo | bits; }
-        }
-    }
-
-    masksOut[innerBlockIdx * 2u] = lo;
-    masksOut[innerBlockIdx * 2u + 1u] = hi;
-
-    var bt = 0u;
-    if (lo != 0u || hi != 0u) {
-        if (lo == 0xFFFFFFFFu && hi == 0xFFFFFFFFu) { bt = 1u; } else { bt = 2u; }
-    }
-    let typeWordIdx = innerBlockIdx >> 4u;
-    let typeBitShift = (innerBlockIdx & 15u) * 2u;
-    atomicOr(&typesOut[typeWordIdx], bt << typeBitShift);
-}
-`;
-const dilateXWgsl = () => /* wgsl */ `
-struct DilateXUniforms {
-    numXWords: u32,
-    ny: u32,
-    nz: u32,
-    halfExtent: u32
-}
-
-@group(0) @binding(0) var<uniform> u: DilateXUniforms;
-@group(0) @binding(1) var<storage, read> src: array<u32>;
-@group(0) @binding(2) var<storage, read_write> dst: array<u32>;
-
-fn readWord(rowOffset: u32, word: i32) -> u32 {
-    if (word < 0 || word >= i32(u.numXWords)) { return 0u; }
-    return src[rowOffset + u32(word)];
-}
-
-@compute @workgroup_size(8, 4, 8)
-fn main(@builtin(global_invocation_id) gid: vec3u) {
-    if (gid.x >= u.numXWords || gid.y >= u.ny || gid.z >= u.nz) { return; }
-
-    let xWord = gid.x;
-    let y = gid.y;
-    let z = gid.z;
-    let rowStride = u.numXWords;
-    let planeStride = rowStride * u.ny;
-    let rowOffset = y * rowStride + z * planeStride;
-    var output = src[rowOffset + xWord];
-    let rowBits = u.numXWords * 32u;
-    let r = min(u.halfExtent, rowBits);
-    for (var d = 1u; d <= r; d = d + 1u) {
-        let wordOffset = i32(d >> 5u);
-        let bitShift = d & 31u;
-        let baseWord = i32(xWord);
-        var shiftedPos = readWord(rowOffset, baseWord + wordOffset);
-        if (bitShift != 0u) {
-            shiftedPos = (shiftedPos >> bitShift) | (readWord(rowOffset, baseWord + wordOffset + 1) << (32u - bitShift));
-        }
-        var shiftedNeg = readWord(rowOffset, baseWord - wordOffset);
-        if (bitShift != 0u) {
-            shiftedNeg = (shiftedNeg << bitShift) | (readWord(rowOffset, baseWord - wordOffset - 1) >> (32u - bitShift));
-        }
-        output = output | shiftedPos | shiftedNeg;
-        if (output == 0xFFFFFFFFu) { break; }
-    }
-    dst[rowOffset + xWord] = output;
-}
-`;
-const dilateYZWgsl = () => /* wgsl */ `
-struct DilateYZUniforms {
-    numXWords: u32,
-    ny: u32,
-    nz: u32,
-    halfExtent: u32,
-    stride: u32,
-    axisLen: u32
-}
-
-@group(0) @binding(0) var<uniform> u: DilateYZUniforms;
-@group(0) @binding(1) var<storage, read> src: array<u32>;
-@group(0) @binding(2) var<storage, read_write> dst: array<u32>;
-
-@compute @workgroup_size(8, 4, 8)
-fn main(@builtin(global_invocation_id) gid: vec3u) {
-    if (gid.x >= u.numXWords || gid.y >= u.ny || gid.z >= u.nz) { return; }
-
-    let xWord = gid.x;
-    let y = gid.y;
-    let z = gid.z;
-    let rowStride = u.numXWords;
-    let planeStride = rowStride * u.ny;
-    let outIdx = i32(xWord) + i32(y) * i32(rowStride) + i32(z) * i32(planeStride);
-    let pos = select(z, y, u.stride == rowStride);
-    let r = i32(u.halfExtent);
-    let lo = max(0, i32(pos) - r);
-    let hi = min(i32(u.axisLen) - 1, i32(pos) + r);
-    let baseIdx = outIdx - i32(pos) * i32(u.stride);
-    var output = 0u;
-    for (var p = lo; p <= hi; p = p + 1) {
-        output = output | src[baseIdx + p * i32(u.stride)];
-        if (output == 0xFFFFFFFFu) { break; }
-    }
-    dst[outIdx] = output;
-}
-`;
-const makeBuffer = (device, size, usage) => (device.createBuffer({ size: Math.max(4, size), usage }));
-const writeUniform = (device, values) => {
-    const buffer = makeBuffer(device, 256, GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST);
-    device.queue.writeBuffer(buffer, 0, values.buffer, values.byteOffset, values.byteLength);
-    return buffer;
-};
-const createStoragePipeline = (device, code) => (device.createComputePipeline({
-    layout: 'auto',
-    compute: { module: device.createShaderModule({ code }), entryPoint: 'main' }
-}));
-const blockAlignedExtent = (halfExtent) => (halfExtent === 0 ? 0 : Math.ceil(halfExtent / 4) * 4);
-const chunkIsEmpty = (src, ox, oy, oz, cx, cy, cz) => {
-    const minBx = Math.max(0, Math.floor(ox / 4));
-    const minBy = Math.max(0, Math.floor(oy / 4));
-    const minBz = Math.max(0, Math.floor(oz / 4));
-    const maxBx = Math.min(src.nbx, Math.ceil((ox + cx) / 4));
-    const maxBy = Math.min(src.nby, Math.ceil((oy + cy) / 4));
-    const maxBz = Math.min(src.nbz, Math.ceil((oz + cz) / 4));
-    if (maxBx <= minBx || maxBy <= minBy || maxBz <= minBz) {
-        return true;
-    }
-    for (let bz = minBz; bz < maxBz; bz++) {
-        for (let by = minBy; by < maxBy; by++) {
-            for (let bx = minBx; bx < maxBx; bx++) {
-                const blockIdx = bx + by * src.nbx + bz * src.bStride;
-                if (readBlockType(src.types, blockIdx) !== BLOCK_EMPTY) {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
-};
-const chunkIsSaturated = (src, ox, oy, oz, cx, cy, cz) => {
-    if (ox < 0 || oy < 0 || oz < 0) {
-        return false;
-    }
-    if (ox + cx > src.nx || oy + cy > src.ny || oz + cz > src.nz) {
-        return false;
-    }
-    const minBx = ox >> 2;
-    const minBy = oy >> 2;
-    const minBz = oz >> 2;
-    const maxBx = (ox + cx + 3) >> 2;
-    const maxBy = (oy + cy + 3) >> 2;
-    const maxBz = (oz + cz + 3) >> 2;
-    for (let bz = minBz; bz < maxBz; bz++) {
-        for (let by = minBy; by < maxBy; by++) {
-            for (let bx = minBx; bx < maxBx; bx++) {
-                const blockIdx = bx + by * src.nbx + bz * src.bStride;
-                if (readBlockType(src.types, blockIdx) !== BLOCK_SOLID) {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
-};
-const insertSaturatedInner = (dst, innerOx, innerOy, innerOz, innerCx, innerCy, innerCz) => {
-    const minBx = Math.max(0, innerOx >> 2);
-    const minBy = Math.max(0, innerOy >> 2);
-    const minBz = Math.max(0, innerOz >> 2);
-    const maxBx = Math.min(dst.nbx, (innerOx + innerCx + 3) >> 2);
-    const maxBy = Math.min(dst.nby, (innerOy + innerCy + 3) >> 2);
-    const maxBz = Math.min(dst.nbz, (innerOz + innerCz + 3) >> 2);
-    for (let bz = minBz; bz < maxBz; bz++) {
-        for (let by = minBy; by < maxBy; by++) {
-            const rowBase = by * dst.nbx + bz * dst.bStride;
-            let blockIdx = rowBase + minBx;
-            const endIdx = rowBase + maxBx;
-            while (blockIdx < endIdx) {
-                const w = blockIdx >>> 4;
-                const shift = (blockIdx & 15) << 1;
-                const remainingInWord = 16 - (blockIdx & 15);
-                const remainingInRow = endIdx - blockIdx;
-                const blocksToWrite = Math.min(remainingInWord, remainingInRow);
-                if (blocksToWrite === 16) {
-                    dst.types[w] = SOLID_WORD;
-                }
-                else {
-                    const bits = blocksToWrite << 1;
-                    const mask = (((1 << bits) - 1) >>> 0) << shift;
-                    dst.types[w] = ((dst.types[w] & ~mask) | (SOLID_WORD & mask)) >>> 0;
-                }
-                blockIdx += blocksToWrite;
-            }
-        }
-    }
-};
-const applyChunkToDst = (dst, typesOut, masksOut, cx, cy, cz, innerNx, innerNy, innerNz) => {
-    const innerBx = innerNx >> 2;
-    const innerBy = innerNy >> 2;
-    const innerBz = innerNz >> 2;
-    const baseBx = cx >> 2;
-    const baseBy = cy >> 2;
-    const baseBz = cz >> 2;
-    let innerIdx = 0;
-    for (let bz = 0; bz < innerBz; bz++) {
-        const globalBz = baseBz + bz;
-        for (let by = 0; by < innerBy; by++) {
-            const globalBy = baseBy + by;
-            const baseGlobalIdx = baseBx + globalBy * dst.nbx + globalBz * dst.bStride;
-            for (let bx = 0; bx < innerBx; bx++, innerIdx++) {
-                const wordIdx = innerIdx >>> 4;
-                const bitShift = (innerIdx & 15) << 1;
-                const bt = (typesOut[wordIdx] >>> bitShift) & 3;
-                if (bt === BLOCK_EMPTY) {
-                    continue;
-                }
-                const globalBlockIdx = baseGlobalIdx + bx;
-                const w = globalBlockIdx >>> 4;
-                const shift = (globalBlockIdx & 15) << 1;
-                dst.types[w] |= bt << shift;
-                if (bt === BLOCK_MIXED) {
-                    const m2 = innerIdx * 2;
-                    dst.masks.set(globalBlockIdx, masksOut[m2], masksOut[m2 + 1]);
-                }
-            }
-        }
-    }
-};
-class GpuDilation {
-    device;
-    extractPipeline;
-    compactPipeline;
-    dilateXPipeline;
-    dilateYZPipeline;
-    slots = [];
-    srcTypesBuffer;
-    srcKeysBuffer;
-    srcLoBuffer;
-    srcHiBuffer;
-    srcMeta = { nbx: 0, nby: 0, nbz: 0, bStride: 0, capMinusOne: 0 };
-    static NUM_SLOTS = 2;
-    constructor(device) {
-        this.device = device;
-        this.extractPipeline = createStoragePipeline(device, extractWgsl());
-        this.compactPipeline = createStoragePipeline(device, compactWgsl());
-        this.dilateXPipeline = createStoragePipeline(device, dilateXWgsl());
-        this.dilateYZPipeline = createStoragePipeline(device, dilateYZWgsl());
-        for (let i = 0; i < GpuDilation.NUM_SLOTS; i++) {
-            const capacity = 1024 * 1024 * 4;
-            const typesOutCapacity = 64 * 1024;
-            const masksOutCapacity = 1024 * 1024;
-            this.slots.push({
-                bufferA: makeBuffer(device, capacity, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC),
-                bufferB: makeBuffer(device, capacity, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC),
-                readTypesBuffer: makeBuffer(device, typesOutCapacity, GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ),
-                readMasksBuffer: makeBuffer(device, masksOutCapacity, GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ),
-                typesOutBuffer: makeBuffer(device, typesOutCapacity, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC),
-                masksOutBuffer: makeBuffer(device, masksOutCapacity, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC),
-                capacity,
-                typesOutCapacity,
-                masksOutCapacity
-            });
-        }
-    }
-    replaceBuffer(slot, key, size, usage) {
-        slot[key].destroy();
-        slot[key] = makeBuffer(this.device, size, usage);
-    }
-    ensureSlotBuffers(slot, numWords) {
-        const neededBytes = numWords * 4;
-        if (neededBytes <= slot.capacity) {
-            return;
-        }
-        let cap = slot.capacity;
-        while (cap < neededBytes) {
-            cap *= 2;
-        }
-        this.replaceBuffer(slot, 'bufferA', cap, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC);
-        this.replaceBuffer(slot, 'bufferB', cap, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC);
-        slot.capacity = cap;
-    }
-    ensureSlotOutputBuffers(slot, innerBlocks) {
-        const typesBytes = ((innerBlocks + 15) >>> 4) * 4;
-        if (slot.typesOutCapacity < typesBytes) {
-            this.replaceBuffer(slot, 'typesOutBuffer', typesBytes, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC);
-            this.replaceBuffer(slot, 'readTypesBuffer', typesBytes, GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ);
-            slot.typesOutCapacity = typesBytes;
-        }
-        const masksBytes = innerBlocks * 8;
-        if (slot.masksOutCapacity < masksBytes) {
-            this.replaceBuffer(slot, 'masksOutBuffer', masksBytes, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC);
-            this.replaceBuffer(slot, 'readMasksBuffer', masksBytes, GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ);
-            slot.masksOutCapacity = masksBytes;
-        }
-    }
-    uploadSrc(src) {
-        this.releaseSrc();
-        this.srcTypesBuffer = makeBuffer(this.device, src.types.byteLength, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST);
-        this.device.queue.writeBuffer(this.srcTypesBuffer, 0, src.types.buffer, src.types.byteOffset, src.types.byteLength);
-        const keysU32 = new Uint32Array(src.masks.keys.buffer, src.masks.keys.byteOffset, src.masks.keys.length);
-        this.srcKeysBuffer = makeBuffer(this.device, keysU32.byteLength, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST);
-        this.srcLoBuffer = makeBuffer(this.device, src.masks.lo.byteLength, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST);
-        this.srcHiBuffer = makeBuffer(this.device, src.masks.hi.byteLength, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST);
-        this.device.queue.writeBuffer(this.srcKeysBuffer, 0, keysU32.buffer, keysU32.byteOffset, keysU32.byteLength);
-        this.device.queue.writeBuffer(this.srcLoBuffer, 0, src.masks.lo.buffer, src.masks.lo.byteOffset, src.masks.lo.byteLength);
-        this.device.queue.writeBuffer(this.srcHiBuffer, 0, src.masks.hi.buffer, src.masks.hi.byteOffset, src.masks.hi.byteLength);
-        this.srcMeta = {
-            nbx: src.nbx,
-            nby: src.nby,
-            nbz: src.nbz,
-            bStride: src.bStride,
-            capMinusOne: src.masks.keys.length - 1
-        };
-    }
-    releaseSrc() {
-        this.srcTypesBuffer?.destroy();
-        this.srcKeysBuffer?.destroy();
-        this.srcLoBuffer?.destroy();
-        this.srcHiBuffer?.destroy();
-        this.srcTypesBuffer = undefined;
-        this.srcKeysBuffer = undefined;
-        this.srcLoBuffer = undefined;
-        this.srcHiBuffer = undefined;
-    }
-    submitChunkSparse(slotIdx, minBx, minBy, minBz, outerBx, outerBy, outerBz, haloBx, haloBy, haloBz, innerBx, innerBy, innerBz, halfExtentXZ, halfExtentY) {
-        if (!this.srcTypesBuffer || !this.srcKeysBuffer || !this.srcLoBuffer || !this.srcHiBuffer) {
-            throw new Error('GpuDilation: must call uploadSrc() before submitChunkSparse()');
-        }
-        const slot = this.slots[slotIdx];
-        const outerNx = outerBx * 4;
-        const outerNy = outerBy * 4;
-        const outerNz = outerBz * 4;
-        const numXWords = (outerNx + 31) >>> 5;
-        const numWords = numXWords * outerNy * outerNz;
-        const innerBlocks = innerBx * innerBy * innerBz;
-        const typesOutWords = (innerBlocks + 15) >>> 4;
-        this.ensureSlotBuffers(slot, numWords);
-        this.ensureSlotOutputBuffers(slot, innerBlocks);
-        const uniformBuffers = [];
-        const makeUniform = (values) => {
-            const buffer = writeUniform(this.device, values);
-            uniformBuffers.push(buffer);
-            return buffer;
-        };
-        {
-            const encoder = this.device.createCommandEncoder();
-            encoder.clearBuffer(slot.bufferA, 0, numWords * 4);
-            const uniforms = new Uint32Array([
-                minBx >>> 0, minBy >>> 0, minBz >>> 0,
-                outerBx, outerBy, outerBz, numXWords,
-                this.srcMeta.nbx, this.srcMeta.nby, this.srcMeta.nbz,
-                this.srcMeta.bStride, this.srcMeta.capMinusOne
-            ]);
-            const uniformBuffer = makeUniform(uniforms);
-            const bindGroup = this.device.createBindGroup({
-                layout: this.extractPipeline.getBindGroupLayout(0),
-                entries: [
-                    { binding: 0, resource: { buffer: uniformBuffer } },
-                    { binding: 1, resource: { buffer: this.srcTypesBuffer } },
-                    { binding: 2, resource: { buffer: this.srcKeysBuffer } },
-                    { binding: 3, resource: { buffer: this.srcLoBuffer } },
-                    { binding: 4, resource: { buffer: this.srcHiBuffer } },
-                    { binding: 5, resource: { buffer: slot.bufferA } }
-                ]
-            });
-            const pass = encoder.beginComputePass();
-            pass.setPipeline(this.extractPipeline);
-            pass.setBindGroup(0, bindGroup);
-            pass.dispatchWorkgroups(Math.ceil(outerBx / 8), Math.ceil(outerBy / 4), Math.ceil(outerBz / 8));
-            pass.end();
-            this.device.queue.submit([encoder.finish()]);
-        }
-        {
-            const encoder = this.device.createCommandEncoder();
-            const dispatch = (pipeline, src, dst, uniforms, wgX, wgY, wgZ) => {
-                const uniformBuffer = makeUniform(uniforms);
-                const bindGroup = this.device.createBindGroup({
-                    layout: pipeline.getBindGroupLayout(0),
-                    entries: [
-                        { binding: 0, resource: { buffer: uniformBuffer } },
-                        { binding: 1, resource: { buffer: src } },
-                        { binding: 2, resource: { buffer: dst } }
-                    ]
-                });
-                const pass = encoder.beginComputePass();
-                pass.setPipeline(pipeline);
-                pass.setBindGroup(0, bindGroup);
-                pass.dispatchWorkgroups(wgX, wgY, wgZ);
-                pass.end();
-            };
-            dispatch(this.dilateXPipeline, slot.bufferA, slot.bufferB, new Uint32Array([numXWords, outerNy, outerNz, halfExtentXZ]), Math.ceil(numXWords / 8), Math.ceil(outerNy / 4), Math.ceil(outerNz / 8));
-            dispatch(this.dilateYZPipeline, slot.bufferB, slot.bufferA, new Uint32Array([numXWords, outerNy, outerNz, halfExtentXZ, numXWords * outerNy, outerNz]), Math.ceil(numXWords / 8), Math.ceil(outerNy / 4), Math.ceil(outerNz / 8));
-            dispatch(this.dilateYZPipeline, slot.bufferA, slot.bufferB, new Uint32Array([numXWords, outerNy, outerNz, halfExtentY, numXWords, outerNy]), Math.ceil(numXWords / 8), Math.ceil(outerNy / 4), Math.ceil(outerNz / 8));
-            encoder.clearBuffer(slot.typesOutBuffer, 0, typesOutWords * 4);
-            const compactUniformBuffer = makeUniform(new Uint32Array([
-                haloBx, haloBy, haloBz, numXWords, innerBx, innerBy, innerBz, outerBy
-            ]));
-            const compactBindGroup = this.device.createBindGroup({
-                layout: this.compactPipeline.getBindGroupLayout(0),
-                entries: [
-                    { binding: 0, resource: { buffer: compactUniformBuffer } },
-                    { binding: 1, resource: { buffer: slot.bufferB } },
-                    { binding: 2, resource: { buffer: slot.typesOutBuffer } },
-                    { binding: 3, resource: { buffer: slot.masksOutBuffer } }
-                ]
-            });
-            const pass = encoder.beginComputePass();
-            pass.setPipeline(this.compactPipeline);
-            pass.setBindGroup(0, compactBindGroup);
-            pass.dispatchWorkgroups(Math.ceil(innerBx / 8), Math.ceil(innerBy / 4), Math.ceil(innerBz / 8));
-            pass.end();
-            encoder.copyBufferToBuffer(slot.typesOutBuffer, 0, slot.readTypesBuffer, 0, typesOutWords * 4);
-            encoder.copyBufferToBuffer(slot.masksOutBuffer, 0, slot.readMasksBuffer, 0, innerBlocks * 8);
-            this.device.queue.submit([encoder.finish()]);
-        }
-        const typesPromise = (async () => {
-            await slot.readTypesBuffer.mapAsync(GPU_MAP_MODE_READ, 0, typesOutWords * 4);
-            const mapped = new Uint32Array(slot.readTypesBuffer.getMappedRange(0, typesOutWords * 4));
-            const out = new Uint32Array(typesOutWords);
-            out.set(mapped);
-            slot.readTypesBuffer.unmap();
-            return out;
-        })();
-        const masksPromise = (async () => {
-            await slot.readMasksBuffer.mapAsync(GPU_MAP_MODE_READ, 0, innerBlocks * 8);
-            const mapped = new Uint32Array(slot.readMasksBuffer.getMappedRange(0, innerBlocks * 8));
-            const out = new Uint32Array(innerBlocks * 2);
-            out.set(mapped);
-            slot.readMasksBuffer.unmap();
-            return out;
-        })();
-        void Promise.all([typesPromise, masksPromise]).then(() => {
-            for (const buffer of uniformBuffers) {
-                buffer.destroy();
-            }
-        });
-        return { types: typesPromise, masks: masksPromise };
-    }
-    destroy() {
-        this.releaseSrc();
-        for (const slot of this.slots) {
-            slot.bufferA.destroy();
-            slot.bufferB.destroy();
-            slot.readTypesBuffer.destroy();
-            slot.readMasksBuffer.destroy();
-            slot.typesOutBuffer.destroy();
-            slot.masksOutBuffer.destroy();
-        }
-    }
-}
-export const gpuDilate3 = async (src, halfExtentXZ, halfExtentY) => {
-    if (halfExtentXZ === 0 && halfExtentY === 0) {
-        return src.clone();
-    }
-    if (!Number.isInteger(halfExtentXZ) || halfExtentXZ < 0) {
-        throw new Error(`gpuDilate3: halfExtentXZ=${halfExtentXZ} must be a non-negative integer`);
-    }
-    if (!Number.isInteger(halfExtentY) || halfExtentY < 0) {
-        throw new Error(`gpuDilate3: halfExtentY=${halfExtentY} must be a non-negative integer`);
-    }
-    const device = await getOrCreateDevice();
-    const gpu = new GpuDilation(device);
-    const dst = new SparseVoxelGrid(src.nx, src.ny, src.nz);
-    const haloX = blockAlignedExtent(halfExtentXZ);
-    const haloY = blockAlignedExtent(halfExtentY);
-    const haloZ = haloX;
-    const haloBx = haloX / 4;
-    const haloBy = haloY / 4;
-    const haloBz = haloZ / 4;
-    const innerStep = CHUNK_INNER & ~3;
-    let currentSlot = 0;
-    let inflight;
-    const drainInflight = async () => {
-        if (!inflight) {
-            return;
-        }
-        const f = inflight;
-        inflight = undefined;
-        const [typesOut, masksOut] = await Promise.all([f.typesPromise, f.masksPromise]);
-        applyChunkToDst(dst, typesOut, masksOut, f.cx, f.cy, f.cz, f.innerNx, f.innerNy, f.innerNz);
-    };
-    gpu.uploadSrc(src);
-    try {
-        for (let cz = 0; cz < src.nz; cz += innerStep) {
-            for (let cy = 0; cy < src.ny; cy += innerStep) {
-                for (let cx = 0; cx < src.nx; cx += innerStep) {
-                    const innerNx = Math.min(innerStep, src.nx - cx);
-                    const innerNy = Math.min(innerStep, src.ny - cy);
-                    const innerNz = Math.min(innerStep, src.nz - cz);
-                    const ox = cx - haloX;
-                    const oy = cy - haloY;
-                    const oz = cz - haloZ;
-                    const outerNx = innerNx + 2 * haloX;
-                    const outerNy = innerNy + 2 * haloY;
-                    const outerNz = innerNz + 2 * haloZ;
-                    if (chunkIsEmpty(src, ox, oy, oz, outerNx, outerNy, outerNz)) {
-                        continue;
-                    }
-                    if (chunkIsSaturated(src, ox, oy, oz, outerNx, outerNy, outerNz)) {
-                        insertSaturatedInner(dst, cx, cy, cz, innerNx, innerNy, innerNz);
-                        continue;
-                    }
-                    const innerBx = innerNx >> 2;
-                    const innerBy = innerNy >> 2;
-                    const innerBz = innerNz >> 2;
-                    const outerBx = outerNx >> 2;
-                    const outerBy = outerNy >> 2;
-                    const outerBz = outerNz >> 2;
-                    const minBx = Math.floor(ox / 4);
-                    const minBy = Math.floor(oy / 4);
-                    const minBz = Math.floor(oz / 4);
-                    const { types, masks } = gpu.submitChunkSparse(currentSlot, minBx, minBy, minBz, outerBx, outerBy, outerBz, haloBx, haloBy, haloBz, innerBx, innerBy, innerBz, halfExtentXZ, halfExtentY);
-                    if (inflight) {
-                        await drainInflight();
-                    }
-                    inflight = {
-                        typesPromise: types,
-                        masksPromise: masks,
-                        cx,
-                        cy,
-                        cz,
-                        innerNx,
-                        innerNy,
-                        innerNz
-                    };
-                    currentSlot = (currentSlot + 1) % GpuDilation.NUM_SLOTS;
-                }
-            }
-        }
-        await drainInflight();
-    }
-    finally {
-        gpu.destroy();
-    }
-    return dst;
-};
+import { getOrCreateDevice } from '../webgpu.js';
+import { BLOCK_EMPTY, BLOCK_MIXED, BLOCK_SOLID, SparseVoxelGrid, readBlockType } from './common.js';
+const GPU_BUFFER_USAGE_STORAGE = 128;
+const GPU_BUFFER_USAGE_COPY_DST = 8;
+const GPU_BUFFER_USAGE_COPY_SRC = 4;
+const GPU_BUFFER_USAGE_UNIFORM = 64;
+const GPU_BUFFER_USAGE_MAP_READ = 1;
+const GPU_MAP_MODE_READ = 1;
+const CHUNK_INNER = 512;
+const SOLID_WORD = 0x55555555 >>> 0;
+function extractWgsl() {
+    return /* wgsl */ `
+struct ExtractUniforms {
+    minBx: i32,
+    minBy: i32,
+    minBz: i32,
+    outerBx: u32,
+    outerBy: u32,
+    outerBz: u32,
+    numXWords: u32,
+    srcNbx: u32,
+    srcNby: u32,
+    srcNbz: u32,
+    srcBStride: u32,
+    srcCapMinusOne: u32
+}
+
+@group(0) @binding(0) var<uniform> u: ExtractUniforms;
+@group(0) @binding(1) var<storage, read> srcTypes: array<u32>;
+@group(0) @binding(2) var<storage, read> srcKeys: array<u32>;
+@group(0) @binding(3) var<storage, read> srcLo: array<u32>;
+@group(0) @binding(4) var<storage, read> srcHi: array<u32>;
+@group(0) @binding(5) var<storage, read_write> dstDense: array<atomic<u32>>;
+
+@compute @workgroup_size(8, 4, 8)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+    if (gid.x >= u.outerBx || gid.y >= u.outerBy || gid.z >= u.outerBz) { return; }
+
+    let chunkBx = i32(gid.x);
+    let chunkBy = i32(gid.y);
+    let chunkBz = i32(gid.z);
+    let globalBx = u.minBx + chunkBx;
+    let globalBy = u.minBy + chunkBy;
+    let globalBz = u.minBz + chunkBz;
+    if (globalBx < 0 || globalBy < 0 || globalBz < 0) { return; }
+    if (globalBx >= i32(u.srcNbx) || globalBy >= i32(u.srcNby) || globalBz >= i32(u.srcNbz)) { return; }
+
+    let blockIdx = u32(globalBx) + u32(globalBy) * u.srcNbx + u32(globalBz) * u.srcBStride;
+    let typeWord = srcTypes[blockIdx >> 4u];
+    let bt = (typeWord >> ((blockIdx & 15u) * 2u)) & 3u;
+    if (bt == 0u) { return; }
+
+    var lo: u32;
+    var hi: u32;
+    if (bt == 1u) {
+        lo = 0xFFFFFFFFu;
+        hi = 0xFFFFFFFFu;
+    } else {
+        var i = (blockIdx * 0x9E3779B9u) & u.srcCapMinusOne;
+        loop {
+            let k = srcKeys[i];
+            if (k == blockIdx) {
+                lo = srcLo[i];
+                hi = srcHi[i];
+                break;
+            }
+            if (k == 0xFFFFFFFFu) { return; }
+            i = (i + 1u) & u.srcCapMinusOne;
+        }
+    }
+
+    let dx0 = u32(chunkBx) * 4u;
+    let wordOffsetX = dx0 / 32u;
+    let bitShiftX = dx0 & 31u;
+    let outerNy = u.outerBy * 4u;
+    let planeWords = u.numXWords * outerNy;
+
+    for (var lz = 0u; lz < 4u; lz = lz + 1u) {
+        let dz = u32(chunkBz) * 4u + lz;
+        let zBitBase = (lz & 1u) * 16u;
+        let word = select(lo, hi, lz >= 2u);
+        for (var ly = 0u; ly < 4u; ly = ly + 1u) {
+            let dy = u32(chunkBy) * 4u + ly;
+            let bitBase = zBitBase + ly * 4u;
+            let pattern = (word >> bitBase) & 0xFu;
+            if (pattern == 0u) { continue; }
+            let wordIdx = wordOffsetX + dy * u.numXWords + dz * planeWords;
+            atomicOr(&dstDense[wordIdx], pattern << bitShiftX);
+        }
+    }
+}
+`;
+}
+function compactWgsl() {
+    return /* wgsl */ `
+struct CompactUniforms {
+    haloBx: u32,
+    haloBy: u32,
+    haloBz: u32,
+    numXWords: u32,
+    innerBx: u32,
+    innerBy: u32,
+    innerBz: u32,
+    outerBy: u32
+}
+
+@group(0) @binding(0) var<uniform> u: CompactUniforms;
+@group(0) @binding(1) var<storage, read> dilatedDense: array<u32>;
+@group(0) @binding(2) var<storage, read_write> typesOut: array<atomic<u32>>;
+@group(0) @binding(3) var<storage, read_write> masksOut: array<u32>;
+
+@compute @workgroup_size(8, 4, 8)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+    if (gid.x >= u.innerBx || gid.y >= u.innerBy || gid.z >= u.innerBz) { return; }
+
+    let innerBlockIdx = gid.x + gid.y * u.innerBx + gid.z * u.innerBx * u.innerBy;
+    let outerBx = gid.x + u.haloBx;
+    let outerBy = gid.y + u.haloBy;
+    let outerBz = gid.z + u.haloBz;
+    let dx0 = outerBx * 4u;
+    let wordOffsetX = dx0 / 32u;
+    let bitShiftX = dx0 & 31u;
+    let outerNy = u.outerBy * 4u;
+    let planeWords = u.numXWords * outerNy;
+
+    var lo = 0u;
+    var hi = 0u;
+    for (var lz = 0u; lz < 4u; lz = lz + 1u) {
+        let dz = outerBz * 4u + lz;
+        let zBitBase = (lz & 1u) * 16u;
+        let inHi = lz >= 2u;
+        let planeBase = dz * planeWords;
+        for (var ly = 0u; ly < 4u; ly = ly + 1u) {
+            let dy = outerBy * 4u + ly;
+            let bitBase = zBitBase + ly * 4u;
+            let wordIdx = wordOffsetX + dy * u.numXWords + planeBase;
+            let pattern = (dilatedDense[wordIdx] >> bitShiftX) & 0xFu;
+            let bits = pattern << bitBase;
+            if (inHi) { hi = hi | bits; } else { lo = lo | bits; }
+        }
+    }
+
+    masksOut[innerBlockIdx * 2u] = lo;
+    masksOut[innerBlockIdx * 2u + 1u] = hi;
+
+    var bt = 0u;
+    if (lo != 0u || hi != 0u) {
+        if (lo == 0xFFFFFFFFu && hi == 0xFFFFFFFFu) { bt = 1u; } else { bt = 2u; }
+    }
+    let typeWordIdx = innerBlockIdx >> 4u;
+    let typeBitShift = (innerBlockIdx & 15u) * 2u;
+    atomicOr(&typesOut[typeWordIdx], bt << typeBitShift);
+}
+`;
+}
+function dilateXWgsl() {
+    return /* wgsl */ `
+struct DilateXUniforms {
+    numXWords: u32,
+    ny: u32,
+    nz: u32,
+    halfExtent: u32
+}
+
+@group(0) @binding(0) var<uniform> u: DilateXUniforms;
+@group(0) @binding(1) var<storage, read> src: array<u32>;
+@group(0) @binding(2) var<storage, read_write> dst: array<u32>;
+
+fn readWord(rowOffset: u32, word: i32) -> u32 {
+    if (word < 0 || word >= i32(u.numXWords)) { return 0u; }
+    return src[rowOffset + u32(word)];
+}
+
+@compute @workgroup_size(8, 4, 8)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+    if (gid.x >= u.numXWords || gid.y >= u.ny || gid.z >= u.nz) { return; }
+
+    let xWord = gid.x;
+    let y = gid.y;
+    let z = gid.z;
+    let rowStride = u.numXWords;
+    let planeStride = rowStride * u.ny;
+    let rowOffset = y * rowStride + z * planeStride;
+    var output = src[rowOffset + xWord];
+    let rowBits = u.numXWords * 32u;
+    let r = min(u.halfExtent, rowBits);
+    for (var d = 1u; d <= r; d = d + 1u) {
+        let wordOffset = i32(d >> 5u);
+        let bitShift = d & 31u;
+        let baseWord = i32(xWord);
+        var shiftedPos = readWord(rowOffset, baseWord + wordOffset);
+        if (bitShift != 0u) {
+            shiftedPos = (shiftedPos >> bitShift) | (readWord(rowOffset, baseWord + wordOffset + 1) << (32u - bitShift));
+        }
+        var shiftedNeg = readWord(rowOffset, baseWord - wordOffset);
+        if (bitShift != 0u) {
+            shiftedNeg = (shiftedNeg << bitShift) | (readWord(rowOffset, baseWord - wordOffset - 1) >> (32u - bitShift));
+        }
+        output = output | shiftedPos | shiftedNeg;
+        if (output == 0xFFFFFFFFu) { break; }
+    }
+    dst[rowOffset + xWord] = output;
+}
+`;
+}
+function dilateYZWgsl() {
+    return /* wgsl */ `
+struct DilateYZUniforms {
+    numXWords: u32,
+    ny: u32,
+    nz: u32,
+    halfExtent: u32,
+    stride: u32,
+    axisLen: u32
+}
+
+@group(0) @binding(0) var<uniform> u: DilateYZUniforms;
+@group(0) @binding(1) var<storage, read> src: array<u32>;
+@group(0) @binding(2) var<storage, read_write> dst: array<u32>;
+
+@compute @workgroup_size(8, 4, 8)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+    if (gid.x >= u.numXWords || gid.y >= u.ny || gid.z >= u.nz) { return; }
+
+    let xWord = gid.x;
+    let y = gid.y;
+    let z = gid.z;
+    let rowStride = u.numXWords;
+    let planeStride = rowStride * u.ny;
+    let outIdx = i32(xWord) + i32(y) * i32(rowStride) + i32(z) * i32(planeStride);
+    let pos = select(z, y, u.stride == rowStride);
+    let r = i32(u.halfExtent);
+    let lo = max(0, i32(pos) - r);
+    let hi = min(i32(u.axisLen) - 1, i32(pos) + r);
+    let baseIdx = outIdx - i32(pos) * i32(u.stride);
+    var output = 0u;
+    for (var p = lo; p <= hi; p = p + 1) {
+        output = output | src[baseIdx + p * i32(u.stride)];
+        if (output == 0xFFFFFFFFu) { break; }
+    }
+    dst[outIdx] = output;
+}
+`;
+}
+function makeBuffer(device, size, usage) {
+    return device.createBuffer({ size: Math.max(4, size), usage });
+}
+function writeUniform(device, values) {
+    const buffer = makeBuffer(device, 256, GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST);
+    device.queue.writeBuffer(buffer, 0, values.buffer, values.byteOffset, values.byteLength);
+    return buffer;
+}
+function createStoragePipeline(device, code) {
+    return device.createComputePipeline({
+        layout: 'auto',
+        compute: { module: device.createShaderModule({ code }), entryPoint: 'main' },
+    });
+}
+function blockAlignedExtent(halfExtent) {
+    return halfExtent === 0 ? 0 : Math.ceil(halfExtent / 4) * 4;
+}
+function chunkIsEmpty(src, ox, oy, oz, cx, cy, cz) {
+    const minBx = Math.max(0, Math.floor(ox / 4));
+    const minBy = Math.max(0, Math.floor(oy / 4));
+    const minBz = Math.max(0, Math.floor(oz / 4));
+    const maxBx = Math.min(src.nbx, Math.ceil((ox + cx) / 4));
+    const maxBy = Math.min(src.nby, Math.ceil((oy + cy) / 4));
+    const maxBz = Math.min(src.nbz, Math.ceil((oz + cz) / 4));
+    if (maxBx <= minBx || maxBy <= minBy || maxBz <= minBz) {
+        return true;
+    }
+    for (let bz = minBz; bz < maxBz; bz++) {
+        for (let by = minBy; by < maxBy; by++) {
+            for (let bx = minBx; bx < maxBx; bx++) {
+                const blockIdx = bx + by * src.nbx + bz * src.bStride;
+                if (readBlockType(src.types, blockIdx) !== BLOCK_EMPTY) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+function chunkIsSaturated(src, ox, oy, oz, cx, cy, cz) {
+    if (ox < 0 || oy < 0 || oz < 0) {
+        return false;
+    }
+    if (ox + cx > src.nx || oy + cy > src.ny || oz + cz > src.nz) {
+        return false;
+    }
+    const minBx = ox >> 2;
+    const minBy = oy >> 2;
+    const minBz = oz >> 2;
+    const maxBx = (ox + cx + 3) >> 2;
+    const maxBy = (oy + cy + 3) >> 2;
+    const maxBz = (oz + cz + 3) >> 2;
+    for (let bz = minBz; bz < maxBz; bz++) {
+        for (let by = minBy; by < maxBy; by++) {
+            for (let bx = minBx; bx < maxBx; bx++) {
+                const blockIdx = bx + by * src.nbx + bz * src.bStride;
+                if (readBlockType(src.types, blockIdx) !== BLOCK_SOLID) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+function insertSaturatedInner(dst, innerOx, innerOy, innerOz, innerCx, innerCy, innerCz) {
+    const minBx = Math.max(0, innerOx >> 2);
+    const minBy = Math.max(0, innerOy >> 2);
+    const minBz = Math.max(0, innerOz >> 2);
+    const maxBx = Math.min(dst.nbx, (innerOx + innerCx + 3) >> 2);
+    const maxBy = Math.min(dst.nby, (innerOy + innerCy + 3) >> 2);
+    const maxBz = Math.min(dst.nbz, (innerOz + innerCz + 3) >> 2);
+    for (let bz = minBz; bz < maxBz; bz++) {
+        for (let by = minBy; by < maxBy; by++) {
+            const rowBase = by * dst.nbx + bz * dst.bStride;
+            let blockIdx = rowBase + minBx;
+            const endIdx = rowBase + maxBx;
+            while (blockIdx < endIdx) {
+                const w = blockIdx >>> 4;
+                const shift = (blockIdx & 15) << 1;
+                const remainingInWord = 16 - (blockIdx & 15);
+                const remainingInRow = endIdx - blockIdx;
+                const blocksToWrite = Math.min(remainingInWord, remainingInRow);
+                if (blocksToWrite === 16) {
+                    dst.types[w] = SOLID_WORD;
+                }
+                else {
+                    const bits = blocksToWrite << 1;
+                    const mask = (((1 << bits) - 1) >>> 0) << shift;
+                    dst.types[w] = ((dst.types[w] & ~mask) | (SOLID_WORD & mask)) >>> 0;
+                }
+                blockIdx += blocksToWrite;
+            }
+        }
+    }
+}
+function applyChunkToDst(dst, typesOut, masksOut, cx, cy, cz, innerNx, innerNy, innerNz) {
+    const innerBx = innerNx >> 2;
+    const innerBy = innerNy >> 2;
+    const innerBz = innerNz >> 2;
+    const baseBx = cx >> 2;
+    const baseBy = cy >> 2;
+    const baseBz = cz >> 2;
+    let innerIdx = 0;
+    for (let bz = 0; bz < innerBz; bz++) {
+        const globalBz = baseBz + bz;
+        for (let by = 0; by < innerBy; by++) {
+            const globalBy = baseBy + by;
+            const baseGlobalIdx = baseBx + globalBy * dst.nbx + globalBz * dst.bStride;
+            for (let bx = 0; bx < innerBx; bx++, innerIdx++) {
+                const wordIdx = innerIdx >>> 4;
+                const bitShift = (innerIdx & 15) << 1;
+                const bt = (typesOut[wordIdx] >>> bitShift) & 3;
+                if (bt === BLOCK_EMPTY) {
+                    continue;
+                }
+                const globalBlockIdx = baseGlobalIdx + bx;
+                const w = globalBlockIdx >>> 4;
+                const shift = (globalBlockIdx & 15) << 1;
+                dst.types[w] |= bt << shift;
+                if (bt === BLOCK_MIXED) {
+                    const m2 = innerIdx * 2;
+                    dst.masks.set(globalBlockIdx, masksOut[m2], masksOut[m2 + 1]);
+                }
+            }
+        }
+    }
+}
+class GpuDilation {
+    static { this.NUM_SLOTS = 2; }
+    constructor(device) {
+        this.slots = [];
+        this.srcMeta = { nbx: 0, nby: 0, nbz: 0, bStride: 0, capMinusOne: 0 };
+        this.device = device;
+        this.extractPipeline = createStoragePipeline(device, extractWgsl());
+        this.compactPipeline = createStoragePipeline(device, compactWgsl());
+        this.dilateXPipeline = createStoragePipeline(device, dilateXWgsl());
+        this.dilateYZPipeline = createStoragePipeline(device, dilateYZWgsl());
+        for (let i = 0; i < GpuDilation.NUM_SLOTS; i++) {
+            const capacity = 1024 * 1024 * 4;
+            const typesOutCapacity = 64 * 1024;
+            const masksOutCapacity = 1024 * 1024;
+            this.slots.push({
+                bufferA: makeBuffer(device, capacity, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC),
+                bufferB: makeBuffer(device, capacity, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC),
+                readTypesBuffer: makeBuffer(device, typesOutCapacity, GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ),
+                readMasksBuffer: makeBuffer(device, masksOutCapacity, GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ),
+                typesOutBuffer: makeBuffer(device, typesOutCapacity, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC),
+                masksOutBuffer: makeBuffer(device, masksOutCapacity, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC),
+                capacity,
+                typesOutCapacity,
+                masksOutCapacity,
+            });
+        }
+    }
+    replaceBuffer(slot, key, size, usage) {
+        slot[key].destroy();
+        slot[key] = makeBuffer(this.device, size, usage);
+    }
+    ensureSlotBuffers(slot, numWords) {
+        const neededBytes = numWords * 4;
+        if (neededBytes <= slot.capacity) {
+            return;
+        }
+        let cap = slot.capacity;
+        while (cap < neededBytes) {
+            cap *= 2;
+        }
+        this.replaceBuffer(slot, 'bufferA', cap, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC);
+        this.replaceBuffer(slot, 'bufferB', cap, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC);
+        slot.capacity = cap;
+    }
+    ensureSlotOutputBuffers(slot, innerBlocks) {
+        const typesBytes = ((innerBlocks + 15) >>> 4) * 4;
+        if (slot.typesOutCapacity < typesBytes) {
+            this.replaceBuffer(slot, 'typesOutBuffer', typesBytes, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC);
+            this.replaceBuffer(slot, 'readTypesBuffer', typesBytes, GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ);
+            slot.typesOutCapacity = typesBytes;
+        }
+        const masksBytes = innerBlocks * 8;
+        if (slot.masksOutCapacity < masksBytes) {
+            this.replaceBuffer(slot, 'masksOutBuffer', masksBytes, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_COPY_SRC);
+            this.replaceBuffer(slot, 'readMasksBuffer', masksBytes, GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ);
+            slot.masksOutCapacity = masksBytes;
+        }
+    }
+    uploadSrc(src) {
+        this.releaseSrc();
+        this.srcTypesBuffer = makeBuffer(this.device, src.types.byteLength, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST);
+        this.device.queue.writeBuffer(this.srcTypesBuffer, 0, src.types.buffer, src.types.byteOffset, src.types.byteLength);
+        const keysU32 = new Uint32Array(src.masks.keys.buffer, src.masks.keys.byteOffset, src.masks.keys.length);
+        this.srcKeysBuffer = makeBuffer(this.device, keysU32.byteLength, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST);
+        this.srcLoBuffer = makeBuffer(this.device, src.masks.lo.byteLength, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST);
+        this.srcHiBuffer = makeBuffer(this.device, src.masks.hi.byteLength, GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST);
+        this.device.queue.writeBuffer(this.srcKeysBuffer, 0, keysU32.buffer, keysU32.byteOffset, keysU32.byteLength);
+        this.device.queue.writeBuffer(this.srcLoBuffer, 0, src.masks.lo.buffer, src.masks.lo.byteOffset, src.masks.lo.byteLength);
+        this.device.queue.writeBuffer(this.srcHiBuffer, 0, src.masks.hi.buffer, src.masks.hi.byteOffset, src.masks.hi.byteLength);
+        this.srcMeta = {
+            nbx: src.nbx,
+            nby: src.nby,
+            nbz: src.nbz,
+            bStride: src.bStride,
+            capMinusOne: src.masks.keys.length - 1,
+        };
+    }
+    releaseSrc() {
+        this.srcTypesBuffer?.destroy();
+        this.srcKeysBuffer?.destroy();
+        this.srcLoBuffer?.destroy();
+        this.srcHiBuffer?.destroy();
+        this.srcTypesBuffer = undefined;
+        this.srcKeysBuffer = undefined;
+        this.srcLoBuffer = undefined;
+        this.srcHiBuffer = undefined;
+    }
+    submitChunkSparse(slotIdx, minBx, minBy, minBz, outerBx, outerBy, outerBz, haloBx, haloBy, haloBz, innerBx, innerBy, innerBz, halfExtentXZ, halfExtentY) {
+        if (!this.srcTypesBuffer || !this.srcKeysBuffer || !this.srcLoBuffer || !this.srcHiBuffer) {
+            throw new Error('GpuDilation: must call uploadSrc() before submitChunkSparse()');
+        }
+        const slot = this.slots[slotIdx];
+        const outerNx = outerBx * 4;
+        const outerNy = outerBy * 4;
+        const outerNz = outerBz * 4;
+        const numXWords = (outerNx + 31) >>> 5;
+        const numWords = numXWords * outerNy * outerNz;
+        const innerBlocks = innerBx * innerBy * innerBz;
+        const typesOutWords = (innerBlocks + 15) >>> 4;
+        this.ensureSlotBuffers(slot, numWords);
+        this.ensureSlotOutputBuffers(slot, innerBlocks);
+        const uniformBuffers = [];
+        const device = this.device;
+        function makeUniform(values) {
+            const buffer = writeUniform(device, values);
+            uniformBuffers.push(buffer);
+            return buffer;
+        }
+        {
+            const encoder = this.device.createCommandEncoder();
+            encoder.clearBuffer(slot.bufferA, 0, numWords * 4);
+            const uniforms = new Uint32Array([
+                minBx >>> 0,
+                minBy >>> 0,
+                minBz >>> 0,
+                outerBx,
+                outerBy,
+                outerBz,
+                numXWords,
+                this.srcMeta.nbx,
+                this.srcMeta.nby,
+                this.srcMeta.nbz,
+                this.srcMeta.bStride,
+                this.srcMeta.capMinusOne,
+            ]);
+            const uniformBuffer = makeUniform(uniforms);
+            const bindGroup = this.device.createBindGroup({
+                layout: this.extractPipeline.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: { buffer: uniformBuffer } },
+                    { binding: 1, resource: { buffer: this.srcTypesBuffer } },
+                    { binding: 2, resource: { buffer: this.srcKeysBuffer } },
+                    { binding: 3, resource: { buffer: this.srcLoBuffer } },
+                    { binding: 4, resource: { buffer: this.srcHiBuffer } },
+                    { binding: 5, resource: { buffer: slot.bufferA } },
+                ],
+            });
+            const pass = encoder.beginComputePass();
+            pass.setPipeline(this.extractPipeline);
+            pass.setBindGroup(0, bindGroup);
+            pass.dispatchWorkgroups(Math.ceil(outerBx / 8), Math.ceil(outerBy / 4), Math.ceil(outerBz / 8));
+            pass.end();
+            this.device.queue.submit([encoder.finish()]);
+        }
+        {
+            const encoder = this.device.createCommandEncoder();
+            function dispatch(pipeline, src, dst, uniforms, wgX, wgY, wgZ) {
+                const uniformBuffer = makeUniform(uniforms);
+                const bindGroup = device.createBindGroup({
+                    layout: pipeline.getBindGroupLayout(0),
+                    entries: [
+                        { binding: 0, resource: { buffer: uniformBuffer } },
+                        { binding: 1, resource: { buffer: src } },
+                        { binding: 2, resource: { buffer: dst } },
+                    ],
+                });
+                const pass = encoder.beginComputePass();
+                pass.setPipeline(pipeline);
+                pass.setBindGroup(0, bindGroup);
+                pass.dispatchWorkgroups(wgX, wgY, wgZ);
+                pass.end();
+            }
+            dispatch(this.dilateXPipeline, slot.bufferA, slot.bufferB, new Uint32Array([numXWords, outerNy, outerNz, halfExtentXZ]), Math.ceil(numXWords / 8), Math.ceil(outerNy / 4), Math.ceil(outerNz / 8));
+            dispatch(this.dilateYZPipeline, slot.bufferB, slot.bufferA, new Uint32Array([numXWords, outerNy, outerNz, halfExtentXZ, numXWords * outerNy, outerNz]), Math.ceil(numXWords / 8), Math.ceil(outerNy / 4), Math.ceil(outerNz / 8));
+            dispatch(this.dilateYZPipeline, slot.bufferA, slot.bufferB, new Uint32Array([numXWords, outerNy, outerNz, halfExtentY, numXWords, outerNy]), Math.ceil(numXWords / 8), Math.ceil(outerNy / 4), Math.ceil(outerNz / 8));
+            encoder.clearBuffer(slot.typesOutBuffer, 0, typesOutWords * 4);
+            const compactUniformBuffer = makeUniform(new Uint32Array([haloBx, haloBy, haloBz, numXWords, innerBx, innerBy, innerBz, outerBy]));
+            const compactBindGroup = this.device.createBindGroup({
+                layout: this.compactPipeline.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: { buffer: compactUniformBuffer } },
+                    { binding: 1, resource: { buffer: slot.bufferB } },
+                    { binding: 2, resource: { buffer: slot.typesOutBuffer } },
+                    { binding: 3, resource: { buffer: slot.masksOutBuffer } },
+                ],
+            });
+            const pass = encoder.beginComputePass();
+            pass.setPipeline(this.compactPipeline);
+            pass.setBindGroup(0, compactBindGroup);
+            pass.dispatchWorkgroups(Math.ceil(innerBx / 8), Math.ceil(innerBy / 4), Math.ceil(innerBz / 8));
+            pass.end();
+            encoder.copyBufferToBuffer(slot.typesOutBuffer, 0, slot.readTypesBuffer, 0, typesOutWords * 4);
+            encoder.copyBufferToBuffer(slot.masksOutBuffer, 0, slot.readMasksBuffer, 0, innerBlocks * 8);
+            this.device.queue.submit([encoder.finish()]);
+        }
+        const typesPromise = (async () => {
+            await slot.readTypesBuffer.mapAsync(GPU_MAP_MODE_READ, 0, typesOutWords * 4);
+            const mapped = new Uint32Array(slot.readTypesBuffer.getMappedRange(0, typesOutWords * 4));
+            const out = new Uint32Array(typesOutWords);
+            out.set(mapped);
+            slot.readTypesBuffer.unmap();
+            return out;
+        })();
+        const masksPromise = (async () => {
+            await slot.readMasksBuffer.mapAsync(GPU_MAP_MODE_READ, 0, innerBlocks * 8);
+            const mapped = new Uint32Array(slot.readMasksBuffer.getMappedRange(0, innerBlocks * 8));
+            const out = new Uint32Array(innerBlocks * 2);
+            out.set(mapped);
+            slot.readMasksBuffer.unmap();
+            return out;
+        })();
+        void Promise.all([typesPromise, masksPromise]).then(() => {
+            for (const buffer of uniformBuffers) {
+                buffer.destroy();
+            }
+        });
+        return { types: typesPromise, masks: masksPromise };
+    }
+    destroy() {
+        this.releaseSrc();
+        for (const slot of this.slots) {
+            slot.bufferA.destroy();
+            slot.bufferB.destroy();
+            slot.readTypesBuffer.destroy();
+            slot.readMasksBuffer.destroy();
+            slot.typesOutBuffer.destroy();
+            slot.masksOutBuffer.destroy();
+        }
+    }
+}
+export async function gpuDilate3(src, halfExtentXZ, halfExtentY) {
+    if (halfExtentXZ === 0 && halfExtentY === 0) {
+        return src.clone();
+    }
+    if (!Number.isInteger(halfExtentXZ) || halfExtentXZ < 0) {
+        throw new Error(`gpuDilate3: halfExtentXZ=${halfExtentXZ} must be a non-negative integer`);
+    }
+    if (!Number.isInteger(halfExtentY) || halfExtentY < 0) {
+        throw new Error(`gpuDilate3: halfExtentY=${halfExtentY} must be a non-negative integer`);
+    }
+    const device = await getOrCreateDevice();
+    const gpu = new GpuDilation(device);
+    const dst = new SparseVoxelGrid(src.nx, src.ny, src.nz);
+    const haloX = blockAlignedExtent(halfExtentXZ);
+    const haloY = blockAlignedExtent(halfExtentY);
+    const haloZ = haloX;
+    const haloBx = haloX / 4;
+    const haloBy = haloY / 4;
+    const haloBz = haloZ / 4;
+    const innerStep = CHUNK_INNER & ~3;
+    let currentSlot = 0;
+    let inflight;
+    async function drainInflight() {
+        if (!inflight) {
+            return;
+        }
+        const f = inflight;
+        inflight = undefined;
+        const [typesOut, masksOut] = await Promise.all([f.typesPromise, f.masksPromise]);
+        applyChunkToDst(dst, typesOut, masksOut, f.cx, f.cy, f.cz, f.innerNx, f.innerNy, f.innerNz);
+    }
+    gpu.uploadSrc(src);
+    try {
+        for (let cz = 0; cz < src.nz; cz += innerStep) {
+            for (let cy = 0; cy < src.ny; cy += innerStep) {
+                for (let cx = 0; cx < src.nx; cx += innerStep) {
+                    const innerNx = Math.min(innerStep, src.nx - cx);
+                    const innerNy = Math.min(innerStep, src.ny - cy);
+                    const innerNz = Math.min(innerStep, src.nz - cz);
+                    const ox = cx - haloX;
+                    const oy = cy - haloY;
+                    const oz = cz - haloZ;
+                    const outerNx = innerNx + 2 * haloX;
+                    const outerNy = innerNy + 2 * haloY;
+                    const outerNz = innerNz + 2 * haloZ;
+                    if (chunkIsEmpty(src, ox, oy, oz, outerNx, outerNy, outerNz)) {
+                        continue;
+                    }
+                    if (chunkIsSaturated(src, ox, oy, oz, outerNx, outerNy, outerNz)) {
+                        insertSaturatedInner(dst, cx, cy, cz, innerNx, innerNy, innerNz);
+                        continue;
+                    }
+                    const innerBx = innerNx >> 2;
+                    const innerBy = innerNy >> 2;
+                    const innerBz = innerNz >> 2;
+                    const outerBx = outerNx >> 2;
+                    const outerBy = outerNy >> 2;
+                    const outerBz = outerNz >> 2;
+                    const minBx = Math.floor(ox / 4);
+                    const minBy = Math.floor(oy / 4);
+                    const minBz = Math.floor(oz / 4);
+                    const { types, masks } = gpu.submitChunkSparse(currentSlot, minBx, minBy, minBz, outerBx, outerBy, outerBz, haloBx, haloBy, haloBz, innerBx, innerBy, innerBz, halfExtentXZ, halfExtentY);
+                    if (inflight) {
+                        await drainInflight();
+                    }
+                    inflight = {
+                        typesPromise: types,
+                        masksPromise: masks,
+                        cx,
+                        cy,
+                        cz,
+                        innerNx,
+                        innerNy,
+                        innerNz,
+                    };
+                    currentSlot = (currentSlot + 1) % GpuDilation.NUM_SLOTS;
+                }
+            }
+        }
+        await drainInflight();
+    }
+    finally {
+        gpu.destroy();
+    }
+    return dst;
+}