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

package/dist/index.cjs

@@ -1,10 +1,14 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 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") {
@@ -16,95 +20,154 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
-  WebGPUBuffer: () => WebGPUBuffer,
-  WebGPUDevice: () => WebGPUDevice,
-  WebGPUSampler: () => WebGPUSampler,
-  WebGPUShader: () => WebGPUShader,
-  WebGPUTexture: () => WebGPUTexture,
-  webgpuAdapter: () => webgpuAdapter
-});
-module.exports = __toCommonJS(dist_exports);
-
-// dist/adapter/webgpu-adapter.js
-var import_core20 = require("@luma.gl/core");
-
-// dist/adapter/webgpu-device.js
-var import_core19 = require("@luma.gl/core");
-
 // dist/adapter/resources/webgpu-buffer.js
-var import_core = require("@luma.gl/core");
-function getByteLength(props) {
-  var _a;
-  return props.byteLength || ((_a = props.data) == null ? void 0 : _a.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() {
-    var _a;
-    (_a = this.handle) == null ? void 0 : _a.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({
+  "dist/adapter/resources/webgpu-buffer.js"() {
+    "use strict";
+    import_core = require("@luma.gl/core");
+    WebGPUBuffer = class extends import_core.Buffer {
+      device;
+      handle;
+      byteLength;
+      constructor(device, props) {
+        var _a, _b;
+        super(device, props);
+        this.device = device;
+        this.byteLength = props.byteLength || ((_a = props.data) == null ? void 0 : _a.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 {
+              (_b = props.onMapped) == null ? void 0 : _b.call(props, 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() {
+        var _a;
+        (_a = this.handle) == null ? void 0 : _a.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 == null ? void 0 : 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 == null ? void 0 : 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();
+        });
+      }
+    };
   }
-};
-
-// dist/adapter/resources/webgpu-texture.js
-var import_core4 = require("@luma.gl/core");
+});
 
 // dist/adapter/helpers/convert-texture-format.js
 function getWebGPUTextureFormat(format) {
@@ -113,266 +176,298 @@ function getWebGPUTextureFormat(format) {
   }
   return format;
 }
+var init_convert_texture_format = __esm({
+  "dist/adapter/helpers/convert-texture-format.js"() {
+    "use strict";
+  }
+});
 
 // dist/adapter/resources/webgpu-sampler.js
-var import_core2 = require("@luma.gl/core");
-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({
+  "dist/adapter/resources/webgpu-sampler.js"() {
+    "use strict";
+    import_core2 = require("@luma.gl/core");
+    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;
-  }
-};
+});
 
 // dist/adapter/resources/webgpu-texture-view.js
-var import_core3 = require("@luma.gl/core");
-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({
+  "dist/adapter/resources/webgpu-texture-view.js"() {
+    "use strict";
+    import_core3 = require("@luma.gl/core");
+    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;
+      }
+    };
   }
-};
+});
 
 // dist/adapter/resources/webgpu-texture.js
