@luma.gl/webgpu 9.1.9 → 9.2.0-alpha.2

package/dist/dist.dev.js

@@ -4,6 +4,7 @@
   else if (typeof define === 'function' && define.amd) define([], factory);
         else if (typeof exports === 'object') exports['luma'] = factory();
   else root['luma'] = factory();})(globalThis, function () {
+"use strict";
 var __exports__ = (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
@@ -11,12 +12,15 @@ var __exports__ = (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
   var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
+    for (var name2 in all)
+      __defProp(target, name2, { get: all[name2], enumerable: true });
   };
   var __copyProps = (to, from, except, desc) => {
     if (from && typeof from === "object" || typeof from === "function") {
@@ -44,99 +48,168 @@ var __exports__ = (() => {
     }
   });
 
-  // bundle.ts
-  var bundle_exports = {};
-  __export(bundle_exports, {
-    WebGPUBuffer: () => WebGPUBuffer,
-    WebGPUDevice: () => WebGPUDevice,
-    WebGPUSampler: () => WebGPUSampler,
-    WebGPUShader: () => WebGPUShader,
-    WebGPUTexture: () => WebGPUTexture,
-    webgpuAdapter: () => webgpuAdapter
-  });
-  __reExport(bundle_exports, __toESM(require_core(), 1));
-
-  // src/adapter/webgpu-adapter.ts
-  var import_core20 = __toESM(require_core(), 1);
-
-  // src/adapter/webgpu-device.ts
-  var import_core19 = __toESM(require_core(), 1);
-
   // src/adapter/resources/webgpu-buffer.ts
-  var import_core = __toESM(require_core(), 1);
-  function getByteLength(props) {
-    return props.byteLength || props.data?.byteLength || 0;
-  }
-  var WebGPUBuffer = class extends import_core.Buffer {
-    device;
-    handle;
-    byteLength;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      this.byteLength = getByteLength(props);
-      const mapBuffer = Boolean(props.data);
-      const size = Math.ceil(this.byteLength / 4) * 4;
-      this.handle = this.props.handle || this.device.handle.createBuffer({
-        size,
-        // usage defaults to vertex
-        usage: this.props.usage || GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-        mappedAtCreation: this.props.mappedAtCreation || mapBuffer,
-        label: this.props.id
-      });
-      if (props.data) {
-        this._writeMapped(props.data);
-      }
-      if (mapBuffer && !props.mappedAtCreation) {
-        this.handle.unmap();
-      }
-    }
-    destroy() {
-      this.handle?.destroy();
-      this.handle = null;
-    }
-    // WebGPU provides multiple ways to write a buffer...
-    write(data, byteOffset = 0) {
-      this.device.handle.queue.writeBuffer(
-        this.handle,
-        byteOffset,
-        data.buffer,
-        data.byteOffset,
-        data.byteLength
-      );
-    }
-    async readAsync(byteOffset = 0, byteLength = this.byteLength) {
-      const tempBuffer = new WebGPUBuffer(this.device, {
-        usage: import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST,
-        byteLength
-      });
-      const commandEncoder = this.device.handle.createCommandEncoder();
-      commandEncoder.copyBufferToBuffer(this.handle, byteOffset, tempBuffer.handle, 0, byteLength);
-      this.device.handle.queue.submit([commandEncoder.finish()]);
-      await tempBuffer.handle.mapAsync(GPUMapMode.READ, byteOffset, byteLength);
-      const arrayBuffer = tempBuffer.handle.getMappedRange().slice(0);
-      tempBuffer.handle.unmap();
-      tempBuffer.destroy();
-      return new Uint8Array(arrayBuffer);
-    }
-    _writeMapped(typedArray) {
-      const arrayBuffer = this.handle.getMappedRange();
-      new typedArray.constructor(arrayBuffer).set(typedArray);
-    }
-    // WEBGPU API
-    mapAsync(mode, offset = 0, size) {
-      return this.handle.mapAsync(mode, offset, size);
-    }
-    getMappedRange(offset = 0, size) {
-      return this.handle.getMappedRange(offset, size);
-    }
-    unmap() {
-      this.handle.unmap();
+  var import_core, WebGPUBuffer;
+  var init_webgpu_buffer = __esm({
+    "src/adapter/resources/webgpu-buffer.ts"() {
+      "use strict";
+      import_core = __toESM(require_core(), 1);
+      WebGPUBuffer = class extends import_core.Buffer {
+        device;
+        handle;
+        byteLength;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          this.byteLength = props.byteLength || props.data?.byteLength || 0;
+          const mappedAtCreation = Boolean(this.props.onMapped || props.data);
+          const size = Math.ceil(this.byteLength / 4) * 4;
+          this.device.pushErrorScope("out-of-memory");
+          this.device.pushErrorScope("validation");
+          this.handle = this.props.handle || this.device.handle.createBuffer({
+            label: this.props.id,
+            // usage defaults to vertex
+            usage: this.props.usage || GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+            mappedAtCreation,
+            size
+          });
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this} creation failed ${error.message}`), this)();
+            this.device.debug();
+          });
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this} out of memory: ${error.message}`), this)();
+            this.device.debug();
+          });
+          this.device.pushErrorScope("validation");
+          if (props.data || props.onMapped) {
+            try {
+              const arrayBuffer = this.handle.getMappedRange();
+              if (props.data) {
+                const typedArray = props.data;
+                new typedArray.constructor(arrayBuffer).set(typedArray);
+              } else {
+                props.onMapped?.(arrayBuffer, "mapped");
+              }
+            } finally {
+              this.handle.unmap();
+            }
+          }
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this} creation failed ${error.message}`), this)();
+            this.device.debug();
+          });
+        }
+        destroy() {
+          this.handle?.destroy();
+          this.handle = null;
+        }
+        write(data, byteOffset = 0) {
+          const arrayBuffer = ArrayBuffer.isView(data) ? data.buffer : data;
+          const dataByteOffset = ArrayBuffer.isView(data) ? data.byteOffset : 0;
+          this.device.pushErrorScope("validation");
+          this.device.handle.queue.writeBuffer(
+            this.handle,
+            byteOffset,
+            arrayBuffer,
+            dataByteOffset,
+            data.byteLength
+          );
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this}.write() ${error.message}`), this)();
+            this.device.debug();
+          });
+        }
+        async mapAndWriteAsync(callback, byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+          const isMappable = (this.usage & import_core.Buffer.MAP_WRITE) !== 0;
+          const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_WRITE | import_core.Buffer.COPY_SRC, 0, this.byteLength) : null;
+          const writeBuffer = mappableBuffer || this;
+          this.device.pushErrorScope("validation");
+          try {
+            await this.device.handle.queue.onSubmittedWorkDone();
+            await writeBuffer.handle.mapAsync(GPUMapMode.WRITE, byteOffset, byteLength);
+            const arrayBuffer = writeBuffer.handle.getMappedRange(byteOffset, byteLength);
+            await callback(arrayBuffer, "mapped");
+            writeBuffer.handle.unmap();
+            if (mappableBuffer) {
+              this._copyBuffer(mappableBuffer, byteOffset, byteLength);
+            }
+          } finally {
+            this.device.popErrorScope((error) => {
+              this.device.reportError(new Error(`${this}.mapAndWriteAsync() ${error.message}`), this)();
+              this.device.debug();
+            });
+            mappableBuffer?.destroy();
+          }
+        }
+        async readAsync(byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+          return this.mapAndReadAsync(
+            (arrayBuffer) => new Uint8Array(arrayBuffer.slice(0)),
+            byteOffset,
+            byteLength
+          );
+        }
+        async mapAndReadAsync(callback, byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+          if (byteOffset % 8 !== 0 || byteLength % 4 !== 0) {
+            throw new Error("byteOffset must be multiple of 8 and byteLength multiple of 4");
+          }
+          if (byteOffset + byteLength > this.handle.size) {
+            throw new Error("Mapping range exceeds buffer size");
+          }
+          const isMappable = (this.usage & import_core.Buffer.MAP_READ) !== 0;
+          const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST, 0, this.byteLength) : null;
+          const readBuffer = mappableBuffer || this;
+          this.device.pushErrorScope("validation");
+          try {
+            await this.device.handle.queue.onSubmittedWorkDone();
+            if (mappableBuffer) {
+              mappableBuffer._copyBuffer(this);
+            }
+            await readBuffer.handle.mapAsync(GPUMapMode.READ, byteOffset, byteLength);
+            const arrayBuffer = readBuffer.handle.getMappedRange(byteOffset, byteLength);
+            const result = await callback(arrayBuffer, "mapped");
+            readBuffer.handle.unmap();
+            return result;
+          } finally {
+            this.device.popErrorScope((error) => {
+              this.device.reportError(new Error(`${this}.mapAndReadAsync() ${error.message}`), this)();
+              this.device.debug();
+            });
+            mappableBuffer?.destroy();
+          }
+        }
+        readSyncWebGL(byteOffset, byteLength) {
+          throw new Error("Not implemented");
+        }
+        // INTERNAL METHODS
+        /**
+         * @todo - A small set of mappable buffers could be cached on the device,
+         * however this goes against the goal of keeping core as a thin GPU API layer.
+         */
+        _getMappableBuffer(usage, byteOffset, byteLength) {
+          import_core.log.warn(`${this} is not readable, creating a temporary Buffer`);
+          const readableBuffer = new WebGPUBuffer(this.device, { usage, byteLength });
+          return readableBuffer;
+        }
+        _copyBuffer(sourceBuffer, byteOffset = 0, byteLength = this.byteLength) {
+          this.device.pushErrorScope("validation");
+          const commandEncoder = this.device.handle.createCommandEncoder();
+          commandEncoder.copyBufferToBuffer(
+            sourceBuffer.handle,
+            byteOffset,
+            this.handle,
+            byteOffset,
+            byteLength
+          );
+          this.device.handle.queue.submit([commandEncoder.finish()]);
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this}._getReadableBuffer() ${error.message}`), this)();
+            this.device.debug();
+          });
+        }
+      };
     }
-  };
-
-  // src/adapter/resources/webgpu-texture.ts
-  var import_core4 = __toESM(require_core(), 1);
+  });
 
   // src/adapter/helpers/convert-texture-format.ts
   function getWebGPUTextureFormat(format) {
@@ -145,346 +218,368 @@ var __exports__ = (() => {
     }
     return format;
   }
+  var init_convert_texture_format = __esm({
+    "src/adapter/helpers/convert-texture-format.ts"() {
+      "use strict";
+    }
+  });
 
   // src/adapter/resources/webgpu-sampler.ts
-  var import_core2 = __toESM(require_core(), 1);
-  var WebGPUSampler = class extends import_core2.Sampler {
-    device;
-    handle;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      const samplerDescriptor = {
-        ...this.props,
-        mipmapFilter: void 0
+  var import_core2, WebGPUSampler;
+  var init_webgpu_sampler = __esm({
+    "src/adapter/resources/webgpu-sampler.ts"() {
+      "use strict";
+      import_core2 = __toESM(require_core(), 1);
+      WebGPUSampler = class extends import_core2.Sampler {
+        device;
+        handle;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          const samplerDescriptor = {
+            ...this.props,
+            mipmapFilter: void 0
+          };
+          if (props.type !== "comparison-sampler") {
+            delete samplerDescriptor.compare;
+          }
+          if (props.mipmapFilter && props.mipmapFilter !== "none") {
+            samplerDescriptor.mipmapFilter = props.mipmapFilter;
+          }
+          this.handle = props.handle || this.device.handle.createSampler(samplerDescriptor);
+          this.handle.label = this.props.id;
+        }
+        destroy() {
+          this.handle = null;
+        }
       };
-      if (props.type !== "comparison-sampler") {
-        delete samplerDescriptor.compare;
-      }
-      if (props.mipmapFilter && props.mipmapFilter !== "none") {
-        samplerDescriptor.mipmapFilter = props.mipmapFilter;
-      }
-      this.handle = this.handle || this.device.handle.createSampler(samplerDescriptor);
-      this.handle.label = this.props.id;
     }
-    destroy() {
-      this.handle = null;
-    }
-  };
+  });
 
   // src/adapter/resources/webgpu-texture-view.ts
-  var import_core3 = __toESM(require_core(), 1);
-  var WebGPUTextureView = class extends import_core3.TextureView {
-    device;
-    handle;
-    texture;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      this.texture = props.texture;
-      this.handle = this.handle || this.texture.handle.createView({
-        format: props.format || this.texture.format,
-        dimension: props.dimension || this.texture.dimension,
-        aspect: props.aspect,
-        baseMipLevel: props.baseMipLevel,
-        mipLevelCount: props.mipLevelCount,
-        // GPUIntegerCoordinate;
-        baseArrayLayer: props.baseArrayLayer,
-        // GPUIntegerCoordinate;
-        arrayLayerCount: props.arrayLayerCount
-        // GPUIntegerCoordinate;
-      });
-      this.handle.label = this.props.id;
-    }
-    destroy() {
-      this.handle = null;
+  var import_core3, WebGPUTextureView;
+  var init_webgpu_texture_view = __esm({
+    "src/adapter/resources/webgpu-texture-view.ts"() {
+      "use strict";
+      import_core3 = __toESM(require_core(), 1);
+      WebGPUTextureView = class extends import_core3.TextureView {
+        device;
+        handle;
+        texture;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          this.texture = props.texture;
+          this.device.pushErrorScope("validation");
+          this.handle = // props.handle ||
+          this.texture.handle.createView({
+            format: this.props.format || this.texture.format,
+            dimension: this.props.dimension || this.texture.dimension,
+            aspect: this.props.aspect,
+            baseMipLevel: this.props.baseMipLevel,
+            mipLevelCount: this.props.mipLevelCount,
+            baseArrayLayer: this.props.baseArrayLayer,
+            arrayLayerCount: this.props.arrayLayerCount
+          });
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`TextureView constructor: ${error.message}`), this)();
+            this.device.debug();
+          });
+          this.handle.label = this.props.id;
+        }
+        destroy() {
+          this.handle = null;
+        }
+      };
     }
-  };
+  });
 
   // src/adapter/resources/webgpu-texture.ts
-  var BASE_DIMENSIONS = {
-    "1d": "1d",
-    "2d": "2d",
-    "2d-array": "2d",
-    cube: "2d",
-    "cube-array": "2d",
-    "3d": "3d"
-  };
-  var WebGPUTexture = class extends import_core4.Texture {
-    device;
-    handle;
-    sampler;
-    view;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      const propsWithData = { ...this.props };
-      if (props.data) {
-        propsWithData.data = props.data;
-      }
-      this.initialize(propsWithData);
-    }
-    destroy() {
-      this.handle?.destroy();
-      this.handle = null;
-    }
-    createView(props) {
-      return new WebGPUTextureView(this.device, { ...props, texture: this });
-    }
-    initialize(props) {
-      this.handle = this.props.handle || this.createHandle();
-      this.handle.label ||= this.id;
-      if (this.props.data) {
-        if (import_core4.Texture.isExternalImage(this.props.data)) {
-          this.copyExternalImage({ image: this.props.data });
-        } else {
-          this.setData({ data: this.props.data });
+  var import_core4, WebGPUTexture;
+  var init_webgpu_texture = __esm({
+    "src/adapter/resources/webgpu-texture.ts"() {
+      "use strict";
+      import_core4 = __toESM(require_core(), 1);
+      init_convert_texture_format();
+      init_webgpu_sampler();
+      init_webgpu_texture_view();
+      WebGPUTexture = class extends import_core4.Texture {
+        device;
+        handle;
+        sampler;
+        view;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          if (this.dimension === "cube") {
+            this.depth = 6;
+          }
+          this.device.pushErrorScope("out-of-memory");
+          this.device.pushErrorScope("validation");
+          this.handle = this.props.handle || this.device.handle.createTexture({
+            label: this.id,
+            size: {
+              width: this.width,
+              height: this.height,
+              depthOrArrayLayers: this.depth
+            },
+            usage: this.props.usage || import_core4.Texture.TEXTURE | import_core4.Texture.COPY_DST,
+            dimension: this.baseDimension,
+            format: getWebGPUTextureFormat(this.format),
+            mipLevelCount: this.mipLevels,
+            sampleCount: this.props.samples
+          });
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this} constructor: ${error.message}`), this)();
+            this.device.debug();
+          });
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this} out of memory: ${error.message}`), this)();
+            this.device.debug();
+          });
+          if (this.props.handle) {
+            this.handle.label ||= this.id;
+            this.width = this.handle.width;
+            this.height = this.handle.height;
+          }
+          this.sampler = props.sampler instanceof WebGPUSampler ? props.sampler : new WebGPUSampler(this.device, props.sampler || {});
+          this.view = new WebGPUTextureView(this.device, {
+            ...this.props,
+            texture: this,
+            mipLevelCount: this.mipLevels,
+            // Note: arrayLayerCount controls the view of array textures, but does not apply to 3d texture depths
+            arrayLayerCount: this.dimension !== "3d" ? this.depth : 1
+          });
+          this._initializeData(props.data);
         }
-      }
-      this.width = this.handle.width;
-      this.height = this.handle.height;
-      this.sampler = props.sampler instanceof WebGPUSampler ? props.sampler : new WebGPUSampler(this.device, props.sampler || {});
-      this.view = new WebGPUTextureView(this.device, { ...this.props, texture: this });
-    }
-    createHandle() {
-      const width = this.props.width || this.props.data?.width || 1;
-      const height = this.props.height || this.props.data?.height || 1;
-      return this.device.handle.createTexture({
-        label: this.id,
-        size: {
-          width,
-          height,
-          depthOrArrayLayers: this.depth
-        },
-        usage: this.props.usage || import_core4.Texture.TEXTURE | import_core4.Texture.COPY_DST,
-        dimension: BASE_DIMENSIONS[this.dimension],
-        format: getWebGPUTextureFormat(this.format),
-        mipLevelCount: this.mipLevels,
-        sampleCount: this.props.samples
-      });
-    }
-    /** @deprecated - intention is to use the createView public API */
-    createGPUTextureView() {
-      return this.handle.createView({ label: this.id });
-    }
-    /**
-     * Set default sampler
-     * Accept a sampler instance or set of props;
-     */
-    setSampler(sampler) {
-      this.sampler = sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);
-      return this;
-    }
-    setTexture1DData(data) {
-      throw new Error("not implemented");
-    }
-    setTexture2DData(lodData, depth, target) {
-      throw new Error("not implemented");
-    }
-    setTexture3DData(lodData, depth, target) {
-      throw new Error("not implemented");
-    }
-    setTextureCubeData(data, depth) {
-      throw new Error("not implemented");
-    }
-    setTextureArrayData(data) {
-      throw new Error("not implemented");
-    }
-    setTextureCubeArrayData(data) {
-      throw new Error("not implemented");
-    }
-    setData(options) {
-      if (ArrayBuffer.isView(options.data)) {
-        const clampedArray = new Uint8ClampedArray(options.data.buffer);
-        const image = new ImageData(clampedArray, this.width, this.height);
-        return this.copyExternalImage({ image });
-      }
-      throw new Error("Texture.setData: Use CommandEncoder to upload data to texture in WebGPU");
-    }
-    copyExternalImage(options) {
-      const size = import_core4.Texture.getExternalImageSize(options.image);
-      const opts = { ...import_core4.Texture.defaultCopyExternalImageOptions, ...size, ...options };
-      const {
-        image,
-        sourceX,
-        sourceY,
-        width,
-        height,
-        depth,
-        mipLevel,
-        x,
-        y,
-        z,
-        aspect,
-        colorSpace,
-        premultipliedAlpha,
-        flipY
-      } = opts;
-      this.device.handle.queue.copyExternalImageToTexture(
-        // source: GPUImageCopyExternalImage
-        {
-          source: image,
-          origin: [sourceX, sourceY],
-          flipY
-        },
-        // destination: GPUImageCopyTextureTagged
-        {
-          texture: this.handle,
-          origin: [x, y, z],
-          mipLevel,
-          aspect,
-          colorSpace,
-          premultipliedAlpha
-        },
-        // copySize: GPUExtent3D
-        [width, height, depth]
-      );
-      return { width, height };
-    }
-    // WebGPU specific
-    /*
-      async readPixels() {
-        const readbackBuffer = device.createBuffer({
-            usage: Buffer.COPY_DST | Buffer.MAP_READ,
-            size: 4 * textureWidth * textureHeight,
-        });
-    
-        // Copy data from the texture to the buffer.
-        const encoder = device.createCommandEncoder();
-        encoder.copyTextureToBuffer(
-            { texture },
-            { buffer, rowPitch: textureWidth * 4 },
-            [textureWidth, textureHeight],
-        );
-        device.submit([encoder.finish()]);
-    
-        // Get the data on the CPU.
-        await buffer.mapAsync(GPUMapMode.READ);
-        saveScreenshot(buffer.getMappedRange());
-        buffer.unmap();
-      }
-    
-      setImageData(imageData, usage): this {
-        let data = null;
-    
-        const bytesPerRow = Math.ceil((img.width * 4) / 256) * 256;
-        if (bytesPerRow == img.width * 4) {
-          data = imageData.data;
-        } else {
-          data = new Uint8Array(bytesPerRow * img.height);
-          let imagePixelIndex = 0;
-          for (let y = 0; y < img.height; ++y) {
-            for (let x = 0; x < img.width; ++x) {
-              const i = x * 4 + y * bytesPerRow;
-              data[i] = imageData.data[imagePixelIndex];
-              data[i + 1] = imageData.data[imagePixelIndex + 1];
-              data[i + 2] = imageData.data[imagePixelIndex + 2];
-              data[i + 3] = imageData.data[imagePixelIndex + 3];
-              imagePixelIndex += 4;
+        destroy() {
+          this.handle?.destroy();
+          this.handle = null;
+        }
+        createView(props) {
+          return new WebGPUTextureView(this.device, { ...props, texture: this });
+        }
+        copyImageData(options_) {
+          const { width, height, depth } = this;
+          const options = this._normalizeCopyImageDataOptions(options_);
+          this.device.pushErrorScope("validation");
+          this.device.handle.queue.writeTexture(
+            // destination: GPUImageCopyTexture
+            {
+              // texture subresource
+              texture: this.handle,
+              mipLevel: options.mipLevel,
+              aspect: options.aspect,
+              // origin to write to
+              origin: [options.x, options.y, options.z]
+            },
+            // data
+            options.data,
+            // dataLayout: GPUImageDataLayout
+            {
+              offset: options.byteOffset,
+              bytesPerRow: options.bytesPerRow,
+              rowsPerImage: options.rowsPerImage
+            },
+            // size: GPUExtent3D - extents of the content to write
+            [width, height, depth]
+          );
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`copyImageData: ${error.message}`), this)();
+            this.device.debug();
+          });
+        }
+        copyExternalImage(options_) {
+          const options = this._normalizeCopyExternalImageOptions(options_);
+          this.device.pushErrorScope("validation");
+          this.device.handle.queue.copyExternalImageToTexture(
+            // source: GPUImageCopyExternalImage
+            {
+              source: options.image,
+              origin: [options.sourceX, options.sourceY],
+              flipY: options.flipY
+            },
+            // destination: GPUImageCopyTextureTagged
+            {
+              texture: this.handle,
+              origin: [options.x, options.y, 0],
+              // options.depth],
+              mipLevel: options.mipLevel,
+              aspect: options.aspect,
+              colorSpace: options.colorSpace,
+              premultipliedAlpha: options.premultipliedAlpha
+            },
+            // copySize: GPUExtent3D
+            [options.width, options.height, 1]
+          );
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`copyExternalImage: ${error.message}`), this)();
+            this.device.debug();
+          });
+          return { width: options.width, height: options.height };
+        }
+        generateMipmapsWebGL() {
+          import_core4.log.warn(`${this}: generateMipmaps not supported in WebGPU`)();
+        }
+        // WebGPU specific
+        /*
+          async readPixels() {
+            const readbackBuffer = device.createBuffer({
+                usage: Buffer.COPY_DST | Buffer.MAP_READ,
+                size: 4 * textureWidth * textureHeight,
+            });
+        
+            // Copy data from the texture to the buffer.
+            const encoder = device.createCommandEncoder();
+            encoder.copyTextureToBuffer(
+                { texture },
+                { buffer, rowPitch: textureWidth * 4 },
+                [textureWidth, textureHeight],
+            );
+            device.submit([encoder.finish()]);
+        
+            // Get the data on the CPU.
+            await buffer.mapAndReadAsync(GPUMapMode.READ);
+            saveScreenshot(buffer.getMappedRange());
+            buffer.unmap();
+          }
+        
+          setImageData(imageData, usage): this {
+            let data = null;
+        
+            const bytesPerRow = Math.ceil((img.width * 4) / 256) * 256;
+            if (bytesPerRow == img.width * 4) {
+              data = imageData.data;
+            } else {
+              data = new Uint8Array(bytesPerRow * img.height);
+              let imagePixelIndex = 0;
+              for (let y = 0; y < img.height; ++y) {
+                for (let x = 0; x < img.width; ++x) {
+                  const i = x * 4 + y * bytesPerRow;
+                  data[i] = imageData.data[imagePixelIndex];
+                  data[i + 1] = imageData.data[imagePixelIndex + 1];
+                  data[i + 2] = imageData.data[imagePixelIndex + 2];
+                  data[i + 3] = imageData.data[imagePixelIndex + 3];
+                  imagePixelIndex += 4;
+                }
+              }
             }
+            return this;
           }
-        }
-        return this;
-      }
-    
-      setBuffer(textureDataBuffer, {bytesPerRow}): this {
-        const commandEncoder = this.device.handle.createCommandEncoder();
-        commandEncoder.copyBufferToTexture(
-          {
-            buffer: textureDataBuffer,
-            bytesPerRow
-          },
-          {
-            texture: this.handle
-          },
-          {
-            width,
-            height,
-            depth
+        
+          setBuffer(textureDataBuffer, {bytesPerRow}): this {
+            const commandEncoder = this.device.handle.createCommandEncoder();
+            commandEncoder.copyBufferToTexture(
+              {
+                buffer: textureDataBuffer,
+                bytesPerRow
+              },
+              {
+                texture: this.handle
+              },
+              {
+                width,
+                height,
+                depth
+              }
+            );
+        
+            this.device.handle.defaultQueue.submit([commandEncoder.finish()]);
+            return this;
           }
-        );
-    
-        this.device.handle.defaultQueue.submit([commandEncoder.finish()]);
-        return this;
-      }
-      */
-  };
+          */
+      };
+    }
+  });
 
   // src/adapter/resources/webgpu-external-texture.ts
-  var import_core5 = __toESM(require_core(), 1);
-  var WebGPUExternalTexture = class extends import_core5.ExternalTexture {
-    device;
-    handle;
-    sampler;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      this.handle = this.props.handle || this.device.handle.importExternalTexture({
-        source: props.source,
-        colorSpace: props.colorSpace
-      });
-      this.sampler = null;
-    }
-    destroy() {
-      this.handle = null;
-    }
-    /** Set default sampler */
-    setSampler(sampler) {
-      this.sampler = sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);
-      return this;
+  var import_core5, WebGPUExternalTexture;
+  var init_webgpu_external_texture = __esm({
+    "src/adapter/resources/webgpu-external-texture.ts"() {
+      "use strict";
+      import_core5 = __toESM(require_core(), 1);
+      init_webgpu_sampler();
+      WebGPUExternalTexture = class extends import_core5.ExternalTexture {
+        device;
+        handle;
+        sampler;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          this.handle = this.props.handle || this.device.handle.importExternalTexture({
+            source: props.source,
+            colorSpace: props.colorSpace
+          });
+          this.sampler = null;
+        }
+        destroy() {
+          this.handle = null;
+        }
+        /** Set default sampler */
+        setSampler(sampler) {
+          this.sampler = sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);
+          return this;
+        }
+      };
     }
-  };
+  });
 
   // src/adapter/resources/webgpu-shader.ts
-  var import_core6 = __toESM(require_core(), 1);
-  var WebGPUShader = class extends import_core6.Shader {
-    device;
-    handle;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      const isGLSL = props.source.includes("#version");
-      if (this.props.language === "glsl" || isGLSL) {
-        throw new Error("GLSL shaders are not supported in WebGPU");
-      }
-      this.device.handle.pushErrorScope("validation");
-      this.handle = this.props.handle || this.device.handle.createShaderModule({ code: props.source });
-      this.device.handle.popErrorScope().then((error) => {
-        if (error) {
-          import_core6.log.error(`${this} creation failed:
-"${error.message}"`, this, this.props.source)();
+  var import_core6, WebGPUShader;
+  var init_webgpu_shader = __esm({
+    "src/adapter/resources/webgpu-shader.ts"() {
+      "use strict";
+      import_core6 = __toESM(require_core(), 1);
+      WebGPUShader = class extends import_core6.Shader {
+        device;
+        handle;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          const isGLSL = props.source.includes("#version");
+          if (this.props.language === "glsl" || isGLSL) {
+            throw new Error("GLSL shaders are not supported in WebGPU");
+          }
+          this.device.pushErrorScope("validation");
+          this.handle = this.props.handle || this.device.handle.createShaderModule({ code: props.source });
+          this.device.popErrorScope((error) => {
+            this.device.reportError(
+              new Error(`${this} creation failed:
+"${error.message}"`),
+              this,
+              this.props.source
+            )();
+            this.device.debug();
+          });
+          this.handle.label = this.props.id;
+          this._checkCompilationError();
         }
-      });
-      this.handle.label = this.props.id;
-      this._checkCompilationError();
-    }
-    get asyncCompilationStatus() {
-      return this.getCompilationInfo().then(() => this.compilationStatus);
-    }
-    async _checkCompilationError() {
-      const shaderLog = await this.getCompilationInfo();
-      const hasErrors = Boolean(shaderLog.find((msg) => msg.type === "error"));
-      this.compilationStatus = hasErrors ? "error" : "success";
-      this.debugShader();
-      if (this.compilationStatus === "error") {
-        import_core6.log.error(`Shader compilation error`, shaderLog)();
-      }
-    }
-    destroy() {
-      this.handle = null;
-    }
-    /** Returns compilation info for this shader */
-    async getCompilationInfo() {
-      const compilationInfo = await this.handle.getCompilationInfo();
-      return compilationInfo.messages;
+        get asyncCompilationStatus() {
+          return this.getCompilationInfo().then(() => this.compilationStatus);
+        }
+        async _checkCompilationError() {
+          const shaderLog = await this.getCompilationInfo();
+          const hasErrors = Boolean(shaderLog.find((msg) => msg.type === "error"));
+          this.compilationStatus = hasErrors ? "error" : "success";
+          this.debugShader();
+          if (this.compilationStatus === "error") {
+            this.device.reportError(new Error(`Shader compilation error`), this, shaderLog)();
+            this.device.debug();
+          }
+        }
+        destroy() {
+          this.handle = null;
+        }
+        /** Returns compilation info for this shader */
+        async getCompilationInfo() {
+          const compilationInfo = await this.handle.getCompilationInfo();
+          return compilationInfo.messages;
+        }
+      };
     }
-  };
-
-  // src/adapter/resources/webgpu-render-pipeline.ts
-  var import_core10 = __toESM(require_core(), 1);
+  });
 
   // src/adapter/helpers/webgpu-parameters.ts
-  var import_core7 = __toESM(require_core(), 1);
   function addDepthStencil(descriptor) {
     descriptor.depthStencil = descriptor.depthStencil || {
       // required, set something
@@ -505,157 +600,9 @@ var __exports__ = (() => {
     const depthStencil = addDepthStencil(descriptor);
     return depthStencil.stencilBack;
   }
-  var PARAMETER_TABLE = {
-    // RASTERIZATION PARAMETERS
-    cullMode: (parameter, value, descriptor) => {
-      descriptor.primitive = descriptor.primitive || {};
-      descriptor.primitive.cullMode = value;
-    },
-    frontFace: (parameter, value, descriptor) => {
-      descriptor.primitive = descriptor.primitive || {};
-      descriptor.primitive.frontFace = value;
-    },
-    // DEPTH
-    depthWriteEnabled: (parameter, value, descriptor) => {
-      const depthStencil = addDepthStencil(descriptor);
-      depthStencil.depthWriteEnabled = value;
-    },
-    depthCompare: (parameter, value, descriptor) => {
-      const depthStencil = addDepthStencil(descriptor);
-      depthStencil.depthCompare = value;
-    },
-    depthFormat: (parameter, value, descriptor) => {
-      const depthStencil = addDepthStencil(descriptor);
-      depthStencil.format = value;
-    },
-    depthBias: (parameter, value, descriptor) => {
-      const depthStencil = addDepthStencil(descriptor);
-      depthStencil.depthBias = value;
-    },
-    depthBiasSlopeScale: (parameter, value, descriptor) => {
-      const depthStencil = addDepthStencil(descriptor);
-      depthStencil.depthBiasSlopeScale = value;
-    },
-    depthBiasClamp: (parameter, value, descriptor) => {
-      const depthStencil = addDepthStencil(descriptor);
-      depthStencil.depthBiasClamp = value;
-    },
-    // STENCIL
-    stencilReadMask: (parameter, value, descriptor) => {
-      const depthStencil = addDepthStencil(descriptor);
-      depthStencil.stencilReadMask = value;
-    },
-    stencilWriteMask: (parameter, value, descriptor) => {
-      const depthStencil = addDepthStencil(descriptor);
-      depthStencil.stencilWriteMask = value;
-    },
-    stencilCompare: (parameter, value, descriptor) => {
-      const stencilFront = addDepthStencilFront(descriptor);
-      const stencilBack = addDepthStencilBack(descriptor);
-      stencilFront.compare = value;
-      stencilBack.compare = value;
-    },
-    stencilPassOperation: (parameter, value, descriptor) => {
-      const stencilFront = addDepthStencilFront(descriptor);
-      const stencilBack = addDepthStencilBack(descriptor);
-      stencilFront.passOp = value;
-      stencilBack.passOp = value;
-    },
-    stencilFailOperation: (parameter, value, descriptor) => {
-      const stencilFront = addDepthStencilFront(descriptor);
-      const stencilBack = addDepthStencilBack(descriptor);
-      stencilFront.failOp = value;
-      stencilBack.failOp = value;
-    },
-    stencilDepthFailOperation: (parameter, value, descriptor) => {
-      const stencilFront = addDepthStencilFront(descriptor);
-      const stencilBack = addDepthStencilBack(descriptor);
-      stencilFront.depthFailOp = value;
-      stencilBack.depthFailOp = value;
-    },
-    // MULTISAMPLE
-    sampleCount: (parameter, value, descriptor) => {
-      descriptor.multisample = descriptor.multisample || {};
-      descriptor.multisample.count = value;
-    },
-    sampleMask: (parameter, value, descriptor) => {
-      descriptor.multisample = descriptor.multisample || {};
-      descriptor.multisample.mask = value;
-    },
-    sampleAlphaToCoverageEnabled: (parameter, value, descriptor) => {
-      descriptor.multisample = descriptor.multisample || {};
-      descriptor.multisample.alphaToCoverageEnabled = value;
-    },
-    // COLOR
-    colorMask: (parameter, value, descriptor) => {
-      const targets = addColorState(descriptor);
-      targets[0].writeMask = value;
-    },
-    blendColorOperation: (parameter, value, descriptor) => {
-      addColorState(descriptor);
-    }
-    /*
-      blendColorSrcTarget: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
-        addColorState(descriptor);
-        targets[0].blend = targets[0].blend || {};
-        targets[0].blend.color = targets[0].blend.color || {};
-        targets[0].blend.color.srcTarget = value;
-      },
-    
-      blendColorDstTarget: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
-        addColorState(descriptor);
-        targets[0].blend = targets[0].blend || {};
-        targets[0].blend.color = targets[0].blend.color || {};
-        targets[0].blend.color.dstTarget = value;
-      },
-    
-      blendAlphaOperation: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
-        addColorState(descriptor);
-        targets[0].blend = targets[0].blend || {};
-        targets[0].blend.alpha = targets[0].blend.alpha || {};
-        targets[0].blend.alpha.operation = value;
-      },
-    
-      blendAlphaSrcTarget: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
-        addColorState(descriptor);
-        targets[0].blend = targets[0].blend || {};
-        targets[0].blend.alpha = targets[0].blend.alpha || {};
-        targets[0].blend.alpha.srcTarget = value;
-      },
-    
-      blendAlphaDstTarget: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
-        addColorState(descriptor);
-        targets[0].blend = targets[0].blend || {};
-        targets[0].blend.alpha = targets[0].blend.alpha || {};
-        targets[0].blend.alpha.dstTarget = value;
-      },
-      */
-  };
-  var DEFAULT_PIPELINE_DESCRIPTOR = {
-    // depthStencil: {
-    //   stencilFront: {},
-    //   stencilBack: {},
-    //   // depthWriteEnabled: true,
-    //   // depthCompare: 'less',
-    //   // format: 'depth24plus-stencil8',
-    // },
-    primitive: {
-      cullMode: "back",
-      topology: "triangle-list"
-    },
-    vertex: {
-      module: void 0,
-      entryPoint: "main"
-    },
-    fragment: {
-      module: void 0,
-      entryPoint: "main",
-      targets: [
-        // { format: props.color0Format || 'bgra8unorm' }
-      ]
-    },
-    layout: "auto"
-  };
+  function notSupported(key, value, descriptor) {
+    import_core7.log.warn(`${key} parameter not supported in WebGPU`)();
+  }
   function applyParametersToRenderPipelineDescriptor(pipelineDescriptor, parameters = {}) {
     Object.assign(pipelineDescriptor, { ...DEFAULT_PIPELINE_DESCRIPTOR, ...pipelineDescriptor });
     setParameters(pipelineDescriptor, parameters);
@@ -663,14 +610,14 @@ var __exports__ = (() => {
   function setParameters(pipelineDescriptor, parameters) {
     for (const [key, value] of Object.entries(parameters)) {
       const setterFunction = PARAMETER_TABLE[key];
-      if (!setterFunction) {
-        import_core7.log.warn(`Illegal parameter ${key}`)();
-        continue;
+      if (setterFunction) {
+        setterFunction(key, value, pipelineDescriptor);
+      } else {
+        import_core7.log.error(`Illegal parameter ${key} in WebGPU`)();
       }
-      setterFunction(key, value, pipelineDescriptor);
     }
   }
-  function addColorState(descriptor) {
+  function addColorState(descriptor, attachment) {
     descriptor.fragment.targets = descriptor.fragment?.targets || [];
     if (!Array.isArray(descriptor.fragment?.targets)) {
       import_core7.log.warn("parameters: no targets array")();
@@ -678,23 +625,201 @@ var __exports__ = (() => {
     if (descriptor.fragment?.targets?.length === 0) {
       descriptor.fragment.targets?.push({});
     }
-    return descriptor.fragment?.targets;
+    return descriptor.fragment?.targets?.[0];
+  }
+  function addBlendState(descriptor, attachment) {
+    const target = addColorState(descriptor, attachment);
+    target.blend = target.blend || { color: {}, alpha: {} };
+    return target.blend;
   }
+  var import_core7, PARAMETER_TABLE, DEFAULT_PIPELINE_DESCRIPTOR;
+  var init_webgpu_parameters = __esm({
+    "src/adapter/helpers/webgpu-parameters.ts"() {
+      "use strict";
+      import_core7 = __toESM(require_core(), 1);
+      PARAMETER_TABLE = {
+        // RASTERIZATION PARAMETERS
+        cullMode: (_, value, descriptor) => {
+          descriptor.primitive = descriptor.primitive || {};
+          descriptor.primitive.cullMode = value;
+        },
+        frontFace: (_, value, descriptor) => {
+          descriptor.primitive = descriptor.primitive || {};
+          descriptor.primitive.frontFace = value;
+        },
+        // DEPTH
+        depthWriteEnabled: (_, value, descriptor) => {
+          if (value) {
+            const depthStencil = addDepthStencil(descriptor);
+            depthStencil.depthWriteEnabled = value;
+          }
+        },
+        depthCompare: (_, value, descriptor) => {
+          const depthStencil = addDepthStencil(descriptor);
+          depthStencil.depthCompare = value;
+        },
+        depthFormat: (_, value, descriptor) => {
+          const depthStencil = addDepthStencil(descriptor);
+          depthStencil.format = value;
+        },
+        depthBias: (_, value, descriptor) => {
+          const depthStencil = addDepthStencil(descriptor);
+          depthStencil.depthBias = value;
+        },
+        depthBiasSlopeScale: (_, value, descriptor) => {
+          const depthStencil = addDepthStencil(descriptor);
+          depthStencil.depthBiasSlopeScale = value;
+        },
+        depthBiasClamp: (_, value, descriptor) => {
+          const depthStencil = addDepthStencil(descriptor);
+          depthStencil.depthBiasClamp = value;
+        },
+        // STENCIL
+        stencilReadMask: (_, value, descriptor) => {
+          const depthStencil = addDepthStencil(descriptor);
+          depthStencil.stencilReadMask = value;
+        },
+        stencilWriteMask: (_, value, descriptor) => {
+          const depthStencil = addDepthStencil(descriptor);
+          depthStencil.stencilWriteMask = value;
+        },
+        stencilCompare: (_, value, descriptor) => {
+          const stencilFront = addDepthStencilFront(descriptor);
+          const stencilBack = addDepthStencilBack(descriptor);
+          stencilFront.compare = value;
+          stencilBack.compare = value;
+        },
+        stencilPassOperation: (_, value, descriptor) => {
+          const stencilFront = addDepthStencilFront(descriptor);
+          const stencilBack = addDepthStencilBack(descriptor);
+          stencilFront.passOp = value;
+          stencilBack.passOp = value;
+        },
+        stencilFailOperation: (_, value, descriptor) => {
+          const stencilFront = addDepthStencilFront(descriptor);
+          const stencilBack = addDepthStencilBack(descriptor);
+          stencilFront.failOp = value;
+          stencilBack.failOp = value;
+        },
+        stencilDepthFailOperation: (_, value, descriptor) => {
+          const stencilFront = addDepthStencilFront(descriptor);
+          const stencilBack = addDepthStencilBack(descriptor);
+          stencilFront.depthFailOp = value;
+          stencilBack.depthFailOp = value;
+        },
+        // MULTISAMPLE
+        sampleCount: (_, value, descriptor) => {
+          descriptor.multisample = descriptor.multisample || {};
+          descriptor.multisample.count = value;
+        },
+        sampleMask: (_, value, descriptor) => {
+          descriptor.multisample = descriptor.multisample || {};
+          descriptor.multisample.mask = value;
+        },
+        sampleAlphaToCoverageEnabled: (_, value, descriptor) => {
+          descriptor.multisample = descriptor.multisample || {};
+          descriptor.multisample.alphaToCoverageEnabled = value;
+        },
+        // COLOR
+        colorMask: (_, value, descriptor) => {
+          const target = addColorState(descriptor, 0);
+          target.writeMask = value;
+        },
+        blend: (_, value, descriptor) => {
+          if (value) {
+            addBlendState(descriptor, 0);
+          }
+        },
+        blendColorOperation: (_, value, descriptor) => {
+          const blend = addBlendState(descriptor, 0);
+          blend.color = blend.color || {};
+          blend.color.operation = value;
+        },
+        blendColorSrcFactor: (_, value, descriptor) => {
+          const blend = addBlendState(descriptor, 0);
+          blend.color = blend.color || {};
+          blend.color.srcFactor = value;
+        },
+        blendColorDstFactor: (_, value, descriptor) => {
+          const blend = addBlendState(descriptor, 0);
+          blend.color.dstFactor = value;
+        },
+        blendAlphaOperation: (_, value, descriptor) => {
+          const blend = addBlendState(descriptor, 0);
+          blend.alpha = blend.alpha || {};
+          blend.alpha.operation = value;
+        },
+        blendAlphaSrcFactor: (_, value, descriptor) => {
+          const blend = addBlendState(descriptor, 0);
+          blend.alpha = blend.alpha || {};
+          blend.alpha.srcFactor = value;
+        },
+        blendAlphaDstFactor: (_, value, descriptor) => {
+          const blend = addBlendState(descriptor, 0);
+          blend.alpha = blend.alpha || {};
+          blend.alpha.dstFactor = value;
+        },
+        unclippedDepth: notSupported,
+        provokingVertex: notSupported,
+        polygonMode: notSupported,
+        polygonOffsetLine: notSupported,
+        clipDistance0: notSupported,
+        clipDistance1: notSupported,
+        clipDistance2: notSupported,
+        clipDistance3: notSupported,
+        clipDistance4: notSupported,
+        clipDistance5: notSupported,
+        clipDistance6: notSupported,
+        clipDistance7: notSupported
+      };
+      DEFAULT_PIPELINE_DESCRIPTOR = {
+        // depthStencil: {
+        //   stencilFront: {},
+        //   stencilBack: {},
+        //   // depthWriteEnabled: true,
+        //   // depthCompare: 'less',
+        //   // format: 'depth24plus-stencil8',
+        // },
+        primitive: {
+          cullMode: "back",
+          topology: "triangle-list"
+        },
+        vertex: {
+          module: void 0,
+          entryPoint: "main"
+        },
+        fragment: {
+          module: void 0,
+          entryPoint: "main",
+          targets: [
+            // { format: props.color0Format || 'bgra8unorm' }
+          ]
+        },
+        layout: "auto"
+      };
+    }
+  });
 
   // src/adapter/helpers/get-bind-group.ts
-  var import_core8 = __toESM(require_core(), 1);
   function getBindGroup(device, bindGroupLayout, shaderLayout, bindings) {
     const entries = getBindGroupEntries(bindings, shaderLayout);
-    return device.createBindGroup({
+    device.pushErrorScope("validation");
+    const bindGroup = device.createBindGroup({
       layout: bindGroupLayout,
       entries
     });
+    device.popErrorScope().then((error) => {
+      if (error) {
+        import_core8.log.error(`bindGroup creation: ${error.message}`, bindGroup)();
+      }
+    });
+    return bindGroup;
   }
-  function getShaderLayoutBinding(shaderLayout, bindingName) {
+  function getShaderLayoutBinding(shaderLayout, bindingName, options) {
     const bindingLayout = shaderLayout.bindings.find(
       (binding) => binding.name === bindingName || `${binding.name.toLocaleLowerCase()}uniforms` === bindingName.toLocaleLowerCase()
     );
-    if (!bindingLayout) {
+    if (!bindingLayout && !options?.ignoreWarnings) {
       import_core8.log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
     }
     return bindingLayout || null;
@@ -704,11 +829,21 @@ var __exports__ = (() => {
     for (const [bindingName, value] of Object.entries(bindings)) {
       let bindingLayout = getShaderLayoutBinding(shaderLayout, bindingName);
       if (bindingLayout) {
-        entries.push(getBindGroupEntry(value, bindingLayout.location));
+        const entry = getBindGroupEntry(value, bindingLayout.location);
+        if (entry) {
+          entries.push(entry);
+        }
       }
-      bindingLayout = getShaderLayoutBinding(shaderLayout, `${bindingName}Sampler`);
-      if (bindingLayout) {
-        entries.push(getBindGroupEntry(value, bindingLayout.location, { sampler: true }));
+      if (value instanceof import_core8.Texture) {
+        bindingLayout = getShaderLayoutBinding(shaderLayout, `${bindingName}Sampler`, {
+          ignoreWarnings: true
+        });
+        if (bindingLayout) {
+          const entry = getBindGroupEntry(value, bindingLayout.location, { sampler: true });
+          if (entry) {
+            entries.push(entry);
+          }
+        }
       }
     }
     return entries;
@@ -727,7 +862,8 @@ var __exports__ = (() => {
         binding: index,
         resource: binding.handle
       };
-    } else if (binding instanceof import_core8.Texture) {
+    }
+    if (binding instanceof import_core8.Texture) {
       if (options?.sampler) {
         return {
           binding: index,
@@ -736,14 +872,21 @@ var __exports__ = (() => {
       }
       return {
         binding: index,
-        resource: binding.handle.createView({ label: "bind-group-auto-created" })
+        resource: binding.view.handle
       };
     }
-    throw new Error("invalid binding");
+    import_core8.log.warn(`invalid binding ${name}`, binding);
+    return null;
   }
+  var import_core8;
+  var init_get_bind_group = __esm({
+    "src/adapter/helpers/get-bind-group.ts"() {
+      "use strict";
+      import_core8 = __toESM(require_core(), 1);
+    }
+  });
 
   // src/adapter/helpers/get-vertex-buffer-layout.ts
-  var import_core9 = __toESM(require_core(), 1);
   function getWebGPUVertexFormat(format) {
     if (format.endsWith("-webgl")) {
       throw new Error(`WebGPU does not support vertex format ${format}`);
@@ -770,14 +913,14 @@ var __exports__ = (() => {
             offset: attributeMapping.byteOffset,
             shaderLocation: location
           });
-          byteStride += (0, import_core9.decodeVertexFormat)(format).byteLength;
+          byteStride += (0, import_core9.getVertexFormatInfo)(format).byteLength;
         }
       } else {
         const attributeLayout = findAttributeLayout(shaderLayout, mapping.name, usedAttributes);
         if (!attributeLayout) {
           continue;
         }
-        byteStride = (0, import_core9.decodeVertexFormat)(format).byteLength;
+        byteStride = (0, import_core9.getVertexFormatInfo)(format).byteLength;
         stepMode = attributeLayout.stepMode || (attributeLayout.name.startsWith("instance") ? "instance" : "vertex");
         vertexAttributes.push({
           format: getWebGPUVertexFormat(format),
@@ -795,7 +938,7 @@ var __exports__ = (() => {
     for (const attribute of shaderLayout.attributes) {
       if (!usedAttributes.has(attribute.name)) {
         vertexBufferLayouts.push({
-          arrayStride: (0, import_core9.decodeVertexFormat)("float32x3").byteLength,
+          arrayStride: (0, import_core9.getVertexFormatInfo)("float32x3").byteLength,
           stepMode: attribute.stepMode || (attribute.name.startsWith("instance") ? "instance" : "vertex"),
           attributes: [
             {
@@ -814,459 +957,254 @@ var __exports__ = (() => {
     });
     return vertexBufferLayouts;
   }
-  function findAttributeLayout(shaderLayout, name, attributeNames) {
-    const attribute = shaderLayout.attributes.find((attribute_) => attribute_.name === name);
+  function findAttributeLayout(shaderLayout, name2, attributeNames) {
+    const attribute = shaderLayout.attributes.find((attribute_) => attribute_.name === name2);
     if (!attribute) {
-      import_core9.log.warn(`Unknown attribute ${name}`)();
+      import_core9.log.warn(`Supplied attribute not present in shader layout: ${name2}`)();
       return null;
     }
     if (attributeNames) {
-      if (attributeNames.has(name)) {
-        throw new Error(`Found multiple entries for attribute: ${name}`);
+      if (attributeNames.has(name2)) {
+        throw new Error(`Found multiple entries for attribute: ${name2}`);
       }
-      attributeNames.add(name);
+      attributeNames.add(name2);
     }
     return attribute;
   }
+  var import_core9;
+  var init_get_vertex_buffer_layout = __esm({
+    "src/adapter/helpers/get-vertex-buffer-layout.ts"() {
+      "use strict";
+      import_core9 = __toESM(require_core(), 1);
+    }
+  });
 
   // src/adapter/resources/webgpu-render-pipeline.ts
-  var WebGPURenderPipeline = class extends import_core10.RenderPipeline {
-    device;
-    handle;
-    vs;
-    fs = null;
-    /** For internal use to create BindGroups */
-    _bindings;
-    _bindGroupLayout = null;
-    _bindGroup = null;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      this.handle = this.props.handle;
-      if (!this.handle) {
-        const descriptor = this._getRenderPipelineDescriptor();
-        import_core10.log.groupCollapsed(1, `new WebGPURenderPipeline(${this.id})`)();
-        import_core10.log.probe(1, JSON.stringify(descriptor, null, 2))();
-        import_core10.log.groupEnd(1)();
-        this.device.handle.pushErrorScope("validation");
-        this.handle = this.device.handle.createRenderPipeline(descriptor);
-        this.device.handle.popErrorScope().then((error) => {
-          if (error) {
-            import_core10.log.error(`${this} creation failed:
-"${error.message}"`, this, this.props.vs?.source)();
+  var import_core10, WebGPURenderPipeline;
+  var init_webgpu_render_pipeline = __esm({
+    "src/adapter/resources/webgpu-render-pipeline.ts"() {
+      "use strict";
+      import_core10 = __toESM(require_core(), 1);
+      init_webgpu_parameters();
+      init_convert_texture_format();
+      init_get_bind_group();
+      init_get_vertex_buffer_layout();
+      WebGPURenderPipeline = class extends import_core10.RenderPipeline {
+        device;
+        handle;
+        vs;
+        fs = null;
+        /** For internal use to create BindGroups */
+        _bindings;
+        _bindGroupLayout = null;
+        _bindGroup = null;
+        get [Symbol.toStringTag]() {
+          return "WebGPURenderPipeline";
+        }
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          this.handle = this.props.handle;
+          if (!this.handle) {
+            const descriptor = this._getRenderPipelineDescriptor();
+            import_core10.log.groupCollapsed(1, `new WebGPURenderPipeline(${this.id})`)();
+            import_core10.log.probe(1, JSON.stringify(descriptor, null, 2))();
+            import_core10.log.groupEnd(1)();
+            this.device.pushErrorScope("validation");
+            this.handle = this.device.handle.createRenderPipeline(descriptor);
+            this.device.popErrorScope((error) => {
+              this.device.reportError(new Error(`${this} creation failed:
+"${error.message}"`), this)();
+              this.device.debug();
+            });
           }
-        });
-      }
-      this.handle.label = this.props.id;
-      this.vs = props.vs;
-      this.fs = props.fs;
-      this._bindings = { ...this.props.bindings };
-    }
-    destroy() {
-      this.handle = null;
-    }
-    /**
-     * @todo Use renderpass.setBindings() ?
-     * @todo Do we want to expose BindGroups in the API and remove this?
-     */
-    setBindings(bindings) {
-      Object.assign(this._bindings, bindings);
-    }
-    /** @todo - should this be moved to renderpass? */
-    draw(options) {
-      const webgpuRenderPass = options.renderPass;
-      this.device.handle.pushErrorScope("validation");
-      webgpuRenderPass.handle.setPipeline(this.handle);
-      this.device.handle.popErrorScope().then((error) => {
-        if (error) {
-          import_core10.log.error(`${this} setPipeline failed:
-"${error.message}"`, this)();
+          this.handle.label = this.props.id;
+          this.vs = props.vs;
+          this.fs = props.fs;
+          this._bindings = { ...this.props.bindings };
         }
-      });
-      const bindGroup = this._getBindGroup();
-      if (bindGroup) {
-        webgpuRenderPass.handle.setBindGroup(0, bindGroup);
-      }
-      options.vertexArray.bindBeforeRender(options.renderPass);
-      if (options.indexCount) {
-        webgpuRenderPass.handle.drawIndexed(
-          options.indexCount,
-          options.instanceCount,
-          options.firstIndex,
-          options.baseVertex,
-          options.firstInstance
-        );
-      } else {
-        webgpuRenderPass.handle.draw(
-          options.vertexCount || 0,
-          options.instanceCount || 1,
-          // If 0, nothing will be drawn
-          options.firstInstance
-        );
-      }
-      options.vertexArray.unbindAfterRender(options.renderPass);
-      return true;
-    }
-    /** Return a bind group created by setBindings */
-    _getBindGroup() {
-      if (this.shaderLayout.bindings.length === 0) {
-        return null;
-      }
-      this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
-      this._bindGroup = this._bindGroup || getBindGroup(this.device.handle, this._bindGroupLayout, this.shaderLayout, this._bindings);
-      return this._bindGroup;
-    }
-    /**
-     * Populate the complex WebGPU GPURenderPipelineDescriptor
-     */
-    _getRenderPipelineDescriptor() {
-      const vertex = {
-        module: this.props.vs.handle,
-        entryPoint: this.props.vertexEntryPoint || "main",
-        buffers: getVertexBufferLayout(this.shaderLayout, this.props.bufferLayout)
-      };
-      const fragment = {
-        module: this.props.fs.handle,
-        entryPoint: this.props.fragmentEntryPoint || "main",
-        targets: [
-          {
-            // TODO exclamation mark hack!
-            format: getWebGPUTextureFormat(this.device.getCanvasContext().format)
+        destroy() {
+          this.handle = null;
+        }
+        /**
+         * @todo Use renderpass.setBindings() ?
+         * @todo Do we want to expose BindGroups in the API and remove this?
+         */
+        setBindings(bindings) {
+          for (const [name2, binding] of Object.entries(bindings)) {
+            if (this._bindings[name2] !== binding) {
+              this._bindGroup = null;
+            }
           }
-        ]
-      };
-      const layout = this.device.createPipelineLayout({
-        shaderLayout: this.shaderLayout
-      });
-      const descriptor = {
-        vertex,
-        fragment,
-        primitive: {
-          topology: this.props.topology
-        },
-        layout: layout.handle
+          Object.assign(this._bindings, bindings);
+        }
+        /** @todo - should this be moved to renderpass? */
+        draw(options) {
+          const webgpuRenderPass = options.renderPass;
+          this.device.pushErrorScope("validation");
+          webgpuRenderPass.handle.setPipeline(this.handle);
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this} setPipeline failed:
+"${error.message}"`), this)();
+            this.device.debug();
+          });
+          const bindGroup = this._getBindGroup();
+          if (bindGroup) {
+            webgpuRenderPass.handle.setBindGroup(0, bindGroup);
+          }
+          options.vertexArray.bindBeforeRender(options.renderPass);
+          if (options.indexCount) {
+            webgpuRenderPass.handle.drawIndexed(
+              options.indexCount,
+              options.instanceCount,
+              options.firstIndex,
+              options.baseVertex,
+              options.firstInstance
+            );
+          } else {
+            webgpuRenderPass.handle.draw(
+              options.vertexCount || 0,
+              options.instanceCount || 1,
+              // If 0, nothing will be drawn
+              options.firstInstance
+            );
+          }
+          options.vertexArray.unbindAfterRender(options.renderPass);
+          return true;
+        }
+        /** Return a bind group created by setBindings */
+        _getBindGroup() {
+          if (this.shaderLayout.bindings.length === 0) {
+            return null;
+          }
+          this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
+          this._bindGroup = this._bindGroup || getBindGroup(this.device.handle, this._bindGroupLayout, this.shaderLayout, this._bindings);
+          return this._bindGroup;
+        }
+        /**
+         * Populate the complex WebGPU GPURenderPipelineDescriptor
+         */
+        _getRenderPipelineDescriptor() {
+          const vertex = {
+            module: this.props.vs.handle,
+            entryPoint: this.props.vertexEntryPoint || "main",
+            buffers: getVertexBufferLayout(this.shaderLayout, this.props.bufferLayout)
+          };
+          const targets = [];
+          if (this.props.colorAttachmentFormats) {
+            for (const format of this.props.colorAttachmentFormats) {
+              targets.push(format ? { format: getWebGPUTextureFormat(format) } : null);
+            }
+          } else {
+            targets.push({ format: getWebGPUTextureFormat(this.device.preferredColorFormat) });
+          }
+          const fragment = {
+            module: this.props.fs.handle,
+            entryPoint: this.props.fragmentEntryPoint || "main",
+            targets
+          };
+          const layout = this.device.createPipelineLayout({
+            shaderLayout: this.shaderLayout
+          });
+          const descriptor = {
+            vertex,
+            fragment,
+            primitive: {
+              topology: this.props.topology
+            },
+            layout: layout.handle
+          };
+          const depthFormat = this.props.depthStencilAttachmentFormat || this.device.preferredDepthFormat;
+          if (this.props.parameters.depthWriteEnabled) {
+            descriptor.depthStencil = {
+              format: getWebGPUTextureFormat(depthFormat)
+            };
+          }
+          applyParametersToRenderPipelineDescriptor(descriptor, this.props.parameters);
+          return descriptor;
+        }
       };
