@deck.gl/arcgis 9.3.0-alpha.3 → 9.3.0-alpha.5

package/dist/dist.dev.js

@@ -48,10 +48,10 @@ var __exports__ = (() => {
     }
   });
 
-  // ../../node_modules/@luma.gl/constants/dist/webgl-constants.js
+  // ../../node_modules/@luma.gl/webgl/dist/constants/webgl-constants.js
   var GLEnum;
   var init_webgl_constants = __esm({
-    "../../node_modules/@luma.gl/constants/dist/webgl-constants.js"() {
+    "../../node_modules/@luma.gl/webgl/dist/constants/webgl-constants.js"() {
       (function(GLEnum2) {
         GLEnum2[GLEnum2["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT";
         GLEnum2[GLEnum2["STENCIL_BUFFER_BIT"] = 1024] = "STENCIL_BUFFER_BIT";
@@ -703,9 +703,9 @@ var __exports__ = (() => {
     }
   });
 
-  // ../../node_modules/@luma.gl/constants/dist/index.js
-  var init_dist = __esm({
-    "../../node_modules/@luma.gl/constants/dist/index.js"() {
+  // ../../node_modules/@luma.gl/webgl/dist/constants/index.js
+  var init_constants = __esm({
+    "../../node_modules/@luma.gl/webgl/dist/constants/index.js"() {
       init_webgl_constants();
     }
   });
@@ -875,7 +875,7 @@ var __exports__ = (() => {
   });
 
   // ../../node_modules/@probe.gl/env/dist/index.js
-  var init_dist2 = __esm({
+  var init_dist = __esm({
     "../../node_modules/@probe.gl/env/dist/index.js"() {
       init_get_browser();
     }
@@ -952,7 +952,7 @@ var __exports__ = (() => {
   var init_webgl_developer_tools = __esm({
     "../../node_modules/@luma.gl/webgl/dist/context/debug/webgl-developer-tools.js"() {
       import_core3 = __toESM(require_core2(), 1);
-      init_dist();
+      init_constants();
     }
   });
 
@@ -2477,6 +2477,15 @@ var __exports__ = (() => {
           }
           gl.bindTexture(texture.glTarget, null);
         }
+        /** Default framebuffer resize is managed by canvas size and should be a no-op. */
+        resizeAttachments(width, height) {
+          if (this.handle === null) {
+            this.width = width;
+            this.height = height;
+            return;
+          }
+          super.resizeAttachments(width, height);
+        }
       };
     }
   });
@@ -2829,7 +2838,12 @@ var __exports__ = (() => {
               throw new Error(this.props.stage);
           }
           device._setWebGLDebugMetadata(this.handle, this, { spector: this.props });
-          this._compile(this.source);
+          const compilationStatus = this._compile(this.source);
+          if (compilationStatus && typeof compilationStatus.catch === "function") {
+            compilationStatus.catch(() => {
+              this.compilationStatus = "error";
+            });
+          }
         }
         destroy() {
           if (this.handle) {
@@ -2860,7 +2874,7 @@ var __exports__ = (() => {
         }
         // PRIVATE METHODS
         /** Compile a shader and get compilation status */
-        async _compile(source) {
+        _compile(source) {
           source = source.startsWith("#version ") ? source : `#version 300 es
 ${source}`;
           const { gl } = this.device;
@@ -2879,10 +2893,11 @@ ${source}`;
             return;
           }
           import_core11.log.once(1, "Shader compilation is asynchronous")();
-          await this._waitForCompilationComplete();
-          import_core11.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
-          this._getCompilationStatus();
-          this.debugShader();
+          return this._waitForCompilationComplete().then(() => {
+            import_core11.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+            this._getCompilationStatus();
+            this.debugShader();
+          });
         }
         /** Use KHR_parallel_shader_compile extension if available */
         async _waitForCompilationComplete() {
@@ -3022,6 +3037,9 @@ ${source}`;
       parameters.depthCompare !== "always" ? gl.enable(2929) : gl.disable(2929);
       gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
     }
+    if (parameters.clearDepth !== void 0) {
+      gl.clearDepth(parameters.clearDepth);
+    }
     if (parameters.stencilWriteMask) {
       const mask = parameters.stencilWriteMask;
       gl.stencilMaskSeparate(1028, mask);
@@ -3395,7 +3413,7 @@ ${source}`;
   function getWebGLCubeFaceTarget(glTarget, dimension, level) {
     return dimension === "cube" ? 34069 + level : glTarget;
   }
-  var import_core15, import_core16, WEBGLTexture;
+  var import_core15, WEBGLTexture;
   var init_webgl_texture = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-texture.js"() {
       import_core15 = __toESM(require_core2(), 1);
@@ -3404,7 +3422,6 @@ ${source}`;
       init_with_parameters();
       init_webgl_texture_view();
       init_shader_formats();
-      import_core16 = __toESM(require_core2(), 1);
       WEBGLTexture = class extends import_core15.Texture {
         // readonly MAX_ATTRIBUTES: number;
         device;
@@ -3536,31 +3553,28 @@ ${source}`;
          * before any WebGL calls are issued.
          */
         readBuffer(options = {}, buffer) {
+          if (!buffer) {
+            throw new Error(`${this} readBuffer requires a destination buffer`);
+          }
           const normalizedOptions = this._getSupportedColorReadOptions(options);
+          const byteOffset = options.byteOffset ?? 0;
           const memoryLayout = this.computeMemoryLayout(normalizedOptions);
-          const readBuffer = buffer || this.device.createBuffer({
-            byteLength: memoryLayout.byteLength,
-            usage: import_core15.Buffer.COPY_DST | import_core15.Buffer.MAP_READ
-          });
-          if (readBuffer.byteLength < memoryLayout.byteLength) {
-            throw new Error(`${this} readBuffer target is too small (${readBuffer.byteLength} < ${memoryLayout.byteLength})`);
+          if (buffer.byteLength < byteOffset + memoryLayout.byteLength) {
+            throw new Error(`${this} readBuffer target is too small (${buffer.byteLength} < ${byteOffset + memoryLayout.byteLength})`);
           }
-          const webglBuffer = readBuffer;
+          const webglBuffer = buffer;
           this.gl.bindBuffer(35051, webglBuffer.handle);
           try {
             this._readColorTextureLayers(normalizedOptions, memoryLayout, (destinationByteOffset) => {
-              this.gl.readPixels(normalizedOptions.x, normalizedOptions.y, normalizedOptions.width, normalizedOptions.height, this.glFormat, this.glType, destinationByteOffset);
+              this.gl.readPixels(normalizedOptions.x, normalizedOptions.y, normalizedOptions.width, normalizedOptions.height, this.glFormat, this.glType, byteOffset + destinationByteOffset);
             });
           } finally {
             this.gl.bindBuffer(35051, null);
           }
-          return readBuffer;
+          return buffer;
         }
         async readDataAsync(options = {}) {
-          const buffer = this.readBuffer(options);
-          const data = await buffer.readAsync();
-          buffer.destroy();
-          return data.buffer;
+          throw new Error(`${this} readDataAsync is deprecated; use readBuffer() with an explicit destination buffer or DynamicTexture.readAsync()`);
         }
         writeBuffer(buffer, options_ = {}) {
           const options = this._normalizeTextureWriteOptions(options_);
@@ -3673,7 +3687,7 @@ ${source}`;
           const options = this._getSupportedColorReadOptions(options_);
           const memoryLayout = this.computeMemoryLayout(options);
           const shaderType = convertGLDataTypeToDataType(this.glType);
-          const ArrayType = (0, import_core16.getTypedArrayConstructor)(shaderType);
+          const ArrayType = (0, import_core15.getTypedArrayConstructor)(shaderType);
           const targetArray = new ArrayType(memoryLayout.byteLength / ArrayType.BYTES_PER_ELEMENT);
           this._readColorTextureLayers(options, memoryLayout, (destinationByteOffset) => {
             const layerView = new ArrayType(targetArray.buffer, targetArray.byteOffset + destinationByteOffset, memoryLayout.bytesPerImage / ArrayType.BYTES_PER_ELEMENT);
@@ -3952,23 +3966,38 @@ ${source}`;
   function mergeShaderLayout(baseLayout, overrideLayout) {
     const mergedLayout = {
       ...baseLayout,
-      attributes: baseLayout.attributes.map((attribute) => ({ ...attribute }))
+      attributes: baseLayout.attributes.map((attribute) => ({ ...attribute })),
+      bindings: baseLayout.bindings.map((binding) => ({ ...binding }))
     };
     for (const attribute of overrideLayout?.attributes || []) {
       const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
       if (!baseAttribute) {
-        import_core17.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
+        import_core16.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
       } else {
         baseAttribute.type = attribute.type || baseAttribute.type;
         baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
       }
     }
+    for (const binding of overrideLayout?.bindings || []) {
+      const baseBinding = getShaderLayoutBindingByName(mergedLayout, binding.name);
+      if (!baseBinding) {
+        import_core16.log.warn(`shader layout binding ${binding.name} not present in shader`);
+        continue;
+      }
+      Object.assign(baseBinding, binding);
+    }
     return mergedLayout;
   }
-  var import_core17, WEBGLRenderPipeline;
+  function getShaderLayoutBindingByName(shaderLayout, bindingName) {
+    return shaderLayout.bindings.find((binding) => binding.name === bindingName || binding.name === `${bindingName}Uniforms` || `${binding.name}Uniforms` === bindingName);
+  }
+  function getBindingValueForLayoutBinding(bindings, bindingName) {
+    return bindings[bindingName] || bindings[`${bindingName}Uniforms`] || bindings[bindingName.replace(/Uniforms$/, "")];
+  }
+  var import_core16, WEBGLRenderPipeline;
   var init_webgl_render_pipeline = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pipeline.js"() {
-      import_core17 = __toESM(require_core2(), 1);
+      import_core16 = __toESM(require_core2(), 1);
       init_device_parameters();
       init_set_uniform();
       init_webgl_buffer();
@@ -3976,7 +4005,7 @@ ${source}`;
       init_webgl_texture();
       init_webgl_texture_view();
       init_webgl_topology_utils();
-      WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
+      WEBGLRenderPipeline = class extends import_core16.RenderPipeline {
         /** The WebGL device that created this render pipeline */
         device;
         /** Handle to underlying WebGL program */
@@ -4026,17 +4055,18 @@ ${source}`;
          * Shared-model draws pass bindings per draw and do not rely on this state.
          */
         setBindings(bindings, options) {
-          for (const [name, value] of Object.entries(bindings)) {
-            const binding = this.shaderLayout.bindings.find((binding_) => binding_.name === name) || this.shaderLayout.bindings.find((binding_) => binding_.name === `${name}Uniforms`);
+          const flatBindings = (0, import_core16.flattenBindingsByGroup)((0, import_core16.normalizeBindingsByGroup)(this.shaderLayout, bindings));
+          for (const [name, value] of Object.entries(flatBindings)) {
+            const binding = getShaderLayoutBindingByName(this.shaderLayout, name);
             if (!binding) {
               const validBindings = this.shaderLayout.bindings.map((binding_) => `"${binding_.name}"`).join(", ");
               if (!options?.disableWarnings) {
-                import_core17.log.warn(`No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
+                import_core16.log.warn(`No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
               }
               continue;
             }
             if (!value) {
-              import_core17.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+              import_core16.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
             }
             switch (binding.type) {
               case "uniform":
@@ -4050,7 +4080,7 @@ ${source}`;
                 }
                 break;
               case "sampler":
-                import_core17.log.warn(`Ignoring sampler ${name}`)();
+                import_core16.log.warn(`Ignoring sampler ${name}`)();
                 break;
               default:
                 throw new Error(binding.type);
@@ -4064,6 +4094,7 @@ ${source}`;
          */
         draw(options) {
           this._syncLinkStatus();
+          const drawBindings = options.bindGroups ? (0, import_core16.flattenBindingsByGroup)(options.bindGroups) : options.bindings || this.bindings;
           const {
             renderPass,
             parameters = this.props.parameters,
@@ -4078,18 +4109,17 @@ ${source}`;
             // firstInstance,
             // baseVertex,
             transformFeedback,
-            bindings = this.bindings,
             uniforms = this.uniforms
           } = options;
           const glDrawMode = getGLDrawMode(topology);
           const isIndexed = Boolean(vertexArray.indexBuffer);
           const glIndexType = vertexArray.indexBuffer?.glIndexType;
           if (this.linkStatus !== "success") {
-            import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+            import_core16.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
             return false;
           }
-          if (!this._areTexturesRenderable(bindings)) {
-            import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
+          if (!this._areTexturesRenderable(drawBindings)) {
+            import_core16.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
             return false;
           }
           this.device.gl.useProgram(this.handle);
@@ -4097,7 +4127,7 @@ ${source}`;
           if (transformFeedback) {
             transformFeedback.begin(this.props.topology);
           }
-          this._applyBindings(bindings, { disableWarnings: this.props.disableWarnings });
+          this._applyBindings(drawBindings, { disableWarnings: this.props.disableWarnings });
           this._applyUniforms(uniforms);
           const webglRenderPass = renderPass;
           withDeviceAndGLParameters(this.device, parameters, webglRenderPass.glParameters, () => {
@@ -4132,8 +4162,8 @@ ${source}`;
         _areTexturesRenderable(bindings) {
           let texturesRenderable = true;
           for (const bindingInfo of this.shaderLayout.bindings) {
-            if (!bindings[bindingInfo.name] && !bindings[bindingInfo.name.replace(/Uniforms$/, "")]) {
-              import_core17.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
+            if (!getBindingValueForLayoutBinding(bindings, bindingInfo.name)) {
+              import_core16.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
               texturesRenderable = false;
             }
           }
@@ -4150,7 +4180,7 @@ ${source}`;
           let textureUnit = 0;
           let uniformBufferIndex = 0;
           for (const binding of this.shaderLayout.bindings) {
-            const value = bindings[binding.name] || bindings[binding.name.replace(/Uniforms$/, "")];
+            const value = getBindingValueForLayoutBinding(bindings, binding.name);
             if (!value) {
               throw new Error(`No value for binding ${binding.name} in ${this.id}`);
             }
@@ -4165,16 +4195,8 @@ ${source}`;
                 if (value instanceof WEBGLBuffer) {
                   gl.bindBufferBase(35345, uniformBufferIndex, value.handle);
                 } else {
-                  gl.bindBufferRange(
-                    35345,
-                    uniformBufferIndex,
-                    // @ts-expect-error
-                    value.buffer.handle,
-                    // @ts-expect-error
-                    value.offset || 0,
-                    // @ts-expect-error
-                    value.size || value.buffer.byteLength - value.offset
-                  );
+                  const bufferBinding = value;
+                  gl.bindBufferRange(35345, uniformBufferIndex, bufferBinding.buffer.handle, bufferBinding.offset || 0, bufferBinding.size || bufferBinding.buffer.byteLength - (bufferBinding.offset || 0));
                 }
                 uniformBufferIndex += 1;
                 break;
@@ -4188,7 +4210,7 @@ ${source}`;
                 } else if (value instanceof WEBGLTexture) {
                   texture = value;
                 } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) {
-                  import_core17.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
+                  import_core16.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
                   texture = value.colorAttachments[0].texture;
                 } else {
                   throw new Error("No texture");
@@ -4397,7 +4419,7 @@ ${source}`;
       }
       const { name, type: glUniformType, size } = activeInfo;
       const uniformType = convertGLUniformTypeToShaderVariableType(glUniformType);
-      const { type, components } = (0, import_core18.getVariableShaderTypeInfo)(uniformType);
+      const { type, components } = (0, import_core17.getVariableShaderTypeInfo)(uniformType);
       varyings.push({ location, name, type, size: size * components });
     }
     varyings.sort((a, b) => a.location - b.location);
@@ -4477,6 +4499,12 @@ ${source}`;
           });
         }
       }
+      const uniformInstancePrefixes = new Set(blockInfo.uniforms.map((uniform) => uniform.name.split(".")[0]).filter((instanceName) => Boolean(instanceName)));
+      const blockAlias = blockInfo.name.replace(/Uniforms$/, "");
+      if (uniformInstancePrefixes.size === 1 && !uniformInstancePrefixes.has(blockInfo.name) && !uniformInstancePrefixes.has(blockAlias)) {
+        const [instanceName] = uniformInstancePrefixes;
+        import_core17.log.warn(`Uniform block "${blockInfo.name}" uses GLSL instance "${instanceName}". luma.gl binds uniform buffers by block name ("${blockInfo.name}") and alias ("${blockAlias}"). Prefer matching the instance name to one of those to avoid confusing silent mismatches.`)();
+      }
       uniformBlocks.push(blockInfo);
     }
     uniformBlocks.sort((a, b) => a.location - b.location);
@@ -4492,7 +4520,7 @@ ${source}`;
     }
     const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
     const matches = UNIFORM_NAME_REGEXP.exec(name);
-    const uniformName = (0, import_core18.assertDefined)(matches?.[1], `Failed to parse GLSL uniform name ${name}`);
+    const uniformName = (0, import_core17.assertDefined)(matches?.[1], `Failed to parse GLSL uniform name ${name}`);
     return {
       name: uniformName,
       // TODO - is this a bug, shouldn't we return the value?
@@ -4500,23 +4528,23 @@ ${source}`;
       isArray: Boolean(matches?.[2])
     };
   }
-  var import_core18;
+  var import_core17;
   var init_get_shader_layout_from_glsl = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/helpers/get-shader-layout-from-glsl.js"() {
-      import_core18 = __toESM(require_core2(), 1);
+      import_core17 = __toESM(require_core2(), 1);
       init_webgl_shadertypes();
     }
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-shared-render-pipeline.js
-  var import_core19, LOG_PROGRAM_PERF_PRIORITY, WEBGLSharedRenderPipeline;
+  var import_core18, LOG_PROGRAM_PERF_PRIORITY, WEBGLSharedRenderPipeline;
   var init_webgl_shared_render_pipeline = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-shared-render-pipeline.js"() {
-      import_core19 = __toESM(require_core2(), 1);
+      import_core18 = __toESM(require_core2(), 1);
       init_get_shader_layout_from_glsl();
       init_webgl_shadertypes();
       LOG_PROGRAM_PERF_PRIORITY = 4;
-      WEBGLSharedRenderPipeline = class extends import_core19.SharedRenderPipeline {
+      WEBGLSharedRenderPipeline = class extends import_core18.SharedRenderPipeline {
         device;
         handle;
         vs;
@@ -4533,9 +4561,9 @@ ${source}`;
             this.device.gl.transformFeedbackVaryings(this.handle, props.varyings, props.bufferMode || 35981);
           }
           this._linkShaders();
-          import_core19.log.time(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+          import_core18.log.time(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
           this.introspectedLayout = getShaderLayoutFromGLSL(this.device.gl, this.handle);
-          import_core19.log.timeEnd(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+          import_core18.log.timeEnd(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
         }
         destroy() {
           if (this.destroyed) {
@@ -4550,17 +4578,17 @@ ${source}`;
           const { gl } = this.device;
           gl.attachShader(this.handle, this.vs.handle);
           gl.attachShader(this.handle, this.fs.handle);
-          import_core19.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+          import_core18.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
           gl.linkProgram(this.handle);
-          import_core19.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+          import_core18.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
           if (!this.device.features.has("compilation-status-async-webgl")) {
             const status2 = this._getLinkStatus();
             this._reportLinkStatus(status2);
             return;
           }
-          import_core19.log.once(1, "RenderPipeline linking is asynchronous")();
+          import_core18.log.once(1, "RenderPipeline linking is asynchronous")();
           await this._waitForLinkComplete();
-          import_core19.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
+          import_core18.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
           const status = this._getLinkStatus();
           this._reportLinkStatus(status);
         }
@@ -4671,44 +4699,29 @@ ${source}`;
     device.gl.bindBuffer(36662, null);
     device.gl.bindBuffer(36663, null);
   }
-  function _copyBufferToTexture(device, options) {
-    throw new Error("Not implemented");
+  function _copyBufferToTexture(_device, _options) {
+    throw new Error("copyBufferToTexture is not supported in WebGL");
   }
   function _copyTextureToBuffer(device, options) {
-    const {
-      /** Texture to copy to/from. */
-      sourceTexture,
-      /**  Mip-map level of the texture to copy to/from. (Default 0) */
-      mipLevel = 0,
-      /** Defines which aspects of the texture to copy to/from. */
-      aspect = "all",
-      /** Width to copy */
-      width = options.sourceTexture.width,
-      /** Height to copy */
-      height = options.sourceTexture.height,
-      depthOrArrayLayers = 0,
-      /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
-      origin = [0, 0, 0],
-      /** Destination buffer */
-      destinationBuffer,
-      /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */
-      byteOffset = 0,
-      /**
-       * The stride, in bytes, between the beginning of each block row and the subsequent block row.
-       * Required if there are multiple block rows (i.e. the copy height or depth is more than one block).
-       */
-      bytesPerRow,
-      /**
-       * Number of block rows per single image of the texture.
-       * rowsPerImage &times; bytesPerRow is the stride, in bytes, between the beginning of each image of data and the subsequent image.
-       * Required if there are multiple images (i.e. the copy depth is more than one).
-       */
-      rowsPerImage
-    } = options;
+    const { sourceTexture, mipLevel = 0, aspect = "all", width = options.sourceTexture.width, height = options.sourceTexture.height, depthOrArrayLayers, origin = [0, 0, 0], destinationBuffer, byteOffset = 0, bytesPerRow, rowsPerImage } = options;
+    if (sourceTexture instanceof import_core19.Texture) {
+      sourceTexture.readBuffer({
+        x: origin[0] ?? 0,
+        y: origin[1] ?? 0,
+        z: origin[2] ?? 0,
+        width,
+        height,
+        depthOrArrayLayers,
+        mipLevel,
+        aspect,
+        byteOffset
+      }, destinationBuffer);
+      return;
+    }
     if (aspect !== "all") {
       throw new Error("aspect not supported in WebGL");
     }
-    if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) {
+    if (mipLevel !== 0 || depthOrArrayLayers !== void 0 || bytesPerRow || rowsPerImage) {
       throw new Error("not implemented");
     }
     const { framebuffer, destroyFramebuffer } = getFramebuffer(sourceTexture);
@@ -4717,7 +4730,7 @@ ${source}`;
       const webglBuffer = destinationBuffer;
       const sourceWidth = width || framebuffer.width;
       const sourceHeight = height || framebuffer.height;
-      const colorAttachment0 = (0, import_core20.assertDefined)(framebuffer.colorAttachments[0]);
+      const colorAttachment0 = (0, import_core19.assertDefined)(framebuffer.colorAttachments[0]);
       const sourceParams = getTextureFormatWebGL(colorAttachment0.texture.props.format);
       const sourceFormat = sourceParams.format;
       const sourceType = sourceParams.type;
@@ -4795,7 +4808,7 @@ ${source}`;
     }
   }
   function getFramebuffer(source) {
-    if (source instanceof import_core20.Texture) {
+    if (source instanceof import_core19.Texture) {
       const { width, height, id } = source;
       const framebuffer = source.device.createFramebuffer({
         id: `framebuffer-for-${id}`,
@@ -4807,13 +4820,13 @@ ${source}`;
     }
     return { framebuffer: source, destroyFramebuffer: false };
   }
-  var import_core20, WEBGLCommandBuffer;
+  var import_core19, WEBGLCommandBuffer;
   var init_webgl_command_buffer = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-command-buffer.js"() {
-      import_core20 = __toESM(require_core2(), 1);
-      init_webgl_texture();
+      import_core19 = __toESM(require_core2(), 1);
       init_webgl_texture_table();
-      WEBGLCommandBuffer = class extends import_core20.CommandBuffer {
+      init_webgl_texture();
+      WEBGLCommandBuffer = class extends import_core19.CommandBuffer {
         device;
         handle = null;
         commands = [];
@@ -4846,14 +4859,14 @@ ${source}`;
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pass.js
-  var import_core21, COLOR_CHANNELS, WEBGLRenderPass;
+  var import_core20, COLOR_CHANNELS, WEBGLRenderPass;
   var init_webgl_render_pass = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pass.js"() {
-      import_core21 = __toESM(require_core2(), 1);
+      import_core20 = __toESM(require_core2(), 1);
       init_with_parameters();
       init_unified_parameter_api();
       COLOR_CHANNELS = [1, 2, 4, 8];
-      WEBGLRenderPass = class extends import_core21.RenderPass {
+      WEBGLRenderPass = class extends import_core20.RenderPass {
         device;
         handle = null;
         /** Parameters that should be applied before each draw call */
@@ -4861,13 +4874,15 @@ ${source}`;
         constructor(device, props) {
           super(device, props);
           this.device = device;
-          if (!props?.framebuffer) {
+          const webglFramebuffer = this.props.framebuffer;
+          const isDefaultFramebuffer = !webglFramebuffer || webglFramebuffer.handle === null;
+          if (isDefaultFramebuffer) {
             device.getDefaultCanvasContext()._resizeDrawingBufferIfNeeded();
           }
           let viewport;
           if (!props?.parameters?.viewport) {
-            if (props?.framebuffer) {
-              const { width, height } = props.framebuffer;
+            if (!isDefaultFramebuffer) {
+              const { width, height } = webglFramebuffer;
               viewport = [0, 0, width, height];
             } else {
               const [width, height] = device.getDefaultCanvasContext().getDrawingBufferSize();
@@ -4876,11 +4891,10 @@ ${source}`;
           }
           this.device.pushState();
           this.setParameters({ viewport, ...this.props.parameters });
-          const webglFramebuffer = this.props.framebuffer;
-          if (this.props.framebuffer && webglFramebuffer?.handle) {
-            const drawBuffers = this.props.framebuffer.colorAttachments.map((_, i) => 36064 + i);
+          if (!isDefaultFramebuffer) {
+            const drawBuffers = webglFramebuffer.colorAttachments.map((_, i) => 36064 + i);
             this.device.gl.drawBuffers(drawBuffers);
-          } else if (!this.props.framebuffer) {
+          } else {
             this.device.gl.drawBuffers([1029]);
           }
           this.clear();
@@ -5018,13 +5032,13 @@ ${source}`;
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-command-encoder.js
-  var import_core22, WEBGLCommandEncoder;
+  var import_core21, WEBGLCommandEncoder;
   var init_webgl_command_encoder = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-command-encoder.js"() {
-      import_core22 = __toESM(require_core2(), 1);
+      import_core21 = __toESM(require_core2(), 1);
       init_webgl_command_buffer();
       init_webgl_render_pass();
-      WEBGLCommandEncoder = class extends import_core22.CommandEncoder {
+      WEBGLCommandEncoder = class extends import_core21.CommandEncoder {
         device;
         handle = null;
         commandBuffer;
@@ -5073,7 +5087,8 @@ ${source}`;
         }
         insertDebugMarker(markerLabel) {
         }
-        resolveQuerySet(querySet, destination, options) {
+        resolveQuerySet(_querySet, _destination, _options) {
+          throw new Error("resolveQuerySet is not supported in WebGL");
         }
         writeTimestamp(querySet, queryIndex) {
           const webglQuerySet = querySet;
@@ -5126,14 +5141,14 @@ ${source}`;
     }
     return true;
   }
-  var import_core23, WEBGLVertexArray;
+  var import_core22, WEBGLVertexArray;
   var init_webgl_vertex_array = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-vertex-array.js"() {
-      import_core23 = __toESM(require_core2(), 1);
-      init_dist2();
+      import_core22 = __toESM(require_core2(), 1);
+      init_dist();
       init_webgl_vertex_formats();
       init_fill_array();
-      WEBGLVertexArray = class extends import_core23.VertexArray {
+      WEBGLVertexArray = class extends import_core22.VertexArray {
         get [Symbol.toStringTag]() {
           return "VertexArray";
         }
@@ -5299,7 +5314,7 @@ ${source}`;
           this.buffer = this.buffer || this.device.createBuffer({ byteLength });
           updateNeeded ||= !compareConstantArrayValues(constantValue, this.bufferValue);
           if (updateNeeded) {
-            const typedArray = (0, import_core23.getScratchArray)(value.constructor, length);
+            const typedArray = (0, import_core22.getScratchArray)(value.constructor, length);
             fillArray({ target: typedArray, source: constantValue, start: 0, count: length });
             this.buffer.write(typedArray);
             this.bufferValue = value;
@@ -5317,13 +5332,13 @@ ${source}`;
     }
     return /^\d+$/.test(value);
   }
-  var import_core24, WEBGLTransformFeedback;
+  var import_core23, WEBGLTransformFeedback;
   var init_webgl_transform_feedback = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-transform-feedback.js"() {
-      import_core24 = __toESM(require_core2(), 1);
-      init_dist3();
+      import_core23 = __toESM(require_core2(), 1);
+      init_dist2();
       init_webgl_topology_utils();
-      WEBGLTransformFeedback = class extends import_core24.TransformFeedback {
+      WEBGLTransformFeedback = class extends import_core23.TransformFeedback {
         device;
         gl;
         handle;
@@ -5386,7 +5401,7 @@ ${source}`;
           const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
           if (location < 0) {
             this.unusedBuffers[locationOrName] = buffer;
-            import_core24.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+            import_core23.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
             return;
           }
           this.buffers[location] = { buffer, byteLength, byteOffset };
@@ -5469,14 +5484,15 @@ ${source}`;
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-query-set.js
-  var import_core25, WEBGLQuerySet;
+  var import_core24, WEBGLQuerySet;
   var init_webgl_query_set = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-query-set.js"() {
-      import_core25 = __toESM(require_core2(), 1);
-      WEBGLQuerySet = class extends import_core25.QuerySet {
+      import_core24 = __toESM(require_core2(), 1);
+      WEBGLQuerySet = class extends import_core24.QuerySet {
         device;
         handle;
         _timestampPairs = [];
+        _pendingReads = /* @__PURE__ */ new Set();
         _occlusionQuery = null;
         _occlusionActive = false;
         get [Symbol.toStringTag]() {
@@ -5512,15 +5528,21 @@ ${source}`;
           }
           for (const pair of this._timestampPairs) {
             if (pair.activeQuery) {
+              this._cancelPendingQuery(pair.activeQuery);
               this.device.gl.deleteQuery(pair.activeQuery.handle);
             }
             for (const query of pair.completedQueries) {
+              this._cancelPendingQuery(query);
               this.device.gl.deleteQuery(query.handle);
             }
           }
           if (this._occlusionQuery) {
+            this._cancelPendingQuery(this._occlusionQuery);
             this.device.gl.deleteQuery(this._occlusionQuery.handle);
           }
+          for (const query of Array.from(this._pendingReads)) {
+            this._cancelPendingQuery(query);
+          }
           this.destroyResource();
         }
         isResultAvailable(queryIndex) {
@@ -5589,7 +5611,11 @@ ${source}`;
             handle: this.handle,
             promise: null,
             result: null,
-            disjoint: false
+            disjoint: false,
+            cancelled: false,
+            pollRequestId: null,
+            resolve: null,
+            reject: null
           };
           this._occlusionActive = true;
         }
@@ -5618,7 +5644,11 @@ ${source}`;
               handle,
               promise: null,
               result: null,
-              disjoint: false
+              disjoint: false,
+              cancelled: false,
+              pollRequestId: null,
+              resolve: null,
+              reject: null
             };
             this.device.gl.beginQuery(35007, handle);
             pair.activeQuery = query;
@@ -5650,6 +5680,10 @@ ${source}`;
           return this._pollQueryAvailability(pair.completedQueries[0]);
         }
         _pollQueryAvailability(query) {
+          if (query.cancelled || this.destroyed) {
+            query.result = 0n;
+            return true;
+          }
           if (query.result !== null || query.disjoint) {
             return true;
           }
@@ -5678,13 +5712,28 @@ ${source}`;
           if (query.promise) {
             return query.promise;
           }
+          this._pendingReads.add(query);
           query.promise = new Promise((resolve, reject) => {
+            query.resolve = resolve;
+            query.reject = reject;
             const poll = () => {
+              query.pollRequestId = null;
+              if (query.cancelled || this.destroyed) {
+                this._pendingReads.delete(query);
+                query.promise = null;
+                query.resolve = null;
+                query.reject = null;
+                resolve(0n);
+                return;
+              }
               if (!this._pollQueryAvailability(query)) {
-                requestAnimationFrame(poll);
+                query.pollRequestId = this._requestAnimationFrame(poll);
                 return;
               }
+              this._pendingReads.delete(query);
               query.promise = null;
+              query.resolve = null;
+              query.reject = null;
               if (query.disjoint) {
                 reject(new Error("GPU timestamp query was invalidated by a disjoint event"));
               } else {
@@ -5695,16 +5744,37 @@ ${source}`;
           });
           return query.promise;
         }
+        _cancelPendingQuery(query) {
+          this._pendingReads.delete(query);
+          query.cancelled = true;
+          if (query.pollRequestId !== null) {
+            this._cancelAnimationFrame(query.pollRequestId);
+            query.pollRequestId = null;
+          }
+          if (query.resolve) {
+            const resolve = query.resolve;
+            query.promise = null;
+            query.resolve = null;
+            query.reject = null;
+            resolve(0n);
+          }
+        }
+        _requestAnimationFrame(callback) {
+          return requestAnimationFrame(callback);
+        }
+        _cancelAnimationFrame(requestId) {
+          cancelAnimationFrame(requestId);
+        }
       };
     }
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-fence.js
-  var import_core26, WEBGLFence;
+  var import_core25, WEBGLFence;
   var init_webgl_fence = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-fence.js"() {
-      import_core26 = __toESM(require_core2(), 1);
-      WEBGLFence = class extends import_core26.Fence {
+      import_core25 = __toESM(require_core2(), 1);
+      WEBGLFence = class extends import_core25.Fence {
         device;
         gl;
         handle;
@@ -5823,7 +5893,7 @@ ${source}`;
     sourceFormat ||= texture?.glFormat || 6408;
     sourceType ||= texture?.glType || 5121;
     target2 = getPixelArray(target2, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
-    const signedType = (0, import_core27.getDataType)(target2);
+    const signedType = import_core26.dataTypeDecoder.getDataType(target2);
     sourceType = sourceType || convertDataTypeToGLDataType(signedType);
     const prevHandle = gl.bindFramebuffer(36160, handle);
     gl.readBuffer(36064 + sourceAttachment);
@@ -5866,7 +5936,7 @@ ${source}`;
     return webglBufferTarget;
   }
   function getFramebuffer2(source) {
-    if (!(source instanceof import_core27.Framebuffer)) {
+    if (!(source instanceof import_core26.Framebuffer)) {
       return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
     }
     return { framebuffer: source, deleteFramebuffer: false };
@@ -5888,14 +5958,14 @@ ${source}`;
     }
     glType ||= 5121;
     const shaderType = convertGLDataTypeToDataType(glType);
-    const ArrayType = (0, import_core27.getTypedArrayConstructor)(shaderType);
+    const ArrayType = import_core26.dataTypeDecoder.getTypedArrayConstructor(shaderType);
     const components = glFormatToComponents(glFormat);
     return new ArrayType(width * height * components);
   }
-  var import_core27;
+  var import_core26;
   var init_webgl_texture_utils = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/helpers/webgl-texture-utils.js"() {
-      import_core27 = __toESM(require_core2(), 1);
+      import_core26 = __toESM(require_core2(), 1);
       init_webgl_shadertypes();
       init_format_utils();
       init_shader_formats();
@@ -5937,10 +6007,10 @@ ${source}`;
     }
     return true;
   }
-  var import_core28, WebGLDevice;
+  var import_core27, WebGLDevice;
   var init_webgl_device = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/webgl-device.js"() {
-      import_core28 = __toESM(require_core2(), 1);
+      import_core27 = __toESM(require_core2(), 1);
       init_webgl_state_tracker();
       init_create_browser_context();
       init_webgl_context_data();
@@ -5969,7 +6039,7 @@ ${source}`;
       init_unified_parameter_api();
       init_with_parameters();
       init_webgl_extensions();
-      WebGLDevice = class extends import_core28.Device {
+      WebGLDevice = class extends import_core27.Device {
         static getDeviceFromContext(gl) {
           if (!gl) {
             return null;
@@ -6020,7 +6090,7 @@ ${source}`;
         }
         constructor(props) {
           super({ ...props, id: props.id || uid("webgl-device") });
-          const canvasContextProps = import_core28.Device._getCanvasContextProps(props);
+          const canvasContextProps = import_core27.Device._getCanvasContextProps(props);
           if (!canvasContextProps) {
             throw new Error("WebGLDevice requires props.createCanvasContext to be set");
           }
@@ -6058,7 +6128,7 @@ ${source}`;
           device = WebGLDevice.getDeviceFromContext(gl);
           if (device) {
             if (props._reuseDevices) {
-              import_core28.log.log(1, `Not creating a new Device, instead returning a reference to Device ${device.id} already attached to WebGL context`, device)();
+              import_core27.log.log(1, `Not creating a new Device, instead returning a reference to Device ${device.id} already attached to WebGL context`, device)();
               this.canvasContext.destroy();
               device._reused = true;
               return device;
@@ -6078,15 +6148,15 @@ ${source}`;
             this.features.initializeFeatures();
           }
           const glState = new WebGLStateTracker(this.gl, {
-            log: (...args) => import_core28.log.log(1, ...args)()
+            log: (...args) => import_core27.log.log(1, ...args)()
           });
           glState.trackState(this.gl, { copyState: false });
           if (props.debug || props.debugWebGL) {
             this.gl = makeDebugContext(this.gl, { debugWebGL: true, traceWebGL: props.debugWebGL });
-            import_core28.log.warn("WebGL debug mode activated. Performance reduced.")();
+            import_core27.log.warn("WebGL debug mode activated. Performance reduced.")();
           }
           if (props.debugWebGL) {
-            import_core28.log.level = Math.max(import_core28.log.level, 1);
+            import_core27.log.level = Math.max(import_core27.log.level, 1);
           }
           this.commandEncoder = new WEBGLCommandEncoder(this, { id: `${this}-command-encoder` });
           this.canvasContext._startObservers();
@@ -6169,13 +6239,7 @@ ${source}`;
         submit(commandBuffer) {
           let submittedCommandEncoder = null;
           if (!commandBuffer) {
-            submittedCommandEncoder = this.commandEncoder;
-            commandBuffer = submittedCommandEncoder.finish();
-            this.commandEncoder.destroy();
-            this.commandEncoder = this.createCommandEncoder({
-              id: submittedCommandEncoder.props.id,
-              timeProfilingQuerySet: submittedCommandEncoder.getTimeProfilingQuerySet()
-            });
+            ({ submittedCommandEncoder, commandBuffer } = this._finalizeDefaultCommandEncoderForSubmit());
           }
           try {
             commandBuffer._executeCommands();
@@ -6189,6 +6253,16 @@ ${source}`;
             commandBuffer.destroy();
           }
         }
+        _finalizeDefaultCommandEncoderForSubmit() {
+          const submittedCommandEncoder = this.commandEncoder;
+          const commandBuffer = submittedCommandEncoder.finish();
+          this.commandEncoder.destroy();
+          this.commandEncoder = this.createCommandEncoder({
+            id: submittedCommandEncoder.props.id,
+            timeProfilingQuerySet: submittedCommandEncoder.getTimeProfilingQuerySet()
+          });
+          return { submittedCommandEncoder, commandBuffer };
+        }
         //
         // TEMPORARY HACKS - will be removed in v9.1
         //
@@ -6210,7 +6284,7 @@ ${source}`;
           return withGLParameters(this.gl, parameters, func);
         }
         resetWebGL() {
-          import_core28.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
+          import_core27.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
           resetGLParameters(this.gl);
         }
         _getDeviceSpecificTextureFormatCapabilities(capabilities) {
@@ -6282,7 +6356,7 @@ ${source}`;
           this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
           const currentConstant = this._constants[location];
           if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-            import_core28.log.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)();
+            import_core27.log.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)();
           }
           this._constants[location] = constant;
           switch (constant.constructor) {
@@ -6319,7 +6393,7 @@ ${source}`;
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/index.js
-  var init_dist3 = __esm({
+  var init_dist2 = __esm({
     "../../node_modules/@luma.gl/webgl/dist/index.js"() {
       init_webgl_device();
       init_webgl_buffer();
@@ -6626,12 +6700,12 @@ ${source}`;
   }
 
   // dist/commons.js
-  var import_core29 = __toESM(require_core(), 1);
+  var import_core28 = __toESM(require_core(), 1);
   var import_engine = __toESM(require_engine(), 1);
-  init_dist3();
+  init_dist2();
   async function createDeckInstance(gl) {
     return new Promise((resolve) => {
-      const deckInstance = new import_core29.Deck({
+      const deckInstance = new import_core28.Deck({
         // Input is handled by the ArcGIS API for JavaScript.
         controller: false,
         // We use the same WebGL context as the ArcGIS API for JavaScript.