-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() {
-    var _a;
-    (_a = this.handle) == null ? void 0 : _a.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({
+  "dist/adapter/resources/webgpu-texture.js"() {
+    "use strict";
+    import_core4 = require("@luma.gl/core");
+    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() {
-    var _a, _b;
-    const width = this.props.width || ((_a = this.props.data) == null ? void 0 : _a.width) || 1;
-    const height = this.props.height || ((_b = this.props.data) == null ? void 0 : _b.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 };
+      destroy() {
+        var _a;
+        (_a = this.handle) == null ? void 0 : _a.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`)();
+      }
+    };
   }
-};
+});
 
 // dist/adapter/resources/webgpu-external-texture.js
-var import_core5 = require("@luma.gl/core");
-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({
+  "dist/adapter/resources/webgpu-external-texture.js"() {
+    "use strict";
+    import_core5 = require("@luma.gl/core");
+    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;
+      }
+    };
   }
-};
+});
 
 // dist/adapter/resources/webgpu-shader.js
-var import_core6 = require("@luma.gl/core");
-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({
+  "dist/adapter/resources/webgpu-shader.js"() {
+    "use strict";
+    import_core6 = require("@luma.gl/core");
+    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;
+      }
+    };
   }
-};
-
-// dist/adapter/resources/webgpu-render-pipeline.js
-var import_core10 = require("@luma.gl/core");
+});
 
 // dist/adapter/helpers/webgpu-parameters.js
-var import_core7 = require("@luma.gl/core");
 function addDepthStencil(descriptor) {
   descriptor.depthStencil = descriptor.depthStencil || {
     // required, set something
@@ -393,157 +488,9 @@ function addDepthStencilBack(descriptor) {
   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);
@@ -551,15 +498,15 @@ function applyParametersToRenderPipelineDescriptor(pipelineDescriptor, parameter
 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) {
-  var _a, _b, _c, _d, _e, _f;
+function addColorState(descriptor, attachment) {
+  var _a, _b, _c, _d, _e, _f, _g;
   descriptor.fragment.targets = ((_a = descriptor.fragment) == null ? void 0 : _a.targets) || [];
   if (!Array.isArray((_b = descriptor.fragment) == null ? void 0 : _b.targets)) {
     import_core7.log.warn("parameters: no targets array")();
@@ -567,21 +514,199 @@ function addColorState(descriptor) {
   if (((_d = (_c = descriptor.fragment) == null ? void 0 : _c.targets) == null ? void 0 : _d.length) === 0) {
     (_e = descriptor.fragment.targets) == null ? void 0 : _e.push({});
   }
-  return (_f = descriptor.fragment) == null ? void 0 : _f.targets;
+  return (_g = (_f = descriptor.fragment) == null ? void 0 : _f.targets) == null ? void 0 : _g[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({
+  "dist/adapter/helpers/webgpu-parameters.js"() {
+    "use strict";
+    import_core7 = require("@luma.gl/core");
+    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"
+    };
+  }
+});
 
 // dist/adapter/helpers/get-bind-group.js
-var import_core8 = require("@luma.gl/core");
 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 == null ? void 0 : options.ignoreWarnings)) {
     import_core8.log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
   }
   return bindingLayout || null;
@@ -591,11 +716,21 @@ function getBindGroupEntries(bindings, shaderLayout) {
   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;
@@ -614,7 +749,8 @@ function getBindGroupEntry(binding, index, options) {
       binding: index,
       resource: binding.handle
     };
-  } else if (binding instanceof import_core8.Texture) {
+  }
+  if (binding instanceof import_core8.Texture) {
     if (options == null ? void 0 : options.sampler) {
       return {
         binding: index,
@@ -623,14 +759,21 @@ function getBindGroupEntry(binding, index, options) {
     }
     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({
+  "dist/adapter/helpers/get-bind-group.js"() {
+    "use strict";
+    import_core8 = require("@luma.gl/core");
+  }
+});
 
 // dist/adapter/helpers/get-vertex-buffer-layout.js
-var import_core9 = require("@luma.gl/core");
 function getWebGPUVertexFormat(format) {
   if (format.endsWith("-webgl")) {
     throw new Error(`WebGPU does not support vertex format ${format}`);
@@ -657,14 +800,14 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
           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),
@@ -682,7 +825,7 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
   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: [
           {
@@ -701,975 +844,1184 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
   });
   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({
+  "dist/adapter/helpers/get-vertex-buffer-layout.js"() {
+    "use strict";
+    import_core9 = require("@luma.gl/core");
+  }
+});
 
 // dist/adapter/resources/webgpu-render-pipeline.js
-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) => {
-        var _a;
-        if (error) {
-          import_core10.log.error(`${this} creation failed:
-"${error.message}"`, this, (_a = this.props.vs) == null ? void 0 : _a.source)();
+var import_core10, WebGPURenderPipeline;
+var init_webgpu_render_pipeline = __esm({
+  "dist/adapter/resources/webgpu-render-pipeline.js"() {
+    "use strict";
+    import_core10 = require("@luma.gl/core");
+    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;
   }
-};
+});
 
 // dist/adapter/resources/webgpu-framebuffer.js
-var import_core11 = require("@luma.gl/core");
-var WebGPUFramebuffer = class extends import_core11.Framebuffer {
-  device;
-  colorAttachments = [];
-  depthStencilAttachment = null;
-  constructor(device, props) {
-    super(device, props);
-    this.device = device;
-    this.autoCreateAttachmentTextures();
-  }
-  updateAttachments() {
+var import_core11, WebGPUFramebuffer;
+var init_webgpu_framebuffer = __esm({
+  "dist/adapter/resources/webgpu-framebuffer.js"() {
+    "use strict";
+    import_core11 = require("@luma.gl/core");
+    WebGPUFramebuffer = class extends import_core11.Framebuffer {
+      device;
+      handle = null;
+      colorAttachments = [];
+      depthStencilAttachment = null;
+      constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.autoCreateAttachmentTextures();
+      }
+      updateAttachments() {
+      }
+    };
   }
-};
+});
 
 // dist/adapter/resources/webgpu-compute-pipeline.js
-var import_core12 = require("@luma.gl/core");
-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;
+var import_core12, WebGPUComputePipeline;
+var init_webgpu_compute_pipeline = __esm({
+  "dist/adapter/resources/webgpu-compute-pipeline.js"() {
+    "use strict";
+    import_core12 = require("@luma.gl/core");
+    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"
+        });
+      }
+      /**
+       * @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;
+      }
+    };
   }
-};
+});
 
-// dist/adapter/resources/webgpu-render-pass.js
-var import_core13 = require("@luma.gl/core");
-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)();
+// dist/adapter/resources/webgpu-vertex-array.js
+var import_core13, import_env, WebGPUVertexArray;
+var init_webgpu_vertex_array = __esm({
+  "dist/adapter/resources/webgpu-vertex-array.js"() {
+    "use strict";
+    import_core13 = require("@luma.gl/core");
+    import_env = require("@probe.gl/env");
+    WebGPUVertexArray = class extends import_core13.VertexArray {
+      get [Symbol.toStringTag]() {
+        return "WebGPUVertexArray";
+      }
+      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 == null ? void 0 : webgpuIndexBuffer.handle) {
+          import_core13.log.info(3, "setting index buffer", webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.handle, webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.indexType)();
+          webgpuRenderPass.handle.setIndexBuffer(
+            webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.handle,
+            // @ts-expect-error TODO - we must enforce type
+            webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.indexType
+          );
+        }
+        for (let location = 0; location < this.maxVertexAttributes; location++) {
+          const webgpuBuffer = this.attributes[location];
+          if (webgpuBuffer == null ? void 0 : webgpuBuffer.handle) {
+            import_core13.log.info(3, `setting vertex buffer ${location}`, webgpuBuffer == null ? void 0 : webgpuBuffer.handle)();
+            webgpuRenderPass.handle.setVertexBuffer(location, webgpuBuffer == null ? void 0 : 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 (0, import_env.getBrowser)() === "Chrome";
       }
-    });
-    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) {
-    var _a, _b;
-    (_a = this.pipeline) == null ? void 0 : _a.setBindings(bindings);
-    const bindGroup = (_b = this.pipeline) == null ? void 0 : _b._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) => {
-      var _a;
-      return {
-        // clear values
-        loadOp: this.props.clearColor !== false ? "clear" : "load",
-        clearValue: convertColor(((_a = this.props.clearColors) == null ? void 0 : _a[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;
+  }
+});
+
+// dist/adapter/webgpu-canvas-context.js
+var import_core14, WebGPUCanvasContext;
+var init_webgpu_canvas_context = __esm({
+  "dist/adapter/webgpu-canvas-context.js"() {
+    "use strict";
+    import_core14 = require("@luma.gl/core");
+    init_webgpu_framebuffer();
+    WebGPUCanvasContext = class extends import_core14.CanvasContext {
+      device;
+      handle;
+      depthStencilAttachment = null;
+      get [Symbol.toStringTag]() {
+        return "WebGPUCanvasContext";
       }
-      if (this.props.clearDepth !== false) {
-        depthStencilAttachment.depthClearValue = this.props.clearDepth;
+      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();
       }
-      const hasDepthAspect = true;
-      if (hasDepthAspect) {
-        depthStencilAttachment.depthLoadOp = this.props.clearDepth !== false ? "clear" : "load";
-        depthStencilAttachment.depthStoreOp = "store";
+      /** Destroy any textures produced while configured and remove the context configuration. */
+      destroy() {
+        this.handle.unconfigure();
+        super.destroy();
       }
-      const hasStencilAspect = false;
-      if (hasStencilAspect) {
-        depthStencilAttachment.stencilLoadOp = this.props.clearStencil !== false ? "clear" : "load";
-        depthStencilAttachment.stencilStoreOp = "store";
+      /** 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 == null ? void 0 : options.depthStencilFormat) {
+          this._createDepthStencilAttachment(options == null ? void 0 : options.depthStencilFormat);
+        }
+        return new WebGPUFramebuffer(this.device, {
+          colorAttachments: [currentColorAttachment],
+          depthStencilAttachment: this.depthStencilAttachment
+        });
       }
-    }
-    return renderPassDescriptor;
+      // 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;
+      }
+    };
   }
-};
+});
+
+// dist/adapter/resources/webgpu-command-buffer.js
+var import_core15, WebGPUCommandBuffer;
+var init_webgpu_command_buffer = __esm({
+  "dist/adapter/resources/webgpu-command-buffer.js"() {
+    "use strict";
+    import_core15 = require("@luma.gl/core");
+    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 == null ? void 0 : props.id) || "unnamed-command-buffer"
+        });
+      }
+    };
+  }
+});
+
+// dist/adapter/resources/webgpu-render-pass.js
 function convertColor(color) {
   return { r: color[0], g: color[1], b: color[2], a: color[3] };
 }
-
-// dist/adapter/resources/webgpu-compute-pass.js
-var import_core14 = require("@luma.gl/core");
-var WebGPUComputePass = class extends import_core14.ComputePass {
-  device;
-  handle;
-  _webgpuPipeline = null;
-  constructor(device, props) {
-    var _a;
-    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
+var import_core16, WebGPURenderPass;
+var init_webgpu_render_pass = __esm({
+  "dist/adapter/resources/webgpu-render-pass.js"() {
+    "use strict";
+    import_core16 = require("@luma.gl/core");
+    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) {
+        var _a, _b;
+        (_a = this.pipeline) == null ? void 0 : _a.setBindings(bindings);
+        const bindGroup = (_b = this.pipeline) == null ? void 0 : _b._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) => {
+          var _a;
+          return {
+            // clear values
+            loadOp: this.props.clearColor !== false ? "clear" : "load",
+            clearValue: convertColor(((_a = this.props.clearColors) == null ? void 0 : _a[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;
       }
-    }
-    this.handle = this.props.handle || ((_a = device.commandEncoder) == null ? void 0 : _a.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);
+    };
   }
-};
+});
 
-// dist/adapter/resources/webgpu-vertex-array.js
-var import_core15 = require("@luma.gl/core");
-var import_env = require("@probe.gl/env");
-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;
-  }
-  /** 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 == null ? void 0 : webgpuIndexBuffer.handle) {
-      import_core15.log.info(3, "setting index buffer", webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.handle, webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.indexType)();
-      webgpuRenderPass.handle.setIndexBuffer(
-        webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.handle,
-        // @ts-expect-error TODO - we must enforce type
-        webgpuIndexBuffer == null ? void 0 : webgpuIndexBuffer.indexType
-      );
-    }
-    for (let location = 0; location < this.maxVertexAttributes; location++) {
-      const webgpuBuffer = this.attributes[location];
-      if (webgpuBuffer == null ? void 0 : webgpuBuffer.handle) {
-        import_core15.log.info(3, `setting vertex buffer ${location}`, webgpuBuffer == null ? void 0 : webgpuBuffer.handle)();
-        webgpuRenderPass.handle.setVertexBuffer(location, webgpuBuffer == null ? void 0 : webgpuBuffer.handle);
+// dist/adapter/resources/webgpu-compute-pass.js
+var import_core17, WebGPUComputePass;
+var init_webgpu_compute_pass = __esm({
+  "dist/adapter/resources/webgpu-compute-pass.js"() {
+    "use strict";
+    import_core17 = require("@luma.gl/core");
+    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
+        });
       }
-    }
-  }
-  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 (0, import_env.getBrowser)() === "Chrome";
+      /** @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);
+      }
+    };
   }
-};
+});
 
-// dist/adapter/webgpu-canvas-context.js
-var import_core16 = require("@luma.gl/core");
-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
-    });
-  }
-  /** 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`)();
-    }
-  }
-  resize(options) {
-    this.update();
-    if (!this.device.handle)
-      return;
-    if (this.canvas) {
-      const devicePixelRatio = this.getDevicePixelRatio(options == null ? void 0 : options.useDevicePixels);
-      this.setDevicePixelRatio(devicePixelRatio, options);
-      return;
-    }
-  }
-  /** 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
-    });
-  }
-  /** 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;
+// dist/adapter/resources/webgpu-command-encoder.js
+var import_core18, WebGPUCommandEncoder;
+var init_webgpu_command_encoder = __esm({
+  "dist/adapter/resources/webgpu-command-encoder.js"() {
+    "use strict";
+    import_core18 = require("@luma.gl/core");
+    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 == null ? void 0 : 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) {
+        var _a, _b, _c;
+        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: (_a = options.extent) == null ? void 0 : _a[0],
+          height: (_b = options.extent) == null ? void 0 : _b[1],
+          depthOrArrayLayers: (_c = options.extent) == null ? void 0 : _c[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 == null ? void 0 : options.firstQuery) || 0, (options == null ? void 0 : options.queryCount) || querySet.props.count - ((options == null ? void 0 : options.firstQuery) || 0), webgpuBuffer.handle, (options == null ? void 0 : options.destinationOffset) || 0);
+      }
+    };
   }
-};
+});
 
 // dist/adapter/resources/webgpu-query-set.js
-var import_core17 = require("@luma.gl/core");
-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() {
-    var _a;
-    (_a = this.handle) == null ? void 0 : _a.destroy();
-    this.handle = null;
+var import_core19, WebGPUQuerySet;
+var init_webgpu_query_set = __esm({
+  "dist/adapter/resources/webgpu-query-set.js"() {
+    "use strict";
+    import_core19 = require("@luma.gl/core");
+    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() {
+        var _a;
+        (_a = this.handle) == null ? void 0 : _a.destroy();
+        this.handle = null;
+      }
+    };
   }
-};
+});
 
 // dist/adapter/resources/webgpu-pipeline-layout.js
-var import_core18 = require("@luma.gl/core");
-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 == null ? void 0 : 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({
+  "dist/adapter/resources/webgpu-pipeline-layout.js"() {
+    "use strict";
+    import_core20 = require("@luma.gl/core");
+    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 == null ? void 0 : 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;
+    };
+  }
+});
+
+// dist/adapter/webgpu-device.js
+var webgpu_device_exports = {};
+__export(webgpu_device_exports, {
+  WebGPUDevice: () => WebGPUDevice
+});
+var import_core21, WebGPUDevice;
+var init_webgpu_device = __esm({
+  "dist/adapter/webgpu-device.js"() {
+    "use strict";
+    import_core21 = require("@luma.gl/core");
+    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;
-};
-
-// dist/adapter/webgpu-device.js
-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() {
-    var _a;
-    const commandBuffer = (_a = this.commandEncoder) == null ? void 0 : _a.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) {
-    var _a;
-    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;
-    (_a = this.handle) == null ? void 0 : _a.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]
-    );
-  }
-};
+});
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  WebGPUBuffer: () => WebGPUBuffer,
+  WebGPUDevice: () => WebGPUDevice,
+  WebGPUSampler: () => WebGPUSampler,
+  WebGPUShader: () => WebGPUShader,
+  WebGPUTexture: () => WebGPUTexture,
+  webgpuAdapter: () => webgpuAdapter
+});
+module.exports = __toCommonJS(dist_exports);
 
 // dist/adapter/webgpu-adapter.js
-var WebGPUAdapter = class extends import_core20.Adapter {
+var import_core22 = require("@luma.gl/core");
+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 == null ? void 0 : handle.queue) {
+      return true;
+    }
+    return false;
+  }
   async create(props) {
     var _a;
     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 ((_a = adapter.requestAdapterInfo) == null ? void 0 : _a.call(adapter));
-    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 ((_a = adapter.requestAdapterInfo) == null ? void 0 : _a.call(adapter));
+      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();
+
+// dist/index.js
+init_webgpu_device();
+init_webgpu_buffer();
+init_webgpu_texture();
+init_webgpu_sampler();
+init_webgpu_shader();
 //# sourceMappingURL=index.cjs.map