-      if (this.props.parameters.depthWriteEnabled && this.props.parameters.depthCompare) {
-        descriptor.depthStencil = {
-          format: "depth24plus",
-          depthWriteEnabled: this.props.parameters.depthWriteEnabled,
-          depthCompare: this.props.parameters.depthCompare
-        };
-      }
-      applyParametersToRenderPipelineDescriptor(descriptor, this.props.parameters);
-      return descriptor;
     }
-  };
+  });
 
   // src/adapter/resources/webgpu-framebuffer.ts
-  var import_core11 = __toESM(require_core(), 1);
-  var WebGPUFramebuffer = class extends import_core11.Framebuffer {
-    device;
-    colorAttachments = [];
-    depthStencilAttachment = null;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      this.autoCreateAttachmentTextures();
-    }
-    updateAttachments() {
-    }
-  };
-
-  // src/adapter/resources/webgpu-compute-pipeline.ts
-  var import_core12 = __toESM(require_core(), 1);
-  var WebGPUComputePipeline = class extends import_core12.ComputePipeline {
-    device;
-    handle;
-    /** For internal use to create BindGroups */
-    _bindGroupLayout = null;
-    _bindGroup = null;
-    /** For internal use to create BindGroups */
-    _bindings = {};
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      const webgpuShader = this.props.shader;
-      this.handle = this.props.handle || this.device.handle.createComputePipeline({
-        label: this.props.id,
-        compute: {
-          module: webgpuShader.handle,
-          entryPoint: this.props.entryPoint,
-          constants: this.props.constants
-        },
-        layout: "auto"
-      });
-    }
-    /**
-     * @todo Use renderpass.setBindings() ?
-     * @todo Do we want to expose BindGroups in the API and remove this?
-     */
-    setBindings(bindings) {
-      Object.assign(this._bindings, bindings);
-    }
-    /** Return a bind group created by setBindings */
-    _getBindGroup() {
-      this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
-      this._bindGroup = this._bindGroup || getBindGroup(this.device.handle, this._bindGroupLayout, this.shaderLayout, this._bindings);
-      return this._bindGroup;
-    }
-  };
-
-  // src/adapter/resources/webgpu-render-pass.ts
-  var import_core13 = __toESM(require_core(), 1);
-  var WebGPURenderPass = class extends import_core13.RenderPass {
-    device;
-    handle;
-    /** Active pipeline */
-    pipeline = null;
-    constructor(device, props = {}) {
-      super(device, props);
-      this.device = device;
-      const framebuffer = props.framebuffer || device.getCanvasContext().getCurrentFramebuffer();
-      const renderPassDescriptor = this.getRenderPassDescriptor(framebuffer);
-      const webgpuQuerySet = props.timestampQuerySet;
-      if (webgpuQuerySet) {
-        renderPassDescriptor.occlusionQuerySet = webgpuQuerySet.handle;
-      }
-      if (device.features.has("timestamp-query")) {
-        const webgpuTSQuerySet = props.timestampQuerySet;
-        renderPassDescriptor.timestampWrites = webgpuTSQuerySet ? {
-          querySet: webgpuTSQuerySet.handle,
-          beginningOfPassWriteIndex: props.beginTimestampIndex,
-          endOfPassWriteIndex: props.endTimestampIndex
-        } : void 0;
-      }
-      if (!device.commandEncoder) {
-        throw new Error("commandEncoder not available");
-      }
-      this.device.handle.pushErrorScope("validation");
-      this.handle = this.props.handle || device.commandEncoder.beginRenderPass(renderPassDescriptor);
-      this.device.handle.popErrorScope().then((error) => {
-        if (error) {
-          import_core13.log.error(`${this} creation failed:
-"${error.message}"`, this)();
-        }
-      });
-      this.handle.label = this.props.id;
-      import_core13.log.groupCollapsed(3, `new WebGPURenderPass(${this.id})`)();
-      import_core13.log.probe(3, JSON.stringify(renderPassDescriptor, null, 2))();
-      import_core13.log.groupEnd(3)();
-    }
-    destroy() {
-    }
-    end() {
-      this.handle.end();
-    }
-    setPipeline(pipeline) {
-      this.pipeline = pipeline;
-      this.handle.setPipeline(this.pipeline.handle);
-    }
-    /** Sets an array of bindings (uniform buffers, samplers, textures, ...) */
-    setBindings(bindings) {
-      this.pipeline?.setBindings(bindings);
-      const bindGroup = this.pipeline?._getBindGroup();
-      if (bindGroup) {
-        this.handle.setBindGroup(0, bindGroup);
-      }
-    }
-    setIndexBuffer(buffer, indexFormat, offset = 0, size) {
-      this.handle.setIndexBuffer(buffer.handle, indexFormat, offset, size);
-    }
-    setVertexBuffer(slot, buffer, offset = 0) {
-      this.handle.setVertexBuffer(slot, buffer.handle, offset);
-    }
-    draw(options) {
-      if (options.indexCount) {
-        this.handle.drawIndexed(
-          options.indexCount,
-          options.instanceCount,
-          options.firstIndex,
-          options.baseVertex,
-          options.firstInstance
-        );
-      } else {
-        this.handle.draw(
-          options.vertexCount || 0,
-          options.instanceCount || 1,
-          options.firstIndex,
-          options.firstInstance
-        );
-      }
-    }
-    drawIndirect() {
-    }
-    setParameters(parameters) {
-      const { blendConstant, stencilReference, scissorRect, viewport } = parameters;
-      if (blendConstant) {
-        this.handle.setBlendConstant(blendConstant);
-      }
-      if (stencilReference) {
-        this.handle.setStencilReference(stencilReference);
-      }
-      if (scissorRect) {
-        this.handle.setScissorRect(scissorRect[0], scissorRect[1], scissorRect[2], scissorRect[3]);
-      }
-      if (viewport) {
-        this.handle.setViewport(
-          viewport[0],
-          viewport[1],
-          viewport[2],
-          viewport[3],
-          viewport[4] ?? 0,
-          viewport[5] ?? 1
-        );
-      }
-    }
-    pushDebugGroup(groupLabel) {
-      this.handle.pushDebugGroup(groupLabel);
-    }
-    popDebugGroup() {
-      this.handle.popDebugGroup();
-    }
-    insertDebugMarker(markerLabel) {
-      this.handle.insertDebugMarker(markerLabel);
-    }
-    beginOcclusionQuery(queryIndex) {
-      this.handle.beginOcclusionQuery(queryIndex);
-    }
-    endOcclusionQuery() {
-      this.handle.endOcclusionQuery();
-    }
-    // executeBundles(bundles: Iterable<GPURenderBundle>): void;
-    // INTERNAL
-    /**
-     * Partial render pass descriptor. Used by WebGPURenderPass.
-     * @returns attachments fields of a renderpass descriptor.
-     */
-    getRenderPassDescriptor(framebuffer) {
-      const renderPassDescriptor = {
-        colorAttachments: []
-      };
-      renderPassDescriptor.colorAttachments = framebuffer.colorAttachments.map(
-        (colorAttachment, index) => ({
-          // clear values
-          loadOp: this.props.clearColor !== false ? "clear" : "load",
-          clearValue: convertColor(
-            this.props.clearColors?.[index] || this.props.clearColor || import_core13.RenderPass.defaultClearColor
-          ),
-          storeOp: this.props.discard ? "discard" : "store",
-          // ...colorAttachment,
-          view: colorAttachment.handle
-        })
-      );
-      if (framebuffer.depthStencilAttachment) {
-        renderPassDescriptor.depthStencilAttachment = {
-          view: framebuffer.depthStencilAttachment.handle
-        };
-        const { depthStencilAttachment } = renderPassDescriptor;
-        if (this.props.depthReadOnly) {
-          depthStencilAttachment.depthReadOnly = true;
-        }
-        if (this.props.clearDepth !== false) {
-          depthStencilAttachment.depthClearValue = this.props.clearDepth;
+  var import_core11, WebGPUFramebuffer;
+  var init_webgpu_framebuffer = __esm({
+    "src/adapter/resources/webgpu-framebuffer.ts"() {
+      "use strict";
+      import_core11 = __toESM(require_core(), 1);
+      WebGPUFramebuffer = class extends import_core11.Framebuffer {
+        device;
+        handle = null;
+        colorAttachments = [];
+        depthStencilAttachment = null;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          this.autoCreateAttachmentTextures();
         }
-        const hasDepthAspect = true;
-        if (hasDepthAspect) {
-          depthStencilAttachment.depthLoadOp = this.props.clearDepth !== false ? "clear" : "load";
-          depthStencilAttachment.depthStoreOp = "store";
+        updateAttachments() {
         }
-        const hasStencilAspect = false;
-        if (hasStencilAspect) {
-          depthStencilAttachment.stencilLoadOp = this.props.clearStencil !== false ? "clear" : "load";
-          depthStencilAttachment.stencilStoreOp = "store";
-        }
-      }
-      return renderPassDescriptor;
+      };
     }
-  };
-  function convertColor(color) {
-    return { r: color[0], g: color[1], b: color[2], a: color[3] };
-  }
+  });
 
-  // src/adapter/resources/webgpu-compute-pass.ts
-  var import_core14 = __toESM(require_core(), 1);
-  var WebGPUComputePass = class extends import_core14.ComputePass {
-    device;
-    handle;
-    _webgpuPipeline = null;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      let timestampWrites;
-      if (device.features.has("timestamp-query")) {
-        const webgpuQuerySet = props.timestampQuerySet;
-        if (webgpuQuerySet) {
-          timestampWrites = {
-            querySet: webgpuQuerySet.handle,
-            beginningOfPassWriteIndex: props.beginTimestampIndex,
-            endOfPassWriteIndex: props.endTimestampIndex
-          };
+  // src/adapter/resources/webgpu-compute-pipeline.ts
+  var import_core12, WebGPUComputePipeline;
+  var init_webgpu_compute_pipeline = __esm({
+    "src/adapter/resources/webgpu-compute-pipeline.ts"() {
+      "use strict";
+      import_core12 = __toESM(require_core(), 1);
+      init_get_bind_group();
+      WebGPUComputePipeline = class extends import_core12.ComputePipeline {
+        device;
+        handle;
+        /** For internal use to create BindGroups */
+        _bindGroupLayout = null;
+        _bindGroup = null;
+        /** For internal use to create BindGroups */
+        _bindings = {};
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          const webgpuShader = this.props.shader;
+          this.handle = this.props.handle || this.device.handle.createComputePipeline({
+            label: this.props.id,
+            compute: {
+              module: webgpuShader.handle,
+              entryPoint: this.props.entryPoint,
+              constants: this.props.constants
+            },
+            layout: "auto"
+          });
         }
-      }
-      this.handle = this.props.handle || device.commandEncoder?.beginComputePass({
-        label: this.props.id,
-        timestampWrites
-      });
-    }
-    /** @note no WebGPU destroy method, just gc */
-    destroy() {
-    }
-    end() {
-      this.handle.end();
-    }
-    setPipeline(pipeline) {
-      const wgpuPipeline = pipeline;
-      this.handle.setPipeline(wgpuPipeline.handle);
-      this._webgpuPipeline = wgpuPipeline;
-      this.setBindings([]);
-    }
-    /**
-     * Sets an array of bindings (uniform buffers, samplers, textures, ...)
-     * TODO - still some API confusion - does this method go here or on the pipeline?
-     */
-    setBindings(bindings) {
-      const bindGroup = this._webgpuPipeline._getBindGroup();
-      this.handle.setBindGroup(0, bindGroup);
-    }
-    /**
-     * Dispatch work to be performed with the current ComputePipeline.
-     * @param x X dimension of the grid of work groups to dispatch.
-     * @param y Y dimension of the grid of work groups to dispatch.
-     * @param z Z dimension of the grid of work groups to dispatch.
-     */
-    dispatch(x, y, z) {
-      this.handle.dispatchWorkgroups(x, y, z);
-    }
-    /**
-     * Dispatch work to be performed with the current ComputePipeline.
-     *
-     * Buffer must be a tightly packed block of three 32-bit unsigned integer values (12 bytes total), given in the same order as the arguments for dispatch()
-     * @param indirectBuffer
-     * @param indirectOffset offset in buffer to the beginning of the dispatch data.
-     */
-    dispatchIndirect(indirectBuffer, indirectByteOffset = 0) {
-      const webgpuBuffer = indirectBuffer;
-      this.handle.dispatchWorkgroupsIndirect(webgpuBuffer.handle, indirectByteOffset);
-    }
-    pushDebugGroup(groupLabel) {
-      this.handle.pushDebugGroup(groupLabel);
-    }
-    popDebugGroup() {
-      this.handle.popDebugGroup();
-    }
-    insertDebugMarker(markerLabel) {
-      this.handle.insertDebugMarker(markerLabel);
+        /**
+         * @todo Use renderpass.setBindings() ?
+         * @todo Do we want to expose BindGroups in the API and remove this?
+         */
+        setBindings(bindings) {
+          Object.assign(this._bindings, bindings);
+        }
+        /** Return a bind group created by setBindings */
+        _getBindGroup() {
+          this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
+          this._bindGroup = this._bindGroup || getBindGroup(this.device.handle, this._bindGroupLayout, this.shaderLayout, this._bindings);
+          return this._bindGroup;
+        }
+      };
     }
-  };
-
-  // src/adapter/resources/webgpu-vertex-array.ts
-  var import_core15 = __toESM(require_core(), 1);
+  });
 
   // ../../node_modules/@probe.gl/env/dist/lib/globals.js
-  var document_ = globalThis.document || {};
-  var process_ = globalThis.process || {};
-  var console_ = globalThis.console;
-  var navigator_ = globalThis.navigator || {};
+  var document_, process_, console_, navigator_;
+  var init_globals = __esm({
+    "../../node_modules/@probe.gl/env/dist/lib/globals.js"() {
+      document_ = globalThis.document || {};
+      process_ = globalThis.process || {};
+      console_ = globalThis.console;
+      navigator_ = globalThis.navigator || {};
+    }
+  });
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
@@ -1280,6 +1218,10 @@ var __exports__ = (() => {
     const userAgent = mockUserAgent || realUserAgent;
     return Boolean(userAgent && userAgent.indexOf("Electron") >= 0);
   }
+  var init_is_electron = __esm({
+    "../../node_modules/@probe.gl/env/dist/lib/is-electron.js"() {
+    }
+  });
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser() {
@@ -1289,6 +1231,11 @@ var __exports__ = (() => {
     );
     return !isNode || isElectron();
   }
+  var init_is_browser = __esm({
+    "../../node_modules/@probe.gl/env/dist/lib/is-browser.js"() {
+      init_is_electron();
+    }
+  });
 
   // ../../node_modules/@probe.gl/env/dist/lib/get-browser.js
   function getBrowser(mockUserAgent) {
@@ -1313,561 +1260,1013 @@ var __exports__ = (() => {
     }
     return "Unknown";
   }
-
-  // src/adapter/resources/webgpu-vertex-array.ts
-  var WebGPUVertexArray = class extends import_core15.VertexArray {
-    get [Symbol.toStringTag]() {
-      return "WebGPUVertexArray";
-    }
-    device;
-    /** Vertex Array is a helper class under WebGPU */
-    handle;
-    // Create a VertexArray
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-    }
-    destroy() {
-    }
-    /**
-     * Set an elements buffer, for indexed rendering.
-     * Must be a Buffer bound to buffer with usage bit Buffer.INDEX set.
-     */
-    setIndexBuffer(buffer) {
-      this.indexBuffer = buffer;
+  var init_get_browser = __esm({
+    "../../node_modules/@probe.gl/env/dist/lib/get-browser.js"() {
+      init_is_browser();
+      init_is_electron();
+      init_globals();
     }
-    /** Set a bufferSlot in vertex attributes array to a buffer, enables the bufferSlot, sets divisor */
-    setBuffer(bufferSlot, buffer) {
-      this.attributes[bufferSlot] = buffer;
+  });
+
+  // ../../node_modules/@probe.gl/env/dist/index.js
+  var init_dist = __esm({
+    "../../node_modules/@probe.gl/env/dist/index.js"() {
+      init_get_browser();
     }
-    bindBeforeRender(renderPass, firstIndex, indexCount) {
-      const webgpuRenderPass = renderPass;
-      const webgpuIndexBuffer = this.indexBuffer;
-      if (webgpuIndexBuffer?.handle) {
-        import_core15.log.info(
-          3,
-          "setting index buffer",
-          webgpuIndexBuffer?.handle,
-          webgpuIndexBuffer?.indexType
-        )();
-        webgpuRenderPass.handle.setIndexBuffer(
-          webgpuIndexBuffer?.handle,
-          // @ts-expect-error TODO - we must enforce type
-          webgpuIndexBuffer?.indexType
-        );
-      }
-      for (let location = 0; location < this.maxVertexAttributes; location++) {
-        const webgpuBuffer = this.attributes[location];
-        if (webgpuBuffer?.handle) {
-          import_core15.log.info(3, `setting vertex buffer ${location}`, webgpuBuffer?.handle)();
-          webgpuRenderPass.handle.setVertexBuffer(location, webgpuBuffer?.handle);
+  });
+
+  // src/adapter/resources/webgpu-vertex-array.ts
+  var import_core13, WebGPUVertexArray;
+  var init_webgpu_vertex_array = __esm({
+    "src/adapter/resources/webgpu-vertex-array.ts"() {
+      "use strict";
+      import_core13 = __toESM(require_core(), 1);
+      init_dist();
+      WebGPUVertexArray = class extends import_core13.VertexArray {
+        get [Symbol.toStringTag]() {
+          return "WebGPUVertexArray";
         }
-      }
-    }
-    unbindAfterRender(renderPass) {
-    }
-    // DEPRECATED METHODS
-    /**
-     * @deprecated is this even an issue for WebGPU?
-     * Attribute 0 can not be disable on most desktop OpenGL based browsers
-     */
-    static isConstantAttributeZeroSupported(device) {
-      return getBrowser() === "Chrome";
+        device;
+        /** Vertex Array is just a helper class under WebGPU */
+        handle = null;
+        // Create a VertexArray
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+        }
+        destroy() {
+        }
+        /**
+         * Set an elements buffer, for indexed rendering.
+         * Must be a Buffer bound to buffer with usage bit Buffer.INDEX set.
+         */
+        setIndexBuffer(buffer) {
+          this.indexBuffer = buffer;
+        }
+        /** Set a bufferSlot in vertex attributes array to a buffer, enables the bufferSlot, sets divisor */
+        setBuffer(bufferSlot, buffer) {
+          this.attributes[bufferSlot] = buffer;
+        }
+        bindBeforeRender(renderPass, firstIndex, indexCount) {
+          const webgpuRenderPass = renderPass;
+          const webgpuIndexBuffer = this.indexBuffer;
+          if (webgpuIndexBuffer?.handle) {
+            import_core13.log.info(
+              3,
+              "setting index buffer",
+              webgpuIndexBuffer?.handle,
+              webgpuIndexBuffer?.indexType
+            )();
+            webgpuRenderPass.handle.setIndexBuffer(
+              webgpuIndexBuffer?.handle,
+              // @ts-expect-error TODO - we must enforce type
+              webgpuIndexBuffer?.indexType
+            );
+          }
+          for (let location = 0; location < this.maxVertexAttributes; location++) {
+            const webgpuBuffer = this.attributes[location];
+            if (webgpuBuffer?.handle) {
+              import_core13.log.info(3, `setting vertex buffer ${location}`, webgpuBuffer?.handle)();
+              webgpuRenderPass.handle.setVertexBuffer(location, webgpuBuffer?.handle);
+            }
+          }
+        }
+        unbindAfterRender(renderPass) {
+        }
+        // DEPRECATED METHODS
+        /**
+         * @deprecated is this even an issue for WebGPU?
+         * Attribute 0 can not be disable on most desktop OpenGL based browsers
+         */
+        static isConstantAttributeZeroSupported(device) {
+          return getBrowser() === "Chrome";
+        }
+      };
     }
-  };
+  });
 
   // src/adapter/webgpu-canvas-context.ts
-  var import_core16 = __toESM(require_core(), 1);
-  var WebGPUCanvasContext = class extends import_core16.CanvasContext {
-    device;
-    gpuCanvasContext;
-    /** Format of returned textures: "bgra8unorm", "rgba8unorm", "rgba16float". */
-    format = navigator.gpu.getPreferredCanvasFormat();
-    /** Default stencil format for depth textures */
-    depthStencilFormat = "depth24plus";
-    depthStencilAttachment = null;
-    get [Symbol.toStringTag]() {
-      return "WebGPUCanvasContext";
-    }
-    constructor(device, adapter, props) {
-      super(props);
-      this.device = device;
-      this.width = -1;
-      this.height = -1;
-      this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
-      this.gpuCanvasContext = this.canvas.getContext("webgpu");
-      this.format = "bgra8unorm";
-    }
-    /** Destroy any textures produced while configured and remove the context configuration. */
-    destroy() {
-      this.gpuCanvasContext.unconfigure();
-    }
-    /** Update framebuffer with properly resized "swap chain" texture views */
-    getCurrentFramebuffer() {
-      this.update();
-      const currentColorAttachment = this.getCurrentTexture();
-      this.width = currentColorAttachment.width;
-      this.height = currentColorAttachment.height;
-      this._createDepthStencilAttachment();
-      return new WebGPUFramebuffer(this.device, {
-        colorAttachments: [currentColorAttachment],
-        depthStencilAttachment: this.depthStencilAttachment
-      });
+  var import_core14, WebGPUCanvasContext;
+  var init_webgpu_canvas_context = __esm({
+    "src/adapter/webgpu-canvas-context.ts"() {
+      "use strict";
+      import_core14 = __toESM(require_core(), 1);
+      init_webgpu_framebuffer();
+      WebGPUCanvasContext = class extends import_core14.CanvasContext {
+        device;
+        handle;
+        depthStencilAttachment = null;
+        get [Symbol.toStringTag]() {
+          return "WebGPUCanvasContext";
+        }
+        constructor(device, adapter, props) {
+          super(props);
+          const context = this.canvas.getContext("webgpu");
+          if (!context) {
+            throw new Error(`${this}: Failed to create WebGPU canvas context`);
+          }
+          this.device = device;
+          this.handle = context;
+          this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
+          this._updateDevice();
+        }
+        /** Destroy any textures produced while configured and remove the context configuration. */
+        destroy() {
+          this.handle.unconfigure();
+          super.destroy();
+        }
+        /** Update framebuffer with properly resized "swap chain" texture views */
+        getCurrentFramebuffer(options = {
+          depthStencilFormat: "depth24plus"
+        }) {
+          const currentColorAttachment = this.getCurrentTexture();
+          if (currentColorAttachment.width !== this.drawingBufferWidth || currentColorAttachment.height !== this.drawingBufferHeight) {
+            const [oldWidth, oldHeight] = this.getDrawingBufferSize();
+            this.drawingBufferWidth = currentColorAttachment.width;
+            this.drawingBufferHeight = currentColorAttachment.height;
+            import_core14.log.log(
+              1,
+              `${this}: Resized to compensate for initial canvas size mismatch ${oldWidth}x${oldHeight} => ${this.drawingBufferWidth}x${this.drawingBufferHeight}px`
+            )();
+          }
+          if (options?.depthStencilFormat) {
+            this._createDepthStencilAttachment(options?.depthStencilFormat);
+          }
+          return new WebGPUFramebuffer(this.device, {
+            colorAttachments: [currentColorAttachment],
+            depthStencilAttachment: this.depthStencilAttachment
+          });
+        }
+        // IMPLEMENTATION OF ABSTRACT METHODS
+        _updateDevice() {
+          if (this.depthStencilAttachment) {
+            this.depthStencilAttachment.destroy();
+            this.depthStencilAttachment = null;
+          }
+          this.handle.configure({
+            device: this.device.handle,
+            format: this.device.preferredColorFormat,
+            // Can be used to define e.g. -srgb views
+            // viewFormats: [...]
+            colorSpace: this.props.colorSpace,
+            alphaMode: this.props.alphaMode
+          });
+        }
+        /** Wrap the current canvas context texture in a luma.gl texture */
+        getCurrentTexture() {
+          const handle = this.handle.getCurrentTexture();
+          return this.device.createTexture({
+            id: `${this.id}#color-texture`,
+            handle,
+            format: this.device.preferredColorFormat,
+            width: handle.width,
+            height: handle.height
+          });
+        }
+        /** We build render targets on demand (i.e. not when size changes but when about to render) */
+        _createDepthStencilAttachment(depthStencilFormat) {
+          if (!this.depthStencilAttachment) {
+            this.depthStencilAttachment = this.device.createTexture({
+              id: `${this.id}#depth-stencil-texture`,
+              usage: import_core14.Texture.RENDER_ATTACHMENT,
+              format: depthStencilFormat,
+              width: this.drawingBufferWidth,
+              height: this.drawingBufferHeight
+            });
+          }
+          return this.depthStencilAttachment;
+        }
+      };
     }
-    /** Resizes and updates render targets if necessary */
-    update() {
-      const oldWidth = this.width;
-      const oldHeight = this.height;
-      const [newWidth, newHeight] = this.getPixelSize();
-      const sizeChanged = newWidth !== oldWidth || newHeight !== oldHeight;
-      if (sizeChanged) {
-        this.width = newWidth;
-        this.height = newHeight;
-        if (this.depthStencilAttachment) {
-          this.depthStencilAttachment.destroy();
-          this.depthStencilAttachment = null;
-        }
-        this.gpuCanvasContext.configure({
-          device: this.device.handle,
-          format: getWebGPUTextureFormat(this.format),
-          // Can be used to define e.g. -srgb views
-          // viewFormats: [...]
-          colorSpace: this.props.colorSpace,
-          alphaMode: this.props.alphaMode
-        });
-        import_core16.log.log(1, `${this} Resized ${oldWidth}x${oldHeight} => ${newWidth}x${newHeight}px`)();
-      }
+  });
+
+  // src/adapter/resources/webgpu-command-buffer.ts
+  var import_core15, WebGPUCommandBuffer;
+  var init_webgpu_command_buffer = __esm({
+    "src/adapter/resources/webgpu-command-buffer.ts"() {
+      "use strict";
+      import_core15 = __toESM(require_core(), 1);
+      WebGPUCommandBuffer = class extends import_core15.CommandBuffer {
+        device;
+        handle;
+        constructor(commandEncoder, props) {
+          super(commandEncoder.device, {});
+          this.device = commandEncoder.device;
+          this.handle = this.props.handle || commandEncoder.handle.finish({
+            label: props?.id || "unnamed-command-buffer"
+          });
+        }
+      };
     }
-    resize(options) {
-      this.update();
-      if (!this.device.handle)
-        return;
-      if (this.canvas) {
-        const devicePixelRatio = this.getDevicePixelRatio(options?.useDevicePixels);
-        this.setDevicePixelRatio(devicePixelRatio, options);
-        return;
-      }
+  });
+
+  // src/adapter/resources/webgpu-render-pass.ts
+  function convertColor(color) {
+    return { r: color[0], g: color[1], b: color[2], a: color[3] };
+  }
+  var import_core16, WebGPURenderPass;
+  var init_webgpu_render_pass = __esm({
+    "src/adapter/resources/webgpu-render-pass.ts"() {
+      "use strict";
+      import_core16 = __toESM(require_core(), 1);
+      WebGPURenderPass = class extends import_core16.RenderPass {
+        device;
+        handle;
+        /** Active pipeline */
+        pipeline = null;
+        constructor(device, props = {}) {
+          super(device, props);
+          this.device = device;
+          const framebuffer = props.framebuffer || device.getCanvasContext().getCurrentFramebuffer();
+          const renderPassDescriptor = this.getRenderPassDescriptor(framebuffer);
+          const webgpuQuerySet = props.timestampQuerySet;
+          if (webgpuQuerySet) {
+            renderPassDescriptor.occlusionQuerySet = webgpuQuerySet.handle;
+          }
+          if (device.features.has("timestamp-query")) {
+            const webgpuTSQuerySet = props.timestampQuerySet;
+            renderPassDescriptor.timestampWrites = webgpuTSQuerySet ? {
+              querySet: webgpuTSQuerySet.handle,
+              beginningOfPassWriteIndex: props.beginTimestampIndex,
+              endOfPassWriteIndex: props.endTimestampIndex
+            } : void 0;
+          }
+          if (!device.commandEncoder) {
+            throw new Error("commandEncoder not available");
+          }
+          this.device.pushErrorScope("validation");
+          this.handle = this.props.handle || device.commandEncoder.handle.beginRenderPass(renderPassDescriptor);
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this} creation failed:
+"${error.message}"`), this)();
+            this.device.debug();
+          });
+          this.handle.label = this.props.id;
+          import_core16.log.groupCollapsed(3, `new WebGPURenderPass(${this.id})`)();
+          import_core16.log.probe(3, JSON.stringify(renderPassDescriptor, null, 2))();
+          import_core16.log.groupEnd(3)();
+        }
+        destroy() {
+        }
+        end() {
+          this.handle.end();
+        }
+        setPipeline(pipeline) {
+          this.pipeline = pipeline;
+          this.device.pushErrorScope("validation");
+          this.handle.setPipeline(this.pipeline.handle);
+          this.device.popErrorScope((error) => {
+            this.device.reportError(new Error(`${this} setPipeline failed:
+"${error.message}"`), this)();
+            this.device.debug();
+          });
+        }
+        /** Sets an array of bindings (uniform buffers, samplers, textures, ...) */
+        setBindings(bindings) {
+          this.pipeline?.setBindings(bindings);
+          const bindGroup = this.pipeline?._getBindGroup();
+          if (bindGroup) {
+            this.handle.setBindGroup(0, bindGroup);
+          }
+        }
+        setIndexBuffer(buffer, indexFormat, offset = 0, size) {
+          this.handle.setIndexBuffer(buffer.handle, indexFormat, offset, size);
+        }
+        setVertexBuffer(slot, buffer, offset = 0) {
+          this.handle.setVertexBuffer(slot, buffer.handle, offset);
+        }
+        draw(options) {
+          if (options.indexCount) {
+            this.handle.drawIndexed(
+              options.indexCount,
+              options.instanceCount,
+              options.firstIndex,
+              options.baseVertex,
+              options.firstInstance
+            );
+          } else {
+            this.handle.draw(
+              options.vertexCount || 0,
+              options.instanceCount || 1,
+              options.firstIndex,
+              options.firstInstance
+            );
+          }
+        }
+        drawIndirect() {
+        }
+        setParameters(parameters) {
+          const { blendConstant, stencilReference, scissorRect, viewport } = parameters;
+          if (blendConstant) {
+            this.handle.setBlendConstant(blendConstant);
+          }
+          if (stencilReference) {
+            this.handle.setStencilReference(stencilReference);
+          }
+          if (scissorRect) {
+            this.handle.setScissorRect(scissorRect[0], scissorRect[1], scissorRect[2], scissorRect[3]);
+          }
+          if (viewport) {
+            this.handle.setViewport(
+              viewport[0],
+              viewport[1],
+              viewport[2],
+              viewport[3],
+              viewport[4] ?? 0,
+              viewport[5] ?? 1
+            );
+          }
+        }
+        pushDebugGroup(groupLabel) {
+          this.handle.pushDebugGroup(groupLabel);
+        }
+        popDebugGroup() {
+          this.handle.popDebugGroup();
+        }
+        insertDebugMarker(markerLabel) {
+          this.handle.insertDebugMarker(markerLabel);
+        }
+        beginOcclusionQuery(queryIndex) {
+          this.handle.beginOcclusionQuery(queryIndex);
+        }
+        endOcclusionQuery() {
+          this.handle.endOcclusionQuery();
+        }
+        // executeBundles(bundles: Iterable<GPURenderBundle>): void;
+        // INTERNAL
+        /**
+         * Partial render pass descriptor. Used by WebGPURenderPass.
+         * @returns attachments fields of a renderpass descriptor.
+         */
+        getRenderPassDescriptor(framebuffer) {
+          const renderPassDescriptor = {
+            colorAttachments: []
+          };
+          renderPassDescriptor.colorAttachments = framebuffer.colorAttachments.map(
+            (colorAttachment, index) => ({
+              // clear values
+              loadOp: this.props.clearColor !== false ? "clear" : "load",
+              clearValue: convertColor(
+                this.props.clearColors?.[index] || this.props.clearColor || import_core16.RenderPass.defaultClearColor
+              ),
+              storeOp: this.props.discard ? "discard" : "store",
+              // ...colorAttachment,
+              view: colorAttachment.handle
+            })
+          );
+          if (framebuffer.depthStencilAttachment) {
+            renderPassDescriptor.depthStencilAttachment = {
+              view: framebuffer.depthStencilAttachment.handle
+            };
+            const { depthStencilAttachment } = renderPassDescriptor;
+            if (this.props.depthReadOnly) {
+              depthStencilAttachment.depthReadOnly = true;
+            }
+            if (this.props.clearDepth !== false) {
+              depthStencilAttachment.depthClearValue = this.props.clearDepth;
+            }
+            const hasDepthAspect = true;
+            if (hasDepthAspect) {
+              depthStencilAttachment.depthLoadOp = this.props.clearDepth !== false ? "clear" : "load";
+              depthStencilAttachment.depthStoreOp = "store";
+            }
+            const hasStencilAspect = false;
+            if (hasStencilAspect) {
+              depthStencilAttachment.stencilLoadOp = this.props.clearStencil !== false ? "clear" : "load";
+              depthStencilAttachment.stencilStoreOp = "store";
+            }
+          }
+          return renderPassDescriptor;
+        }
+      };
     }
-    /** Wrap the current canvas context texture in a luma.gl texture */
-    getCurrentTexture() {
-      return this.device.createTexture({
-        id: `${this.id}#color-texture`,
-        handle: this.gpuCanvasContext.getCurrentTexture(),
-        format: this.format
-      });
+  });
+
+  // src/adapter/resources/webgpu-compute-pass.ts
+  var import_core17, WebGPUComputePass;
+  var init_webgpu_compute_pass = __esm({
+    "src/adapter/resources/webgpu-compute-pass.ts"() {
+      "use strict";
+      import_core17 = __toESM(require_core(), 1);
+      WebGPUComputePass = class extends import_core17.ComputePass {
+        device;
+        handle;
+        _webgpuPipeline = null;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          let timestampWrites;
+          if (device.features.has("timestamp-query")) {
+            const webgpuQuerySet = props.timestampQuerySet;
+            if (webgpuQuerySet) {
+              timestampWrites = {
+                querySet: webgpuQuerySet.handle,
+                beginningOfPassWriteIndex: props.beginTimestampIndex,
+                endOfPassWriteIndex: props.endTimestampIndex
+              };
+            }
+          }
+          this.handle = this.props.handle || device.commandEncoder.handle.beginComputePass({
+            label: this.props.id,
+            timestampWrites
+          });
+        }
+        /** @note no WebGPU destroy method, just gc */
+        destroy() {
+        }
+        end() {
+          this.handle.end();
+        }
+        setPipeline(pipeline) {
+          const wgpuPipeline = pipeline;
+          this.handle.setPipeline(wgpuPipeline.handle);
+          this._webgpuPipeline = wgpuPipeline;
+          this.setBindings([]);
+        }
+        /**
+         * Sets an array of bindings (uniform buffers, samplers, textures, ...)
+         * TODO - still some API confusion - does this method go here or on the pipeline?
+         */
+        setBindings(bindings) {
+          const bindGroup = this._webgpuPipeline._getBindGroup();
+          this.handle.setBindGroup(0, bindGroup);
+        }
+        /**
+         * Dispatch work to be performed with the current ComputePipeline.
+         * @param x X dimension of the grid of work groups to dispatch.
+         * @param y Y dimension of the grid of work groups to dispatch.
+         * @param z Z dimension of the grid of work groups to dispatch.
+         */
+        dispatch(x, y, z) {
+          this.handle.dispatchWorkgroups(x, y, z);
+        }
+        /**
+         * Dispatch work to be performed with the current ComputePipeline.
+         *
+         * Buffer must be a tightly packed block of three 32-bit unsigned integer values (12 bytes total), given in the same order as the arguments for dispatch()
+         * @param indirectBuffer
+         * @param indirectOffset offset in buffer to the beginning of the dispatch data.
+         */
+        dispatchIndirect(indirectBuffer, indirectByteOffset = 0) {
+          const webgpuBuffer = indirectBuffer;
+          this.handle.dispatchWorkgroupsIndirect(webgpuBuffer.handle, indirectByteOffset);
+        }
+        pushDebugGroup(groupLabel) {
+          this.handle.pushDebugGroup(groupLabel);
+        }
+        popDebugGroup() {
+          this.handle.popDebugGroup();
+        }
+        insertDebugMarker(markerLabel) {
+          this.handle.insertDebugMarker(markerLabel);
+        }
+      };
     }
-    /** We build render targets on demand (i.e. not when size changes but when about to render) */
-    _createDepthStencilAttachment() {
-      if (!this.depthStencilAttachment) {
-        this.depthStencilAttachment = this.device.createTexture({
-          id: `${this.id}#depth-stencil-texture`,
-          format: this.depthStencilFormat,
-          width: this.width,
-          height: this.height,
-          usage: GPUTextureUsage.RENDER_ATTACHMENT
-        });
-      }
-      return this.depthStencilAttachment;
+  });
+
+  // src/adapter/resources/webgpu-command-encoder.ts
+  var import_core18, WebGPUCommandEncoder;
+  var init_webgpu_command_encoder = __esm({
+    "src/adapter/resources/webgpu-command-encoder.ts"() {
+      "use strict";
+      import_core18 = __toESM(require_core(), 1);
+      init_webgpu_command_buffer();
+      init_webgpu_render_pass();
+      init_webgpu_compute_pass();
+      WebGPUCommandEncoder = class extends import_core18.CommandEncoder {
+        device;
+        handle;
+        constructor(device, props = {}) {
+          super(device, props);
+          this.device = device;
+          this.handle = props.handle || this.device.handle.createCommandEncoder({
+            label: this.props.id
+            // TODO was this removed in standard?
+            // measureExecutionTime: this.props.measureExecutionTime
+          });
+          this.handle.label = this.props.id;
+        }
+        destroy() {
+        }
+        finish(props) {
+          this.device.pushErrorScope("validation");
+          const commandBuffer = new WebGPUCommandBuffer(this, {
+            id: props?.id || "unnamed-command-buffer"
+          });
+          this.device.popErrorScope((error) => {
+            const message = `${this} command encoding: ${error.message}. Maybe add depthWriteEnabled to your Model?`;
+            this.device.reportError(new Error(message), this)();
+            this.device.debug();
+          });
+          return commandBuffer;
+        }
+        /**
+         * Allows a render pass to begin against a canvas context
+         * @todo need to support a "Framebuffer" equivalent (aka preconfigured RenderPassDescriptors?).
+         */
+        beginRenderPass(props) {
+          return new WebGPURenderPass(this.device, props);
+        }
+        beginComputePass(props) {
+          return new WebGPUComputePass(this.device, props);
+        }
+        // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
+        // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
+        copyBufferToBuffer(options) {
+          const webgpuSourceBuffer = options.sourceBuffer;
+          const WebGPUDestinationBuffer = options.destinationBuffer;
+          this.handle.copyBufferToBuffer(
+            webgpuSourceBuffer.handle,
+            options.sourceOffset ?? 0,
+            WebGPUDestinationBuffer.handle,
+            options.destinationOffset ?? 0,
+            options.size ?? 0
+          );
+        }
+        copyBufferToTexture(options) {
+          const webgpuSourceBuffer = options.sourceBuffer;
+          const WebGPUDestinationTexture = options.destinationTexture;
+          this.handle.copyBufferToTexture(
+            {
+              buffer: webgpuSourceBuffer.handle,
+              offset: options.offset ?? 0,
+              bytesPerRow: options.bytesPerRow,
+              rowsPerImage: options.rowsPerImage
+            },
+            {
+              texture: WebGPUDestinationTexture.handle,
+              mipLevel: options.mipLevel ?? 0,
+              origin: options.origin ?? {}
+              // aspect: options.aspect
+            },
+            {
+              // @ts-ignore
+              width: options.extent?.[0],
+              height: options.extent?.[1],
+              depthOrArrayLayers: options.extent?.[2]
+            }
+          );
+        }
+        copyTextureToBuffer(options) {
+        }
+        copyTextureToTexture(options) {
+        }
+        pushDebugGroup(groupLabel) {
+          this.handle.pushDebugGroup(groupLabel);
+        }
+        popDebugGroup() {
+          this.handle.popDebugGroup();
+        }
+        insertDebugMarker(markerLabel) {
+          this.handle.insertDebugMarker(markerLabel);
+        }
+        resolveQuerySet(querySet, destination, options) {
+          const webgpuQuerySet = querySet;
+          const webgpuBuffer = destination;
+          this.handle.resolveQuerySet(
+            webgpuQuerySet.handle,
+            options?.firstQuery || 0,
+            options?.queryCount || querySet.props.count - (options?.firstQuery || 0),
+            webgpuBuffer.handle,
+            options?.destinationOffset || 0
+          );
+        }
+      };
     }
-  };
+  });
 
   // src/adapter/resources/webgpu-query-set.ts
-  var import_core17 = __toESM(require_core(), 1);
-  var WebGPUQuerySet = class extends import_core17.QuerySet {
-    device;
-    handle;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      this.handle = this.props.handle || this.device.handle.createQuerySet({
-        type: this.props.type,
-        count: this.props.count
-      });
-      this.handle.label = this.props.id;
-    }
-    destroy() {
-      this.handle?.destroy();
-      this.handle = null;
+  var import_core19, WebGPUQuerySet;
+  var init_webgpu_query_set = __esm({
+    "src/adapter/resources/webgpu-query-set.ts"() {
+      "use strict";
+      import_core19 = __toESM(require_core(), 1);
+      WebGPUQuerySet = class extends import_core19.QuerySet {
+        device;
+        handle;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          this.handle = this.props.handle || this.device.handle.createQuerySet({
+            type: this.props.type,
+            count: this.props.count
+          });
+          this.handle.label = this.props.id;
+        }
+        destroy() {
+          this.handle?.destroy();
+          this.handle = null;
+        }
+      };
     }
-  };
+  });
 
   // src/adapter/resources/webgpu-pipeline-layout.ts
-  var import_core18 = __toESM(require_core(), 1);
-  var WebGPUPipelineLayout = class extends import_core18.PipelineLayout {
-    device;
-    handle;
-    constructor(device, props) {
-      super(device, props);
-      this.device = device;
-      const bindGroupEntries = this.mapShaderLayoutToBindGroupEntries();
-      this.handle = this.device.handle.createPipelineLayout({
-        label: props?.id ?? "unnamed-pipeline-layout",
-        bindGroupLayouts: [
-          // TODO (kaapp): We can cache these to re-use them across
-          // layers, particularly if using a separate group for injected
-          // bindings (e.g. project/lighting)
-          this.device.handle.createBindGroupLayout({
-            label: "bind-group-layout",
-            entries: bindGroupEntries
-          })
-        ]
-      });
-    }
-    destroy() {
-      this.handle = null;
-    }
-    mapShaderLayoutToBindGroupEntries() {
-      const bindGroupEntries = [];
-      for (let i = 0; i < this.props.shaderLayout.bindings.length; i++) {
-        const binding = this.props.shaderLayout.bindings[i];
-        const bindingTypeInfo = {};
-        switch (binding.type) {
-          case "uniform": {
-            bindingTypeInfo.buffer = {
-              type: "uniform",
-              hasDynamicOffset: binding.hasDynamicOffset,
-              minBindingSize: binding.minBindingSize
-            };
-            break;
+  var import_core20, WebGPUPipelineLayout, isStorageTextureBindingLayout;
+  var init_webgpu_pipeline_layout = __esm({
+    "src/adapter/resources/webgpu-pipeline-layout.ts"() {
+      "use strict";
+      import_core20 = __toESM(require_core(), 1);
+      WebGPUPipelineLayout = class extends import_core20.PipelineLayout {
+        device;
+        handle;
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          const bindGroupEntries = this.mapShaderLayoutToBindGroupEntries();
+          this.handle = this.device.handle.createPipelineLayout({
+            label: props?.id ?? "unnamed-pipeline-layout",
+            bindGroupLayouts: [
+              // TODO (kaapp): We can cache these to re-use them across
+              // layers, particularly if using a separate group for injected
+              // bindings (e.g. project/lighting)
+              this.device.handle.createBindGroupLayout({
+                label: "bind-group-layout",
+                entries: bindGroupEntries
+              })
+            ]
+          });
+        }
+        destroy() {
+          this.handle = null;
+        }
+        mapShaderLayoutToBindGroupEntries() {
+          const bindGroupEntries = [];
+          for (let i = 0; i < this.props.shaderLayout.bindings.length; i++) {
+            const binding = this.props.shaderLayout.bindings[i];
+            const bindingTypeInfo = {};
+            switch (binding.type) {
+              case "uniform": {
+                bindingTypeInfo.buffer = {
+                  type: "uniform",
+                  hasDynamicOffset: binding.hasDynamicOffset,
+                  minBindingSize: binding.minBindingSize
+                };
+                break;
+              }
+              case "read-only-storage": {
+                bindingTypeInfo.buffer = {
+                  type: "read-only-storage",
+                  hasDynamicOffset: binding.hasDynamicOffset,
+                  minBindingSize: binding.minBindingSize
+                };
+                break;
+              }
+              case "sampler": {
+                bindingTypeInfo.sampler = {
+                  type: binding.samplerType
+                };
+                break;
+              }
+              case "storage": {
+                if (isStorageTextureBindingLayout(binding)) {
+                  bindingTypeInfo.storageTexture = {
+                    // TODO (kaapp): Not all formats in the binding layout are supported
+                    // by WebGPU, but at least it will provide a clear error for now.
+                    format: binding.format,
+                    access: binding.access,
+                    viewDimension: binding.viewDimension
+                  };
+                } else {
+                  bindingTypeInfo.buffer = {
+                    type: "storage",
+                    hasDynamicOffset: binding.hasDynamicOffset,
+                    minBindingSize: binding.minBindingSize
+                  };
+                }
+                break;
+              }
+              case "texture": {
+                bindingTypeInfo.texture = {
+                  multisampled: binding.multisampled,
+                  sampleType: binding.sampleType,
+                  viewDimension: binding.viewDimension
+                };
+                break;
+              }
+              default: {
+                import_core20.log.warn("unhandled binding type when creating pipeline descriptor")();
+              }
+            }
+            const VISIBILITY_ALL = GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT | GPUShaderStage.COMPUTE;
+            bindGroupEntries.push({
+              binding: binding.location,
+              visibility: binding.visibility || VISIBILITY_ALL,
+              ...bindingTypeInfo
+            });
           }
-          case "read-only-storage": {
-            bindingTypeInfo.buffer = {
-              type: "read-only-storage",
-              hasDynamicOffset: binding.hasDynamicOffset,
-              minBindingSize: binding.minBindingSize
-            };
-            break;
+          return bindGroupEntries;
+        }
+      };
+      isStorageTextureBindingLayout = (maybe) => {
+        return maybe.format !== void 0;
+      };
+    }
+  });
+
+  // src/adapter/webgpu-device.ts
+  var webgpu_device_exports = {};
+  __export(webgpu_device_exports, {
+    WebGPUDevice: () => WebGPUDevice
+  });
+  var import_core21, WebGPUDevice;
+  var init_webgpu_device = __esm({
+    "src/adapter/webgpu-device.ts"() {
+      "use strict";
+      import_core21 = __toESM(require_core(), 1);
+      init_webgpu_buffer();
+      init_webgpu_texture();
+      init_webgpu_external_texture();
+      init_webgpu_sampler();
+      init_webgpu_shader();
+      init_webgpu_render_pipeline();
+      init_webgpu_framebuffer();
+      init_webgpu_compute_pipeline();
+      init_webgpu_vertex_array();
+      init_webgpu_canvas_context();
+      init_webgpu_command_encoder();
+      init_webgpu_query_set();
+      init_webgpu_pipeline_layout();
+      WebGPUDevice = class extends import_core21.Device {
+        /** The underlying WebGPU device */
+        handle;
+        /* The underlying WebGPU adapter */
+        adapter;
+        /* The underlying WebGPU adapter's info */
+        adapterInfo;
+        /** type of this device */
+        type = "webgpu";
+        preferredColorFormat = navigator.gpu.getPreferredCanvasFormat();
+        preferredDepthFormat = "depth24plus";
+        features;
+        info;
+        limits;
+        lost;
+        canvasContext = null;
+        _isLost = false;
+        commandEncoder;
+        get [Symbol.toStringTag]() {
+          return "WebGPUDevice";
+        }
+        toString() {
+          return `WebGPUDevice(${this.id})`;
+        }
+        constructor(props, device, adapter, adapterInfo) {
+          super({ ...props, id: props.id || "webgpu-device" });
+          this.handle = device;
+          this.adapter = adapter;
+          this.adapterInfo = adapterInfo;
+          this.info = this._getInfo();
+          this.features = this._getFeatures();
+          this.limits = this.handle.limits;
+          device.addEventListener("uncapturederror", (event) => {
+            event.preventDefault();
+            const errorMessage = event instanceof GPUUncapturedErrorEvent ? event.error.message : "Unknown WebGPU error";
+            this.reportError(new Error(errorMessage), this)();
+            this.debug();
+          });
+          this.lost = new Promise(async (resolve) => {
+            const lostInfo = await this.handle.lost;
+            this._isLost = true;
+            resolve({ reason: "destroyed", message: lostInfo.message });
+          });
+          const canvasContextProps = import_core21.Device._getCanvasContextProps(props);
+          if (canvasContextProps) {
+            this.canvasContext = new WebGPUCanvasContext(this, this.adapter, canvasContextProps);
           }
-          case "sampler": {
-            bindingTypeInfo.sampler = {
-              type: binding.samplerType
-            };
-            break;
+          this.commandEncoder = this.createCommandEncoder({});
+        }
+        // TODO
+        // Load the glslang module now so that it is available synchronously when compiling shaders
+        // const {glsl = true} = props;
+        // this.glslang = glsl && await loadGlslangModule();
+        destroy() {
+          this.handle.destroy();
+        }
+        get isLost() {
+          return this._isLost;
+        }
+        isVertexFormatSupported(format) {
+          const info = this.getVertexFormatInfo(format);
+          return !info.webglOnly;
+        }
+        getTextureByteAlignment() {
+          return 1;
+        }
+        createBuffer(props) {
+          const newProps = this._normalizeBufferProps(props);
+          return new WebGPUBuffer(this, newProps);
+        }
+        createTexture(props) {
+          return new WebGPUTexture(this, props);
+        }
+        createExternalTexture(props) {
+          return new WebGPUExternalTexture(this, props);
+        }
+        createShader(props) {
+          return new WebGPUShader(this, props);
+        }
+        createSampler(props) {
+          return new WebGPUSampler(this, props);
+        }
+        createRenderPipeline(props) {
+          return new WebGPURenderPipeline(this, props);
+        }
+        createFramebuffer(props) {
+          return new WebGPUFramebuffer(this, props);
+        }
+        createComputePipeline(props) {
+          return new WebGPUComputePipeline(this, props);
+        }
+        createVertexArray(props) {
+          return new WebGPUVertexArray(this, props);
+        }
+        createCommandEncoder(props) {
+          return new WebGPUCommandEncoder(this, props);
+        }
+        // WebGPU specifics
+        createTransformFeedback(props) {
+          throw new Error("Transform feedback not supported in WebGPU");
+        }
+        createQuerySet(props) {
+          return new WebGPUQuerySet(this, props);
+        }
+        createCanvasContext(props) {
+          return new WebGPUCanvasContext(this, this.adapter, props);
+        }
+        createPipelineLayout(props) {
+          return new WebGPUPipelineLayout(this, props);
+        }
+        submit(commandBuffer) {
+          if (!commandBuffer) {
+            commandBuffer = this.commandEncoder.finish();
+            this.commandEncoder.destroy();
+            this.commandEncoder = this.createCommandEncoder({ id: `${this.id}-default-encoder` });
           }
-          case "storage": {
-            if (isStorageTextureBindingLayout(binding)) {
-              bindingTypeInfo.storageTexture = {
-                // TODO (kaapp): Not all formats in the binding layout are supported
-                // by WebGPU, but at least it will provide a clear error for now.
-                format: binding.format,
-                access: binding.access,
-                viewDimension: binding.viewDimension
-              };
-            } else {
-              bindingTypeInfo.buffer = {
-                type: "storage",
-                hasDynamicOffset: binding.hasDynamicOffset,
-                minBindingSize: binding.minBindingSize
-              };
+          this.pushErrorScope("validation");
+          this.handle.queue.submit([commandBuffer.handle]);
+          this.popErrorScope((error) => {
+            this.reportError(new Error(`${this} command submission: ${error.message}`), this)();
+            this.debug();
+          });
+        }
+        // WebGPU specific
+        pushErrorScope(scope) {
+          this.handle.pushErrorScope(scope);
+        }
+        popErrorScope(handler) {
+          this.handle.popErrorScope().then((error) => {
+            if (error) {
+              handler(error);
             }
-            break;
+          });
+        }
+        // PRIVATE METHODS
+        _getInfo() {
+          const [driver, driverVersion] = (this.adapterInfo.driver || "").split(" Version ");
+          const vendor = this.adapterInfo.vendor || this.adapter.__brand || "unknown";
+          const renderer = driver || "";
+          const version = driverVersion || "";
+          const gpu = vendor === "apple" ? "apple" : "unknown";
+          const gpuArchitecture = this.adapterInfo.architecture || "unknown";
+          const gpuBackend = this.adapterInfo.backend || "unknown";
+          const gpuType = (this.adapterInfo.type || "").split(" ")[0].toLowerCase() || "unknown";
+          return {
+            type: "webgpu",
+            vendor,
+            renderer,
+            version,
+            gpu,
+            gpuType,
+            gpuBackend,
+            gpuArchitecture,
+            shadingLanguage: "wgsl",
+            shadingLanguageVersion: 100
+          };
+        }
+        _getFeatures() {
+          const features = new Set(this.handle.features);
+          if (features.has("depth-clamping")) {
+            features.delete("depth-clamping");
+            features.add("depth-clip-control");
           }
-          case "texture": {
-            bindingTypeInfo.texture = {
-              multisampled: binding.multisampled,
-              sampleType: binding.sampleType,
-              viewDimension: binding.viewDimension
-            };
-            break;
+          if (features.has("texture-compression-bc")) {
+            features.add("texture-compression-bc5-webgl");
           }
-          default: {
-            console.warn("unhandled binding type when creating pipeline descriptor");
+          const WEBGPU_ALWAYS_FEATURES = [
+            "timer-query-webgl",
+            "compilation-status-async-webgl",
+            "float32-renderable-webgl",
+            "float16-renderable-webgl",
+            "norm16-renderable-webgl",
+            "texture-filterable-anisotropic-webgl",
+            "shader-noperspective-interpolation-webgl"
+          ];
+          for (const feature of WEBGPU_ALWAYS_FEATURES) {
+            features.add(feature);
           }
+          return new import_core21.DeviceFeatures(Array.from(features), this.props._disabledFeatures);
         }
-        const VISIBILITY_ALL = GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT | GPUShaderStage.COMPUTE;
-        bindGroupEntries.push({
-          binding: binding.location,
-          visibility: binding.visibility || VISIBILITY_ALL,
-          ...bindingTypeInfo
-        });
-      }
-      return bindGroupEntries;
-    }
-  };
-  var isStorageTextureBindingLayout = (maybe) => {
-    return maybe.format !== void 0;
-  };
-
-  // src/adapter/webgpu-device.ts
-  var WebGPUDevice = class extends import_core19.Device {
-    /** type of this device */
-    type = "webgpu";
-    /** The underlying WebGPU device */
-    handle;
-    /* The underlying WebGPU adapter */
-    adapter;
-    /* The underlying WebGPU adapter's info */
-    adapterInfo;
-    features;
-    info;
-    limits;
-    lost;
-    canvasContext = null;
-    _isLost = false;
-    commandEncoder = null;
-    renderPass = null;
-    constructor(props, device, adapter, adapterInfo) {
-      super({ ...props, id: props.id || "webgpu-device" });
-      this.handle = device;
-      this.adapter = adapter;
-      this.adapterInfo = adapterInfo;
-      this.info = this._getInfo();
-      this.features = this._getFeatures();
-      this.limits = this.handle.limits;
-      device.addEventListener("uncapturederror", (event) => {
-        const errorMessage = event instanceof GPUUncapturedErrorEvent ? event.error.message : "Unknown WebGPU error";
-        this.reportError(new Error(errorMessage));
-        if (this.props.debug) {
-          debugger;
-        }
-        event.preventDefault();
-      });
-      this.lost = new Promise(async (resolve) => {
-        const lostInfo = await this.handle.lost;
-        this._isLost = true;
-        resolve({ reason: "destroyed", message: lostInfo.message });
-      });
-      const canvasContextProps = import_core19.Device._getCanvasContextProps(props);
-      if (canvasContextProps) {
-        this.canvasContext = new WebGPUCanvasContext(this, this.adapter, canvasContextProps);
-      }
-    }
-    // TODO
-    // Load the glslang module now so that it is available synchronously when compiling shaders
-    // const {glsl = true} = props;
-    // this.glslang = glsl && await loadGlslangModule();
-    destroy() {
-      this.handle.destroy();
-    }
-    get isLost() {
-      return this._isLost;
-    }
-    createBuffer(props) {
-      const newProps = this._normalizeBufferProps(props);
-      return new WebGPUBuffer(this, newProps);
-    }
-    createTexture(props) {
-      return new WebGPUTexture(this, props);
-    }
-    createExternalTexture(props) {
-      return new WebGPUExternalTexture(this, props);
-    }
-    createShader(props) {
-      return new WebGPUShader(this, props);
-    }
-    createSampler(props) {
-      return new WebGPUSampler(this, props);
-    }
-    createRenderPipeline(props) {
-      return new WebGPURenderPipeline(this, props);
-    }
-    createFramebuffer(props) {
-      return new WebGPUFramebuffer(this, props);
-    }
-    createComputePipeline(props) {
-      return new WebGPUComputePipeline(this, props);
-    }
-    createVertexArray(props) {
-      return new WebGPUVertexArray(this, props);
-    }
-    // WebGPU specifics
-    /**
-     * Allows a render pass to begin against a canvas context
-     * @todo need to support a "Framebuffer" equivalent (aka preconfigured RenderPassDescriptors?).
-     */
-    beginRenderPass(props) {
-      this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();
-      return new WebGPURenderPass(this, props);
-    }
-    beginComputePass(props) {
-      this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();
-      return new WebGPUComputePass(this, props);
-    }
-    // createCommandEncoder(props: CommandEncoderProps): WebGPUCommandEncoder {
-    //   return new WebGPUCommandEncoder(this, props);
-    // }
-    createTransformFeedback(props) {
-      throw new Error("Transform feedback not supported in WebGPU");
-    }
-    createQuerySet(props) {
-      return new WebGPUQuerySet(this, props);
-    }
-    createCanvasContext(props) {
-      return new WebGPUCanvasContext(this, this.adapter, props);
-    }
-    createPipelineLayout(props) {
-      return new WebGPUPipelineLayout(this, props);
-    }
-    submit() {
-      const commandBuffer = this.commandEncoder?.finish();
-      if (commandBuffer) {
-        this.handle.pushErrorScope("validation");
-        this.handle.queue.submit([commandBuffer]);
-        this.handle.popErrorScope().then((error) => {
-          if (error) {
-            this.reportError(new Error(`WebGPU command submission failed: ${error.message}`));
+        _getDeviceSpecificTextureFormatCapabilities(capabilities) {
+          const { format } = capabilities;
+          if (format.includes("webgl")) {
+            return { format, create: false, render: false, filter: false, blend: false, store: false };
           }
-        });
-      }
-    }
-    // PRIVATE METHODS
-    _getInfo() {
-      const [driver, driverVersion] = (this.adapterInfo.driver || "").split(" Version ");
-      const vendor = this.adapterInfo.vendor || this.adapter.__brand || "unknown";
-      const renderer = driver || "";
-      const version = driverVersion || "";
-      const gpu = vendor === "apple" ? "apple" : "unknown";
-      const gpuArchitecture = this.adapterInfo.architecture || "unknown";
-      const gpuBackend = this.adapterInfo.backend || "unknown";
-      const gpuType = (this.adapterInfo.type || "").split(" ")[0].toLowerCase() || "unknown";
-      return {
-        type: "webgpu",
-        vendor,
-        renderer,
-        version,
-        gpu,
-        gpuType,
-        gpuBackend,
-        gpuArchitecture,
-        shadingLanguage: "wgsl",
-        shadingLanguageVersion: 100
+          return capabilities;
+        }
       };
     }
-    _getFeatures() {
-      const features = new Set(this.handle.features);
-      if (features.has("depth-clamping")) {
-        features.delete("depth-clamping");
-        features.add("depth-clip-control");
-      }
-      if (features.has("texture-compression-bc")) {
-        features.add("texture-compression-bc5-webgl");
-      }
-      const WEBGPU_ALWAYS_FEATURES = [
-        "timer-query-webgl",
-        "compilation-status-async-webgl",
-        "float32-renderable-webgl",
-        "float16-renderable-webgl",
-        "norm16-renderable-webgl",
-        "texture-filterable-anisotropic-webgl",
-        "shader-noperspective-interpolation-webgl"
-      ];
-      for (const feature of WEBGPU_ALWAYS_FEATURES) {
-        features.add(feature);
-      }
-      return new import_core19.DeviceFeatures(Array.from(features), this.props._disabledFeatures);
-    }
-    _getDeviceSpecificTextureFormatCapabilities(capabilities) {
-      const { format } = capabilities;
-      if (format.includes("webgl")) {
-        return { format, create: false, render: false, filter: false, blend: false, store: false };
-      }
-      return capabilities;
-    }
-    // DEPRECATED METHODS
-    // @deprecated
-    copyExternalImageToTexture(options) {
-      const {
-        source,
-        sourceX = 0,
-        sourceY = 0,
-        texture,
-        mipLevel = 0,
-        aspect = "all",
-        colorSpace = "display-p3",
-        premultipliedAlpha = false,
-        // destinationX,
-        // destinationY,
-        // desitnationZ,
-        width = texture.width,
-        height = texture.height,
-        depth = 1
-      } = options;
-      const webGpuTexture = texture;
-      this.handle?.queue.copyExternalImageToTexture(
-        // source: GPUImageCopyExternalImage
-        {
-          source,
-          origin: [sourceX, sourceY]
-        },
-        // destination: GPUImageCopyTextureTagged
-        {
-          texture: webGpuTexture.handle,
-          origin: [0, 0, 0],
-          // [x, y, z],
-          mipLevel,
-          aspect,
-          colorSpace,
-          premultipliedAlpha
-        },
-        // copySize: GPUExtent3D
-        [width, height, depth]
-      );
-    }
-  };
+  });
+
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
+    WebGPUBuffer: () => WebGPUBuffer,
+    WebGPUDevice: () => WebGPUDevice,
+    WebGPUSampler: () => WebGPUSampler,
+    WebGPUShader: () => WebGPUShader,
+    WebGPUTexture: () => WebGPUTexture,
+    webgpuAdapter: () => webgpuAdapter
+  });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/adapter/webgpu-adapter.ts
-  var WebGPUAdapter = class extends import_core20.Adapter {
+  var import_core22 = __toESM(require_core(), 1);
+  var WebGPUAdapter = class extends import_core22.Adapter {
     /** type of device's created by this adapter */
     type = "webgpu";
-    constructor() {
-      super();
-      WebGPUDevice.adapter = this;
-    }
-    /** Check if WebGPU is available */
     isSupported() {
       return Boolean(typeof navigator !== "undefined" && navigator.gpu);
     }
+    isDeviceHandle(handle) {
+      if (typeof GPUDevice !== "undefined" && handle instanceof GPUDevice) {
+        return true;
+      }
+      if (handle?.queue) {
+        return true;
+      }
+      return false;
+    }
     async create(props) {
       if (!navigator.gpu) {
-        throw new Error(
-          "WebGPU not available. Open in Chrome Canary and turn on chrome://flags/#enable-unsafe-webgpu"
-        );
-      }
-      import_core20.log.groupCollapsed(1, "WebGPUDevice created")();
-      const adapter = await navigator.gpu.requestAdapter({
-        powerPreference: "high-performance"
-        // forceSoftware: false
-      });
-      if (!adapter) {
-        throw new Error("Failed to request WebGPU adapter");
+        throw new Error("WebGPU not available. Recent Chrome browsers should work.");
       }
-      const adapterInfo = adapter.info || // @ts-ignore Chrome has removed this function
-      await adapter.requestAdapterInfo?.();
-      import_core20.log.probe(2, "Adapter available", adapterInfo)();
-      const requiredFeatures = [];
-      const requiredLimits = {};
-      if (props._requestMaxLimits) {
-        requiredFeatures.push(...Array.from(adapter.features));
-        const limits = Object.keys(adapter.limits).filter(
-          (key) => !["minSubgroupSize", "maxSubgroupSize"].includes(key)
-        );
-        for (const key of limits) {
-          const limit = key;
-          const value = adapter.limits[limit];
-          if (typeof value === "number") {
-            requiredLimits[limit] = value;
+      import_core22.log.groupCollapsed(1, "WebGPUDevice created")();
+      try {
+        const adapter = await navigator.gpu.requestAdapter({
+          powerPreference: "high-performance"
+          // forceSoftware: false
+        });
+        if (!adapter) {
+          throw new Error("Failed to request WebGPU adapter");
+        }
+        const adapterInfo = adapter.info || // @ts-ignore
+        await adapter.requestAdapterInfo?.();
+        import_core22.log.probe(2, "Adapter available", adapterInfo)();
+        const requiredFeatures = [];
+        const requiredLimits = {};
+        if (props._requestMaxLimits) {
+          requiredFeatures.push(...Array.from(adapter.features));
+          const limits = Object.keys(adapter.limits).filter(
+            (key) => !["minSubgroupSize", "maxSubgroupSize"].includes(key)
+          );
+          for (const key of limits) {
+            const limit = key;
+            const value = adapter.limits[limit];
+            if (typeof value === "number") {
+              requiredLimits[limit] = value;
+            }
           }
         }
+        const gpuDevice = await adapter.requestDevice({
+          requiredFeatures,
+          requiredLimits
+        });
+        import_core22.log.probe(1, "GPUDevice available")();
+        const { WebGPUDevice: WebGPUDevice2 } = await Promise.resolve().then(() => (init_webgpu_device(), webgpu_device_exports));
+        const device = new WebGPUDevice2(props, gpuDevice, adapter, adapterInfo);
+        import_core22.log.probe(
+          1,
+          "Device created. For more info, set chrome://flags/#enable-webgpu-developer-features"
+        )();
+        import_core22.log.table(1, device.info)();
+        return device;
+      } finally {
+        import_core22.log.groupEnd(1)();
       }
-      const gpuDevice = await adapter.requestDevice({
-        requiredFeatures,
-        requiredLimits
-      });
-      import_core20.log.probe(1, "GPUDevice available")();
-      const device = new WebGPUDevice(props, gpuDevice, adapter, adapterInfo);
-      import_core20.log.probe(
-        1,
-        "Device created. For more info, set chrome://flags/#enable-webgpu-developer-features"
-      )();
-      import_core20.log.table(1, device.info)();
-      import_core20.log.groupEnd(1)();
-      return device;
     }
     async attach(handle) {
       throw new Error("WebGPUAdapter.attach() not implemented");
     }
   };
   var webgpuAdapter = new WebGPUAdapter();
+
+  // src/index.ts
+  init_webgpu_device();
+  init_webgpu_buffer();
+  init_webgpu_texture();
+  init_webgpu_sampler();
+  init_webgpu_shader();
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;