npm - @luma.gl/webgl - Versions diffs - 9.0.0-beta.5 → 9.0.0-beta.7 - Mend

@luma.gl/webgl 9.0.0-beta.5 → 9.0.0-beta.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (192) hide show

package/dist/index.cjs CHANGED Viewed

@@ -30,7 +30,6 @@ __export(dist_exports, {
   WEBGLFramebuffer: () => WEBGLFramebuffer,
   WEBGLRenderPass: () => WEBGLRenderPass,
   WEBGLRenderPipeline: () => WEBGLRenderPipeline,
-  WEBGLRenderbuffer: () => WEBGLRenderbuffer,
   WEBGLResource: () => WebGLResource,
   WEBGLSampler: () => WEBGLSampler,
   WEBGLShader: () => WEBGLShader,
@@ -41,6 +40,7 @@ __export(dist_exports, {
   WebGLDevice: () => WebGLDevice,
   WebGLResource: () => WebGLResource,
   _TEXTURE_FORMATS: () => TEXTURE_FORMATS,
+  _WEBGLRenderbuffer: () => WEBGLRenderbuffer,
   convertGLToTextureFormat: () => convertGLToTextureFormat,
   getGLParameters: () => getGLParameters,
   getShaderLayout: () => getShaderLayout,
@@ -56,8 +56,7 @@ __export(dist_exports, {
 module.exports = __toCommonJS(dist_exports);
 // dist/adapter/webgl-device.js
-var import_core26 = require("@luma.gl/core");
-var import_env3 = require("@probe.gl/env");
+var import_core27 = require("@luma.gl/core");
 // dist/context/state-tracker/track-context-state.js
 var import_core = require("@luma.gl/core");
@@ -65,102 +64,99 @@ var import_core = require("@luma.gl/core");
 // dist/context/parameters/webgl-parameter-tables.js
 var import_constants = require("@luma.gl/constants");
 var GL_PARAMETER_DEFAULTS = {
-  [import_constants.GL.BLEND]: false,
-  [import_constants.GL.BLEND_COLOR]: new Float32Array([0, 0, 0, 0]),
-  [import_constants.GL.BLEND_EQUATION_RGB]: import_constants.GL.FUNC_ADD,
-  [import_constants.GL.BLEND_EQUATION_ALPHA]: import_constants.GL.FUNC_ADD,
-  [import_constants.GL.BLEND_SRC_RGB]: import_constants.GL.ONE,
-  [import_constants.GL.BLEND_DST_RGB]: import_constants.GL.ZERO,
-  [import_constants.GL.BLEND_SRC_ALPHA]: import_constants.GL.ONE,
-  [import_constants.GL.BLEND_DST_ALPHA]: import_constants.GL.ZERO,
-  [import_constants.GL.COLOR_CLEAR_VALUE]: new Float32Array([0, 0, 0, 0]),
+  [3042]: false,
+  [32773]: new Float32Array([0, 0, 0, 0]),
+  [32777]: 32774,
+  [34877]: 32774,
+  [32969]: 1,
+  [32968]: 0,
+  [32971]: 1,
+  [32970]: 0,
+  [3106]: new Float32Array([0, 0, 0, 0]),
   // TBD
-  [import_constants.GL.COLOR_WRITEMASK]: [true, true, true, true],
-  [import_constants.GL.CULL_FACE]: false,
-  [import_constants.GL.CULL_FACE_MODE]: import_constants.GL.BACK,
-  [import_constants.GL.DEPTH_TEST]: false,
-  [import_constants.GL.DEPTH_CLEAR_VALUE]: 1,
-  [import_constants.GL.DEPTH_FUNC]: import_constants.GL.LESS,
-  [import_constants.GL.DEPTH_RANGE]: new Float32Array([0, 1]),
+  [3107]: [true, true, true, true],
+  [2884]: false,
+  [2885]: 1029,
+  [2929]: false,
+  [2931]: 1,
+  [2932]: 513,
+  [2928]: new Float32Array([0, 1]),
   // TBD
-  [import_constants.GL.DEPTH_WRITEMASK]: true,
-  [import_constants.GL.DITHER]: true,
-  [import_constants.GL.CURRENT_PROGRAM]: null,
+  [2930]: true,
+  [3024]: true,
+  [35725]: null,
   // FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
-  [import_constants.GL.FRAMEBUFFER_BINDING]: null,
-  [import_constants.GL.RENDERBUFFER_BINDING]: null,
-  [import_constants.GL.VERTEX_ARRAY_BINDING]: null,
-  [import_constants.GL.ARRAY_BUFFER_BINDING]: null,
-  [import_constants.GL.FRONT_FACE]: import_constants.GL.CCW,
-  [import_constants.GL.GENERATE_MIPMAP_HINT]: import_constants.GL.DONT_CARE,
-  [import_constants.GL.LINE_WIDTH]: 1,
-  [import_constants.GL.POLYGON_OFFSET_FILL]: false,
-  [import_constants.GL.POLYGON_OFFSET_FACTOR]: 0,
-  [import_constants.GL.POLYGON_OFFSET_UNITS]: 0,
-  [import_constants.GL.SAMPLE_ALPHA_TO_COVERAGE]: false,
-  [import_constants.GL.SAMPLE_COVERAGE]: false,
-  [import_constants.GL.SAMPLE_COVERAGE_VALUE]: 1,
-  [import_constants.GL.SAMPLE_COVERAGE_INVERT]: false,
-  [import_constants.GL.SCISSOR_TEST]: false,
+  [36006]: null,
+  [36007]: null,
+  [34229]: null,
+  [34964]: null,
+  [2886]: 2305,
+  [33170]: 4352,
+  [2849]: 1,
+  [32823]: false,
+  [32824]: 0,
+  [10752]: 0,
+  [32926]: false,
+  [32928]: false,
+  [32938]: 1,
+  [32939]: false,
+  [3089]: false,
   // Note: Dynamic value. If scissor test enabled we expect users to set correct scissor box
-  [import_constants.GL.SCISSOR_BOX]: new Int32Array([0, 0, 1024, 1024]),
-  [import_constants.GL.STENCIL_TEST]: false,
-  [import_constants.GL.STENCIL_CLEAR_VALUE]: 0,
-  [import_constants.GL.STENCIL_WRITEMASK]: 4294967295,
-  [import_constants.GL.STENCIL_BACK_WRITEMASK]: 4294967295,
-  [import_constants.GL.STENCIL_FUNC]: import_constants.GL.ALWAYS,
-  [import_constants.GL.STENCIL_REF]: 0,
-  [import_constants.GL.STENCIL_VALUE_MASK]: 4294967295,
-  [import_constants.GL.STENCIL_BACK_FUNC]: import_constants.GL.ALWAYS,
-  [import_constants.GL.STENCIL_BACK_REF]: 0,
-  [import_constants.GL.STENCIL_BACK_VALUE_MASK]: 4294967295,
-  [import_constants.GL.STENCIL_FAIL]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_PASS_DEPTH_FAIL]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_PASS_DEPTH_PASS]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_BACK_FAIL]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: import_constants.GL.KEEP,
-  [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: import_constants.GL.KEEP,
+  [3088]: new Int32Array([0, 0, 1024, 1024]),
+  [2960]: false,
+  [2961]: 0,
+  [2968]: 4294967295,
+  [36005]: 4294967295,
+  [2962]: 519,
+  [2967]: 0,
+  [2963]: 4294967295,
+  [34816]: 519,
+  [36003]: 0,
+  [36004]: 4294967295,
+  [2964]: 7680,
+  [2965]: 7680,
+  [2966]: 7680,
+  [34817]: 7680,
+  [34818]: 7680,
+  [34819]: 7680,
   // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame.
-  [import_constants.GL.VIEWPORT]: [0, 0, 1024, 1024],
-  // WEBGL1 PIXEL PACK/UNPACK MODES
-  [import_constants.GL.PACK_ALIGNMENT]: 4,
-  [import_constants.GL.UNPACK_ALIGNMENT]: 4,
-  [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: false,
-  [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
-  [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: import_constants.GL.BROWSER_DEFAULT_WEBGL,
-  // WEBGL2 / EXTENSIONS
-  // gl1: 'OES_standard_derivatives'
-  [import_constants.GL.TRANSFORM_FEEDBACK_BINDING]: null,
-  [import_constants.GL.COPY_READ_BUFFER_BINDING]: null,
-  [import_constants.GL.COPY_WRITE_BUFFER_BINDING]: null,
-  [import_constants.GL.PIXEL_PACK_BUFFER_BINDING]: null,
-  [import_constants.GL.PIXEL_UNPACK_BUFFER_BINDING]: null,
-  [import_constants.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: import_constants.GL.DONT_CARE,
-  [import_constants.GL.READ_FRAMEBUFFER_BINDING]: null,
-  [import_constants.GL.RASTERIZER_DISCARD]: false,
-  [import_constants.GL.PACK_ROW_LENGTH]: 0,
-  [import_constants.GL.PACK_SKIP_PIXELS]: 0,
-  [import_constants.GL.PACK_SKIP_ROWS]: 0,
-  [import_constants.GL.UNPACK_ROW_LENGTH]: 0,
-  [import_constants.GL.UNPACK_IMAGE_HEIGHT]: 0,
-  [import_constants.GL.UNPACK_SKIP_PIXELS]: 0,
-  [import_constants.GL.UNPACK_SKIP_ROWS]: 0,
-  [import_constants.GL.UNPACK_SKIP_IMAGES]: 0
+  [2978]: [0, 0, 1024, 1024],
+  [36389]: null,
+  [36662]: null,
+  [36663]: null,
+  [35053]: null,
+  [35055]: null,
+  [35723]: 4352,
+  [36010]: null,
+  [35977]: false,
+  [3333]: 4,
+  [3317]: 4,
+  [37440]: false,
+  [37441]: false,
+  [37443]: 37444,
+  [3330]: 0,
+  [3332]: 0,
+  [3331]: 0,
+  [3314]: 0,
+  [32878]: 0,
+  [3316]: 0,
+  [3315]: 0,
+  [32877]: 0
 };
 var enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key);
 var hint = (gl, value, key) => gl.hint(key, value);
 var pixelStorei = (gl, value, key) => gl.pixelStorei(key, value);
 var bindFramebuffer = (gl, value, key) => {
-  const target = key === import_constants.GL.FRAMEBUFFER_BINDING ? import_constants.GL.DRAW_FRAMEBUFFER : import_constants.GL.READ_FRAMEBUFFER;
+  const target = key === 36006 ? 36009 : 36008;
   return gl.bindFramebuffer(target, value);
 };
 var bindBuffer = (gl, value, key) => {
   const bindingMap = {
-    [import_constants.GL.ARRAY_BUFFER_BINDING]: import_constants.GL.ARRAY_BUFFER,
-    [import_constants.GL.COPY_READ_BUFFER_BINDING]: import_constants.GL.COPY_READ_BUFFER,
-    [import_constants.GL.COPY_WRITE_BUFFER_BINDING]: import_constants.GL.COPY_WRITE_BUFFER,
-    [import_constants.GL.PIXEL_PACK_BUFFER_BINDING]: import_constants.GL.PIXEL_PACK_BUFFER,
-    [import_constants.GL.PIXEL_UNPACK_BUFFER_BINDING]: import_constants.GL.PIXEL_UNPACK_BUFFER
+    [34964]: 34962,
+    [36662]: 36662,
+    [36663]: 36663,
+    [35053]: 35051,
+    [35055]: 35052
   };
   const glTarget = bindingMap[key];
   gl.bindBuffer(glTarget, value);
@@ -169,93 +165,108 @@ function isArray(array) {
   return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView);
 }
 var GL_PARAMETER_SETTERS = {
-  [import_constants.GL.BLEND]: enable,
-  [import_constants.GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
-  [import_constants.GL.BLEND_EQUATION_RGB]: "blendEquation",
-  [import_constants.GL.BLEND_EQUATION_ALPHA]: "blendEquation",
-  [import_constants.GL.BLEND_SRC_RGB]: "blendFunc",
-  [import_constants.GL.BLEND_DST_RGB]: "blendFunc",
-  [import_constants.GL.BLEND_SRC_ALPHA]: "blendFunc",
-  [import_constants.GL.BLEND_DST_ALPHA]: "blendFunc",
-  [import_constants.GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
-  [import_constants.GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
-  [import_constants.GL.CULL_FACE]: enable,
-  [import_constants.GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
-  [import_constants.GL.DEPTH_TEST]: enable,
-  [import_constants.GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
-  [import_constants.GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
-  [import_constants.GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
-  [import_constants.GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
-  [import_constants.GL.DITHER]: enable,
-  [import_constants.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-  [import_constants.GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
-  [import_constants.GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(import_constants.GL.RENDERBUFFER, value),
-  [import_constants.GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => {
+  [3042]: enable,
+  [32773]: (gl, value) => gl.blendColor(...value),
+  [32777]: "blendEquation",
+  [34877]: "blendEquation",
+  [32969]: "blendFunc",
+  [32968]: "blendFunc",
+  [32971]: "blendFunc",
+  [32970]: "blendFunc",
+  [3106]: (gl, value) => gl.clearColor(...value),
+  [3107]: (gl, value) => gl.colorMask(...value),
+  [2884]: enable,
+  [2885]: (gl, value) => gl.cullFace(value),
+  [2929]: enable,
+  [2931]: (gl, value) => gl.clearDepth(value),
+  [2932]: (gl, value) => gl.depthFunc(value),
+  [2928]: (gl, value) => gl.depthRange(...value),
+  [2930]: (gl, value) => gl.depthMask(value),
+  [3024]: enable,
+  [35723]: hint,
+  [35725]: (gl, value) => gl.useProgram(value),
+  [36007]: (gl, value) => gl.bindRenderbuffer(36161, value),
+  [36389]: (gl, value) => {
     var _a;
-    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, import_constants.GL.TRANSFORM_FEEDBACK, value);
+    return (_a = gl.bindTransformFeedback) == null ? void 0 : _a.call(gl, 36386, value);
   },
-  [import_constants.GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
+  [34229]: (gl, value) => gl.bindVertexArray(value),
   // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
-  [import_constants.GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
-  [import_constants.GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
+  [36006]: bindFramebuffer,
+  [36010]: bindFramebuffer,
   // Buffers
-  [import_constants.GL.ARRAY_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.COPY_READ_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
-  [import_constants.GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
-  [import_constants.GL.GENERATE_MIPMAP_HINT]: hint,
-  [import_constants.GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
-  [import_constants.GL.POLYGON_OFFSET_FILL]: enable,
-  [import_constants.GL.POLYGON_OFFSET_FACTOR]: "polygonOffset",
-  [import_constants.GL.POLYGON_OFFSET_UNITS]: "polygonOffset",
-  [import_constants.GL.RASTERIZER_DISCARD]: enable,
-  [import_constants.GL.SAMPLE_ALPHA_TO_COVERAGE]: enable,
-  [import_constants.GL.SAMPLE_COVERAGE]: enable,
-  [import_constants.GL.SAMPLE_COVERAGE_VALUE]: "sampleCoverage",
-  [import_constants.GL.SAMPLE_COVERAGE_INVERT]: "sampleCoverage",
-  [import_constants.GL.SCISSOR_TEST]: enable,
-  [import_constants.GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
-  [import_constants.GL.STENCIL_TEST]: enable,
-  [import_constants.GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
-  [import_constants.GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants.GL.FRONT, value),
-  [import_constants.GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(import_constants.GL.BACK, value),
-  [import_constants.GL.STENCIL_FUNC]: "stencilFuncFront",
-  [import_constants.GL.STENCIL_REF]: "stencilFuncFront",
-  [import_constants.GL.STENCIL_VALUE_MASK]: "stencilFuncFront",
-  [import_constants.GL.STENCIL_BACK_FUNC]: "stencilFuncBack",
-  [import_constants.GL.STENCIL_BACK_REF]: "stencilFuncBack",
-  [import_constants.GL.STENCIL_BACK_VALUE_MASK]: "stencilFuncBack",
-  [import_constants.GL.STENCIL_FAIL]: "stencilOpFront",
-  [import_constants.GL.STENCIL_PASS_DEPTH_FAIL]: "stencilOpFront",
-  [import_constants.GL.STENCIL_PASS_DEPTH_PASS]: "stencilOpFront",
-  [import_constants.GL.STENCIL_BACK_FAIL]: "stencilOpBack",
-  [import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
-  [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
-  [import_constants.GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
-  // WEBGL1 PIXEL PACK/UNPACK MODES
-  [import_constants.GL.PACK_ALIGNMENT]: pixelStorei,
-  [import_constants.GL.UNPACK_ALIGNMENT]: pixelStorei,
-  [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: pixelStorei,
-  [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,
-  [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,
-  // WEBGL2 PIXEL PACK/UNPACK MODES
-  // RASTERIZER_DISCARD ...
-  [import_constants.GL.PACK_ROW_LENGTH]: pixelStorei,
-  [import_constants.GL.PACK_SKIP_PIXELS]: pixelStorei,
-  [import_constants.GL.PACK_SKIP_ROWS]: pixelStorei,
-  [import_constants.GL.UNPACK_ROW_LENGTH]: pixelStorei,
-  [import_constants.GL.UNPACK_IMAGE_HEIGHT]: pixelStorei,
-  [import_constants.GL.UNPACK_SKIP_PIXELS]: pixelStorei,
-  [import_constants.GL.UNPACK_SKIP_ROWS]: pixelStorei,
-  [import_constants.GL.UNPACK_SKIP_IMAGES]: pixelStorei,
+  [34964]: bindBuffer,
+  [36662]: bindBuffer,
+  [36663]: bindBuffer,
+  [35053]: bindBuffer,
+  [35055]: bindBuffer,
+  [2886]: (gl, value) => gl.frontFace(value),
+  [33170]: hint,
+  [2849]: (gl, value) => gl.lineWidth(value),
+  [32823]: enable,
+  [32824]: "polygonOffset",
+  [10752]: "polygonOffset",
+  [35977]: enable,
+  [32926]: enable,
+  [32928]: enable,
+  [32938]: "sampleCoverage",
+  [32939]: "sampleCoverage",
+  [3089]: enable,
+  [3088]: (gl, value) => gl.scissor(...value),
+  [2960]: enable,
+  [2961]: (gl, value) => gl.clearStencil(value),
+  [2968]: (gl, value) => gl.stencilMaskSeparate(1028, value),
+  [36005]: (gl, value) => gl.stencilMaskSeparate(1029, value),
+  [2962]: "stencilFuncFront",
+  [2967]: "stencilFuncFront",
+  [2963]: "stencilFuncFront",
+  [34816]: "stencilFuncBack",
+  [36003]: "stencilFuncBack",
+  [36004]: "stencilFuncBack",
+  [2964]: "stencilOpFront",
+  [2965]: "stencilOpFront",
+  [2966]: "stencilOpFront",
+  [34817]: "stencilOpBack",
+  [34818]: "stencilOpBack",
+  [34819]: "stencilOpBack",
+  [2978]: (gl, value) => gl.viewport(...value),
+  // WEBGL2 EXTENSIONS
+  // EXT_depth_clamp https://registry.khronos.org/webgl/extensions/EXT_depth_clamp/
+  [34383]: enable,
+  // WEBGL_provoking_vertex https://registry.khronos.org/webgl/extensions/WEBGL_provoking_vertex/
+  // [GL.PROVOKING_VERTEX_WEBL]: TODO - extension function needed
+  // WEBGL_polygon_mode https://registry.khronos.org/webgl/extensions/WEBGL_polygon_mode/
+  // POLYGON_MODE_WEBGL  TODO - extension function needed
+  [10754]: enable,
+  // WEBGL_clip_cull_distance https://registry.khronos.org/webgl/extensions/WEBGL_clip_cull_distance/
+  [12288]: enable,
+  [12289]: enable,
+  [12290]: enable,
+  [12291]: enable,
+  [12292]: enable,
+  [12293]: enable,
+  [12294]: enable,
+  [12295]: enable,
+  // PIXEL PACK/UNPACK MODES
+  [3333]: pixelStorei,
+  [3317]: pixelStorei,
+  [37440]: pixelStorei,
+  [37441]: pixelStorei,
+  [37443]: pixelStorei,
+  [3330]: pixelStorei,
+  [3332]: pixelStorei,
+  [3331]: pixelStorei,
+  [3314]: pixelStorei,
+  [32878]: pixelStorei,
+  [3316]: pixelStorei,
+  [3315]: pixelStorei,
+  [32877]: pixelStorei,
   // Function-style setters
   framebuffer: (gl, framebuffer) => {
     const handle = framebuffer && "handle" in framebuffer ? framebuffer.handle : framebuffer;
-    return gl.bindFramebuffer(import_constants.GL.FRAMEBUFFER, handle);
+    return gl.bindFramebuffer(36160, handle);
   },
-  blend: (gl, value) => value ? gl.enable(import_constants.GL.BLEND) : gl.disable(import_constants.GL.BLEND),
+  blend: (gl, value) => value ? gl.enable(3042) : gl.disable(3042),
   blendColor: (gl, value) => gl.blendColor(...value),
   blendEquation: (gl, args) => {
     const separateModes = typeof args === "number" ? [args, args] : args;
@@ -269,42 +280,42 @@ var GL_PARAMETER_SETTERS = {
   clearDepth: (gl, value) => gl.clearDepth(value),
   clearStencil: (gl, value) => gl.clearStencil(value),
   colorMask: (gl, value) => gl.colorMask(...value),
-  cull: (gl, value) => value ? gl.enable(import_constants.GL.CULL_FACE) : gl.disable(import_constants.GL.CULL_FACE),
+  cull: (gl, value) => value ? gl.enable(2884) : gl.disable(2884),
   cullFace: (gl, value) => gl.cullFace(value),
-  depthTest: (gl, value) => value ? gl.enable(import_constants.GL.DEPTH_TEST) : gl.disable(import_constants.GL.DEPTH_TEST),
+  depthTest: (gl, value) => value ? gl.enable(2929) : gl.disable(2929),
   depthFunc: (gl, value) => gl.depthFunc(value),
   depthMask: (gl, value) => gl.depthMask(value),
   depthRange: (gl, value) => gl.depthRange(...value),
-  dither: (gl, value) => value ? gl.enable(import_constants.GL.DITHER) : gl.disable(import_constants.GL.DITHER),
+  dither: (gl, value) => value ? gl.enable(3024) : gl.disable(3024),
   derivativeHint: (gl, value) => {
-    gl.hint(import_constants.GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
+    gl.hint(35723, value);
   },
   frontFace: (gl, value) => gl.frontFace(value),
-  mipmapHint: (gl, value) => gl.hint(import_constants.GL.GENERATE_MIPMAP_HINT, value),
+  mipmapHint: (gl, value) => gl.hint(33170, value),
   lineWidth: (gl, value) => gl.lineWidth(value),
-  polygonOffsetFill: (gl, value) => value ? gl.enable(import_constants.GL.POLYGON_OFFSET_FILL) : gl.disable(import_constants.GL.POLYGON_OFFSET_FILL),
+  polygonOffsetFill: (gl, value) => value ? gl.enable(32823) : gl.disable(32823),
   polygonOffset: (gl, value) => gl.polygonOffset(...value),
   sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
-  scissorTest: (gl, value) => value ? gl.enable(import_constants.GL.SCISSOR_TEST) : gl.disable(import_constants.GL.SCISSOR_TEST),
+  scissorTest: (gl, value) => value ? gl.enable(3089) : gl.disable(3089),
   scissor: (gl, value) => gl.scissor(...value),
-  stencilTest: (gl, value) => value ? gl.enable(import_constants.GL.STENCIL_TEST) : gl.disable(import_constants.GL.STENCIL_TEST),
+  stencilTest: (gl, value) => value ? gl.enable(2960) : gl.disable(2960),
   stencilMask: (gl, value) => {
     value = isArray(value) ? value : [value, value];
     const [mask, backMask] = value;
-    gl.stencilMaskSeparate(import_constants.GL.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants.GL.BACK, backMask);
+    gl.stencilMaskSeparate(1028, mask);
+    gl.stencilMaskSeparate(1029, backMask);
   },
   stencilFunc: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [func, ref, mask, backFunc, backRef, backMask] = args;
-    gl.stencilFuncSeparate(import_constants.GL.FRONT, func, ref, mask);
-    gl.stencilFuncSeparate(import_constants.GL.BACK, backFunc, backRef, backMask);
+    gl.stencilFuncSeparate(1028, func, ref, mask);
+    gl.stencilFuncSeparate(1029, backFunc, backRef, backMask);
   },
   stencilOp: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;
-    gl.stencilOpSeparate(import_constants.GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants.GL.BACK, backSfail, backDpfail, backDppass);
+    gl.stencilOpSeparate(1028, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(1029, backSfail, backDpfail, backDppass);
   },
   viewport: (gl, value) => gl.viewport(...value)
 };
@@ -312,14 +323,14 @@ function getValue(glEnum, values, cache) {
   return values[glEnum] !== void 0 ? values[glEnum] : cache[glEnum];
 }
 var GL_COMPOSITE_PARAMETER_SETTERS = {
-  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(getValue(import_constants.GL.BLEND_EQUATION_RGB, values, cache), getValue(import_constants.GL.BLEND_EQUATION_ALPHA, values, cache)),
-  blendFunc: (gl, values, cache) => gl.blendFuncSeparate(getValue(import_constants.GL.BLEND_SRC_RGB, values, cache), getValue(import_constants.GL.BLEND_DST_RGB, values, cache), getValue(import_constants.GL.BLEND_SRC_ALPHA, values, cache), getValue(import_constants.GL.BLEND_DST_ALPHA, values, cache)),
-  polygonOffset: (gl, values, cache) => gl.polygonOffset(getValue(import_constants.GL.POLYGON_OFFSET_FACTOR, values, cache), getValue(import_constants.GL.POLYGON_OFFSET_UNITS, values, cache)),
-  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(getValue(import_constants.GL.SAMPLE_COVERAGE_VALUE, values, cache), getValue(import_constants.GL.SAMPLE_COVERAGE_INVERT, values, cache)),
-  stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(import_constants.GL.FRONT, getValue(import_constants.GL.STENCIL_FUNC, values, cache), getValue(import_constants.GL.STENCIL_REF, values, cache), getValue(import_constants.GL.STENCIL_VALUE_MASK, values, cache)),
-  stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(import_constants.GL.BACK, getValue(import_constants.GL.STENCIL_BACK_FUNC, values, cache), getValue(import_constants.GL.STENCIL_BACK_REF, values, cache), getValue(import_constants.GL.STENCIL_BACK_VALUE_MASK, values, cache)),
-  stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(import_constants.GL.FRONT, getValue(import_constants.GL.STENCIL_FAIL, values, cache), getValue(import_constants.GL.STENCIL_PASS_DEPTH_FAIL, values, cache), getValue(import_constants.GL.STENCIL_PASS_DEPTH_PASS, values, cache)),
-  stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(import_constants.GL.BACK, getValue(import_constants.GL.STENCIL_BACK_FAIL, values, cache), getValue(import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache), getValue(import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache))
+  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(getValue(32777, values, cache), getValue(34877, values, cache)),
+  blendFunc: (gl, values, cache) => gl.blendFuncSeparate(getValue(32969, values, cache), getValue(32968, values, cache), getValue(32971, values, cache), getValue(32970, values, cache)),
+  polygonOffset: (gl, values, cache) => gl.polygonOffset(getValue(32824, values, cache), getValue(10752, values, cache)),
+  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(getValue(32938, values, cache), getValue(32939, values, cache)),
+  stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(1028, getValue(2962, values, cache), getValue(2967, values, cache), getValue(2963, values, cache)),
+  stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(1029, getValue(34816, values, cache), getValue(36003, values, cache), getValue(36004, values, cache)),
+  stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(1028, getValue(2964, values, cache), getValue(2965, values, cache), getValue(2966, values, cache)),
+  stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(1029, getValue(34817, values, cache), getValue(34818, values, cache), getValue(34819, values, cache))
 };
 var GL_HOOKED_SETTERS = {
   // GENERIC SETTERS
@@ -337,39 +348,39 @@ var GL_HOOKED_SETTERS = {
   }),
   // SPECIFIC SETTERS
   useProgram: (update, value) => update({
-    [import_constants.GL.CURRENT_PROGRAM]: value
+    [35725]: value
   }),
   bindRenderbuffer: (update, target, value) => update({
-    [import_constants.GL.RENDERBUFFER_BINDING]: value
+    [36007]: value
   }),
   bindTransformFeedback: (update, target, value) => update({
-    [import_constants.GL.TRANSFORM_FEEDBACK_BINDING]: value
+    [36389]: value
   }),
   bindVertexArray: (update, value) => update({
-    [import_constants.GL.VERTEX_ARRAY_BINDING]: value
+    [34229]: value
   }),
   bindFramebuffer: (update, target, framebuffer) => {
     switch (target) {
-      case import_constants.GL.FRAMEBUFFER:
+      case 36160:
         return update({
-          [import_constants.GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer,
-          [import_constants.GL.READ_FRAMEBUFFER_BINDING]: framebuffer
+          [36006]: framebuffer,
+          [36010]: framebuffer
         });
-      case import_constants.GL.DRAW_FRAMEBUFFER:
-        return update({ [import_constants.GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer });
-      case import_constants.GL.READ_FRAMEBUFFER:
-        return update({ [import_constants.GL.READ_FRAMEBUFFER_BINDING]: framebuffer });
+      case 36009:
+        return update({ [36006]: framebuffer });
+      case 36008:
+        return update({ [36010]: framebuffer });
       default:
         return null;
     }
   },
   bindBuffer: (update, target, buffer) => {
     const pname = {
-      [import_constants.GL.ARRAY_BUFFER]: [import_constants.GL.ARRAY_BUFFER_BINDING],
-      [import_constants.GL.COPY_READ_BUFFER]: [import_constants.GL.COPY_READ_BUFFER_BINDING],
-      [import_constants.GL.COPY_WRITE_BUFFER]: [import_constants.GL.COPY_WRITE_BUFFER_BINDING],
-      [import_constants.GL.PIXEL_PACK_BUFFER]: [import_constants.GL.PIXEL_PACK_BUFFER_BINDING],
-      [import_constants.GL.PIXEL_UNPACK_BUFFER]: [import_constants.GL.PIXEL_UNPACK_BUFFER_BINDING]
+      [34962]: [34964],
+      [36662]: [36662],
+      [36663]: [36663],
+      [35051]: [35053],
+      [35052]: [35055]
     }[target];
     if (pname) {
       return update({ [pname]: buffer });
@@ -377,162 +388,154 @@ var GL_HOOKED_SETTERS = {
     return { valueChanged: true };
   },
   blendColor: (update, r, g, b, a) => update({
-    [import_constants.GL.BLEND_COLOR]: new Float32Array([r, g, b, a])
+    [32773]: new Float32Array([r, g, b, a])
   }),
   blendEquation: (update, mode) => update({
-    [import_constants.GL.BLEND_EQUATION_RGB]: mode,
-    [import_constants.GL.BLEND_EQUATION_ALPHA]: mode
+    [32777]: mode,
+    [34877]: mode
   }),
   blendEquationSeparate: (update, modeRGB, modeAlpha) => update({
-    [import_constants.GL.BLEND_EQUATION_RGB]: modeRGB,
-    [import_constants.GL.BLEND_EQUATION_ALPHA]: modeAlpha
+    [32777]: modeRGB,
+    [34877]: modeAlpha
   }),
   blendFunc: (update, src, dst) => update({
-    [import_constants.GL.BLEND_SRC_RGB]: src,
-    [import_constants.GL.BLEND_DST_RGB]: dst,
-    [import_constants.GL.BLEND_SRC_ALPHA]: src,
-    [import_constants.GL.BLEND_DST_ALPHA]: dst
+    [32969]: src,
+    [32968]: dst,
+    [32971]: src,
+    [32970]: dst
   }),
   blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({
-    [import_constants.GL.BLEND_SRC_RGB]: srcRGB,
-    [import_constants.GL.BLEND_DST_RGB]: dstRGB,
-    [import_constants.GL.BLEND_SRC_ALPHA]: srcAlpha,
-    [import_constants.GL.BLEND_DST_ALPHA]: dstAlpha
+    [32969]: srcRGB,
+    [32968]: dstRGB,
+    [32971]: srcAlpha,
+    [32970]: dstAlpha
   }),
   clearColor: (update, r, g, b, a) => update({
-    [import_constants.GL.COLOR_CLEAR_VALUE]: new Float32Array([r, g, b, a])
+    [3106]: new Float32Array([r, g, b, a])
   }),
   clearDepth: (update, depth) => update({
-    [import_constants.GL.DEPTH_CLEAR_VALUE]: depth
+    [2931]: depth
   }),
   clearStencil: (update, s) => update({
-    [import_constants.GL.STENCIL_CLEAR_VALUE]: s
+    [2961]: s
   }),
   colorMask: (update, r, g, b, a) => update({
-    [import_constants.GL.COLOR_WRITEMASK]: [r, g, b, a]
+    [3107]: [r, g, b, a]
   }),
   cullFace: (update, mode) => update({
-    [import_constants.GL.CULL_FACE_MODE]: mode
+    [2885]: mode
   }),
   depthFunc: (update, func) => update({
-    [import_constants.GL.DEPTH_FUNC]: func
+    [2932]: func
   }),
   depthRange: (update, zNear, zFar) => update({
-    [import_constants.GL.DEPTH_RANGE]: new Float32Array([zNear, zFar])
+    [2928]: new Float32Array([zNear, zFar])
   }),
   depthMask: (update, mask) => update({
-    [import_constants.GL.DEPTH_WRITEMASK]: mask
+    [2930]: mask
   }),
   frontFace: (update, face) => update({
-    [import_constants.GL.FRONT_FACE]: face
+    [2886]: face
   }),
   lineWidth: (update, width) => update({
-    [import_constants.GL.LINE_WIDTH]: width
+    [2849]: width
   }),
   polygonOffset: (update, factor, units) => update({
-    [import_constants.GL.POLYGON_OFFSET_FACTOR]: factor,
-    [import_constants.GL.POLYGON_OFFSET_UNITS]: units
+    [32824]: factor,
+    [10752]: units
   }),
   sampleCoverage: (update, value, invert) => update({
-    [import_constants.GL.SAMPLE_COVERAGE_VALUE]: value,
-    [import_constants.GL.SAMPLE_COVERAGE_INVERT]: invert
+    [32938]: value,
+    [32939]: invert
   }),
   scissor: (update, x, y, width, height) => update({
-    [import_constants.GL.SCISSOR_BOX]: new Int32Array([x, y, width, height])
+    [3088]: new Int32Array([x, y, width, height])
   }),
   stencilMask: (update, mask) => update({
-    [import_constants.GL.STENCIL_WRITEMASK]: mask,
-    [import_constants.GL.STENCIL_BACK_WRITEMASK]: mask
+    [2968]: mask,
+    [36005]: mask
   }),
   stencilMaskSeparate: (update, face, mask) => update({
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_WRITEMASK : import_constants.GL.STENCIL_BACK_WRITEMASK]: mask
+    [face === 1028 ? 2968 : 36005]: mask
   }),
   stencilFunc: (update, func, ref, mask) => update({
-    [import_constants.GL.STENCIL_FUNC]: func,
-    [import_constants.GL.STENCIL_REF]: ref,
-    [import_constants.GL.STENCIL_VALUE_MASK]: mask,
-    [import_constants.GL.STENCIL_BACK_FUNC]: func,
-    [import_constants.GL.STENCIL_BACK_REF]: ref,
-    [import_constants.GL.STENCIL_BACK_VALUE_MASK]: mask
+    [2962]: func,
+    [2967]: ref,
+    [2963]: mask,
+    [34816]: func,
+    [36003]: ref,
+    [36004]: mask
   }),
   stencilFuncSeparate: (update, face, func, ref, mask) => update({
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_FUNC : import_constants.GL.STENCIL_BACK_FUNC]: func,
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_REF : import_constants.GL.STENCIL_BACK_REF]: ref,
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_VALUE_MASK : import_constants.GL.STENCIL_BACK_VALUE_MASK]: mask
+    [face === 1028 ? 2962 : 34816]: func,
+    [face === 1028 ? 2967 : 36003]: ref,
+    [face === 1028 ? 2963 : 36004]: mask
   }),
   stencilOp: (update, fail, zfail, zpass) => update({
-    [import_constants.GL.STENCIL_FAIL]: fail,
-    [import_constants.GL.STENCIL_PASS_DEPTH_FAIL]: zfail,
-    [import_constants.GL.STENCIL_PASS_DEPTH_PASS]: zpass,
-    [import_constants.GL.STENCIL_BACK_FAIL]: fail,
-    [import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
-    [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
+    [2964]: fail,
+    [2965]: zfail,
+    [2966]: zpass,
+    [34817]: fail,
+    [34818]: zfail,
+    [34819]: zpass
   }),
   stencilOpSeparate: (update, face, fail, zfail, zpass) => update({
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_FAIL : import_constants.GL.STENCIL_BACK_FAIL]: fail,
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_PASS_DEPTH_FAIL : import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
-    [face === import_constants.GL.FRONT ? import_constants.GL.STENCIL_PASS_DEPTH_PASS : import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
+    [face === 1028 ? 2964 : 34817]: fail,
+    [face === 1028 ? 2965 : 34818]: zfail,
+    [face === 1028 ? 2966 : 34819]: zpass
   }),
   viewport: (update, x, y, width, height) => update({
-    [import_constants.GL.VIEWPORT]: [x, y, width, height]
+    [2978]: [x, y, width, height]
   })
 };
 var isEnabled = (gl, key) => gl.isEnabled(key);
 var GL_PARAMETER_GETTERS = {
-  [import_constants.GL.BLEND]: isEnabled,
-  [import_constants.GL.CULL_FACE]: isEnabled,
-  [import_constants.GL.DEPTH_TEST]: isEnabled,
-  [import_constants.GL.DITHER]: isEnabled,
-  [import_constants.GL.POLYGON_OFFSET_FILL]: isEnabled,
-  [import_constants.GL.SAMPLE_ALPHA_TO_COVERAGE]: isEnabled,
-  [import_constants.GL.SAMPLE_COVERAGE]: isEnabled,
-  [import_constants.GL.SCISSOR_TEST]: isEnabled,
-  [import_constants.GL.STENCIL_TEST]: isEnabled,
-  [import_constants.GL.RASTERIZER_DISCARD]: isEnabled
+  [3042]: isEnabled,
+  [2884]: isEnabled,
+  [2929]: isEnabled,
+  [3024]: isEnabled,
+  [32823]: isEnabled,
+  [32926]: isEnabled,
+  [32928]: isEnabled,
+  [3089]: isEnabled,
+  [2960]: isEnabled,
+  [35977]: isEnabled
 };
 var NON_CACHE_PARAMETERS = /* @__PURE__ */ new Set([
-  // setter not intercepted
-  import_constants.GL.ACTIVE_TEXTURE,
-  import_constants.GL.TRANSFORM_FEEDBACK_ACTIVE,
-  import_constants.GL.TRANSFORM_FEEDBACK_PAUSED,
-  // setters bindBufferRange/bindBufferBase cannot be pruned based on cache
-  import_constants.GL.TRANSFORM_FEEDBACK_BUFFER_BINDING,
-  import_constants.GL.UNIFORM_BUFFER_BINDING,
-  // states depending on VERTEX_ARRAY_BINDING
-  import_constants.GL.ELEMENT_ARRAY_BUFFER_BINDING,
-  // states depending on READ_FRAMEBUFFER_BINDING
-  import_constants.GL.IMPLEMENTATION_COLOR_READ_FORMAT,
-  import_constants.GL.IMPLEMENTATION_COLOR_READ_TYPE,
-  // states depending on FRAMEBUFFER_BINDING
-  import_constants.GL.READ_BUFFER,
-  import_constants.GL.DRAW_BUFFER0,
-  import_constants.GL.DRAW_BUFFER1,
-  import_constants.GL.DRAW_BUFFER2,
-  import_constants.GL.DRAW_BUFFER3,
-  import_constants.GL.DRAW_BUFFER4,
-  import_constants.GL.DRAW_BUFFER5,
-  import_constants.GL.DRAW_BUFFER6,
-  import_constants.GL.DRAW_BUFFER7,
-  import_constants.GL.DRAW_BUFFER8,
-  import_constants.GL.DRAW_BUFFER9,
-  import_constants.GL.DRAW_BUFFER10,
-  import_constants.GL.DRAW_BUFFER11,
-  import_constants.GL.DRAW_BUFFER12,
-  import_constants.GL.DRAW_BUFFER13,
-  import_constants.GL.DRAW_BUFFER14,
-  import_constants.GL.DRAW_BUFFER15,
-  // states depending on ACTIVE_TEXTURE
-  import_constants.GL.SAMPLER_BINDING,
-  import_constants.GL.TEXTURE_BINDING_2D,
-  import_constants.GL.TEXTURE_BINDING_2D_ARRAY,
-  import_constants.GL.TEXTURE_BINDING_3D,
-  import_constants.GL.TEXTURE_BINDING_CUBE_MAP
+  34016,
+  36388,
+  36387,
+  35983,
+  35368,
+  34965,
+  35739,
+  35738,
+  3074,
+  34853,
+  34854,
+  34855,
+  34856,
+  34857,
+  34858,
+  34859,
+  34860,
+  34861,
+  34862,
+  34863,
+  34864,
+  34865,
+  34866,
+  34867,
+  34868,
+  35097,
+  32873,
+  35869,
+  32874,
+  34068
 ]);
 // dist/context/parameters/unified-parameter-api.js
-function setGLParameters(device, parameters) {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+function setGLParameters(gl, parameters) {
   if (isObjectEmpty(parameters)) {
     return;
   }
@@ -556,9 +559,7 @@ function setGLParameters(device, parameters) {
     }
   }
 }
-function getGLParameters(device, parameters = GL_PARAMETER_DEFAULTS) {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+function getGLParameters(gl, parameters = GL_PARAMETER_DEFAULTS) {
   if (typeof parameters === "number") {
     const key = parameters;
     const getter = GL_PARAMETER_GETTERS[key];
@@ -572,8 +573,8 @@ function getGLParameters(device, parameters = GL_PARAMETER_DEFAULTS) {
   }
   return state;
 }
-function resetGLParameters(device) {
-  setGLParameters(device, GL_PARAMETER_DEFAULTS);
+function resetGLParameters(gl) {
+  setGLParameters(gl, GL_PARAMETER_DEFAULTS);
 }
 function isObjectEmpty(object) {
   for (const key in object) {
@@ -741,7 +742,7 @@ function installProgramSpy(gl) {
   };
 }
-// dist/context/context/create-browser-context.js
+// dist/context/helpers/create-browser-context.js
 var DEFAULT_CONTEXT_PROPS = {
   powerPreference: "high-performance",
   // After all, most apps are using WebGL for performance reasons
@@ -774,15 +775,26 @@ function createBrowserContext(canvas, props) {
 // dist/adapter/device-helpers/webgl-device-info.js
 var import_constants2 = require("@luma.gl/constants");
-function getDeviceInfo(gl) {
-  const vendorMasked = gl.getParameter(import_constants2.GL.VENDOR);
-  const rendererMasked = gl.getParameter(import_constants2.GL.RENDERER);
-  const ext = gl.getExtension("WEBGL_debug_renderer_info");
-  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants2.GL.VENDOR);
-  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants2.GL.RENDERER);
+// dist/context/helpers/webgl-extensions.js
+function getWebGLExtension(gl, name, extensions) {
+  if (extensions[name] === void 0) {
+    extensions[name] = gl.getExtension(name) || null;
+  }
+  return extensions[name];
+}
+// dist/adapter/device-helpers/webgl-device-info.js
+function getDeviceInfo(gl, extensions) {
+  const vendorMasked = gl.getParameter(7936);
+  const rendererMasked = gl.getParameter(7937);
+  getWebGLExtension(gl, "WEBGL_debug_renderer_info", extensions);
+  const ext = extensions.WEBGL_debug_renderer_info;
+  const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : 7936);
+  const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : 7937);
   const vendor = vendorUnmasked || vendorMasked;
   const renderer = rendererUnmasked || rendererMasked;
-  const version = gl.getParameter(import_constants2.GL.VERSION);
+  const version = gl.getParameter(7938);
   const gpu = identifyGPUVendor(vendor, renderer);
   const gpuBackend = identifyGPUBackend(vendor, renderer);
   const gpuType = identifyGPUType(vendor, renderer);
@@ -844,6 +856,9 @@ function identifyGPUType(vendor, renderer) {
   }
 }
+// dist/adapter/device-helpers/webgl-device-features.js
+var import_core3 = require("@luma.gl/core");
 // dist/adapter/converters/texture-formats.js
 var import_core2 = require("@luma.gl/core");
 var import_constants4 = require("@luma.gl/constants");
@@ -853,29 +868,29 @@ var import_constants3 = require("@luma.gl/constants");
 function getGLFromVertexType(dataType) {
   switch (dataType) {
     case "uint8":
-      return import_constants3.GL.UNSIGNED_BYTE;
+      return 5121;
     case "sint8":
-      return import_constants3.GL.BYTE;
+      return 5120;
     case "unorm8":
-      return import_constants3.GL.UNSIGNED_BYTE;
+      return 5121;
     case "snorm8":
-      return import_constants3.GL.BYTE;
+      return 5120;
     case "uint16":
-      return import_constants3.GL.UNSIGNED_SHORT;
+      return 5123;
     case "sint16":
-      return import_constants3.GL.SHORT;
+      return 5122;
     case "unorm16":
-      return import_constants3.GL.UNSIGNED_SHORT;
+      return 5123;
     case "snorm16":
-      return import_constants3.GL.SHORT;
+      return 5122;
     case "uint32":
-      return import_constants3.GL.UNSIGNED_INT;
+      return 5125;
     case "sint32":
-      return import_constants3.GL.INT;
+      return 5124;
     case "float16":
-      return import_constants3.GL.HALF_FLOAT;
+      return 5131;
     case "float32":
-      return import_constants3.GL.FLOAT;
+      return 5126;
   }
   throw new Error(String(dataType));
 }
@@ -887,6 +902,14 @@ var texture_compression_etc2 = "texture-compression-etc2";
 var texture_compression_etc1_webgl = "texture-compression-etc1-webgl";
 var texture_compression_pvrtc_webgl = "texture-compression-pvrtc-webgl";
 var texture_compression_atc_webgl = "texture-compression-atc-webgl";
+var float32_renderable = "float32-renderable-webgl";
+var float16_renderable = "float16-renderable-webgl";
+var rgb9e5ufloat_renderable = "rgb9e5ufloat_renderable-webgl";
+var snorm8_renderable = "snorm8-renderable-webgl";
+var norm16_renderable = "norm16-renderable-webgl";
+var snorm16_renderable = "snorm16-renderable-webgl";
+var float32_filterable = "float32-filterable";
+var float16_filterable = "float16-filterable-webgl";
 var X_S3TC = "WEBGL_compressed_texture_s3tc";
 var X_S3TC_SRGB = "WEBGL_compressed_texture_s3tc_srgb";
 var X_RGTC = "EXT_texture_compression_rgtc";
@@ -896,15 +919,18 @@ var X_ASTC = "WEBGL_compressed_texture_astc";
 var X_ETC1 = "WEBGL_compressed_texture_etc1";
 var X_PVRTC = "WEBGL_compressed_texture_pvrtc";
 var X_ATC = "WEBGL_compressed_texture_atc";
-var EXT_TEXTURE_NORM16 = "EXT_texture_norm16";
-var EXT_FLOAT_RENDER_WEBGL2 = "EXT_color_buffer_float";
-var TEXTURE_FEATURE_CHECKS = {
+var EXT_texture_norm16 = "EXT_texture_norm16";
+var EXT_render_snorm = "EXT_render_snorm";
+var EXT_color_buffer_float = "EXT_color_buffer_float";
+var TEXTURE_FEATURES = {
   "float32-renderable-webgl": ["EXT_color_buffer_float"],
-  // [false, 'EXT_color_buffer_float'],
   "float16-renderable-webgl": ["EXT_color_buffer_half_float"],
-  "norm16-renderable-webgl": [EXT_TEXTURE_NORM16],
-  "float32-filterable-linear-webgl": ["OES_texture_float_linear"],
-  "float16-filterable-linear-webgl": ["OES_texture_half_float_linear"],
+  "rgb9e5ufloat_renderable-webgl": ["WEBGL_render_shared_exponent"],
+  "snorm8-renderable-webgl": [EXT_render_snorm],
+  "norm16-renderable-webgl": [EXT_texture_norm16],
+  "snorm16-renderable-webgl": [EXT_texture_norm16, EXT_render_snorm],
+  "float32-filterable": ["OES_texture_float_linear"],
+  "float16-filterable-webgl": ["OES_texture_half_float_linear"],
   "texture-filterable-anisotropic-webgl": ["EXT_texture_filter_anisotropic"],
   "texture-blend-float-webgl": ["EXT_float_blend"],
   "texture-compression-bc": [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC],
@@ -918,216 +944,267 @@ var TEXTURE_FEATURE_CHECKS = {
   "texture-compression-pvrtc-webgl": [X_PVRTC],
   "texture-compression-atc-webgl": [X_ATC]
 };
-function checkTextureFeature(gl, feature) {
-  const extensions = TEXTURE_FEATURE_CHECKS[feature] || [];
-  return extensions.every((extension) => gl.getExtension(extension));
+function isTextureFeature(feature) {
+  return feature in TEXTURE_FEATURES;
 }
-function getTextureFeatures(gl) {
-  const textureFeatures = Object.keys(TEXTURE_FEATURE_CHECKS);
-  return textureFeatures.filter((feature) => checkTextureFeature(gl, feature));
+function checkTextureFeature(gl, feature, extensions) {
+  const textureExtensions = TEXTURE_FEATURES[feature] || [];
+  return textureExtensions.every((extension) => getWebGLExtension(gl, extension, extensions));
 }
 var TEXTURE_FORMATS = {
-  // Unsized formats that leave the precision up to the driver.
-  // TODO - Fix bpp constants
-  // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
+  // Unsized formats that leave the precision up to the driver. TODO - Fix bpp constants
   "rgb8unorm-unsized": {
-    gl: import_constants4.GL.RGB,
+    gl: 6407,
     b: 4,
     c: 2,
     bpp: 4,
-    dataFormat: import_constants4.GL.RGB,
-    types: [import_constants4.GL.UNSIGNED_BYTE, import_constants4.GL.UNSIGNED_SHORT_5_6_5]
+    dataFormat: 6407,
+    types: [5121, 33635]
   },
   "rgba8unorm-unsized": {
-    gl: import_constants4.GL.RGBA,
+    gl: 6408,
     b: 4,
     c: 2,
     bpp: 4,
-    dataFormat: import_constants4.GL.RGBA,
-    types: [import_constants4.GL.UNSIGNED_BYTE, import_constants4.GL.UNSIGNED_SHORT_4_4_4_4, import_constants4.GL.UNSIGNED_SHORT_5_5_5_1]
+    dataFormat: 6408,
+    types: [5121, 32819, 32820]
   },
+  // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
   // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 8-bit formats
-  "r8unorm": { gl: import_constants4.GL.R8, b: 1, c: 1, renderbuffer: true },
-  "r8snorm": { gl: import_constants4.GL.R8_SNORM, b: 1, c: 1 },
-  "r8uint": { gl: import_constants4.GL.R8UI, b: 1, c: 1, renderbuffer: true },
-  "r8sint": { gl: import_constants4.GL.R8I, b: 1, c: 1, renderbuffer: true },
+  "r8unorm": { gl: 33321, b: 1, c: 1, rb: true },
+  "r8snorm": { gl: 36756, b: 1, c: 1, render: snorm8_renderable },
+  "r8uint": { gl: 33330, b: 1, c: 1, rb: true },
+  "r8sint": { gl: 33329, b: 1, c: 1, rb: true },
   // 16-bit formats
-  "rg8unorm": { gl: import_constants4.GL.RG8, b: 2, c: 2, renderbuffer: true },
-  "rg8snorm": { gl: import_constants4.GL.RG8_SNORM, b: 2, c: 2 },
-  "rg8uint": { gl: import_constants4.GL.RG8UI, b: 2, c: 2, renderbuffer: true },
-  "rg8sint": { gl: import_constants4.GL.RG8I, b: 2, c: 2, renderbuffer: true },
-  "r16uint": { gl: import_constants4.GL.R16UI, b: 2, c: 1, renderbuffer: true },
-  "r16sint": { gl: import_constants4.GL.R16I, b: 2, c: 1, renderbuffer: true },
-  "r16float": { gl: import_constants4.GL.R16F, b: 2, c: 1, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl", renderbuffer: true },
-  "r16unorm-webgl": { gl: import_constants4.GL.R16_EXT, b: 2, c: 1, f: "norm16-renderable-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-  "r16snorm-webgl": { gl: import_constants4.GL.R16_SNORM_EXT, b: 2, c: 1, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg8unorm": { gl: 33323, b: 2, c: 2, rb: true },
+  "rg8snorm": { gl: 36757, b: 2, c: 2, render: snorm8_renderable },
+  "rg8uint": { gl: 33336, b: 2, c: 2, rb: true },
+  "rg8sint": { gl: 33335, b: 2, c: 2, rb: true },
+  "r16uint": { gl: 33332, b: 2, c: 1, rb: true },
+  "r16sint": { gl: 33331, b: 2, c: 1, rb: true },
+  "r16float": { gl: 33325, b: 2, c: 1, render: float16_renderable, filter: "float16-filterable-webgl", rb: true },
+  "r16unorm-webgl": { gl: 33322, b: 2, c: 1, f: norm16_renderable, rb: true },
+  "r16snorm-webgl": { gl: 36760, b: 2, c: 1, f: snorm16_renderable },
   // Packed 16-bit formats
-  "rgba4unorm-webgl": { gl: import_constants4.GL.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
-  "rgb565unorm-webgl": { gl: import_constants4.GL.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
-  "rgb5a1unorm-webgl": { gl: import_constants4.GL.RGB5_A1, b: 2, c: 4, wgpu: false, renderbuffer: true },
+  "rgba4unorm-webgl": { gl: 32854, b: 2, c: 4, wgpu: false, rb: true },
+  "rgb565unorm-webgl": { gl: 36194, b: 2, c: 4, wgpu: false, rb: true },
+  "rgb5a1unorm-webgl": { gl: 32855, b: 2, c: 4, wgpu: false, rb: true },
   // 24-bit formats
-  "rgb8unorm-webgl": { gl: import_constants4.GL.RGB8, b: 3, c: 3, wgpu: false },
-  "rgb8snorm-webgl": { gl: import_constants4.GL.RGB8_SNORM, b: 3, c: 3, wgpu: false },
+  "rgb8unorm-webgl": { gl: 32849, b: 3, c: 3, wgpu: false },
+  "rgb8snorm-webgl": { gl: 36758, b: 3, c: 3, wgpu: false },
   // 32-bit formats
-  "rgba8unorm": { gl: import_constants4.GL.RGBA8, b: 4, c: 2, bpp: 4 },
-  "rgba8unorm-srgb": { gl: import_constants4.GL.SRGB8_ALPHA8, b: 4, c: 4, bpp: 4 },
-  "rgba8snorm": { gl: import_constants4.GL.RGBA8_SNORM, b: 4, c: 4 },
-  "rgba8uint": { gl: import_constants4.GL.RGBA8UI, b: 4, c: 4, bpp: 4 },
-  "rgba8sint": { gl: import_constants4.GL.RGBA8I, b: 4, c: 4, bpp: 4 },
+  "rgba8unorm": { gl: 32856, b: 4, c: 2, bpp: 4 },
+  "rgba8unorm-srgb": { gl: 35907, b: 4, c: 4, bpp: 4 },
+  "rgba8snorm": { gl: 36759, b: 4, c: 4, render: snorm8_renderable },
+  "rgba8uint": { gl: 36220, b: 4, c: 4, bpp: 4 },
+  "rgba8sint": { gl: 36238, b: 4, c: 4, bpp: 4 },
   // reverse colors, webgpu only
   "bgra8unorm": { b: 4, c: 4 },
   "bgra8unorm-srgb": { b: 4, c: 4 },
-  "rg16uint": { gl: import_constants4.GL.RG16UI, b: 4, c: 1, bpp: 4 },
-  "rg16sint": { gl: import_constants4.GL.RG16I, b: 4, c: 2, bpp: 4 },
+  "rg16uint": { gl: 33338, b: 4, c: 1, bpp: 4 },
+  "rg16sint": { gl: 33337, b: 4, c: 2, bpp: 4 },
   // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-  "rg16float": { gl: import_constants4.GL.RG16F, bpp: 4, b: 4, c: 2, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl", renderbuffer: true },
-  "rg16unorm-webgl": { gl: import_constants4.GL.RG16_EXT, b: 2, c: 2, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
-  "rg16snorm-webgl": { gl: import_constants4.GL.RG16_SNORM_EXT, b: 2, c: 2, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
-  "r32uint": { gl: import_constants4.GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32sint": { gl: import_constants4.GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32float": { gl: import_constants4.GL.R32F, bpp: 4, b: 4, c: 1, render: "float32-renderable-webgl", filter: "float32-filterable-linear-webgl" },
+  "rg16float": { gl: 33327, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true },
+  "rg16unorm-webgl": { gl: 33324, b: 2, c: 2, render: norm16_renderable },
+  "rg16snorm-webgl": { gl: 36761, b: 2, c: 2, render: snorm16_renderable },
+  "r32uint": { gl: 33334, b: 4, c: 1, bpp: 4, rb: true },
+  "r32sint": { gl: 33333, b: 4, c: 1, bpp: 4, rb: true },
+  "r32float": { gl: 33326, bpp: 4, b: 4, c: 1, render: float32_renderable, filter: float32_filterable },
   // Packed 32-bit formats
-  "rgb9e5ufloat": { gl: import_constants4.GL.RGB9_E5, b: 4, c: 3, p: 1, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl" },
-  "rg11b10ufloat": { gl: import_constants4.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "float32-renderable-webgl", renderbuffer: true },
-  "rgb10a2unorm": { gl: import_constants4.GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
-  "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants4.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
+  "rgb9e5ufloat": { gl: 35901, b: 4, c: 3, p: 1, render: rgb9e5ufloat_renderable },
+  // , filter: true},
+  "rg11b10ufloat": { gl: 35898, b: 4, c: 3, p: 1, render: float32_renderable, rb: true },
+  "rgb10a2unorm": { gl: 32857, b: 4, c: 4, p: 1, rb: true },
+  "rgb10a2uint-webgl": { b: 4, c: 4, gl: 36975, p: 1, wgpu: false, bpp: 4, rb: true },
   // 48-bit formats
-  "rgb16unorm-webgl": { gl: import_constants4.GL.RGB16_EXT, b: 2, c: 3, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
-  "rgb16snorm-webgl": { gl: import_constants4.GL.RGB16_SNORM_EXT, b: 2, c: 3, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+  "rgb16unorm-webgl": { gl: 32852, b: 2, c: 3, f: norm16_renderable },
+  // rgb not renderable
+  "rgb16snorm-webgl": { gl: 36762, b: 2, c: 3, f: norm16_renderable },
+  // rgb not renderable
   // 64-bit formats
-  "rg32uint": { gl: import_constants4.GL.RG32UI, b: 8, c: 2, renderbuffer: true },
-  "rg32sint": { gl: import_constants4.GL.RG32I, b: 8, c: 2, renderbuffer: true },
-  "rg32float": { gl: import_constants4.GL.RG32F, b: 8, c: 2, render: "float32-renderable-webgl", filter: "float32-filterable-linear-webgl", renderbuffer: true },
-  "rgba16uint": { gl: import_constants4.GL.RGBA16UI, b: 8, c: 4, renderbuffer: true },
-  "rgba16sint": { gl: import_constants4.GL.RGBA16I, b: 8, c: 4, renderbuffer: true },
-  "rgba16float": { gl: import_constants4.GL.RGBA16F, b: 8, c: 4, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl" },
-  "rgba16unorm-webgl": { gl: import_constants4.GL.RGBA16_EXT, b: 2, c: 4, f: "norm16-renderable-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-  "rgba16snorm-webgl": { gl: import_constants4.GL.RGBA16_SNORM_EXT, b: 2, c: 4, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg32uint": { gl: 33340, b: 8, c: 2, rb: true },
+  "rg32sint": { gl: 33339, b: 8, c: 2, rb: true },
+  "rg32float": { gl: 33328, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, rb: true },
+  "rgba16uint": { gl: 36214, b: 8, c: 4, rb: true },
+  "rgba16sint": { gl: 36232, b: 8, c: 4, rb: true },
+  "rgba16float": { gl: 34842, b: 8, c: 4, render: float16_renderable, filter: float16_filterable },
+  "rgba16unorm-webgl": { gl: 32859, b: 2, c: 4, render: norm16_renderable, rb: true },
+  "rgba16snorm-webgl": { gl: 36763, b: 2, c: 4, render: snorm16_renderable },
   // 96-bit formats (deprecated!)
   "rgb32float-webgl": {
-    gl: import_constants4.GL.RGB32F,
-    render: "float32-renderable-webgl",
-    filter: "float32-filterable-linear-webgl",
-    gl2ext: EXT_FLOAT_RENDER_WEBGL2,
-    dataFormat: import_constants4.GL.RGB,
-    types: [import_constants4.GL.FLOAT]
+    gl: 34837,
+    render: float32_renderable,
+    filter: float32_filterable,
+    gl2ext: EXT_color_buffer_float,
+    dataFormat: 6407,
+    types: [5126]
   },
   // 128-bit formats
-  "rgba32uint": { gl: import_constants4.GL.RGBA32UI, b: 16, c: 4, renderbuffer: true },
-  "rgba32sint": { gl: import_constants4.GL.RGBA32I, b: 16, c: 4, renderbuffer: true },
-  "rgba32float": { gl: import_constants4.GL.RGBA32F, b: 16, c: 4, render: "float32-renderable-webgl", filter: "float32-filterable-linear-webgl", renderbuffer: true },
+  "rgba32uint": { gl: 36208, b: 16, c: 4, rb: true },
+  "rgba32sint": { gl: 36226, b: 16, c: 4, rb: true },
+  "rgba32float": { gl: 34836, b: 16, c: 4, render: float32_renderable, filter: float32_filterable, rb: true },
   // Depth and stencil formats
-  "stencil8": { gl: import_constants4.GL.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants4.GL.STENCIL_ATTACHMENT, renderbuffer: true },
+  "stencil8": { gl: 36168, b: 1, c: 1, attachment: 36128, rb: true },
   // 8 stencil bits
-  "depth16unorm": { gl: import_constants4.GL.DEPTH_COMPONENT16, b: 2, c: 1, attachment: import_constants4.GL.DEPTH_ATTACHMENT, renderbuffer: true },
+  "depth16unorm": {
+    gl: 33189,
+    b: 2,
+    c: 1,
+    attachment: 36096,
+    dataFormat: 6402,
+    types: [5123],
+    rb: true
+  },
   // 16 depth bits
-  "depth24plus": { gl: import_constants4.GL.DEPTH_COMPONENT24, b: 3, c: 1, attachment: import_constants4.GL.DEPTH_ATTACHMENT },
-  "depth32float": { gl: import_constants4.GL.DEPTH_COMPONENT32F, b: 4, c: 1, attachment: import_constants4.GL.DEPTH_ATTACHMENT, renderbuffer: true },
+  "depth24plus": {
+    gl: 33190,
+    b: 3,
+    c: 1,
+    attachment: 36096,
+    dataFormat: 6402,
+    types: [5125]
+  },
+  "depth32float": {
+    gl: 36012,
+    b: 4,
+    c: 1,
+    attachment: 36096,
+    dataFormat: 6402,
+    types: [5126],
+    rb: true
+  },
   // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
-  "depth24plus-stencil8": { gl: import_constants4.GL.DEPTH_STENCIL, b: 4, c: 2, p: 1, attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true, depthTexture: true },
+  "depth24plus-stencil8": {
+    gl: 35056,
+    b: 4,
+    c: 2,
+    p: 1,
+    attachment: 33306,
+    rb: true,
+    depthTexture: true,
+    dataFormat: 34041,
+    types: [34042]
+  },
   // "depth24unorm-stencil8" feature
-  "depth24unorm-stencil8": { gl: import_constants4.GL.DEPTH24_STENCIL8, b: 4, c: 2, p: 1, attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
-  // "depth32float-stencil8" feature
-  "depth32float-stencil8": { gl: import_constants4.GL.DEPTH32F_STENCIL8, b: 5, c: 2, p: 1, attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT, renderbuffer: true },
+  "depth24unorm-stencil8": {
+    gl: 35056,
+    b: 4,
+    c: 2,
+    p: 1,
+    attachment: 33306,
+    dataFormat: 34041,
+    types: [34042],
+    rb: true
+  },
+  // "depth32float-stencil8" feature - TODO below is render buffer only?
+  "depth32float-stencil8": {
+    gl: 36013,
+    b: 5,
+    c: 2,
+    p: 1,
+    attachment: 33306,
+    dataFormat: 34041,
+    types: [36269],
+    rb: true
+  },
   // BC compressed formats: check device.features.has("texture-compression-bc");
-  "bc1-rgb-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc1-rgb-unorm-srgb-webgl": { gl: import_constants4.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc1-rgba-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_S3TC_DXT1_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc1-rgba-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB_S3TC_DXT1_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc2-rgba-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_S3TC_DXT3_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc2-rgba-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc3-rgba-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_S3TC_DXT5_EXT, x: X_S3TC, f: texture_compression_bc },
-  "bc3-rgba-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, x: X_S3TC_SRGB, f: texture_compression_bc },
-  "bc4-r-unorm": { gl: import_constants4.GL.COMPRESSED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc4-r-snorm": { gl: import_constants4.GL.COMPRESSED_SIGNED_RED_RGTC1_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc5-rg-unorm": { gl: import_constants4.GL.COMPRESSED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc5-rg-snorm": { gl: import_constants4.GL.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, x: X_RGTC, f: texture_compression_bc },
-  "bc6h-rgb-ufloat": { gl: import_constants4.GL.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc6h-rgb-float": { gl: import_constants4.GL.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc7-rgba-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
-  "bc7-rgba-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT, x: X_BPTC, f: texture_compression_bc },
+  "bc1-rgb-unorm-webgl": { gl: 33776, x: X_S3TC, f: texture_compression_bc },
+  "bc1-rgb-unorm-srgb-webgl": { gl: 35916, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc1-rgba-unorm": { gl: 33777, x: X_S3TC, f: texture_compression_bc },
+  "bc1-rgba-unorm-srgb": { gl: 35916, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc2-rgba-unorm": { gl: 33778, x: X_S3TC, f: texture_compression_bc },
+  "bc2-rgba-unorm-srgb": { gl: 35918, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc3-rgba-unorm": { gl: 33779, x: X_S3TC, f: texture_compression_bc },
+  "bc3-rgba-unorm-srgb": { gl: 35919, x: X_S3TC_SRGB, f: texture_compression_bc },
+  "bc4-r-unorm": { gl: 36283, x: X_RGTC, f: texture_compression_bc },
+  "bc4-r-snorm": { gl: 36284, x: X_RGTC, f: texture_compression_bc },
+  "bc5-rg-unorm": { gl: 36285, x: X_RGTC, f: texture_compression_bc },
+  "bc5-rg-snorm": { gl: 36286, x: X_RGTC, f: texture_compression_bc },
+  "bc6h-rgb-ufloat": { gl: 36495, x: X_BPTC, f: texture_compression_bc },
+  "bc6h-rgb-float": { gl: 36494, x: X_BPTC, f: texture_compression_bc },
+  "bc7-rgba-unorm": { gl: 36492, x: X_BPTC, f: texture_compression_bc },
+  "bc7-rgba-unorm-srgb": { gl: 36493, x: X_BPTC, f: texture_compression_bc },
   // WEBGL_compressed_texture_etc: device.features.has("texture-compression-etc2")
   // Note: Supposedly guaranteed availability compressed formats in WebGL2, but through CPU decompression
-  "etc2-rgb8unorm": { gl: import_constants4.GL.COMPRESSED_RGB8_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8a1unorm": { gl: import_constants4.GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
-  "etc2-rgb8a1unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, f: texture_compression_etc2 },
-  "etc2-rgba8unorm": { gl: import_constants4.GL.COMPRESSED_RGBA8_ETC2_EAC, f: texture_compression_etc2 },
-  "etc2-rgba8unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, f: texture_compression_etc2 },
-  "eac-r11unorm": { gl: import_constants4.GL.COMPRESSED_R11_EAC, f: texture_compression_etc2 },
-  "eac-r11snorm": { gl: import_constants4.GL.COMPRESSED_SIGNED_R11_EAC, f: texture_compression_etc2 },
-  "eac-rg11unorm": { gl: import_constants4.GL.COMPRESSED_RG11_EAC, f: texture_compression_etc2 },
-  "eac-rg11snorm": { gl: import_constants4.GL.COMPRESSED_SIGNED_RG11_EAC, f: texture_compression_etc2 },
+  "etc2-rgb8unorm": { gl: 37492, f: texture_compression_etc2 },
+  "etc2-rgb8unorm-srgb": { gl: 37494, f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm": { gl: 37496, f: texture_compression_etc2 },
+  "etc2-rgb8a1unorm-srgb": { gl: 37497, f: texture_compression_etc2 },
+  "etc2-rgba8unorm": { gl: 37493, f: texture_compression_etc2 },
+  "etc2-rgba8unorm-srgb": { gl: 37495, f: texture_compression_etc2 },
+  "eac-r11unorm": { gl: 37488, f: texture_compression_etc2 },
+  "eac-r11snorm": { gl: 37489, f: texture_compression_etc2 },
+  "eac-rg11unorm": { gl: 37490, f: texture_compression_etc2 },
+  "eac-rg11snorm": { gl: 37491, f: texture_compression_etc2 },
   // X_ASTC compressed formats: device.features.has("texture-compression-astc")
-  "astc-4x4-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_4x4_KHR, f: texture_compression_astc },
-  "astc-4x4-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, f: texture_compression_astc },
-  "astc-5x4-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_5x4_KHR, f: texture_compression_astc },
-  "astc-5x4-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, f: texture_compression_astc },
-  "astc-5x5-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_5x5_KHR, f: texture_compression_astc },
-  "astc-5x5-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, f: texture_compression_astc },
-  "astc-6x5-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_6x5_KHR, f: texture_compression_astc },
-  "astc-6x5-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, f: texture_compression_astc },
-  "astc-6x6-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_6x6_KHR, f: texture_compression_astc },
-  "astc-6x6-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, f: texture_compression_astc },
-  "astc-8x5-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_8x5_KHR, f: texture_compression_astc },
-  "astc-8x5-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, f: texture_compression_astc },
-  "astc-8x6-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_8x6_KHR, f: texture_compression_astc },
-  "astc-8x6-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, f: texture_compression_astc },
-  "astc-8x8-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_8x8_KHR, f: texture_compression_astc },
-  "astc-8x8-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, f: texture_compression_astc },
-  "astc-10x5-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x5-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x6-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_10x6_KHR, f: texture_compression_astc },
-  "astc-10x6-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, f: texture_compression_astc },
-  "astc-10x8-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_10x8_KHR, f: texture_compression_astc },
-  "astc-10x8-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, f: texture_compression_astc },
-  "astc-10x10-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-10x10-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, f: texture_compression_astc },
-  "astc-12x10-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_12x10_KHR, f: texture_compression_astc },
-  "astc-12x10-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, f: texture_compression_astc },
-  "astc-12x12-unorm": { gl: import_constants4.GL.COMPRESSED_RGBA_ASTC_12x12_KHR, f: texture_compression_astc },
-  "astc-12x12-unorm-srgb": { gl: import_constants4.GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, f: texture_compression_astc },
+  "astc-4x4-unorm": { gl: 37808, f: texture_compression_astc },
+  "astc-4x4-unorm-srgb": { gl: 37840, f: texture_compression_astc },
+  "astc-5x4-unorm": { gl: 37809, f: texture_compression_astc },
+  "astc-5x4-unorm-srgb": { gl: 37841, f: texture_compression_astc },
+  "astc-5x5-unorm": { gl: 37810, f: texture_compression_astc },
+  "astc-5x5-unorm-srgb": { gl: 37842, f: texture_compression_astc },
+  "astc-6x5-unorm": { gl: 37811, f: texture_compression_astc },
+  "astc-6x5-unorm-srgb": { gl: 37843, f: texture_compression_astc },
+  "astc-6x6-unorm": { gl: 37812, f: texture_compression_astc },
+  "astc-6x6-unorm-srgb": { gl: 37844, f: texture_compression_astc },
+  "astc-8x5-unorm": { gl: 37813, f: texture_compression_astc },
+  "astc-8x5-unorm-srgb": { gl: 37845, f: texture_compression_astc },
+  "astc-8x6-unorm": { gl: 37814, f: texture_compression_astc },
+  "astc-8x6-unorm-srgb": { gl: 37846, f: texture_compression_astc },
+  "astc-8x8-unorm": { gl: 37815, f: texture_compression_astc },
+  "astc-8x8-unorm-srgb": { gl: 37847, f: texture_compression_astc },
+  "astc-10x5-unorm": { gl: 37819, f: texture_compression_astc },
+  "astc-10x5-unorm-srgb": { gl: 37851, f: texture_compression_astc },
+  "astc-10x6-unorm": { gl: 37817, f: texture_compression_astc },
+  "astc-10x6-unorm-srgb": { gl: 37849, f: texture_compression_astc },
+  "astc-10x8-unorm": { gl: 37818, f: texture_compression_astc },
+  "astc-10x8-unorm-srgb": { gl: 37850, f: texture_compression_astc },
+  "astc-10x10-unorm": { gl: 37819, f: texture_compression_astc },
+  "astc-10x10-unorm-srgb": { gl: 37851, f: texture_compression_astc },
+  "astc-12x10-unorm": { gl: 37820, f: texture_compression_astc },
+  "astc-12x10-unorm-srgb": { gl: 37852, f: texture_compression_astc },
+  "astc-12x12-unorm": { gl: 37821, f: texture_compression_astc },
+  "astc-12x12-unorm-srgb": { gl: 37853, f: texture_compression_astc },
   // WEBGL_compressed_texture_pvrtc
-  "pvrtc-rgb4unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rgba4unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rbg2unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
-  "pvrtc-rgba2unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgb4unorm-webgl": { gl: 35840, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba4unorm-webgl": { gl: 35842, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rbg2unorm-webgl": { gl: 35841, f: texture_compression_pvrtc_webgl },
+  "pvrtc-rgba2unorm-webgl": { gl: 35843, f: texture_compression_pvrtc_webgl },
   // WEBGL_compressed_texture_etc1
-  "etc1-rbg-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_ETC1_WEBGL, f: texture_compression_etc1_webgl },
+  "etc1-rbg-unorm-webgl": { gl: 36196, f: texture_compression_etc1_webgl },
   // WEBGL_compressed_texture_atc
-  "atc-rgb-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGB_ATC_WEBGL, f: texture_compression_atc_webgl },
-  "atc-rgba-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL, f: texture_compression_atc_webgl },
-  "atc-rgbai-unorm-webgl": { gl: import_constants4.GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL, f: texture_compression_atc_webgl }
+  "atc-rgb-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl },
+  "atc-rgba-unorm-webgl": { gl: 35986, f: texture_compression_atc_webgl },
+  "atc-rgbai-unorm-webgl": { gl: 34798, f: texture_compression_atc_webgl }
 };
 var DATA_FORMAT_CHANNELS = {
-  [import_constants4.GL.RED]: 1,
-  [import_constants4.GL.RED_INTEGER]: 1,
-  [import_constants4.GL.RG]: 2,
-  [import_constants4.GL.RG_INTEGER]: 2,
-  [import_constants4.GL.RGB]: 3,
-  [import_constants4.GL.RGB_INTEGER]: 3,
-  [import_constants4.GL.RGBA]: 4,
-  [import_constants4.GL.RGBA_INTEGER]: 4,
-  [import_constants4.GL.DEPTH_COMPONENT]: 1,
-  [import_constants4.GL.DEPTH_STENCIL]: 1,
-  [import_constants4.GL.ALPHA]: 1,
-  [import_constants4.GL.LUMINANCE]: 1,
-  [import_constants4.GL.LUMINANCE_ALPHA]: 2
+  [6403]: 1,
+  [36244]: 1,
+  [33319]: 2,
+  [33320]: 2,
+  [6407]: 3,
+  [36248]: 3,
+  [6408]: 4,
+  [36249]: 4,
+  [6402]: 1,
+  [34041]: 1,
+  [6406]: 1,
+  [6409]: 1,
+  [6410]: 2
 };
 var TYPE_SIZES = {
-  [import_constants4.GL.FLOAT]: 4,
-  [import_constants4.GL.UNSIGNED_INT]: 4,
-  [import_constants4.GL.INT]: 4,
-  [import_constants4.GL.UNSIGNED_SHORT]: 2,
-  [import_constants4.GL.SHORT]: 2,
-  [import_constants4.GL.HALF_FLOAT]: 2,
-  [import_constants4.GL.BYTE]: 1,
-  [import_constants4.GL.UNSIGNED_BYTE]: 1
+  [5126]: 4,
+  [5125]: 4,
+  [5124]: 4,
+  [5123]: 2,
+  [5122]: 2,
+  [5131]: 2,
+  [5120]: 1,
+  [5121]: 1
 };
-function isTextureFormatSupported(gl, formatOrGL) {
-  const format = convertGLToTextureFormat(formatOrGL);
+function isTextureFormatSupported(gl, format, extensions) {
   const info = TEXTURE_FORMATS[format];
   if (!info) {
     return false;
@@ -1137,13 +1214,13 @@ function isTextureFormatSupported(gl, formatOrGL) {
   }
   const extension = info.x || info.gl2ext;
   if (extension) {
-    return Boolean(gl.getExtension(extension));
+    return Boolean(getWebGLExtension(gl, extension, extensions));
   }
   return true;
 }
-function isRenderbufferFormatSupported(gl, format) {
+function isRenderbufferFormatSupported(gl, format, extensions) {
   var _a;
-  return isTextureFormatSupported(gl, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
+  return isTextureFormatSupported(gl, format, extensions) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.rb);
 }
 function convertGLToTextureFormat(format) {
   if (typeof format === "string") {
@@ -1163,9 +1240,11 @@ function convertTextureFormatToGL(format) {
   }
   return webglFormat;
 }
-function isTextureFormatFilterable(gl, formatOrGL) {
-  const format = convertGLToTextureFormat(formatOrGL);
-  if (!isTextureFormatSupported(gl, format)) {
+function isTextureFormatFilterable(gl, format, extensions) {
+  if (!isTextureFormatSupported(gl, format, extensions)) {
+    return false;
+  }
+  if (format.startsWith("depth") || format.startsWith("stencil")) {
     return false;
   }
   try {
@@ -1177,16 +1256,15 @@ function isTextureFormatFilterable(gl, formatOrGL) {
     return false;
   }
   if (format.endsWith("32float")) {
-    return Boolean(gl.getExtension("OES_texture_float_linear"));
+    return Boolean(getWebGLExtension(gl, "OES_texture_float_linear, extensions", extensions));
   }
   if (format.endsWith("16float")) {
-    return Boolean(gl.getExtension("OES_texture_half_float_linear"));
+    return Boolean(getWebGLExtension(gl, "OES_texture_half_float_linear, extensions", extensions));
   }
   return true;
 }
-function isTextureFormatRenderable(gl, formatOrGL) {
-  const format = convertGLToTextureFormat(formatOrGL);
-  if (!isTextureFormatSupported(gl, format)) {
+function isTextureFormatRenderable(gl, format, extensions) {
+  if (!isTextureFormatSupported(gl, format, extensions)) {
     return false;
   }
   if (typeof format === "number") {
@@ -1194,15 +1272,16 @@ function isTextureFormatRenderable(gl, formatOrGL) {
   }
   return true;
 }
-function getWebGLTextureParameters(formatOrGL) {
-  const format = convertGLToTextureFormat(formatOrGL);
+function getWebGLTextureParameters(format) {
+  var _a;
+  const formatData = TEXTURE_FORMATS[format];
   const webglFormat = convertTextureFormatToGL(format);
   const decoded = (0, import_core2.decodeTextureFormat)(format);
   return {
     format: webglFormat,
-    dataFormat: getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
+    dataFormat: (formatData == null ? void 0 : formatData.dataFormat) || getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
     // depth formats don't have a type
-    type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : import_constants4.GL.UNSIGNED_BYTE,
+    type: decoded.dataType ? getGLFromVertexType(decoded.dataType) : ((_a = formatData == null ? void 0 : formatData.types) == null ? void 0 : _a[0]) || 5121,
     // @ts-expect-error
     compressed: decoded.compressed
   };
@@ -1214,221 +1293,228 @@ function getDepthStencilAttachmentWebGL(format) {
   }
   return info.attachment;
 }
-function getTextureFormatBytesPerPixel(formatOrGL) {
-  const format = convertGLToTextureFormat(formatOrGL);
+function getTextureFormatBytesPerPixel(format) {
   const params = getWebGLTextureParameters(format);
   const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4;
   const channelSize = TYPE_SIZES[params.type] || 1;
   return channels * channelSize;
 }
 function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
-  if (format === import_constants4.GL.RGBA || format === import_constants4.GL.RGB) {
+  if (format === 6408 || format === 6407) {
     return format;
   }
   switch (dataFormat) {
     case "r":
-      return integer && !normalized ? import_constants4.GL.RED_INTEGER : import_constants4.GL.RED;
+      return integer && !normalized ? 36244 : 6403;
     case "rg":
-      return integer && !normalized ? import_constants4.GL.RG_INTEGER : import_constants4.GL.RG;
+      return integer && !normalized ? 33320 : 33319;
     case "rgb":
-      return integer && !normalized ? import_constants4.GL.RGB_INTEGER : import_constants4.GL.RGB;
+      return integer && !normalized ? 36248 : 6407;
     case "rgba":
-      return integer && !normalized ? import_constants4.GL.RGBA_INTEGER : import_constants4.GL.RGBA;
+      return integer && !normalized ? 36249 : 6408;
     default:
-      return import_constants4.GL.RGBA;
+      return 6408;
   }
 }
 // dist/adapter/device-helpers/webgl-device-features.js
-function getDeviceFeatures(gl) {
-  const features = getWebGLFeatures(gl);
-  for (const textureFeature of getTextureFeatures(gl)) {
-    features.add(textureFeature);
-  }
-  return features;
-}
-function getWebGLFeatures(gl) {
-  gl.getExtension("EXT_color_buffer_float");
-  const features = /* @__PURE__ */ new Set();
-  for (const feature of Object.keys(WEBGL_FEATURES)) {
-    if (isFeatureSupported(gl, feature)) {
-      features.add(feature);
-    }
-  }
-  return features;
-}
-function isFeatureSupported(gl, feature) {
-  const featureInfo = WEBGL_FEATURES[feature];
-  return typeof featureInfo === "string" ? Boolean(gl.getExtension(featureInfo)) : Boolean(featureInfo);
-}
 var WEBGL_FEATURES = {
-  webgl: true,
-  glsl: true,
-  "uniforms-webgl": true,
-  "transform-feedback-webgl": true,
-  "constant-attributes-webgl": true,
+  // optional WebGPU features
+  "depth-clip-control": "EXT_depth_clamp",
+  // TODO these seem subtly different
+  // 'timestamp-query' // GPUQueryType "timestamp-query"
+  // "indirect-first-instance"
+  // Textures are handled by getTextureFeatures()
+  // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8'
+  // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
+  // optional WebGL features
   "timer-query-webgl": "EXT_disjoint_timer_query_webgl2",
-  "shader-status-async-webgl": "KHR_parallel_shader_compile"
+  "compilation-status-async-webgl": "KHR_parallel_shader_compile",
+  "polygon-mode-webgl": "WEBGL_polygon_mode",
+  "provoking-vertex-webgl": "WEBGL_provoking_vertex",
+  "shader-clip-cull-distance-webgl": "WEBGL_clip_cull_distance",
+  "shader-noperspective-interpolation-webgl": "NV_shader_noperspective_interpolation",
+  "shader-conservative-depth-webgl": "EXT_conservative_depth"
   // Textures are handled by getTextureFeatures()
 };
+var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
+  gl;
+  extensions;
+  testedFeatures = /* @__PURE__ */ new Set();
+  constructor(gl, extensions, disabledFeatures) {
+    super([], disabledFeatures);
+    this.gl = gl;
+    this.extensions = extensions;
+    getWebGLExtension(gl, "EXT_color_buffer_float", extensions);
+  }
+  *[Symbol.iterator]() {
+    for (const feature of Object.keys(WEBGL_FEATURES)) {
+      if (this.has(feature)) {
+        yield feature;
+      }
+    }
+    for (const feature of Object.keys(TEXTURE_FEATURES)) {
+      if (this.has(feature)) {
+        yield feature;
+      }
+    }
+    return [];
+  }
+  has(feature) {
+    if (this.disabledFeatures[feature]) {
+      return false;
+    }
+    if (!this.testedFeatures.has(feature)) {
+      this.testedFeatures.add(feature);
+      if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) {
+        this.features.add(feature);
+      }
+      if (this.getWebGLFeature(feature)) {
+        this.features.add(feature);
+      }
+    }
+    return this.features.has(feature);
+  }
+  // FOR DEVICE
+  initializeFeatures() {
+    for (const feature of this) {
+    }
+  }
+  // IMPLEMENTATION
+  /** Extract all WebGL features */
+  getWebGLFeature(feature) {
+    const featureInfo = WEBGL_FEATURES[feature];
+    const isSupported = typeof featureInfo === "string" ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions)) : Boolean(featureInfo);
+    return isSupported;
+  }
+};
 // dist/adapter/device-helpers/webgl-device-limits.js
+var import_core4 = require("@luma.gl/core");
 var import_constants5 = require("@luma.gl/constants");
-function getDeviceLimits(gl) {
-  return {
-    maxTextureDimension1D: 0,
-    // WebGL does not support 1D textures
-    maxTextureDimension2D: gl.getParameter(import_constants5.GL.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl.getParameter(import_constants5.GL.MAX_3D_TEXTURE_SIZE),
-    maxTextureArrayLayers: gl.getParameter(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS),
-    maxBindGroups: 1,
-    // TBD - if we emulate bind groups we could support any number...
-    maxDynamicUniformBuffersPerPipelineLayout: 0,
-    // TBD
-    maxDynamicStorageBuffersPerPipelineLayout: 0,
-    // TBD
-    maxSampledTexturesPerShaderStage: gl.getParameter(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
-    // TBD
-    maxSamplersPerShaderStage: gl.getParameter(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-    maxStorageBuffersPerShaderStage: 0,
-    // TBD
-    maxStorageTexturesPerShaderStage: 0,
-    // TBD
-    maxUniformBuffersPerShaderStage: gl.getParameter(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS),
-    maxUniformBufferBindingSize: gl.getParameter(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE),
-    maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl.getParameter(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT),
-    minStorageBufferOffsetAlignment: 0,
-    // TBD
-    maxVertexBuffers: 0,
-    maxVertexAttributes: gl.getParameter(import_constants5.GL.MAX_VERTEX_ATTRIBS),
-    maxVertexBufferArrayStride: 2048,
-    // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl.getParameter(import_constants5.GL.MAX_VARYING_COMPONENTS),
-    maxComputeWorkgroupStorageSize: 0,
-    // WebGL does not support compute shaders
-    maxComputeInvocationsPerWorkgroup: 0,
-    // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeX: 0,
-    // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeY: 0,
-    // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeZ: 0,
-    // WebGL does not support compute shaders
-    maxComputeWorkgroupsPerDimension: 0
-    // WebGL does not support compute shaders
-  };
-}
-function getWebGLLimits(gl) {
-  function get(pname) {
-    return gl.getParameter(pname);
+var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
+  get maxTextureDimension1D() {
+    return 0;
   }
-  function get2(pname, defaultValue) {
-    return gl.getParameter(pname) || defaultValue;
+  // WebGL does not support 1D textures
+  get maxTextureDimension2D() {
+    return this.getParameter(3379);
   }
-  return {
-    [import_constants5.GL.ALIASED_LINE_WIDTH_RANGE]: get(import_constants5.GL.ALIASED_LINE_WIDTH_RANGE),
-    [import_constants5.GL.ALIASED_POINT_SIZE_RANGE]: get(import_constants5.GL.ALIASED_POINT_SIZE_RANGE),
-    [import_constants5.GL.MAX_TEXTURE_SIZE]: get(import_constants5.GL.MAX_TEXTURE_SIZE),
-    [import_constants5.GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(import_constants5.GL.MAX_CUBE_MAP_TEXTURE_SIZE),
-    // GLint
-    [import_constants5.GL.MAX_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_TEXTURE_IMAGE_UNITS),
-    // GLint
-    [import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
-    // GLint
-    [import_constants5.GL.MAX_RENDERBUFFER_SIZE]: get(import_constants5.GL.MAX_RENDERBUFFER_SIZE),
-    // GLint
-    [import_constants5.GL.MAX_VARYING_VECTORS]: get(import_constants5.GL.MAX_VARYING_VECTORS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_ATTRIBS]: get(import_constants5.GL.MAX_VERTEX_ATTRIBS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_UNIFORM_VECTORS]: get(import_constants5.GL.MAX_VERTEX_UNIFORM_VECTORS),
-    // GLint
-    [import_constants5.GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(import_constants5.GL.MAX_FRAGMENT_UNIFORM_VECTORS),
-    // GLint
-    [import_constants5.GL.MAX_VIEWPORT_DIMS]: get(import_constants5.GL.MAX_VIEWPORT_DIMS),
-    // Extensions
-    [import_constants5.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(import_constants5.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT),
-    // getMaxAnistropy(),
-    // WebGL2 Limits
-    [import_constants5.GL.MAX_3D_TEXTURE_SIZE]: get2(import_constants5.GL.MAX_3D_TEXTURE_SIZE),
-    //  GLint
-    [import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS),
-    // GLint
-    // [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL), //  GLint64
-    [import_constants5.GL.MAX_COLOR_ATTACHMENTS]: get2(import_constants5.GL.MAX_COLOR_ATTACHMENTS),
-    //  GLint
-    [import_constants5.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS),
-    // GLint64
-    [import_constants5.GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_COMBINED_UNIFORM_BLOCKS),
-    //  GLint
-    [import_constants5.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
-    // GLint64
-    [import_constants5.GL.MAX_DRAW_BUFFERS]: get2(import_constants5.GL.MAX_DRAW_BUFFERS),
-    // GLint
-    [import_constants5.GL.MAX_ELEMENT_INDEX]: get2(import_constants5.GL.MAX_ELEMENT_INDEX),
-    //  GLint64
-    [import_constants5.GL.MAX_ELEMENTS_INDICES]: get2(import_constants5.GL.MAX_ELEMENTS_INDICES),
-    // GLint
-    [import_constants5.GL.MAX_ELEMENTS_VERTICES]: get2(import_constants5.GL.MAX_ELEMENTS_VERTICES),
-    //  GLint
-    [import_constants5.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(import_constants5.GL.MAX_FRAGMENT_INPUT_COMPONENTS),
-    //  GLint
-    [import_constants5.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_FRAGMENT_UNIFORM_BLOCKS),
-    //  GLint
-    [import_constants5.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS),
-    //  GLint
-    [import_constants5.GL.MAX_SAMPLES]: get2(import_constants5.GL.MAX_SAMPLES),
-    //  GLint
-    // [GL.MAX_SERVER_WAIT_TIMEOUT]: get2(GL.MAX_SERVER_WAIT_TIMEOUT), //  GLint64
-    [import_constants5.GL.MAX_TEXTURE_LOD_BIAS]: get2(import_constants5.GL.MAX_TEXTURE_LOD_BIAS),
-    // GLfloat
-    [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(import_constants5.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS),
-    //  GLint
-    [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
-    //  GLint
-    [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS),
-    // GLint
-    [import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE]: get2(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE),
-    // GLint64
-    [import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS),
-    //  GLint
-    [import_constants5.GL.MAX_VARYING_COMPONENTS]: get2(import_constants5.GL.MAX_VARYING_COMPONENTS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(import_constants5.GL.MAX_VERTEX_OUTPUT_COMPONENTS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_VERTEX_UNIFORM_BLOCKS),
-    //  GLint
-    [import_constants5.GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_VERTEX_UNIFORM_COMPONENTS),
-    //  GLint
-    [import_constants5.GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(import_constants5.GL.MIN_PROGRAM_TEXEL_OFFSET),
-    // GLint
-    [import_constants5.GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(import_constants5.GL.MAX_PROGRAM_TEXEL_OFFSET),
-    // GLint
-    [import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT)
-    // GLint
-  };
-}
+  get maxTextureDimension3D() {
+    return this.getParameter(32883);
+  }
+  get maxTextureArrayLayers() {
+    return this.getParameter(35071);
+  }
+  get maxBindGroups() {
+    return 0;
+  }
+  get maxDynamicUniformBuffersPerPipelineLayout() {
+    return 0;
+  }
+  // TBD
+  get maxDynamicStorageBuffersPerPipelineLayout() {
+    return 0;
+  }
+  // TBD
+  get maxSampledTexturesPerShaderStage() {
+    return this.getParameter(35660);
+  }
+  // ) TBD
+  get maxSamplersPerShaderStage() {
+    return this.getParameter(35661);
+  }
+  get maxStorageBuffersPerShaderStage() {
+    return 0;
+  }
+  // TBD
+  get maxStorageTexturesPerShaderStage() {
+    return 0;
+  }
+  // TBD
+  get maxUniformBuffersPerShaderStage() {
+    return this.getParameter(35375);
+  }
+  get maxUniformBufferBindingSize() {
+    return this.getParameter(35376);
+  }
+  get maxStorageBufferBindingSize() {
+    return 0;
+  }
+  get minUniformBufferOffsetAlignment() {
+    return this.getParameter(35380);
+  }
+  get minStorageBufferOffsetAlignment() {
+    return 0;
+  }
+  get maxVertexBuffers() {
+    return 16;
+  }
+  // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
+  get maxVertexAttributes() {
+    return this.getParameter(34921);
+  }
+  get maxVertexBufferArrayStride() {
+    return 2048;
+  }
+  // TBD, this is just the default value from WebGPU
+  get maxInterStageShaderComponents() {
+    return this.getParameter(35659);
+  }
+  get maxComputeWorkgroupStorageSize() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeInvocationsPerWorkgroup() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeX() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeY() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeZ() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupsPerDimension() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  // PRIVATE
+  gl;
+  limits = {};
+  constructor(gl) {
+    super();
+    this.gl = gl;
+  }
+  getParameter(parameter) {
+    if (this.limits[parameter] === void 0) {
+      this.limits[parameter] = this.gl.getParameter(parameter);
+    }
+    return this.limits[parameter];
+  }
+};
 // dist/adapter/webgl-canvas-context.js
 var import_core11 = require("@luma.gl/core");
 // dist/adapter/resources/webgl-framebuffer.js
 var import_core10 = require("@luma.gl/core");
-var import_constants12 = require("@luma.gl/constants");
+var import_constants11 = require("@luma.gl/constants");
 // dist/adapter/resources/webgl-texture.js
-var import_core6 = require("@luma.gl/core");
+var import_core9 = require("@luma.gl/core");
 var import_constants10 = require("@luma.gl/constants");
 // dist/context/state-tracker/with-parameters.js
-function withGLParameters(device, parameters, func) {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
+function withGLParameters(gl, parameters, func) {
   if (isObjectEmpty2(parameters)) {
-    return func(device);
+    return func(gl);
   }
   const { nocatch = true } = parameters;
   pushContextState(gl);
@@ -1457,23 +1543,24 @@ function isObjectEmpty2(object) {
 var import_constants7 = require("@luma.gl/constants");
 // dist/adapter/converters/device-parameters.js
-var import_core3 = require("@luma.gl/core");
+var import_core5 = require("@luma.gl/core");
 var import_constants6 = require("@luma.gl/constants");
 function withDeviceAndGLParameters(device, parameters, glParameters, func) {
-  if ((0, import_core3.isObjectEmpty)(parameters)) {
+  if ((0, import_core5.isObjectEmpty)(parameters)) {
     return func(device);
   }
-  pushContextState(device.gl);
+  const webglDevice = device;
+  pushContextState(webglDevice.gl);
   try {
     setDeviceParameters(device, parameters);
-    setGLParameters(device, glParameters);
+    setGLParameters(webglDevice.gl, glParameters);
     return func(device);
   } finally {
-    popContextState(device.gl);
+    popContextState(webglDevice.gl);
   }
 }
 function withDeviceParameters(device, parameters, func) {
-  if ((0, import_core3.isObjectEmpty)(parameters)) {
+  if ((0, import_core5.isObjectEmpty)(parameters)) {
     return func(device);
   }
   pushContextState(device.gl);
@@ -1485,63 +1572,120 @@ function withDeviceParameters(device, parameters, func) {
   }
 }
 function setDeviceParameters(device, parameters) {
-  const webglDevice = WebGLDevice.attach(device);
+  const webglDevice = device;
   const { gl } = webglDevice;
   if (parameters.cullMode) {
     switch (parameters.cullMode) {
       case "none":
-        gl.disable(import_constants6.GL.CULL_FACE);
+        gl.disable(2884);
         break;
       case "front":
-        gl.enable(import_constants6.GL.CULL_FACE);
-        gl.cullFace(import_constants6.GL.FRONT);
+        gl.enable(2884);
+        gl.cullFace(1028);
         break;
       case "back":
-        gl.enable(import_constants6.GL.CULL_FACE);
-        gl.cullFace(import_constants6.GL.BACK);
+        gl.enable(2884);
+        gl.cullFace(1029);
         break;
     }
   }
   if (parameters.frontFace) {
     gl.frontFace(map("frontFace", parameters.frontFace, {
-      ccw: import_constants6.GL.CCW,
-      cw: import_constants6.GL.CW
+      ccw: 2305,
+      cw: 2304
     }));
   }
+  if (parameters.unclippedDepth) {
+    if (device.features.has("depth-clip-control")) {
+      gl.enable(34383);
+    }
+  }
   if (parameters.depthBias !== void 0) {
     gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
   }
+  if (device.features.has("provoking-vertex-webgl")) {
+    const extensions = webglDevice.getExtension("WEBGL_provoking_vertex");
+    const ext = extensions.WEBGL_provoking_vertex;
+    if (parameters.provokingVertex) {
+      const vertex = map("provokingVertex", parameters.provokingVertex, {
+        first: 36429,
+        last: 36430
+      });
+      ext == null ? void 0 : ext.provokingVertexWEBGL(vertex);
+    }
+  }
+  if (device.features.has("polygon-mode-webgl")) {
+    const extensions = webglDevice.getExtension("WEBGL_polygon_mode");
+    const ext = extensions.WEBGL_polygon_mode;
+    if (parameters.polygonMode) {
+      const mode = map("polygonMode", parameters.provokingVertex, {
+        fill: 6914,
+        lint: 6913
+      });
+      ext == null ? void 0 : ext.polygonModeWEBGL(1028, mode);
+      ext == null ? void 0 : ext.polygonModeWEBGL(1029, mode);
+    }
+    if (parameters.polygonOffsetLine) {
+      gl.enable(10754);
+    }
+  }
+  if (device.features.has("shader-clip-cull-distance-webgl")) {
+    if (parameters.clipDistance0) {
+      gl.enable(12288);
+    }
+    if (parameters.clipDistance1) {
+      gl.enable(12289);
+    }
+    if (parameters.clipDistance2) {
+      gl.enable(12290);
+    }
+    if (parameters.clipDistance3) {
+      gl.enable(12291);
+    }
+    if (parameters.clipDistance4) {
+      gl.enable(12292);
+    }
+    if (parameters.clipDistance5) {
+      gl.enable(12293);
+    }
+    if (parameters.clipDistance6) {
+      gl.enable(12294);
+    }
+    if (parameters.clipDistance7) {
+      gl.enable(12295);
+    }
+  }
   if (parameters.depthWriteEnabled !== void 0) {
     gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
   }
   if (parameters.depthCompare) {
-    parameters.depthCompare !== "always" ? gl.enable(import_constants6.GL.DEPTH_TEST) : gl.disable(import_constants6.GL.DEPTH_TEST);
+    parameters.depthCompare !== "always" ? gl.enable(2929) : gl.disable(2929);
     gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
   }
   if (parameters.stencilWriteMask) {
     const mask = parameters.stencilWriteMask;
-    gl.stencilMaskSeparate(import_constants6.GL.FRONT, mask);
-    gl.stencilMaskSeparate(import_constants6.GL.BACK, mask);
+    gl.stencilMaskSeparate(1028, mask);
+    gl.stencilMaskSeparate(1029, mask);
   }
   if (parameters.stencilReadMask) {
-    import_core3.log.warn("stencilReadMask not supported under WebGL");
+    import_core5.log.warn("stencilReadMask not supported under WebGL");
   }
   if (parameters.stencilCompare) {
     const mask = parameters.stencilReadMask || 4294967295;
     const glValue = convertCompareFunction("depthCompare", parameters.stencilCompare);
-    parameters.stencilCompare !== "always" ? gl.enable(import_constants6.GL.STENCIL_TEST) : gl.disable(import_constants6.GL.STENCIL_TEST);
-    gl.stencilFuncSeparate(import_constants6.GL.FRONT, glValue, 0, mask);
-    gl.stencilFuncSeparate(import_constants6.GL.BACK, glValue, 0, mask);
+    parameters.stencilCompare !== "always" ? gl.enable(2960) : gl.disable(2960);
+    gl.stencilFuncSeparate(1028, glValue, 0, mask);
+    gl.stencilFuncSeparate(1029, glValue, 0, mask);
   }
   if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
     const dppass = convertStencilOperation("stencilPassOperation", parameters.stencilPassOperation);
     const sfail = convertStencilOperation("stencilFailOperation", parameters.stencilFailOperation);
     const dpfail = convertStencilOperation("stencilDepthFailOperation", parameters.stencilDepthFailOperation);
-    gl.stencilOpSeparate(import_constants6.GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(import_constants6.GL.BACK, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(1028, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(1029, sfail, dpfail, dppass);
   }
   if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
-    gl.enable(import_constants6.GL.BLEND);
+    gl.enable(3042);
     const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add");
     const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add");
     gl.blendEquationSeparate(colorEquation, alphaEquation);
@@ -1554,49 +1698,49 @@ function setDeviceParameters(device, parameters) {
 }
 function convertCompareFunction(parameter, value) {
   return map(parameter, value, {
-    never: import_constants6.GL.NEVER,
-    less: import_constants6.GL.LESS,
-    equal: import_constants6.GL.EQUAL,
-    "less-equal": import_constants6.GL.LEQUAL,
-    greater: import_constants6.GL.GREATER,
-    "not-equal": import_constants6.GL.NOTEQUAL,
-    "greater-equal": import_constants6.GL.GEQUAL,
-    always: import_constants6.GL.ALWAYS
+    never: 512,
+    less: 513,
+    equal: 514,
+    "less-equal": 515,
+    greater: 516,
+    "not-equal": 517,
+    "greater-equal": 518,
+    always: 519
   });
 }
 function convertStencilOperation(parameter, value) {
   return map(parameter, value, {
-    keep: import_constants6.GL.KEEP,
-    zero: import_constants6.GL.ZERO,
-    replace: import_constants6.GL.REPLACE,
-    invert: import_constants6.GL.INVERT,
-    "increment-clamp": import_constants6.GL.INCR,
-    "decrement-clamp": import_constants6.GL.DECR,
-    "increment-wrap": import_constants6.GL.INCR_WRAP,
-    "decrement-wrap": import_constants6.GL.DECR_WRAP
+    keep: 7680,
+    zero: 0,
+    replace: 7681,
+    invert: 5386,
+    "increment-clamp": 7682,
+    "decrement-clamp": 7683,
+    "increment-wrap": 34055,
+    "decrement-wrap": 34056
   });
 }
 function convertBlendOperationToEquation(parameter, value) {
   return map(parameter, value, {
-    "add": import_constants6.GL.FUNC_ADD,
-    "subtract": import_constants6.GL.FUNC_SUBTRACT,
-    "reverse-subtract": import_constants6.GL.FUNC_REVERSE_SUBTRACT,
-    "min": import_constants6.GL.MIN,
-    "max": import_constants6.GL.MAX
+    add: 32774,
+    subtract: 32778,
+    "reverse-subtract": 32779,
+    min: 32775,
+    max: 32776
   });
 }
 function convertBlendFactorToFunction(parameter, value) {
   return map(parameter, value, {
-    "one": import_constants6.GL.ONE,
-    "zero": import_constants6.GL.ZERO,
-    "src-color": import_constants6.GL.SRC_COLOR,
-    "one-minus-src-color": import_constants6.GL.ONE_MINUS_SRC_COLOR,
-    "dst-color": import_constants6.GL.DST_COLOR,
-    "one-minus-dst-color": import_constants6.GL.ONE_MINUS_DST_COLOR,
-    "src-alpha": import_constants6.GL.SRC_ALPHA,
-    "one-minus-src-alpha": import_constants6.GL.ONE_MINUS_SRC_ALPHA,
-    "dst-alpha": import_constants6.GL.DST_ALPHA,
-    "one-minus-dst-alpha": import_constants6.GL.ONE_MINUS_DST_ALPHA
+    one: 1,
+    zero: 0,
+    "src-color": 768,
+    "one-minus-src-color": 769,
+    "dst-color": 774,
+    "one-minus-dst-color": 775,
+    "src-alpha": 770,
+    "one-minus-src-alpha": 771,
+    "dst-alpha": 772,
+    "one-minus-dst-alpha": 773
   });
 }
 function message(parameter, value) {
@@ -1616,53 +1760,53 @@ function mapBoolean(parameter, value) {
 function convertSamplerParametersToWebGL(props) {
   const params = {};
   if (props.addressModeU) {
-    params[import_constants7.GL.TEXTURE_WRAP_S] = convertAddressMode(props.addressModeU);
+    params[10242] = convertAddressMode(props.addressModeU);
   }
   if (props.addressModeV) {
-    params[import_constants7.GL.TEXTURE_WRAP_T] = convertAddressMode(props.addressModeV);
+    params[10243] = convertAddressMode(props.addressModeV);
   }
   if (props.addressModeW) {
-    params[import_constants7.GL.TEXTURE_WRAP_R] = convertAddressMode(props.addressModeW);
+    params[32882] = convertAddressMode(props.addressModeW);
   }
   if (props.magFilter) {
-    params[import_constants7.GL.TEXTURE_MAG_FILTER] = convertMaxFilterMode(props.magFilter);
+    params[10240] = convertMaxFilterMode(props.magFilter);
   }
   if (props.minFilter || props.mipmapFilter) {
-    params[import_constants7.GL.TEXTURE_MIN_FILTER] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
+    params[10241] = convertMinFilterMode(props.minFilter || "linear", props.mipmapFilter);
   }
   if (props.lodMinClamp !== void 0) {
-    params[import_constants7.GL.TEXTURE_MIN_LOD] = props.lodMinClamp;
+    params[33082] = props.lodMinClamp;
   }
   if (props.lodMaxClamp !== void 0) {
-    params[import_constants7.GL.TEXTURE_MAX_LOD] = props.lodMaxClamp;
+    params[33083] = props.lodMaxClamp;
   }
   if (props.type === "comparison-sampler") {
-    params[import_constants7.GL.TEXTURE_COMPARE_MODE] = import_constants7.GL.COMPARE_REF_TO_TEXTURE;
+    params[34892] = 34894;
   }
   if (props.compare) {
-    params[import_constants7.GL.TEXTURE_COMPARE_FUNC] = convertCompareFunction("compare", props.compare);
+    params[34893] = convertCompareFunction("compare", props.compare);
   }
   if (props.maxAnisotropy) {
-    params[import_constants7.GL.TEXTURE_MAX_ANISOTROPY_EXT] = props.maxAnisotropy;
+    params[34046] = props.maxAnisotropy;
   }
   return params;
 }
 function convertAddressMode(addressMode) {
   switch (addressMode) {
     case "clamp-to-edge":
-      return import_constants7.GL.CLAMP_TO_EDGE;
+      return 33071;
     case "repeat":
-      return import_constants7.GL.REPEAT;
+      return 10497;
     case "mirror-repeat":
-      return import_constants7.GL.MIRRORED_REPEAT;
+      return 33648;
   }
 }
 function convertMaxFilterMode(maxFilter) {
   switch (maxFilter) {
     case "nearest":
-      return import_constants7.GL.NEAREST;
+      return 9728;
     case "linear":
-      return import_constants7.GL.LINEAR;
+      return 9729;
   }
 }
 function convertMinFilterMode(minFilter, mipmapFilter) {
@@ -1671,16 +1815,16 @@ function convertMinFilterMode(minFilter, mipmapFilter) {
   }
   switch (minFilter) {
     case "nearest":
-      return mipmapFilter === "nearest" ? import_constants7.GL.NEAREST_MIPMAP_NEAREST : import_constants7.GL.NEAREST_MIPMAP_LINEAR;
+      return mipmapFilter === "nearest" ? 9984 : 9986;
     case "linear":
-      return mipmapFilter === "nearest" ? import_constants7.GL.LINEAR_MIPMAP_NEAREST : import_constants7.GL.LINEAR_MIPMAP_LINEAR;
+      return mipmapFilter === "nearest" ? 9985 : 9987;
   }
 }
 // dist/adapter/resources/webgl-buffer.js
-var import_core4 = require("@luma.gl/core");
+var import_core6 = require("@luma.gl/core");
 var import_constants8 = require("@luma.gl/constants");
-var WEBGLBuffer = class extends import_core4.Buffer {
+var WEBGLBuffer = class extends import_core6.Buffer {
   device;
   gl;
   handle;
@@ -1689,7 +1833,7 @@ var WEBGLBuffer = class extends import_core4.Buffer {
   /** Usage is a hint on how frequently the buffer will be updates */
   glUsage;
   /** Index type is needed when issuing draw calls, so we pre-compute it */
-  glIndexType = import_constants8.GL.UNSIGNED_SHORT;
+  glIndexType = 5123;
   /** Number of bytes allocated on the GPU for this buffer */
   byteLength;
   /** Number of bytes used */
@@ -1703,7 +1847,7 @@ var WEBGLBuffer = class extends import_core4.Buffer {
     device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
     this.glTarget = getWebGLTarget(this.props.usage);
     this.glUsage = getWebGLUsage(this.props.usage);
-    this.glIndexType = this.props.indexType === "uint32" ? import_constants8.GL.UNSIGNED_INT : import_constants8.GL.UNSIGNED_SHORT;
+    this.glIndexType = this.props.indexType === "uint32" ? 5125 : 5123;
     if (props.data) {
       this._initWithData(props.data, props.byteOffset, props.byteLength);
     } else {
@@ -1725,7 +1869,7 @@ var WEBGLBuffer = class extends import_core4.Buffer {
   }
   // Allocate a GPU buffer of specified size.
   _initWithByteLength(byteLength) {
-    (0, import_core4.assert)(byteLength >= 0);
+    (0, import_core6.assert)(byteLength >= 0);
     let data = byteLength;
     if (byteLength === 0) {
       data = new Float32Array(0);
@@ -1752,7 +1896,7 @@ var WEBGLBuffer = class extends import_core4.Buffer {
   write(data, byteOffset = 0) {
     const srcOffset = 0;
     const byteLength = void 0;
-    const glTarget = import_constants8.GL.COPY_WRITE_BUFFER;
+    const glTarget = 36663;
     this.gl.bindBuffer(glTarget, this.handle);
     if (srcOffset !== 0 || byteLength !== void 0) {
       this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
@@ -1771,42 +1915,42 @@ var WEBGLBuffer = class extends import_core4.Buffer {
     byteLength = byteLength ?? this.byteLength - byteOffset;
     const data = new Uint8Array(byteLength);
     const dstOffset = 0;
-    this.gl.bindBuffer(import_constants8.GL.COPY_READ_BUFFER, this.handle);
-    this.gl.getBufferSubData(import_constants8.GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
-    this.gl.bindBuffer(import_constants8.GL.COPY_READ_BUFFER, null);
+    this.gl.bindBuffer(36662, this.handle);
+    this.gl.getBufferSubData(36662, byteOffset, data, dstOffset, byteLength);
+    this.gl.bindBuffer(36662, null);
     this._setDebugData(data, byteOffset, byteLength);
     return data;
   }
 };
 function getWebGLTarget(usage) {
-  if (usage & import_core4.Buffer.INDEX) {
-    return import_constants8.GL.ELEMENT_ARRAY_BUFFER;
+  if (usage & import_core6.Buffer.INDEX) {
+    return 34963;
   }
-  if (usage & import_core4.Buffer.VERTEX) {
-    return import_constants8.GL.ARRAY_BUFFER;
+  if (usage & import_core6.Buffer.VERTEX) {
+    return 34962;
   }
-  if (usage & import_core4.Buffer.UNIFORM) {
-    return import_constants8.GL.UNIFORM_BUFFER;
+  if (usage & import_core6.Buffer.UNIFORM) {
+    return 35345;
   }
-  return import_constants8.GL.ARRAY_BUFFER;
+  return 34962;
 }
 function getWebGLUsage(usage) {
-  if (usage & import_core4.Buffer.INDEX) {
-    return import_constants8.GL.STATIC_DRAW;
+  if (usage & import_core6.Buffer.INDEX) {
+    return 35044;
   }
-  if (usage & import_core4.Buffer.VERTEX) {
-    return import_constants8.GL.STATIC_DRAW;
+  if (usage & import_core6.Buffer.VERTEX) {
+    return 35044;
   }
-  if (usage & import_core4.Buffer.UNIFORM) {
-    return import_constants8.GL.DYNAMIC_DRAW;
+  if (usage & import_core6.Buffer.UNIFORM) {
+    return 35048;
   }
-  return import_constants8.GL.STATIC_DRAW;
+  return 35044;
 }
 // dist/adapter/resources/webgl-sampler.js
-var import_core5 = require("@luma.gl/core");
+var import_core7 = require("@luma.gl/core");
 var import_constants9 = require("@luma.gl/constants");
-var WEBGLSampler = class extends import_core5.Sampler {
+var WEBGLSampler = class extends import_core7.Sampler {
   device;
   handle;
   parameters;
@@ -1831,8 +1975,8 @@ var WEBGLSampler = class extends import_core5.Sampler {
     for (const [pname, value] of Object.entries(parameters)) {
       const param = Number(pname);
       switch (param) {
-        case import_constants9.GL.TEXTURE_MIN_LOD:
-        case import_constants9.GL.TEXTURE_MAX_LOD:
+        case 33082:
+        case 33083:
           this.device.gl.samplerParameterf(this.handle, param, value);
           break;
         default:
@@ -1843,6 +1987,22 @@ var WEBGLSampler = class extends import_core5.Sampler {
   }
 };
+// dist/adapter/resources/webgl-texture-view.js
+var import_core8 = require("@luma.gl/core");
+var WEBGLTextureView = class extends import_core8.TextureView {
+  device;
+  gl;
+  handle;
+  texture;
+  constructor(device, props) {
+    super(device, { ...import_core8.Texture.defaultProps, ...props });
+    this.device = device;
+    this.gl = this.device.gl;
+    this.handle = null;
+    this.texture = props.texture;
+  }
+};
 // dist/adapter/resources/webgl-texture.js
 var DEFAULT_WEBGL_TEXTURE_PROPS = {
   // deprecated
@@ -1854,13 +2014,14 @@ var DEFAULT_WEBGL_TEXTURE_PROPS = {
   textureUnit: void 0,
   target: void 0
 };
-var _WEBGLTexture = class extends import_core6.Texture {
+var _WEBGLTexture = class extends import_core9.Texture {
   MAX_ATTRIBUTES;
   device;
   gl;
   handle;
-  /** Sampler object (currently unused) */
+  // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
   sampler = void 0;
+  view = void 0;
   // data;
   glFormat = void 0;
   type = void 0;
@@ -1891,11 +2052,11 @@ var _WEBGLTexture = class extends import_core6.Texture {
     this.gl = this.device.gl;
     this.handle = this.props.handle || this.gl.createTexture();
     this.device.setSpectorMetadata(this.handle, { ...this.props, data: typeof this.props.data });
-    this.glFormat = import_constants10.GL.RGBA;
+    this.glFormat = 6408;
     this.target = getWebGLTextureTarget(this.props);
     this.loaded = false;
     if (typeof ((_a = this.props) == null ? void 0 : _a.data) === "string") {
-      Object.assign(this.props, { data: (0, import_core6.loadImage)(this.props.data) });
+      Object.assign(this.props, { data: (0, import_core9.loadImage)(this.props.data) });
     }
     this.initialize(this.props);
     Object.seal(this);
@@ -1911,6 +2072,9 @@ var _WEBGLTexture = class extends import_core6.Texture {
   toString() {
     return `Texture(${this.id},${this.width}x${this.height})`;
   }
+  createView(props) {
+    return new WEBGLTextureView(this.device, { ...props, texture: this });
+  }
   // eslint-disable-next-line max-statements
   initialize(props = {}) {
     if (this.props.dimension === "cube") {
@@ -1954,7 +2118,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
     this.dataFormat = dataFormat;
     this.textureUnit = textureUnit;
     if (Number.isFinite(this.textureUnit)) {
-      this.gl.activeTexture(import_constants10.GL.TEXTURE0 + this.textureUnit);
+      this.gl.activeTexture(33984 + this.textureUnit);
       this.gl.bindTexture(this.target, this.handle);
     }
     this.mipmaps = mipmaps;
@@ -1972,7 +2136,8 @@ var _WEBGLTexture = class extends import_core6.Texture {
     });
     this.setSampler(props.sampler);
     this._setSamplerParameters(parameters);
-    if (mipmaps) {
+    this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 });
+    if (mipmaps && this.device.isTextureFormatFilterable(props.format)) {
       this.generateMipmap();
     }
     if (isVideo) {
@@ -2120,9 +2285,9 @@ var _WEBGLTexture = class extends import_core6.Texture {
           );
           break;
         case "buffer":
-          this.device.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+          this.device.gl.bindBuffer(35052, data.handle || data);
           this.device.gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, offset);
-          this.device.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, null);
+          this.device.gl.bindBuffer(35052, null);
           break;
         case "browser-object":
           gl.texImage2D(target, level, glFormat, width, height, 0, dataFormat, type, data);
@@ -2133,7 +2298,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
           }
           break;
         default:
-          (0, import_core6.assert)(false, "Unknown image data type");
+          (0, import_core9.assert)(false, "Unknown image data type");
       }
     });
     if (data && data.byteLength) {
@@ -2160,7 +2325,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
       width,
       height
     }));
-    (0, import_core6.assert)(this.depth === 1, "texSubImage not supported for 3D textures");
+    (0, import_core9.assert)(this.depth === 1, "texSubImage not supported for 3D textures");
     if (!data) {
       data = pixels;
     }
@@ -2182,9 +2347,9 @@ var _WEBGLTexture = class extends import_core6.Texture {
       } else if (ArrayBuffer.isView(data)) {
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
       } else if (typeof WebGLBuffer !== "undefined" && data instanceof WebGLBuffer) {
-        this.device.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, data);
+        this.device.gl.bindBuffer(35052, data);
         this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
-        this.device.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, null);
+        this.device.gl.bindBuffer(35052, null);
       } else {
         this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
       }
@@ -2200,17 +2365,17 @@ var _WEBGLTexture = class extends import_core6.Texture {
    * rendering can be faster.
    */
   copyFramebuffer(opts = {}) {
-    import_core6.log.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")();
+    import_core9.log.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")();
     return null;
   }
   getActiveUnit() {
-    return this.gl.getParameter(import_constants10.GL.ACTIVE_TEXTURE) - import_constants10.GL.TEXTURE0;
+    return this.gl.getParameter(34016) - 33984;
   }
   bind(textureUnit = this.textureUnit) {
     const { gl } = this;
     if (textureUnit !== void 0) {
       this.textureUnit = textureUnit;
-      gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      gl.activeTexture(33984 + textureUnit);
     }
     gl.bindTexture(this.target, this.handle);
     return textureUnit;
@@ -2219,7 +2384,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
     const { gl } = this;
     if (textureUnit !== void 0) {
       this.textureUnit = textureUnit;
-      gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      gl.activeTexture(33984 + textureUnit);
     }
     gl.bindTexture(this.target, null);
     return textureUnit;
@@ -2272,16 +2437,16 @@ var _WEBGLTexture = class extends import_core6.Texture {
     } else {
       size = { width, height };
     }
-    (0, import_core6.assert)(size, "Could not deduced texture size");
-    (0, import_core6.assert)(width === void 0 || size.width === width, "Deduced texture width does not match supplied width");
-    (0, import_core6.assert)(height === void 0 || size.height === height, "Deduced texture height does not match supplied height");
+    (0, import_core9.assert)(size, "Could not deduced texture size");
+    (0, import_core9.assert)(width === void 0 || size.width === width, "Deduced texture width does not match supplied width");
+    (0, import_core9.assert)(height === void 0 || size.height === height, "Deduced texture height does not match supplied height");
     return size;
   }
   // CUBE MAP METHODS
   /* eslint-disable max-statements, max-len */
   async setCubeMapImageData(options) {
     const { gl } = this;
-    const { width, height, pixels, data, format = import_constants10.GL.RGBA, type = import_constants10.GL.UNSIGNED_BYTE } = options;
+    const { width, height, pixels, data, format = 6408, type = 5121 } = options;
     const imageDataMap = pixels || data;
     const resolvedFaces = await Promise.all(_WEBGLTexture.FACES.map((face) => {
       const facePixels = imageDataMap[face];
@@ -2290,7 +2455,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
     this.bind();
     _WEBGLTexture.FACES.forEach((face, index) => {
       if (resolvedFaces[index].length > 1 && this.props.mipmaps !== false) {
-        import_core6.log.warn(`${this.id} has mipmap and multiple LODs.`)();
+        import_core9.log.warn(`${this.id} has mipmap and multiple LODs.`)();
       }
       resolvedFaces[index].forEach((image, lodLevel) => {
         if (width && height) {
@@ -2310,8 +2475,8 @@ var _WEBGLTexture = class extends import_core6.Texture {
       height,
       pixels,
       data,
-      format = import_constants10.GL.RGBA,
-      type = import_constants10.GL.UNSIGNED_BYTE
+      format = 6408,
+      type = 5121
       // generateMipmap = false // TODO
     } = options;
     const { gl } = this;
@@ -2365,7 +2530,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
         );
       }
       if (data instanceof WEBGLBuffer) {
-        this.gl.bindBuffer(import_constants10.GL.PIXEL_UNPACK_BUFFER, data.handle);
+        this.gl.bindBuffer(35052, data.handle);
         this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, 0, format, type, offset);
       }
     });
@@ -2383,7 +2548,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
    * Sets sampler parameters on texture
    */
   _setSamplerParameters(parameters) {
-    if ((0, import_core6.isObjectEmpty)(parameters)) {
+    if ((0, import_core9.isObjectEmpty)(parameters)) {
       return;
     }
     logParameters(parameters);
@@ -2392,8 +2557,8 @@ var _WEBGLTexture = class extends import_core6.Texture {
       const param = Number(pname);
       const value = pvalue;
       switch (param) {
-        case import_constants10.GL.TEXTURE_MIN_LOD:
-        case import_constants10.GL.TEXTURE_MAX_LOD:
+        case 33082:
+        case 33083:
           this.gl.texParameterf(this.target, param, value);
           break;
         default:
@@ -2408,23 +2573,23 @@ var _WEBGLTexture = class extends import_core6.Texture {
 var WEBGLTexture = _WEBGLTexture;
 // TODO - remove?
 __publicField(WEBGLTexture, "FACES", [
-  import_constants10.GL.TEXTURE_CUBE_MAP_POSITIVE_X,
-  import_constants10.GL.TEXTURE_CUBE_MAP_NEGATIVE_X,
-  import_constants10.GL.TEXTURE_CUBE_MAP_POSITIVE_Y,
-  import_constants10.GL.TEXTURE_CUBE_MAP_NEGATIVE_Y,
-  import_constants10.GL.TEXTURE_CUBE_MAP_POSITIVE_Z,
-  import_constants10.GL.TEXTURE_CUBE_MAP_NEGATIVE_Z
+  34069,
+  34070,
+  34071,
+  34072,
+  34073,
+  34074
 ]);
 function getWebGLTextureTarget(props) {
   switch (props.dimension) {
     case "2d":
-      return import_constants10.GL.TEXTURE_2D;
+      return 3553;
     case "cube":
-      return import_constants10.GL.TEXTURE_CUBE_MAP;
+      return 34067;
     case "2d-array":
-      return import_constants10.GL.TEXTURE_2D_ARRAY;
+      return 35866;
     case "3d":
-      return import_constants10.GL.TEXTURE_3D;
+      return 32879;
     case "1d":
     case "cube-array":
     default:
@@ -2432,380 +2597,114 @@ function getWebGLTextureTarget(props) {
   }
 }
 function logParameters(parameters) {
-  import_core6.log.log(1, "texture sampler parameters", parameters)();
-}
-// dist/adapter/objects/webgl-renderbuffer.js
-var import_core9 = require("@luma.gl/core");
-var import_constants11 = require("@luma.gl/constants");
-// dist/adapter/objects/webgl-resource.js
-var import_core8 = require("@luma.gl/core");
-// dist/adapter/objects/constants-to-keys.js
-var import_core7 = require("@luma.gl/core");
-function getKeyValue(gl, name) {
-  if (typeof name !== "string") {
-    return name;
-  }
-  const number = Number(name);
-  if (!isNaN(number)) {
-    return number;
-  }
-  name = name.replace(/^.*\./, "");
-  const value = gl[name];
-  (0, import_core7.assert)(value !== void 0, `Accessing undefined constant GL.${name}`);
-  return value;
+  import_core9.log.log(1, "texture sampler parameters", parameters)();
 }
-// dist/adapter/objects/webgl-resource.js
-var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
-var WebGLResource = class extends import_core8.Resource {
+// dist/adapter/resources/webgl-framebuffer.js
+var WEBGLFramebuffer = class extends import_core10.Framebuffer {
   device;
   gl;
-  gl2;
-  _handle;
-  _bound = false;
-  // Only meaningful for resources that allocate GPU memory
-  byteLength = 0;
-  constructor(device, props, defaultProps) {
-    super(device, props, defaultProps);
-    this.device = WebGLDevice.attach(device);
-    const gl = this.device.gl;
-    const { id } = props || {};
-    this.gl = gl;
-    this.gl2 = gl;
-    this.id = id || (0, import_core8.uid)(this.constructor.name);
-    this._handle = props == null ? void 0 : props.handle;
-    if (this._handle === void 0) {
-      this._handle = this._createHandle();
-    }
-    this.byteLength = 0;
-  }
-  toString() {
-    return `${this.constructor.name}(${this.id})`;
-  }
-  get handle() {
-    return this._handle;
+  handle;
+  get texture() {
+    return this.colorAttachments[0];
   }
-  delete({ deleteChildren = false } = {}) {
-    const children = this._handle && this._deleteHandle(this._handle);
-    if (this._handle) {
-      this.removeStats();
-    }
-    this._handle = null;
-    if (children && deleteChildren) {
-      children.filter(Boolean).forEach((child) => child.destroy());
+  constructor(device, props) {
+    super(device, props);
+    const isDefaultFramebuffer = props.handle === null;
+    this.device = device;
+    this.gl = device.gl;
+    this.handle = this.props.handle || isDefaultFramebuffer ? this.props.handle : this.gl.createFramebuffer();
+    if (!isDefaultFramebuffer) {
+      device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props });
+      this.autoCreateAttachmentTextures();
+      this.gl.bindFramebuffer(36160, this.handle);
+      for (let i = 0; i < this.colorAttachments.length; ++i) {
+        const attachment = this.colorAttachments[i];
+        const attachmentPoint = 36064 + i;
+        if (attachment) {
+          this._attachOne(attachmentPoint, attachment);
+        }
+      }
+      if (this.depthStencilAttachment) {
+        this._attachOne(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format), this.depthStencilAttachment);
+      }
+      if (props.check !== false) {
+        const status = this.gl.checkFramebufferStatus(36160);
+        if (status !== 36053) {
+          throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
+        }
+      }
+      this.gl.bindFramebuffer(36160, null);
     }
-    return this;
   }
-  bind(funcOrHandle = this.handle) {
-    if (typeof funcOrHandle !== "function") {
-      this._bindHandle(funcOrHandle);
-      return this;
-    }
-    let value;
-    if (!this._bound) {
-      this._bindHandle(this.handle);
-      this._bound = true;
-      value = funcOrHandle();
-      this._bound = false;
-      this._bindHandle(null);
-    } else {
-      value = funcOrHandle();
+  /** destroys any auto created resources etc. */
+  destroy() {
+    super.destroy();
+    if (!this.destroyed && this.handle !== null) {
+      this.gl.deleteFramebuffer(this.handle);
     }
-    return value;
   }
-  unbind() {
-    this.bind(null);
+  // PRIVATE
+  /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
+  createDepthStencilTexture(format) {
+    return new WEBGLTexture(this.device, {
+      id: `${this.id}-depth-stencil`,
+      format,
+      width: this.width,
+      height: this.height,
+      mipmaps: false
+    });
   }
   /**
-   * Query a Resource parameter
-   *
-   * @param name
-   * @return param
+   * Attachment resize is expected to be a noop if size is same
    */
-  getParameter(pname, props = {}) {
-    pname = getKeyValue(this.gl, pname);
-    (0, import_core8.assert)(pname);
-    const parameters = this.constructor.PARAMETERS || {};
-    const parameter = parameters[pname];
-    if (parameter) {
-      const parameterAvailable = !("extension" in parameter) || this.gl.getExtension(parameter.extension);
-      if (!parameterAvailable) {
-        return parameter.webgl2;
-      }
+  resizeAttachments(width, height) {
+    if (this.handle === null) {
+      this.width = this.gl.drawingBufferWidth;
+      this.height = this.gl.drawingBufferHeight;
+      return this;
     }
-    return this._getParameter(pname, props);
-  }
-  // Many resources support a getParameter call -
-  // getParameters will get all parameters - slow but useful for debugging
-  // eslint-disable-next-line complexity
-  getParameters(options = {}) {
-    const { parameters, keys } = options;
-    const PARAMETERS = this.constructor.PARAMETERS || {};
-    const values = {};
-    const parameterKeys = parameters || Object.keys(PARAMETERS);
-    for (const pname of parameterKeys) {
-      const parameter = PARAMETERS[pname];
-      const parameterAvailable = parameter && (!("extension" in parameter) || this.gl.getExtension(parameter.extension));
-      if (parameterAvailable) {
-        const key = keys ? this.device.getGLKey(pname) : pname;
-        values[key] = this.getParameter(pname, options);
-        if (keys && parameter.type === "GLenum") {
-          values[key] = this.device.getGLKey(values[key]);
-        }
-      }
+    if (width === void 0) {
+      width = this.gl.drawingBufferWidth;
     }
-    return values;
-  }
-  /**
-   * Update a Resource setting
-   *
-   * @todo - cache parameter to avoid issuing WebGL calls?
-   *
-   * @param pname - parameter (GL constant, value or key)
-   * @param value {GLint|GLfloat|GLenum}
-   * @return returns self to enable chaining
-   */
-  setParameter(pname, value) {
-    pname = getKeyValue(this.gl, pname);
-    (0, import_core8.assert)(pname);
-    const parameters = this.constructor.PARAMETERS || {};
-    const parameter = parameters[pname];
-    if (parameter) {
-      const parameterAvailable = !("extension" in parameter) || this.gl.getExtension(parameter.extension);
-      if (!parameterAvailable) {
-        throw new Error("Parameter not available on this platform");
-      }
-      if (parameter.type === "GLenum") {
-        value = getKeyValue(value);
-      }
-    }
-    this._setParameter(pname, value);
-    return this;
-  }
-  /*
-   * Batch update resource parameters
-   * Assumes the subclass supports a setParameter call
-   */
-  setParameters(parameters) {
-    for (const pname in parameters) {
-      this.setParameter(pname, parameters[pname]);
-    }
-    return this;
-  }
-  // Install stubs for removed methods
-  stubRemovedMethods(className, version, methodNames) {
-    return (0, import_core8.stubRemovedMethods)(this, className, version, methodNames);
-  }
-  // PUBLIC VIRTUAL METHODS
-  initialize(props) {
-  }
-  // PROTECTED METHODS - These must be overridden by subclass
-  _createHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _deleteHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _bindHandle(handle) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _getOptsFromHandle() {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _getParameter(pname, props) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-  _setParameter(pname, value) {
-    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
-  }
-};
-// dist/adapter/objects/webgl-renderbuffer.js
-var _WEBGLRenderbuffer = class extends WebGLResource {
-  get [Symbol.toStringTag]() {
-    return "Renderbuffer";
-  }
-  get width() {
-    return this.props.width;
-  }
-  get height() {
-    return this.props.height;
-  }
-  get format() {
-    return this.props.format;
-  }
-  get samples() {
-    return this.props.samples;
-  }
-  get attachment() {
-    return;
-  }
-  /** WebGL format constant */
-  glFormat;
-  static isTextureFormatSupported(device, format) {
-    return isRenderbufferFormatSupported(device.gl, format);
-  }
-  constructor(device, props) {
-    if (typeof props.format === "number") {
-      throw new Error("Renderbuffer");
-    }
-    super(device, props, _WEBGLRenderbuffer.defaultProps);
-    this.glFormat = convertTextureFormatToGL(this.props.format);
-    this._initialize(this.props);
-  }
-  resize(size) {
-    if (size.width !== this.width || size.height !== this.height) {
-      Object.assign(this.props, { ...size, format: this.format, samples: this.samples });
-      this._initialize(this.props);
-    }
-  }
-  // PRIVATE METHODS
-  /** Creates and initializes a renderbuffer object's data store */
-  _initialize(props) {
-    const { format, width, height, samples } = props;
-    (0, import_core9.assert)(format, "Needs format");
-    this.trackDeallocatedMemory();
-    this.gl.bindRenderbuffer(import_constants11.GL.RENDERBUFFER, this.handle);
-    if (samples !== 0) {
-      this.gl.renderbufferStorageMultisample(import_constants11.GL.RENDERBUFFER, samples, this.glFormat, width, height);
-    } else {
-      this.gl.renderbufferStorage(import_constants11.GL.RENDERBUFFER, this.glFormat, width, height);
-    }
-    this.gl.bindRenderbuffer(import_constants11.GL.RENDERBUFFER, null);
-    this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat));
-  }
-  // RESOURCE IMPLEMENTATION
-  _createHandle() {
-    return this.gl.createRenderbuffer();
-  }
-  _deleteHandle() {
-    this.gl.deleteRenderbuffer(this.handle);
-    this.trackDeallocatedMemory();
-  }
-  _bindHandle(handle) {
-    this.gl.bindRenderbuffer(import_constants11.GL.RENDERBUFFER, handle);
-  }
-};
-var WEBGLRenderbuffer = _WEBGLRenderbuffer;
-__publicField(WEBGLRenderbuffer, "defaultProps", {
-  id: void 0,
-  handle: void 0,
-  userData: void 0,
-  format: void 0,
-  // 'depth16unorm'
-  width: 1,
-  height: 1,
-  samples: 0
-});
-// dist/adapter/resources/webgl-framebuffer.js
-var WEBGLFramebuffer = class extends import_core10.Framebuffer {
-  device;
-  gl;
-  handle;
-  get texture() {
-    return this.colorAttachments[0];
-  }
-  constructor(device, props) {
-    super(device, props);
-    const isDefaultFramebuffer = props.handle === null;
-    this.device = device;
-    this.gl = device.gl;
-    this.handle = this.props.handle || isDefaultFramebuffer ? this.props.handle : this.gl.createFramebuffer();
-    if (!isDefaultFramebuffer) {
-      device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props });
-      this.autoCreateAttachmentTextures();
-      this.gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, this.handle);
-      for (let i = 0; i < this.colorAttachments.length; ++i) {
-        const attachment = this.colorAttachments[i];
-        const attachmentPoint = import_constants12.GL.COLOR_ATTACHMENT0 + i;
-        if (attachment) {
-          this._attachOne(attachmentPoint, attachment);
-        }
-      }
-      if (this.depthStencilAttachment) {
-        this._attachOne(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.format), this.depthStencilAttachment);
-      }
-      this.gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, null);
-    }
-    if (props.check !== false) {
-      this._checkStatus();
-    }
-  }
-  /** destroys any auto created resources etc. */
-  destroy() {
-    super.destroy();
-    if (!this.destroyed && this.handle !== null) {
-      this.gl.deleteFramebuffer(this.handle);
-    }
-  }
-  // PRIVATE
-  /** Check the status */
-  _checkStatus() {
-    const { gl } = this;
-    const prevHandle = gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, this.handle);
-    const status = gl.checkFramebufferStatus(import_constants12.GL.FRAMEBUFFER);
-    gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, prevHandle || null);
-    if (status !== gl.FRAMEBUFFER_COMPLETE) {
-      throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
-    }
-  }
-  /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
-  createDepthStencilTexture(format) {
-    return new WEBGLRenderbuffer(this.device, {
-      id: `${this.id}-depth-stencil`,
-      // TODO misleading if not depth and stencil?
-      format,
-      // dataFormat: GL.DEPTH_STENCIL,
-      // type: GL.UNSIGNED_INT_24_8,
-      width: this.width,
-      height: this.height
-    });
-  }
-  /**
-   * Attachment resize is expected to be a noop if size is same
-   */
-  resizeAttachments(width, height) {
-    if (this.handle === null) {
-      this.width = this.gl.drawingBufferWidth;
-      this.height = this.gl.drawingBufferHeight;
-      return this;
-    }
-    if (width === void 0) {
-      width = this.gl.drawingBufferWidth;
-    }
-    if (height === void 0) {
-      height = this.gl.drawingBufferHeight;
-    }
-    for (const colorAttachment of this.colorAttachments) {
-      colorAttachment.resize({ width, height });
-    }
-    if (this.depthStencilAttachment) {
-      this.depthStencilAttachment.resize({ width, height });
-    }
-    return this;
+    if (height === void 0) {
+      height = this.gl.drawingBufferHeight;
+    }
+    for (const colorAttachment of this.colorAttachments) {
+      colorAttachment.texture.resize({ width, height });
+    }
+    if (this.depthStencilAttachment) {
+      this.depthStencilAttachment.texture.resize({ width, height });
+    }
+    return this;
   }
   /** Attach one attachment */
   _attachOne(attachmentPoint, attachment) {
-    if (attachment instanceof WEBGLRenderbuffer) {
-      this._attachWEBGLRenderbuffer(attachmentPoint, attachment);
-      return attachment;
-    } else if (Array.isArray(attachment)) {
+    if (Array.isArray(attachment)) {
       const [texture, layer = 0, level = 0] = attachment;
       this._attachTexture(attachmentPoint, texture, layer, level);
       return texture;
-    } else if (attachment instanceof WEBGLTexture) {
+    }
+    if (attachment instanceof WEBGLTexture) {
       this._attachTexture(attachmentPoint, attachment, 0, 0);
       return attachment;
     }
+    if (attachment instanceof WEBGLTextureView) {
+      const textureView = attachment;
+      this._attachTexture(attachmentPoint, textureView.texture, textureView.props.baseMipLevel, textureView.props.baseArrayLayer);
+      return attachment.texture;
+    }
     throw new Error("attach");
   }
-  _attachWEBGLRenderbuffer(attachment, renderbuffer) {
-    this.gl.framebufferRenderbuffer(import_constants12.GL.FRAMEBUFFER, attachment, import_constants12.GL.RENDERBUFFER, renderbuffer.handle);
-  }
+  // TODO - we do not seem to need render buffers in WebGL 2
+  // protected _attachWEBGLRenderbuffer(attachment: GL, renderbuffer: WEBGLRenderbuffer): void {
+  //   this.gl.framebufferRenderbuffer(
+  //     GL.FRAMEBUFFER,
+  //     attachment,
+  //     GL.RENDERBUFFER,
+  //     renderbuffer.handle
+  //   );
+  // }
   /**
    * @param attachment
    * @param texture
@@ -2816,16 +2715,16 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
     const { gl } = this.device;
     gl.bindTexture(texture.target, texture.handle);
     switch (texture.target) {
-      case import_constants12.GL.TEXTURE_2D_ARRAY:
-      case import_constants12.GL.TEXTURE_3D:
-        gl.framebufferTextureLayer(import_constants12.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+      case 35866:
+      case 32879:
+        gl.framebufferTextureLayer(36160, attachment, texture.target, level, layer);
         break;
-      case import_constants12.GL.TEXTURE_CUBE_MAP:
+      case 34067:
         const face = mapIndexToCubeMapFace(layer);
-        gl.framebufferTexture2D(import_constants12.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+        gl.framebufferTexture2D(36160, attachment, face, texture.handle, level);
         break;
-      case import_constants12.GL.TEXTURE_2D:
-        gl.framebufferTexture2D(import_constants12.GL.FRAMEBUFFER, attachment, import_constants12.GL.TEXTURE_2D, texture.handle, level);
+      case 3553:
+        gl.framebufferTexture2D(36160, attachment, 3553, texture.handle, level);
         break;
       default:
         (0, import_core10.assert)(false, "Illegal texture type");
@@ -2834,21 +2733,21 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
   }
 };
 function mapIndexToCubeMapFace(layer) {
-  return layer < import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
+  return layer < 34069 ? layer + 34069 : layer;
 }
 function _getFrameBufferStatus(status) {
   switch (status) {
-    case import_constants12.GL.FRAMEBUFFER_COMPLETE:
+    case 36053:
       return "success";
-    case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+    case 36054:
       return "Mismatched attachments";
-    case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+    case 36055:
       return "No attachments";
-    case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+    case 36057:
       return "Height/width mismatch";
-    case import_constants12.GL.FRAMEBUFFER_UNSUPPORTED:
+    case 36061:
       return "Unsupported or split attachments";
-    case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+    case 36182:
       return "Samples mismatch";
     default:
       return `${status}`;
@@ -2965,10 +2864,10 @@ function initializeSpectorJS(props) {
 // dist/context/debug/webgl-developer-tools.js
 var import_core13 = require("@luma.gl/core");
-var import_constants13 = require("@luma.gl/constants");
+var import_constants12 = require("@luma.gl/constants");
 var import_env = require("@probe.gl/env");
 var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
-function getContextData(gl) {
+function getWebGLContextData(gl) {
   gl.luma = gl.luma || {};
   return gl.luma;
 }
@@ -2986,7 +2885,7 @@ function makeDebugContext(gl, props = {}) {
   return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
 }
 function getRealContext(gl) {
-  const data = getContextData(gl);
+  const data = getWebGLContextData(gl);
   return data.realContext ? data.realContext : gl;
 }
 function getDebugContext(gl, props) {
@@ -2994,15 +2893,15 @@ function getDebugContext(gl, props) {
     import_core13.log.warn("webgl-debug not loaded")();
     return gl;
   }
-  const data = getContextData(gl);
+  const data = getWebGLContextData(gl);
   if (data.debugContext) {
     return data.debugContext;
   }
-  globalThis.WebGLDebugUtils.init({ ...import_constants13.GL, ...gl });
+  globalThis.WebGLDebugUtils.init({ ...import_constants12.GL, ...gl });
   const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
-  for (const key in import_constants13.GL) {
-    if (!(key in glDebug) && typeof import_constants13.GL[key] === "number") {
-      glDebug[key] = import_constants13.GL[key];
+  for (const key in import_constants12.GL) {
+    if (!(key in glDebug) && typeof import_constants12.GL[key] === "number") {
+      glDebug[key] = import_constants12.GL[key];
     }
   }
   class WebGLDebugContext {
@@ -3060,7 +2959,7 @@ function onValidateGLFunc(props, functionName, functionArgs) {
 // dist/adapter/resources/webgl-shader.js
 var import_core14 = require("@luma.gl/core");
-var import_constants14 = require("@luma.gl/constants");
+var import_constants13 = require("@luma.gl/constants");
 // dist/adapter/helpers/parse-shader-compiler-log.js
 function parseShaderCompilerLog(errLog) {
@@ -3115,10 +3014,10 @@ var WEBGLShader = class extends import_core14.Shader {
     this.device = device;
     switch (this.props.stage) {
       case "vertex":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants14.GL.VERTEX_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(35633);
         break;
       case "fragment":
-        this.handle = this.props.handle || this.device.gl.createShader(import_constants14.GL.FRAGMENT_SHADER);
+        this.handle = this.props.handle || this.device.gl.createShader(35632);
         break;
       default:
         throw new Error(this.props.stage);
@@ -3140,6 +3039,11 @@ var WEBGLShader = class extends import_core14.Shader {
     const log9 = this.device.gl.getShaderInfoLog(this.handle);
     return parseShaderCompilerLog(log9);
   }
+  getTranslatedSource() {
+    const extensions = this.device.getExtension("WEBGL_debug_shaders");
+    const ext = extensions.WEBGL_debug_shaders;
+    return ext == null ? void 0 : ext.getTranslatedShaderSource(this.handle);
+  }
   // PRIVATE METHODS
   /** Compile a shader and get compilation status */
   async _compile(source) {
@@ -3153,7 +3057,7 @@ ${source2}`;
       this.compilationStatus = "pending";
       return;
     }
-    if (!this.device.features.has("shader-status-async-webgl")) {
+    if (!this.device.features.has("compilation-status-async-webgl")) {
       this._getCompilationStatus();
       if (this.compilationStatus === "error") {
         throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);
@@ -3171,13 +3075,13 @@ ${source2}`;
   async _waitForCompilationComplete() {
     const waitMs = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
     const DELAY_MS = 10;
-    if (!this.device.features.has("shader-status-async-webgl")) {
+    if (!this.device.features.has("compilation-status-async-webgl")) {
       await waitMs(DELAY_MS);
       return;
     }
     const { gl } = this.device;
     for (; ; ) {
-      const complete = gl.getShaderParameter(this.handle, import_constants14.GL.COMPLETION_STATUS);
+      const complete = gl.getShaderParameter(this.handle, 37297);
       if (complete) {
         return;
       }
@@ -3188,15 +3092,15 @@ ${source2}`;
    * Get the shader compilation status
    * TODO - Load log even when no error reported, to catch warnings?
    * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
-  */
+   */
   _getCompilationStatus() {
-    this.compilationStatus = this.device.gl.getShaderParameter(this.handle, import_constants14.GL.COMPILE_STATUS) ? "success" : "error";
+    this.compilationStatus = this.device.gl.getShaderParameter(this.handle, 35713) ? "success" : "error";
   }
 };
 // dist/adapter/resources/webgl-render-pass.js
 var import_core15 = require("@luma.gl/core");
-var import_constants15 = require("@luma.gl/constants");
+var import_constants14 = require("@luma.gl/constants");
 var GL_DEPTH_BUFFER_BIT = 256;
 var GL_STENCIL_BUFFER_BIT = 1024;
 var GL_COLOR_BUFFER_BIT = 16384;
@@ -3215,7 +3119,7 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
   end() {
     popContextState(this.device.gl);
     if (this.props.framebuffer) {
-      setGLParameters(this.device, { framebuffer: null });
+      setGLParameters(this.device.gl, { framebuffer: null });
     }
   }
   pushDebugGroup(groupLabel) {
@@ -3224,7 +3128,6 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
   }
   insertDebugMarker(markerLabel) {
   }
-  // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
   // beginOcclusionQuery(queryIndex: number): void;
   // endOcclusionQuery(): void;
   // executeBundles(bundles: Iterable<GPURenderBundle>): void;
@@ -3240,7 +3143,7 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
       glParameters.depthMask = !this.props.depthReadOnly;
     }
     glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;
-    glParameters[import_constants15.GL.RASTERIZER_DISCARD] = this.props.discard;
+    glParameters[35977] = this.props.discard;
     if (parameters.viewport) {
       if (parameters.viewport.length >= 6) {
         glParameters.viewport = parameters.viewport.slice(0, 4);
@@ -3258,12 +3161,20 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
     }
     if (parameters.stencilReference) {
       console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
-      parameters[import_constants15.GL.STENCIL_REF] = parameters.stencilReference;
+      parameters[2967] = parameters.stencilReference;
     }
     this.glParameters = glParameters;
-    setGLParameters(this.device, glParameters);
+    setGLParameters(this.device.gl, glParameters);
+  }
+  beginOcclusionQuery(queryIndex) {
+    const webglQuerySet = this.props.occlusionQuerySet;
+    webglQuerySet == null ? void 0 : webglQuerySet.beginOcclusionQuery();
   }
-  // Internal
+  endOcclusionQuery() {
+    const webglQuerySet = this.props.occlusionQuerySet;
+    webglQuerySet == null ? void 0 : webglQuerySet.endOcclusionQuery();
+  }
+  // PRIVATE
   /**
    * Optionally clears depth, color and stencil buffers based on parameters
    */
@@ -3283,7 +3194,7 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
       glParameters.clearStencil = this.props.clearStencil;
     }
     if (clearMask !== 0) {
-      withGLParameters(this.device, glParameters, () => {
+      withGLParameters(this.device.gl, glParameters, () => {
         this.device.gl.clear(clearMask);
       });
     }
@@ -3312,37 +3223,37 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
 // dist/adapter/resources/webgl-render-pipeline.js
 var import_core17 = require("@luma.gl/core");
 var import_core18 = require("@luma.gl/core");
-var import_constants22 = require("@luma.gl/constants");
+var import_constants21 = require("@luma.gl/constants");
 // dist/adapter/helpers/get-shader-layout.js
-var import_constants19 = require("@luma.gl/constants");
+var import_constants18 = require("@luma.gl/constants");
 // dist/classic/accessor.js
 var import_core16 = require("@luma.gl/core");
-var import_constants17 = require("@luma.gl/constants");
+var import_constants16 = require("@luma.gl/constants");
 // dist/classic/typed-array-utils.js
-var import_constants16 = require("@luma.gl/constants");
+var import_constants15 = require("@luma.gl/constants");
 var ERR_TYPE_DEDUCTION = "Failed to deduce GL constant from typed array";
 function getGLTypeFromTypedArray(arrayOrType) {
   const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
   switch (type) {
     case Float32Array:
-      return import_constants16.GL.FLOAT;
+      return 5126;
     case Uint16Array:
-      return import_constants16.GL.UNSIGNED_SHORT;
+      return 5123;
     case Uint32Array:
-      return import_constants16.GL.UNSIGNED_INT;
+      return 5125;
     case Uint8Array:
-      return import_constants16.GL.UNSIGNED_BYTE;
+      return 5121;
     case Uint8ClampedArray:
-      return import_constants16.GL.UNSIGNED_BYTE;
+      return 5121;
     case Int8Array:
-      return import_constants16.GL.BYTE;
+      return 5120;
     case Int16Array:
-      return import_constants16.GL.SHORT;
+      return 5122;
     case Int32Array:
-      return import_constants16.GL.INT;
+      return 5124;
     default:
       throw new Error(ERR_TYPE_DEDUCTION);
   }
@@ -3350,22 +3261,22 @@ function getGLTypeFromTypedArray(arrayOrType) {
 function getTypedArrayFromGLType(glType, options) {
   const { clamped = true } = options || {};
   switch (glType) {
-    case import_constants16.GL.FLOAT:
+    case 5126:
       return Float32Array;
-    case import_constants16.GL.UNSIGNED_SHORT:
-    case import_constants16.GL.UNSIGNED_SHORT_5_6_5:
-    case import_constants16.GL.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants16.GL.UNSIGNED_SHORT_5_5_5_1:
+    case 5123:
+    case 33635:
+    case 32819:
+    case 32820:
       return Uint16Array;
-    case import_constants16.GL.UNSIGNED_INT:
+    case 5125:
       return Uint32Array;
-    case import_constants16.GL.UNSIGNED_BYTE:
+    case 5121:
       return clamped ? Uint8ClampedArray : Uint8Array;
-    case import_constants16.GL.BYTE:
+    case 5120:
       return Int8Array;
-    case import_constants16.GL.SHORT:
+    case 5122:
       return Int16Array;
-    case import_constants16.GL.INT:
+    case 5124:
       return Int32Array;
     default:
       throw new Error("Failed to deduce typed array type from GL constant");
@@ -3376,7 +3287,7 @@ function getTypedArrayFromGLType(glType, options) {
 var DEFAULT_ACCESSOR_VALUES = {
   offset: 0,
   stride: 0,
-  type: import_constants17.GL.FLOAT,
+  type: 5126,
   size: 1,
   divisor: 0,
   normalized: false,
@@ -3399,12 +3310,12 @@ var Accessor = class {
   buffer;
   index;
   static getBytesPerElement(accessor) {
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || 5126);
     return ArrayType.BYTES_PER_ELEMENT;
   }
   static getBytesPerVertex(accessor) {
     (0, import_core16.assert)(accessor.size);
-    const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
+    const ArrayType = getTypedArrayFromGLType(accessor.type || 5126);
     return ArrayType.BYTES_PER_ELEMENT * accessor.size;
   }
   // Combines (merges) a list of accessors. On top of default values
@@ -3435,7 +3346,7 @@ var Accessor = class {
     props = (0, import_core16.checkProps)("Accessor", props, PROP_CHECKS);
     if (props.type !== void 0) {
       this.type = props.type;
-      if (props.type === import_constants17.GL.INT || props.type === import_constants17.GL.UNSIGNED_INT) {
+      if (props.type === 5124 || props.type === 5125) {
         this.integer = true;
       }
     }
@@ -3499,62 +3410,62 @@ var Accessor = class {
 };
 // dist/adapter/helpers/decode-webgl-types.js
-var import_constants18 = require("@luma.gl/constants");
+var import_constants17 = require("@luma.gl/constants");
 function isSamplerUniform(type) {
   return SAMPLER_TYPES.includes(type);
 }
 var SAMPLER_TYPES = [
-  import_constants18.GL.SAMPLER_2D,
-  import_constants18.GL.SAMPLER_CUBE,
-  import_constants18.GL.SAMPLER_3D,
-  import_constants18.GL.SAMPLER_2D_SHADOW,
-  import_constants18.GL.SAMPLER_2D_ARRAY,
-  import_constants18.GL.SAMPLER_2D_ARRAY_SHADOW,
-  import_constants18.GL.SAMPLER_CUBE_SHADOW,
-  import_constants18.GL.INT_SAMPLER_2D,
-  import_constants18.GL.INT_SAMPLER_3D,
-  import_constants18.GL.INT_SAMPLER_CUBE,
-  import_constants18.GL.INT_SAMPLER_2D_ARRAY,
-  import_constants18.GL.UNSIGNED_INT_SAMPLER_2D,
-  import_constants18.GL.UNSIGNED_INT_SAMPLER_3D,
-  import_constants18.GL.UNSIGNED_INT_SAMPLER_CUBE,
-  import_constants18.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
+  35678,
+  35680,
+  35679,
+  35682,
+  36289,
+  36292,
+  36293,
+  36298,
+  36299,
+  36300,
+  36303,
+  36306,
+  36307,
+  36308,
+  36311
 ];
 var COMPOSITE_GL_TYPES = {
-  [import_constants18.GL.FLOAT]: [import_constants18.GL.FLOAT, 1, "float", "f32", "float32"],
-  [import_constants18.GL.FLOAT_VEC2]: [import_constants18.GL.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
-  [import_constants18.GL.FLOAT_VEC3]: [import_constants18.GL.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
-  [import_constants18.GL.FLOAT_VEC4]: [import_constants18.GL.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
-  [import_constants18.GL.INT]: [import_constants18.GL.INT, 1, "int", "i32", "sint32"],
-  [import_constants18.GL.INT_VEC2]: [import_constants18.GL.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
-  [import_constants18.GL.INT_VEC3]: [import_constants18.GL.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
-  [import_constants18.GL.INT_VEC4]: [import_constants18.GL.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
-  [import_constants18.GL.UNSIGNED_INT]: [import_constants18.GL.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
-  [import_constants18.GL.UNSIGNED_INT_VEC2]: [import_constants18.GL.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
-  [import_constants18.GL.UNSIGNED_INT_VEC3]: [import_constants18.GL.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
-  [import_constants18.GL.UNSIGNED_INT_VEC4]: [import_constants18.GL.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
-  [import_constants18.GL.BOOL]: [import_constants18.GL.FLOAT, 1, "bool", "f32", "float32"],
-  [import_constants18.GL.BOOL_VEC2]: [import_constants18.GL.FLOAT, 2, "bvec2", "vec2<f32>", "float32x2"],
-  [import_constants18.GL.BOOL_VEC3]: [import_constants18.GL.FLOAT, 3, "bvec3", "vec3<f32>", "float32x3"],
-  [import_constants18.GL.BOOL_VEC4]: [import_constants18.GL.FLOAT, 4, "bvec4", "vec4<f32>", "float32x4"],
+  [5126]: [5126, 1, "float", "f32", "float32"],
+  [35664]: [5126, 2, "vec2", "vec2<f32>", "float32x2"],
+  [35665]: [5126, 3, "vec3", "vec3<f32>", "float32x3"],
+  [35666]: [5126, 4, "vec4", "vec4<f32>", "float32x4"],
+  [5124]: [5124, 1, "int", "i32", "sint32"],
+  [35667]: [5124, 2, "ivec2", "vec2<i32>", "sint32x2"],
+  [35668]: [5124, 3, "ivec3", "vec3<i32>", "sint32x3"],
+  [35669]: [5124, 4, "ivec4", "vec4<i32>", "sint32x4"],
+  [5125]: [5125, 1, "uint", "u32", "uint32"],
+  [36294]: [5125, 2, "uvec2", "vec2<u32>", "uint32x2"],
+  [36295]: [5125, 3, "uvec3", "vec3<u32>", "uint32x3"],
+  [36296]: [5125, 4, "uvec4", "vec4<u32>", "uint32x4"],
+  [35670]: [5126, 1, "bool", "f32", "float32"],
+  [35671]: [5126, 2, "bvec2", "vec2<f32>", "float32x2"],
+  [35672]: [5126, 3, "bvec3", "vec3<f32>", "float32x3"],
+  [35673]: [5126, 4, "bvec4", "vec4<f32>", "float32x4"],
   // TODO - are sizes/components below correct?
-  [import_constants18.GL.FLOAT_MAT2]: [import_constants18.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
+  [35674]: [5126, 8, "mat2", "mat2x2<f32>"],
   // 4
-  [import_constants18.GL.FLOAT_MAT2x3]: [import_constants18.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
+  [35685]: [5126, 8, "mat2x3", "mat2x3<f32>"],
   // 6
-  [import_constants18.GL.FLOAT_MAT2x4]: [import_constants18.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
+  [35686]: [5126, 8, "mat2x4", "mat2x4<f32>"],
   // 8
-  [import_constants18.GL.FLOAT_MAT3x2]: [import_constants18.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
+  [35687]: [5126, 12, "mat3x2", "mat3x2<f32>"],
   // 6
-  [import_constants18.GL.FLOAT_MAT3]: [import_constants18.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
+  [35675]: [5126, 12, "mat3", "mat3x3<f32>"],
   // 9
-  [import_constants18.GL.FLOAT_MAT3x4]: [import_constants18.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
+  [35688]: [5126, 12, "mat3x4", "mat3x4<f32>"],
   // 12
-  [import_constants18.GL.FLOAT_MAT4x2]: [import_constants18.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
+  [35689]: [5126, 16, "mat4x2", "mat4x2<f32>"],
   // 8
-  [import_constants18.GL.FLOAT_MAT4x3]: [import_constants18.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
+  [35690]: [5126, 16, "mat4x3", "mat4x3<f32>"],
   // 12
-  [import_constants18.GL.FLOAT_MAT4]: [import_constants18.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
+  [35676]: [5126, 16, "mat4", "mat4x4<f32>"]
   // 16
 };
 function decodeGLUniformType(glUniformType) {
@@ -3627,7 +3538,7 @@ function getShaderLayout(gl, program) {
 }
 function readAttributeDeclarations(gl, program) {
   const attributes = [];
-  const count = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+  const count = gl.getProgramParameter(program, 35721);
   for (let index = 0; index < count; index++) {
     const activeInfo = gl.getActiveAttrib(program, index);
     if (!activeInfo) {
@@ -3656,7 +3567,7 @@ function readAttributeDeclarations(gl, program) {
 }
 function readVaryings(gl, program) {
   const varyings = [];
-  const count = gl.getProgramParameter(program, import_constants19.GL.TRANSFORM_FEEDBACK_VARYINGS);
+  const count = gl.getProgramParameter(program, 35971);
   for (let location = 0; location < count; location++) {
     const activeInfo = gl.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
@@ -3673,7 +3584,7 @@ function readVaryings(gl, program) {
 }
 function readUniformBindings(gl, program) {
   const uniforms = [];
-  const uniformCount = gl.getProgramParameter(program, import_constants19.GL.ACTIVE_UNIFORMS);
+  const uniformCount = gl.getProgramParameter(program, 35718);
   for (let i = 0; i < uniformCount; i++) {
     const activeInfo = gl.getActiveUniform(program, i);
     if (!activeInfo) {
@@ -3709,22 +3620,22 @@ function readUniformBindings(gl, program) {
 function readUniformBlocks(gl, program) {
   const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname);
   const uniformBlocks = [];
-  const blockCount = gl.getProgramParameter(program, import_constants19.GL.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl.getProgramParameter(program, 35382);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
     const blockInfo = {
       name: gl.getActiveUniformBlockName(program, blockIndex) || "",
-      location: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_BINDING),
-      byteLength: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_DATA_SIZE),
-      vertex: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
-      fragment: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
-      uniformCount: getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
+      location: getBlockParameter(blockIndex, 35391),
+      byteLength: getBlockParameter(blockIndex, 35392),
+      vertex: getBlockParameter(blockIndex, 35396),
+      fragment: getBlockParameter(blockIndex, 35398),
+      uniformCount: getBlockParameter(blockIndex, 35394),
       uniforms: []
     };
-    const uniformIndices = getBlockParameter(blockIndex, import_constants19.GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
-    const uniformType = gl.getActiveUniforms(program, uniformIndices, import_constants19.GL.UNIFORM_TYPE);
-    const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, import_constants19.GL.UNIFORM_SIZE);
-    const uniformOffset = gl.getActiveUniforms(program, uniformIndices, import_constants19.GL.UNIFORM_OFFSET);
-    const uniformStride = gl.getActiveUniforms(program, uniformIndices, import_constants19.GL.UNIFORM_ARRAY_STRIDE);
+    const uniformIndices = getBlockParameter(blockIndex, 35395) || [];
+    const uniformType = gl.getActiveUniforms(program, uniformIndices, 35383);
+    const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, 35384);
+    const uniformOffset = gl.getActiveUniforms(program, uniformIndices, 35387);
+    const uniformStride = gl.getActiveUniforms(program, uniformIndices, 35388);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
       const activeInfo = gl.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
@@ -3747,21 +3658,21 @@ function readUniformBlocks(gl, program) {
   return uniformBlocks;
 }
 var SAMPLER_UNIFORMS_GL_TO_GPU = {
-  [import_constants19.GL.SAMPLER_2D]: ["2d", "float"],
-  [import_constants19.GL.SAMPLER_CUBE]: ["cube", "float"],
-  [import_constants19.GL.SAMPLER_3D]: ["3d", "float"],
-  [import_constants19.GL.SAMPLER_2D_SHADOW]: ["3d", "depth"],
-  [import_constants19.GL.SAMPLER_2D_ARRAY]: ["2d-array", "float"],
-  [import_constants19.GL.SAMPLER_2D_ARRAY_SHADOW]: ["2d-array", "depth"],
-  [import_constants19.GL.SAMPLER_CUBE_SHADOW]: ["cube", "float"],
-  [import_constants19.GL.INT_SAMPLER_2D]: ["2d", "sint"],
-  [import_constants19.GL.INT_SAMPLER_3D]: ["3d", "sint"],
-  [import_constants19.GL.INT_SAMPLER_CUBE]: ["cube", "sint"],
-  [import_constants19.GL.INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"],
-  [import_constants19.GL.UNSIGNED_INT_SAMPLER_2D]: ["2d", "uint"],
-  [import_constants19.GL.UNSIGNED_INT_SAMPLER_3D]: ["3d", "uint"],
-  [import_constants19.GL.UNSIGNED_INT_SAMPLER_CUBE]: ["cube", "uint"],
-  [import_constants19.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"]
+  [35678]: ["2d", "float"],
+  [35680]: ["cube", "float"],
+  [35679]: ["3d", "float"],
+  [35682]: ["3d", "depth"],
+  [36289]: ["2d-array", "float"],
+  [36292]: ["2d-array", "depth"],
+  [36293]: ["cube", "float"],
+  [36298]: ["2d", "sint"],
+  [36299]: ["3d", "sint"],
+  [36300]: ["cube", "sint"],
+  [36303]: ["2d-array", "uint"],
+  [36306]: ["2d", "uint"],
+  [36307]: ["3d", "uint"],
+  [36308]: ["cube", "uint"],
+  [36311]: ["2d-array", "uint"]
 };
 function getSamplerInfo(type) {
   const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
@@ -3792,7 +3703,7 @@ function parseUniformName(name) {
 }
 // dist/adapter/helpers/set-uniform.js
-var import_constants20 = require("@luma.gl/constants");
+var import_constants19 = require("@luma.gl/constants");
 function setUniform(gl, location, type, value) {
   const gl2 = gl;
   let uniformValue = value;
@@ -3804,97 +3715,97 @@ function setUniform(gl, location, type, value) {
   }
   const arrayValue = typeof uniformValue === "number" ? [uniformValue] : uniformValue;
   switch (type) {
-    case import_constants20.GL.SAMPLER_2D:
-    case import_constants20.GL.SAMPLER_CUBE:
-    case import_constants20.GL.SAMPLER_3D:
-    case import_constants20.GL.SAMPLER_2D_SHADOW:
-    case import_constants20.GL.SAMPLER_2D_ARRAY:
-    case import_constants20.GL.SAMPLER_2D_ARRAY_SHADOW:
-    case import_constants20.GL.SAMPLER_CUBE_SHADOW:
-    case import_constants20.GL.INT_SAMPLER_2D:
-    case import_constants20.GL.INT_SAMPLER_3D:
-    case import_constants20.GL.INT_SAMPLER_CUBE:
-    case import_constants20.GL.INT_SAMPLER_2D_ARRAY:
-    case import_constants20.GL.UNSIGNED_INT_SAMPLER_2D:
-    case import_constants20.GL.UNSIGNED_INT_SAMPLER_3D:
-    case import_constants20.GL.UNSIGNED_INT_SAMPLER_CUBE:
-    case import_constants20.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
+    case 35678:
+    case 35680:
+    case 35679:
+    case 35682:
+    case 36289:
+    case 36292:
+    case 36293:
+    case 36298:
+    case 36299:
+    case 36300:
+    case 36303:
+    case 36306:
+    case 36307:
+    case 36308:
+    case 36311:
       if (typeof value !== "number") {
         throw new Error("samplers must be set to integers");
       }
       return gl.uniform1i(location, value);
-    case import_constants20.GL.FLOAT:
+    case 5126:
       return gl.uniform1fv(location, arrayValue);
-    case import_constants20.GL.FLOAT_VEC2:
+    case 35664:
       return gl.uniform2fv(location, arrayValue);
-    case import_constants20.GL.FLOAT_VEC3:
+    case 35665:
       return gl.uniform3fv(location, arrayValue);
-    case import_constants20.GL.FLOAT_VEC4:
+    case 35666:
       return gl.uniform4fv(location, arrayValue);
-    case import_constants20.GL.INT:
+    case 5124:
       return gl.uniform1iv(location, arrayValue);
-    case import_constants20.GL.INT_VEC2:
+    case 35667:
       return gl.uniform2iv(location, arrayValue);
-    case import_constants20.GL.INT_VEC3:
+    case 35668:
       return gl.uniform3iv(location, arrayValue);
-    case import_constants20.GL.INT_VEC4:
+    case 35669:
       return gl.uniform4iv(location, arrayValue);
-    case import_constants20.GL.BOOL:
+    case 35670:
       return gl.uniform1iv(location, arrayValue);
-    case import_constants20.GL.BOOL_VEC2:
+    case 35671:
       return gl.uniform2iv(location, arrayValue);
-    case import_constants20.GL.BOOL_VEC3:
+    case 35672:
       return gl.uniform3iv(location, arrayValue);
-    case import_constants20.GL.BOOL_VEC4:
+    case 35673:
       return gl.uniform4iv(location, arrayValue);
-    case import_constants20.GL.UNSIGNED_INT:
+    case 5125:
       return gl2.uniform1uiv(location, arrayValue, 1);
-    case import_constants20.GL.UNSIGNED_INT_VEC2:
+    case 36294:
       return gl2.uniform2uiv(location, arrayValue, 2);
-    case import_constants20.GL.UNSIGNED_INT_VEC3:
+    case 36295:
       return gl2.uniform3uiv(location, arrayValue, 3);
-    case import_constants20.GL.UNSIGNED_INT_VEC4:
+    case 36296:
       return gl2.uniform4uiv(location, arrayValue, 4);
-    case import_constants20.GL.FLOAT_MAT2:
+    case 35674:
       return gl.uniformMatrix2fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT3:
+    case 35675:
       return gl.uniformMatrix3fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT4:
+    case 35676:
       return gl.uniformMatrix4fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT2x3:
+    case 35685:
       return gl2.uniformMatrix2x3fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT2x4:
+    case 35686:
       return gl2.uniformMatrix2x4fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT3x2:
+    case 35687:
       return gl2.uniformMatrix3x2fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT3x4:
+    case 35688:
       return gl2.uniformMatrix3x4fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT4x2:
+    case 35689:
       return gl2.uniformMatrix4x2fv(location, false, arrayValue);
-    case import_constants20.GL.FLOAT_MAT4x3:
+    case 35690:
       return gl2.uniformMatrix4x3fv(location, false, arrayValue);
   }
   throw new Error("Illegal uniform");
 }
 // dist/adapter/helpers/webgl-topology-utils.js
-var import_constants21 = require("@luma.gl/constants");
+var import_constants20 = require("@luma.gl/constants");
 function getGLDrawMode(topology) {
   switch (topology) {
     case "point-list":
-      return import_constants21.GL.POINTS;
+      return 0;
     case "line-list":
-      return import_constants21.GL.LINES;
+      return 1;
     case "line-strip":
-      return import_constants21.GL.LINE_STRIP;
+      return 3;
     case "line-loop-webgl":
-      return import_constants21.GL.LINE_LOOP;
+      return 2;
     case "triangle-list":
-      return import_constants21.GL.TRIANGLES;
+      return 4;
     case "triangle-strip":
-      return import_constants21.GL.TRIANGLE_STRIP;
+      return 5;
     case "triangle-fan-webgl":
-      return import_constants21.GL.TRIANGLE_FAN;
+      return 6;
     default:
       throw new Error(topology);
   }
@@ -3902,19 +3813,19 @@ function getGLDrawMode(topology) {
 function getGLPrimitive(topology) {
   switch (topology) {
     case "point-list":
-      return import_constants21.GL.POINTS;
+      return 0;
     case "line-list":
-      return import_constants21.GL.LINES;
+      return 1;
     case "line-strip":
-      return import_constants21.GL.LINES;
+      return 1;
     case "line-loop-webgl":
-      return import_constants21.GL.LINES;
+      return 1;
     case "triangle-list":
-      return import_constants21.GL.TRIANGLES;
+      return 4;
     case "triangle-strip":
-      return import_constants21.GL.TRIANGLES;
+      return 4;
     case "triangle-fan-webgl":
-      return import_constants21.GL.TRIANGLES;
+      return 4;
     default:
       throw new Error(topology);
   }
@@ -3949,13 +3860,15 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     this.device.setSpectorMetadata(this.handle, { id: this.props.id });
     this.vs = (0, import_core17.cast)(props.vs);
     this.fs = (0, import_core17.cast)(props.fs);
-    const { varyings, bufferMode = import_constants22.GL.SEPARATE_ATTRIBS } = props;
+    const { varyings, bufferMode = 35981 } = props;
     if (varyings && varyings.length > 0) {
       this.varyings = varyings;
       this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
     }
     this._linkShaders();
+    import_core17.log.time(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
     this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
+    import_core17.log.timeEnd(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
     this.shaderLayout = (0, import_core18.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
     switch (this.props.topology) {
       case "triangle-fan-webgl":
@@ -3993,7 +3906,7 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
           }
           break;
         case "texture":
-          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+          if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
             throw new Error("texture value");
           }
           break;
@@ -4006,23 +3919,12 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
       this.bindings[name] = value;
     }
   }
-  /** This function is @deprecated, use uniform buffers */
-  setUniforms(uniforms) {
-    const { bindings } = (0, import_core17.splitUniformsAndBindings)(uniforms);
-    Object.keys(bindings).forEach((name) => {
-      import_core17.log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
-    });
-    Object.assign(this.uniforms, uniforms);
-  }
   /** @todo needed for portable model
    * @note The WebGL API is offers many ways to draw things
    * This function unifies those ways into a single call using common parameters with sane defaults
    */
   draw(options) {
     var _a;
-    if (this.linkStatus !== "success") {
-      return false;
-    }
     const {
       renderPass,
       vertexArray,
@@ -4039,9 +3941,18 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     const isIndexed = Boolean(vertexArray.indexBuffer);
     const glIndexType = (_a = vertexArray.indexBuffer) == null ? void 0 : _a.glIndexType;
     const isInstanced = Number(instanceCount) > 0;
+    if (this.linkStatus !== "success") {
+      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+      return false;
+    }
     if (!this._areTexturesRenderable() || vertexCount === 0) {
+      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
       return false;
     }
+    if (vertexCount === 0) {
+      import_core17.log.info(2, `RenderPipeline:${this.id}.draw() aborted - no vertices to draw`)();
+      return true;
+    }
     this.device.gl.useProgram(this.handle);
     vertexArray.bindBeforeRender(renderPass);
     if (transformFeedback) {
@@ -4074,6 +3985,14 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     vertexArray.unbindAfterRender(renderPass);
     return true;
   }
+  // DEPRECATED METHODS
+  setUniformsWebGL(uniforms) {
+    const { bindings } = (0, import_core17.splitUniformsAndBindings)(uniforms);
+    Object.keys(bindings).forEach((name) => {
+      import_core17.log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
+    });
+    Object.assign(this.uniforms, uniforms);
+  }
   // PRIVATE METHODS
   // setAttributes(attributes: Record<string, Buffer>): void {}
   // setBindings(bindings: Record<string, Binding>): void {}
@@ -4086,7 +4005,7 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     import_core17.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
     if (import_core17.log.level === 0) {
     }
-    if (!this.device.features.has("shader-status-async-webgl")) {
+    if (!this.device.features.has("compilation-status-async-webgl")) {
       const status2 = this._getLinkStatus();
       this._reportLinkStatus(status2);
       return;
@@ -4122,13 +4041,13 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
    */
   _getLinkStatus() {
     const { gl } = this.device;
-    const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
+    const linked = gl.getProgramParameter(this.handle, 35714);
     if (!linked) {
       this.linkStatus = "error";
       return "linking";
     }
     gl.validateProgram(this.handle);
-    const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
+    const validated = gl.getProgramParameter(this.handle, 35715);
     if (!validated) {
       this.linkStatus = "error";
       return "validation";
@@ -4140,13 +4059,13 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
   async _waitForLinkComplete() {
     const waitMs = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
     const DELAY_MS = 10;
-    if (!this.device.features.has("shader-status-async-webgl")) {
+    if (!this.device.features.has("compilation-status-async-webgl")) {
       await waitMs(DELAY_MS);
       return;
     }
     const { gl } = this.device;
     for (; ; ) {
-      const complete = gl.getProgramParameter(this.handle, import_constants22.GL.COMPLETION_STATUS);
+      const complete = gl.getProgramParameter(this.handle, 37297);
       if (complete) {
         return;
       }
@@ -4186,15 +4105,15 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
         case "uniform":
           const { name } = binding;
           const location = gl.getUniformBlockIndex(this.handle, name);
-          if (location === import_constants22.GL.INVALID_INDEX) {
+          if (location === 4294967295) {
             throw new Error(`Invalid uniform block name ${name}`);
           }
           gl.uniformBlockBinding(this.handle, uniformBufferIndex, location);
           if (value instanceof WEBGLBuffer) {
-            gl.bindBufferBase(import_constants22.GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
+            gl.bindBufferBase(35345, uniformBufferIndex, value.handle);
           } else {
             gl.bindBufferRange(
-              import_constants22.GL.UNIFORM_BUFFER,
+              35345,
               uniformBufferIndex,
               // @ts-expect-error
               value.buffer.handle,
@@ -4207,11 +4126,13 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
           uniformBufferIndex += 1;
           break;
         case "texture":
-          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+          if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
             throw new Error("texture");
           }
           let texture;
-          if (value instanceof WEBGLTexture) {
+          if (value instanceof WEBGLTextureView) {
+            texture = value.texture;
+          } else if (value instanceof WEBGLTexture) {
             texture = value;
           } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTexture) {
             import_core17.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
@@ -4219,7 +4140,7 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
           } else {
             throw new Error("No texture");
           }
-          gl.activeTexture(import_constants22.GL.TEXTURE0 + textureUnit);
+          gl.activeTexture(33984 + textureUnit);
           gl.bindTexture(texture.target, texture.handle);
           textureUnit += 1;
           break;
@@ -4251,7 +4172,7 @@ var import_core20 = require("@luma.gl/core");
 // dist/adapter/resources/webgl-command-buffer.js
 var import_core19 = require("@luma.gl/core");
-var import_constants23 = require("@luma.gl/constants");
+var import_constants22 = require("@luma.gl/constants");
 function cast2(value) {
   return value;
 }
@@ -4284,11 +4205,11 @@ var WEBGLCommandBuffer = class extends import_core19.CommandBuffer {
 function _copyBufferToBuffer(device, options) {
   const source = cast2(options.source);
   const destination = cast2(options.destination);
-  device.gl.bindBuffer(import_constants23.GL.COPY_READ_BUFFER, source.handle);
-  device.gl.bindBuffer(import_constants23.GL.COPY_WRITE_BUFFER, destination.handle);
-  device.gl.copyBufferSubData(import_constants23.GL.COPY_READ_BUFFER, import_constants23.GL.COPY_WRITE_BUFFER, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
-  device.gl.bindBuffer(import_constants23.GL.COPY_READ_BUFFER, null);
-  device.gl.bindBuffer(import_constants23.GL.COPY_WRITE_BUFFER, null);
+  device.gl.bindBuffer(36662, source.handle);
+  device.gl.bindBuffer(36663, destination.handle);
+  device.gl.copyBufferSubData(36662, 36663, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
+  device.gl.bindBuffer(36662, null);
+  device.gl.bindBuffer(36663, null);
 }
 function _copyBufferToTexture(device, options) {
   throw new Error("Not implemented");
@@ -4335,15 +4256,15 @@ function _copyTextureToBuffer(device, options) {
     const webglBuffer = destination;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
-    const sourceParams = getWebGLTextureParameters(framebuffer.texture.format);
+    const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format);
     const sourceFormat = sourceParams.dataFormat;
     const sourceType = sourceParams.type;
-    device.gl.bindBuffer(import_constants23.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
-    device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, framebuffer.handle);
+    device.gl.bindBuffer(35051, webglBuffer.handle);
+    device.gl.bindFramebuffer(36160, framebuffer.handle);
     device.gl.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset);
   } finally {
-    device.gl.bindBuffer(import_constants23.GL.PIXEL_PACK_BUFFER, null);
-    device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, null);
+    device.gl.bindBuffer(35051, null);
+    device.gl.bindFramebuffer(36160, null);
     if (destroyFramebuffer) {
       framebuffer.destroy();
     }
@@ -4374,11 +4295,11 @@ function _copyTextureToTexture(device, options) {
     // depthOrArrayLayers = 0
   } = options;
   const destinationMipmaplevel = 0;
-  const destinationInternalFormat = import_constants23.GL.RGBA;
+  const destinationInternalFormat = 6408;
   const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
   const [sourceX, sourceY] = origin;
   const isSubCopy = false;
-  device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, framebuffer.handle);
+  device.gl.bindFramebuffer(36160, framebuffer.handle);
   let texture = null;
   let textureTarget;
   if (destination instanceof WEBGLTexture) {
@@ -4461,11 +4382,13 @@ var WEBGLCommandEncoder = class extends import_core20.CommandEncoder {
   }
   insertDebugMarker(markerLabel) {
   }
+  resolveQuerySet(querySet, destination, options) {
+  }
 };
 // dist/adapter/resources/webgl-vertex-array.js
 var import_core21 = require("@luma.gl/core");
-var import_constants24 = require("@luma.gl/constants");
+var import_constants23 = require("@luma.gl/constants");
 var import_env2 = require("@probe.gl/env");
 var WEBGLVertexArray = class extends import_core21.VertexArray {
   get [Symbol.toStringTag]() {
@@ -4505,22 +4428,22 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
    */
   setIndexBuffer(indexBuffer) {
     const buffer = indexBuffer;
-    if (buffer && buffer.glTarget !== import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
+    if (buffer && buffer.glTarget !== 34963) {
       throw new Error("Use .setBuffer()");
     }
     this.device.gl.bindVertexArray(this.handle);
-    this.device.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, buffer ? buffer.handle : null);
+    this.device.gl.bindBuffer(34963, buffer ? buffer.handle : null);
     this.indexBuffer = buffer;
   }
   /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
   setBuffer(location, attributeBuffer) {
     const buffer = attributeBuffer;
-    if (buffer.glTarget === import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
+    if (buffer.glTarget === 34963) {
       throw new Error("Use .setIndexBuffer()");
     }
     const { size, type, stride, offset, normalized, integer, divisor } = this._getAccessor(location);
     this.device.gl.bindVertexArray(this.handle);
-    this.device.gl.bindBuffer(import_constants24.GL.ARRAY_BUFFER, buffer.handle);
+    this.device.gl.bindBuffer(34962, buffer.handle);
     if (integer) {
       this.device.gl.vertexAttribIPointer(location, size, type, stride, offset);
     } else {
@@ -4531,7 +4454,7 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
     this.attributes[location] = buffer;
   }
   /** Set a location in vertex attributes array to a constant value, disables the location */
-  setConstant(location, value) {
+  setConstantWebGL(location, value) {
     this._enable(location, false);
     this.attributes[location] = value;
   }
@@ -4540,7 +4463,7 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
     this.device.gl.bindVertexArray(this.handle);
     if (!this.init) {
       const webglBuffer = this.indexBuffer;
-      this.device.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, (webglBuffer == null ? void 0 : webglBuffer.handle) || null);
+      this.device.gl.bindBuffer(34963, (webglBuffer == null ? void 0 : webglBuffer.handle) || null);
       this.init = true;
     }
     this._applyConstantAttributes();
@@ -4559,7 +4482,7 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
     for (let location = 0; location < this.maxVertexAttributes; ++location) {
       const constant = this.attributes[location];
       if (ArrayBuffer.isView(constant)) {
-        this.device.setConstantAttribute(location, constant);
+        this.device.setConstantAttributeWebGL(location, constant);
       }
     }
   }
@@ -4665,7 +4588,7 @@ function compareConstantArrayValues(v1, v2) {
 // dist/adapter/resources/webgl-transform-feedback.js
 var import_core22 = require("@luma.gl/core");
-var import_constants25 = require("@luma.gl/constants");
+var import_constants24 = require("@luma.gl/constants");
 var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
   device;
   gl;
@@ -4701,7 +4624,7 @@ var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
     super.destroy();
   }
   begin(topology = "point-list") {
-    this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, this.handle);
+    this.gl.bindTransformFeedback(36386, this.handle);
     if (this.bindOnUse) {
       this._bindBuffers();
     }
@@ -4712,7 +4635,7 @@ var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
     if (!this.bindOnUse) {
       this._unbindBuffers();
     }
-    this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, null);
+    this.gl.bindTransformFeedback(36386, null);
   }
   // SUBCLASS
   setBuffers(buffers) {
@@ -4746,16 +4669,16 @@ var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
   }
   bind(funcOrHandle = this.handle) {
     if (typeof funcOrHandle !== "function") {
-      this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, funcOrHandle);
+      this.gl.bindTransformFeedback(36386, funcOrHandle);
       return this;
     }
     let value;
     if (!this._bound) {
-      this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, this.handle);
+      this.gl.bindTransformFeedback(36386, this.handle);
       this._bound = true;
       value = funcOrHandle();
       this._bound = false;
-      this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, null);
+      this.gl.bindTransformFeedback(36386, null);
     } else {
       value = funcOrHandle();
     }
@@ -4796,15 +4719,15 @@ var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
   }
   _unbindBuffers() {
     for (const bufferIndex in this.buffers) {
-      this.gl.bindBufferBase(import_constants25.GL.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);
+      this.gl.bindBufferBase(35982, Number(bufferIndex), null);
     }
   }
   _bindBuffer(index, buffer, byteOffset = 0, byteLength) {
     const handle = buffer && buffer.handle;
     if (!handle || byteLength === void 0) {
-      this.gl.bindBufferBase(import_constants25.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);
+      this.gl.bindBufferBase(35982, index, handle);
     } else {
-      this.gl.bindBufferRange(import_constants25.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
+      this.gl.bindBufferRange(35982, index, handle, byteOffset, byteLength);
     }
   }
 };
@@ -4815,57 +4738,187 @@ function isIndex(value) {
   return /^\d+$/.test(value);
 }
+// dist/adapter/resources/webgl-query-set.js
+var import_core23 = require("@luma.gl/core");
+var import_constants25 = require("@luma.gl/constants");
+var WEBGLQuerySet = class extends import_core23.QuerySet {
+  device;
+  handle;
+  target = null;
+  _queryPending = false;
+  _pollingPromise = null;
+  get [Symbol.toStringTag]() {
+    return "Query";
+  }
+  // Create a query class
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+    if (props.count > 1) {
+      throw new Error("WebGL QuerySet can only have one value");
+    }
+    this.handle = this.device.gl.createQuery();
+    Object.seal(this);
+  }
+  destroy() {
+    this.device.gl.deleteQuery(this.handle);
+  }
+  // FOR RENDER PASS AND COMMAND ENCODER
+  /**
+   * Shortcut for timer query (dependent on extension in both WebGL1 and 2)
+   * Measures GPU time delta between this call and a matching `end` call in the
+   * GPU instruction stream.
+   */
+  beginTimestampQuery() {
+    return this._begin(35007);
+  }
+  endTimestampQuery() {
+    this._end();
+  }
+  // Shortcut for occlusion queries
+  beginOcclusionQuery(options) {
+    return this._begin((options == null ? void 0 : options.conservative) ? 36202 : 35887);
+  }
+  endOcclusionQuery() {
+    this._end();
+  }
+  // Shortcut for transformFeedbackQuery
+  beginTransformFeedbackQuery() {
+    return this._begin(35976);
+  }
+  endTransformFeedbackQuery() {
+    this._end();
+  }
+  async resolveQuery() {
+    const value = await this.pollQuery();
+    return [value];
+  }
+  // PRIVATE METHODS
+  /**
+   * Due to OpenGL API limitations, after calling `begin()` on one Query
+   * instance, `end()` must be called on that same instance before
+   * calling `begin()` on another query. While there can be multiple
+   * outstanding queries representing disjoint `begin()`/`end()` intervals.
+   * It is not possible to interleave or overlap `begin` and `end` calls.
+   */
+  _begin(target) {
+    if (this._queryPending) {
+      return;
+    }
+    this.target = target;
+    this.device.gl.beginQuery(this.target, this.handle);
+    return;
+  }
+  // ends the current query
+  _end() {
+    if (this._queryPending) {
+      return;
+    }
+    if (this.target) {
+      this.device.gl.endQuery(this.target);
+      this.target = null;
+      this._queryPending = true;
+    }
+    return;
+  }
+  // Returns true if the query result is available
+  isResultAvailable() {
+    if (!this._queryPending) {
+      return false;
+    }
+    const resultAvailable = this.device.gl.getQueryParameter(this.handle, 34919);
+    if (resultAvailable) {
+      this._queryPending = false;
+    }
+    return resultAvailable;
+  }
+  // Timing query is disjoint, i.e. results are invalid
+  isTimerDisjoint() {
+    return this.device.gl.getParameter(36795);
+  }
+  // Returns query result.
+  getResult() {
+    return this.device.gl.getQueryParameter(this.handle, 34918);
+  }
+  // Returns the query result, converted to milliseconds to match JavaScript conventions.
+  getTimerMilliseconds() {
+    return this.getResult() / 1e6;
+  }
+  // Polls the query
+  pollQuery(limit = Number.POSITIVE_INFINITY) {
+    if (this._pollingPromise) {
+      return this._pollingPromise;
+    }
+    let counter = 0;
+    this._pollingPromise = new Promise((resolve, reject) => {
+      const poll = () => {
+        if (this.isResultAvailable()) {
+          resolve(this.getResult());
+          this._pollingPromise = null;
+        } else if (counter++ > limit) {
+          reject("Timed out");
+          this._pollingPromise = null;
+        } else {
+          requestAnimationFrame(poll);
+        }
+      };
+      requestAnimationFrame(poll);
+    });
+    return this._pollingPromise;
+  }
+};
 // dist/classic/copy-and-blit.js
-var import_core24 = require("@luma.gl/core");
+var import_core25 = require("@luma.gl/core");
 var import_constants27 = require("@luma.gl/constants");
 // dist/classic/format-utils.js
-var import_core23 = require("@luma.gl/core");
+var import_core24 = require("@luma.gl/core");
 var import_constants26 = require("@luma.gl/constants");
 function glFormatToComponents(format) {
   switch (format) {
-    case import_constants26.GL.ALPHA:
-    case import_constants26.GL.R32F:
-    case import_constants26.GL.RED:
+    case 6406:
+    case 33326:
+    case 6403:
       return 1;
-    case import_constants26.GL.RG32F:
-    case import_constants26.GL.RG:
+    case 33328:
+    case 33319:
       return 2;
-    case import_constants26.GL.RGB:
-    case import_constants26.GL.RGB32F:
+    case 6407:
+    case 34837:
       return 3;
-    case import_constants26.GL.RGBA:
-    case import_constants26.GL.RGBA32F:
+    case 6408:
+    case 34836:
       return 4;
     default:
-      (0, import_core23.assert)(false);
+      (0, import_core24.assert)(false);
       return 0;
   }
 }
 function glTypeToBytes(type) {
   switch (type) {
-    case import_constants26.GL.UNSIGNED_BYTE:
+    case 5121:
       return 1;
-    case import_constants26.GL.UNSIGNED_SHORT_5_6_5:
-    case import_constants26.GL.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants26.GL.UNSIGNED_SHORT_5_5_5_1:
+    case 33635:
+    case 32819:
+    case 32820:
       return 2;
-    case import_constants26.GL.FLOAT:
+    case 5126:
       return 4;
     default:
-      (0, import_core23.assert)(false);
+      (0, import_core24.assert)(false);
       return 0;
   }
 }
 // dist/classic/copy-and-blit.js
 function readPixelsToArray(source, options) {
-  var _a;
+  var _a, _b;
   const {
     sourceX = 0,
     sourceY = 0,
-    sourceFormat = import_constants27.GL.RGBA,
-    sourceAttachment = import_constants27.GL.COLOR_ATTACHMENT0
+    sourceFormat = 6408,
+    sourceAttachment = 36064
     // TODO - support gl.readBuffer
   } = options || {};
   let {
@@ -4876,31 +4929,31 @@ function readPixelsToArray(source, options) {
     sourceType
   } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-  (0, import_core24.assert)(framebuffer);
+  (0, import_core25.assert)(framebuffer);
   const { gl, handle } = framebuffer;
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
-  const attachment = sourceAttachment - import_constants27.GL.COLOR_ATTACHMENT0;
-  sourceType = sourceType || ((_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.type) || import_constants27.GL.UNSIGNED_BYTE;
+  const attachment = sourceAttachment - 36064;
+  sourceType = sourceType || ((_b = (_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.texture) == null ? void 0 : _b.type) || 5121;
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
-  const prevHandle = gl.bindFramebuffer(import_constants27.GL.FRAMEBUFFER, handle);
+  const prevHandle = gl.bindFramebuffer(36160, handle);
   gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  gl.bindFramebuffer(import_constants27.GL.FRAMEBUFFER, prevHandle || null);
+  gl.bindFramebuffer(36160, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
   return target;
 }
 function readPixelsToBuffer(source, options) {
-  const { target, sourceX = 0, sourceY = 0, sourceFormat = import_constants27.GL.RGBA, targetByteOffset = 0 } = options || {};
+  const { target, sourceX = 0, sourceY = 0, sourceFormat = 6408, targetByteOffset = 0 } = options || {};
   let { sourceWidth, sourceHeight, sourceType } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-  (0, import_core24.assert)(framebuffer);
+  (0, import_core25.assert)(framebuffer);
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
   const webglFramebuffer = framebuffer;
-  sourceType = sourceType || import_constants27.GL.UNSIGNED_BYTE;
+  sourceType = sourceType || 5121;
   let webglBufferTarget = target;
   if (!webglBufferTarget) {
     const components = glFormatToComponents(sourceFormat);
@@ -4924,7 +4977,7 @@ function readPixelsToBuffer(source, options) {
   return webglBufferTarget;
 }
 function getFramebuffer2(source) {
-  if (!(source instanceof import_core24.Framebuffer)) {
+  if (!(source instanceof import_core25.Framebuffer)) {
     return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
   }
   return { framebuffer: source, deleteFramebuffer: false };
@@ -4944,14 +4997,14 @@ function getPixelArray(pixelArray, type, format, width, height) {
   if (pixelArray) {
     return pixelArray;
   }
-  type = type || import_constants27.GL.UNSIGNED_BYTE;
+  type = type || 5121;
   const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
   const components = glFormatToComponents(format);
   return new ArrayType(width * height * components);
 }
 // dist/classic/clear.js
-var import_core25 = require("@luma.gl/core");
+var import_core26 = require("@luma.gl/core");
 var GL_DEPTH_BUFFER_BIT2 = 256;
 var GL_STENCIL_BUFFER_BIT2 = 1024;
 var GL_COLOR_BUFFER_BIT2 = 16384;
@@ -4981,37 +5034,33 @@ function clear(device, options) {
       parameters.clearStencil = depth;
     }
   }
-  (0, import_core25.assert)(clearFlags !== 0, ERR_ARGUMENTS);
-  withGLParameters(device, parameters, () => {
-    const gl = device.gl;
+  (0, import_core26.assert)(clearFlags !== 0, ERR_ARGUMENTS);
+  const gl = device.gl;
+  withGLParameters(gl, parameters, () => {
     gl.clear(clearFlags);
   });
 }
 // dist/adapter/webgl-device.js
 var LOG_LEVEL2 = 1;
-var _WebGLDevice = class extends import_core26.Device {
-  static isSupported() {
-    return typeof WebGL2RenderingContext !== "undefined";
-  }
+var _WebGLDevice = class extends import_core27.Device {
+  /** type of this device */
+  type = "webgl";
+  /** The underlying WebGL context */
+  handle;
+  features;
+  limits;
   info;
   canvasContext;
-  handle;
-  get features() {
-    this._features = this._features || getDeviceFeatures(this.gl);
-    return this._features;
-  }
-  get limits() {
-    this._limits = this._limits || getDeviceLimits(this.gl);
-    return this._limits;
-  }
   lost;
   _resolveContextLost;
-  _features;
-  _limits;
   //
   // Static methods, expected to be present by `luma.createDevice()`
   //
+  /** Check if WebGL 2 is available */
+  static isSupported() {
+    return typeof WebGL2RenderingContext !== "undefined";
+  }
   /**
    * Get a device instance from a GL context
    * Creates and instruments the device if not already created
@@ -5022,7 +5071,7 @@ var _WebGLDevice = class extends import_core26.Device {
     if (gl instanceof _WebGLDevice) {
       return gl;
     }
-    if ((gl == null ? void 0 : gl.device) instanceof import_core26.Device) {
+    if ((gl == null ? void 0 : gl.device) instanceof import_core27.Device) {
       return gl.device;
     }
     if (!isWebGL(gl)) {
@@ -5031,26 +5080,34 @@ var _WebGLDevice = class extends import_core26.Device {
     return new _WebGLDevice({ gl });
   }
   static async create(props = {}) {
-    import_core26.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
-    if (typeof props.canvas === "string") {
-      await import_core26.CanvasContext.pageLoaded;
+    var _a;
+    import_core27.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+    const promises = [];
+    if (props.debug) {
+      promises.push(loadWebGLDeveloperTools());
+    }
+    if (props.spector) {
+      promises.push(loadSpectorJS());
     }
-    if (import_core26.log.get("debug") || props.debug) {
-      await loadWebGLDeveloperTools();
+    if (typeof props.canvas === "string") {
+      promises.push(import_core27.CanvasContext.pageLoaded);
     }
-    const { spector: spector2 } = props;
-    if (import_core26.log.get("spector") || spector2) {
-      await loadSpectorJS();
+    const results = await Promise.allSettled(promises);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        import_core27.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+      }
     }
-    import_core26.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
-    if (props.gl && props.gl.device) {
+    import_core27.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+    if ((_a = props.gl) == null ? void 0 : _a.device) {
+      import_core27.log.warn("reattaching existing device")();
       return _WebGLDevice.attach(props.gl);
     }
     const device = new _WebGLDevice(props);
-    const message2 = `Created ${device.info.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-    import_core26.log.probe(LOG_LEVEL2, message2)();
-    import_core26.log.table(LOG_LEVEL2, device.info)();
-    import_core26.log.groupEnd(LOG_LEVEL2)();
+    const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
+    import_core27.log.probe(LOG_LEVEL2, message2)();
+    import_core27.log.table(LOG_LEVEL2, device.info)();
+    import_core27.log.groupEnd(LOG_LEVEL2)();
     return device;
   }
   //
@@ -5058,54 +5115,60 @@ var _WebGLDevice = class extends import_core26.Device {
   //
   constructor(props) {
     var _a, _b;
-    super({ ...props, id: props.id || (0, import_core26.uid)("webgl-device") });
+    super({ ...props, id: props.id || (0, import_core27.uid)("webgl-device") });
     const device = (_a = props.gl) == null ? void 0 : _a.device;
     if (device) {
       throw new Error(`WebGL context already attached to device ${device.id}`);
     }
-    const canvas = props.canvas || ((_b = props.gl) == null ? void 0 : _b.canvas);
+    const canvas = ((_b = props.gl) == null ? void 0 : _b.canvas) || props.canvas;
     this.canvasContext = new WebGLCanvasContext(this, { ...props, canvas });
     this.lost = new Promise((resolve) => {
       this._resolveContextLost = resolve;
     });
-    const onContextLost = (event) => {
-      var _a2;
-      return (_a2 = this._resolveContextLost) == null ? void 0 : _a2.call(this, {
-        reason: "destroyed",
-        message: "Computer entered sleep mode, or too many apps or browser tabs are using the GPU."
-      });
-    };
     let gl = props.gl || null;
-    gl = gl || ((0, import_env3.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, { ...props, onContextLost }) : null);
+    gl ||= createBrowserContext(this.canvasContext.canvas, {
+      ...props,
+      onContextLost: (event) => {
+        var _a2;
+        return (_a2 = this._resolveContextLost) == null ? void 0 : _a2.call(this, {
+          reason: "destroyed",
+          message: "Entered sleep mode, or too many apps or browser tabs are using the GPU."
+        });
+      }
+    });
     if (!gl) {
       throw new Error("WebGL context creation failed");
     }
     this.handle = gl;
-    this.gl = this.handle;
-    this.canvasContext.resize();
-    this.info = getDeviceInfo(this.gl);
+    this.gl = gl;
     this.gl.device = this;
-    this.gl._version = this.isWebGL2 ? 2 : 1;
+    this.gl._version = 2;
+    this.info = getDeviceInfo(this.gl, this._extensions);
+    this.limits = new WebGLDeviceLimits(this.gl);
+    this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props.disabledFeatures);
+    if (this.props.initalizeFeatures) {
+      this.features.initializeFeatures();
+    }
+    this.canvasContext.resize();
     const { enable: enable2 = true, copyState = false } = props;
     trackContextState(this.gl, {
       enable: enable2,
       copyState,
-      log: (...args) => import_core26.log.log(1, ...args)()
+      log: (...args) => import_core27.log.log(1, ...args)()
     });
-    if ((0, import_env3.isBrowser)() && props.debug) {
+    if (props.debug) {
       this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true });
       this.debug = true;
-      import_core26.log.level = Math.max(import_core26.log.level, 1);
-      import_core26.log.warn("WebGL debug mode activated. Performance reduced.")();
+      import_core27.log.level = Math.max(import_core27.log.level, 1);
+      import_core27.log.warn("WebGL debug mode activated. Performance reduced.")();
     }
-    if ((0, import_env3.isBrowser)() && props.spector) {
-      const canvas2 = this.handle.canvas || props.canvas;
-      this.spector = initializeSpectorJS({ ...this.props, canvas: canvas2 });
+    if (props.spector) {
+      this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas });
     }
   }
   /**
    * Destroys the context
-   * @note Has no effect for browser contexts, there is no browser API for destroying contexts
+   * @note Has no effect for WebGL browser contexts, there is no browser API for destroying contexts
    */
   destroy() {
   }
@@ -5116,13 +5179,13 @@ var _WebGLDevice = class extends import_core26.Device {
     return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight];
   }
   isTextureFormatSupported(format) {
-    return isTextureFormatSupported(this.gl, format);
+    return isTextureFormatSupported(this.gl, format, this._extensions);
   }
   isTextureFormatFilterable(format) {
-    return isTextureFormatFilterable(this.gl, format);
+    return isTextureFormatFilterable(this.gl, format, this._extensions);
   }
   isTextureFormatRenderable(format) {
-    return isTextureFormatRenderable(this.gl, format);
+    return isTextureFormatRenderable(this.gl, format, this._extensions);
   }
   // IMPLEMENTATION OF ABSTRACT DEVICE
   createCanvasContext(props) {
@@ -5147,12 +5210,18 @@ var _WebGLDevice = class extends import_core26.Device {
   createFramebuffer(props) {
     return new WEBGLFramebuffer(this, props);
   }
-  createRenderPipeline(props) {
-    return new WEBGLRenderPipeline(this, props);
-  }
   createVertexArray(props) {
     return new WEBGLVertexArray(this, props);
   }
+  createTransformFeedback(props) {
+    return new WEBGLTransformFeedback(this, props);
+  }
+  createQuerySet(props) {
+    return new WEBGLQuerySet(this, props);
+  }
+  createRenderPipeline(props) {
+    return new WEBGLRenderPipeline(this, props);
+  }
   beginRenderPass(props) {
     return new WEBGLRenderPass(this, props);
   }
@@ -5162,16 +5231,7 @@ var _WebGLDevice = class extends import_core26.Device {
   beginComputePass(props) {
     throw new Error("ComputePass not supported in WebGL");
   }
-  createTransformFeedback(props) {
-    return new WEBGLTransformFeedback(this, props);
-  }
   renderPass = null;
-  getDefaultRenderPass() {
-    this.renderPass = this.renderPass || this.beginRenderPass({
-      framebuffer: this.canvasContext.getCurrentFramebuffer()
-    });
-    return this.renderPass;
-  }
   createCommandEncoder(props) {
     return new WEBGLCommandEncoder(this, props);
   }
@@ -5187,7 +5247,7 @@ var _WebGLDevice = class extends import_core26.Device {
   }
   //
   // TEMPORARY HACKS - will be removed in v9.1
-  //
+  //
   /** @deprecated - should use command encoder */
   readPixelsToArrayWebGL(source, options) {
     return readPixelsToArray(source, options);
@@ -5197,13 +5257,13 @@ var _WebGLDevice = class extends import_core26.Device {
     return readPixelsToBuffer(source, options);
   }
   setParametersWebGL(parameters) {
-    setGLParameters(this, parameters);
+    setGLParameters(this.gl, parameters);
   }
   getParametersWebGL(parameters) {
-    return getGLParameters(this, parameters);
+    return getGLParameters(this.gl, parameters);
   }
   withParametersWebGL(parameters, func) {
-    withGLParameters(this, parameters, func);
+    withGLParameters(this.gl, parameters, func);
   }
   clearWebGL(options) {
     clear(this, options);
@@ -5220,13 +5280,7 @@ var _WebGLDevice = class extends import_core26.Device {
   _extensions = {};
   _polyfilled = false;
   /** Instance of Spector.js (if initialized) */
-  spector;
-  _webglLimits;
-  /** Return WebGL specific limits */
-  get webglLimits() {
-    this._webglLimits = this._webglLimits || getWebGLLimits(this.gl);
-    return this._webglLimits;
-  }
+  spectorJS;
   /**
    * Triggers device (or WebGL context) loss.
    * @note primarily intended for testing how application reacts to device loss
@@ -5234,7 +5288,8 @@ var _WebGLDevice = class extends import_core26.Device {
   loseDevice() {
     var _a;
     let deviceLossTriggered = false;
-    const ext = this.gl.getExtension("WEBGL_lose_context");
+    const extensions = this.getExtension("WEBGL_lose_context");
+    const ext = extensions.WEBGL_lose_context;
     if (ext) {
       deviceLossTriggered = true;
       ext.loseContext();
@@ -5283,11 +5338,12 @@ var _WebGLDevice = class extends import_core26.Device {
    * so they need to be updated before every render
    * @todo - remember/cache values to avoid setting them unnecessarily?
    */
-  setConstantAttribute(location, constant) {
-    this._constants = this._constants || new Array(this.limits.maxVertexAttributes).fill(null);
+  setConstantAttributeWebGL(location, constant) {
+    const maxVertexAttributes = this.limits.maxVertexAttributes;
+    this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
     const currentConstant = this._constants[location];
     if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-      import_core26.log.info(1, `setConstantAttribute(${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) {
@@ -5301,14 +5357,20 @@ var _WebGLDevice = class extends import_core26.Device {
         setConstantUintArray(this, location, constant);
         break;
       default:
-        (0, import_core26.assert)(false);
+        (0, import_core27.assert)(false);
     }
   }
+  /** Ensure extensions are only requested once */
+  getExtension(name) {
+    getWebGLExtension(this.gl, name, this._extensions);
+    return this._extensions;
+  }
 };
 var WebGLDevice = _WebGLDevice;
 //
 // Public `Device` API
 //
+/** type of this device */
 __publicField(WebGLDevice, "type", "webgl");
 function isWebGL(gl) {
   if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
@@ -5331,7 +5393,7 @@ function setConstantFloatArray(device, location, array) {
       device.gl.vertexAttrib4fv(location, array);
       break;
     default:
-      (0, import_core26.assert)(false);
+      (0, import_core27.assert)(false);
   }
 }
 function setConstantIntArray(device, location, array) {
@@ -5351,4 +5413,174 @@ function compareConstantArrayValues2(v1, v2) {
   }
   return true;
 }
+// dist/adapter/objects/webgl-resource.js
+var import_core28 = require("@luma.gl/core");
+var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
+var WebGLResource = class extends import_core28.Resource {
+  device;
+  gl;
+  gl2;
+  _handle;
+  _bound = false;
+  // Only meaningful for resources that allocate GPU memory
+  byteLength = 0;
+  constructor(device, props, defaultProps) {
+    super(device, props, defaultProps);
+    this.device = device;
+    const gl = this.device.gl;
+    const { id } = props || {};
+    this.gl = gl;
+    this.gl2 = gl;
+    this.id = id || (0, import_core28.uid)(this.constructor.name);
+    this._handle = props == null ? void 0 : props.handle;
+    if (this._handle === void 0) {
+      this._handle = this._createHandle();
+    }
+    this.byteLength = 0;
+  }
+  toString() {
+    return `${this.constructor.name}(${this.id})`;
+  }
+  get handle() {
+    return this._handle;
+  }
+  delete({ deleteChildren = false } = {}) {
+    const children = this._handle && this._deleteHandle(this._handle);
+    if (this._handle) {
+      this.removeStats();
+    }
+    this._handle = null;
+    if (children && deleteChildren) {
+      children.filter(Boolean).forEach((child) => child.destroy());
+    }
+    return this;
+  }
+  bind(funcOrHandle = this.handle) {
+    if (typeof funcOrHandle !== "function") {
+      this._bindHandle(funcOrHandle);
+      return this;
+    }
+    let value;
+    if (!this._bound) {
+      this._bindHandle(this.handle);
+      this._bound = true;
+      value = funcOrHandle();
+      this._bound = false;
+      this._bindHandle(null);
+    } else {
+      value = funcOrHandle();
+    }
+    return value;
+  }
+  unbind() {
+    this.bind(null);
+  }
+  // Install stubs for removed methods
+  stubRemovedMethods(className, version, methodNames) {
+    return (0, import_core28.stubRemovedMethods)(this, className, version, methodNames);
+  }
+  // PUBLIC VIRTUAL METHODS
+  initialize(props) {
+  }
+  // PROTECTED METHODS - These must be overridden by subclass
+  _createHandle() {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _deleteHandle() {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _bindHandle(handle) {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _getOptsFromHandle() {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _getParameter(pname, props) {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+  _setParameter(pname, value) {
+    throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+};
+// dist/adapter/objects/webgl-renderbuffer.js
+var import_core29 = require("@luma.gl/core");
+var import_constants28 = require("@luma.gl/constants");
+var _WEBGLRenderbuffer = class extends WebGLResource {
+  get [Symbol.toStringTag]() {
+    return "Renderbuffer";
+  }
+  get width() {
+    return this.props.width;
+  }
+  get height() {
+    return this.props.height;
+  }
+  get format() {
+    return this.props.format;
+  }
+  get samples() {
+    return this.props.samples;
+  }
+  get attachment() {
+    return;
+  }
+  /** WebGL format constant */
+  glFormat;
+  static isTextureFormatSupported(device, format) {
+    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
+  }
+  constructor(device, props) {
+    if (typeof props.format === "number") {
+      throw new Error("Renderbuffer");
+    }
+    super(device, props, _WEBGLRenderbuffer.defaultProps);
+    this.glFormat = convertTextureFormatToGL(this.props.format);
+    this._initialize(this.props);
+  }
+  resize(size) {
+    if (size.width !== this.width || size.height !== this.height) {
+      Object.assign(this.props, { ...size, format: this.format, samples: this.samples });
+      this._initialize(this.props);
+    }
+  }
+  // PRIVATE METHODS
+  /** Creates and initializes a renderbuffer object's data store */
+  _initialize(props) {
+    const { format, width, height, samples } = props;
+    (0, import_core29.assert)(format, "Needs format");
+    this.trackDeallocatedMemory();
+    this.gl.bindRenderbuffer(36161, this.handle);
+    if (samples !== 0) {
+      this.gl.renderbufferStorageMultisample(36161, samples, this.glFormat, width, height);
+    } else {
+      this.gl.renderbufferStorage(36161, this.glFormat, width, height);
+    }
+    this.gl.bindRenderbuffer(36161, null);
+    this.trackAllocatedMemory(width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.format));
+  }
+  // RESOURCE IMPLEMENTATION
+  _createHandle() {
+    return this.gl.createRenderbuffer();
+  }
+  _deleteHandle() {
+    this.gl.deleteRenderbuffer(this.handle);
+    this.trackDeallocatedMemory();
+  }
+  _bindHandle(handle) {
+    this.gl.bindRenderbuffer(36161, handle);
+  }
+};
+var WEBGLRenderbuffer = _WEBGLRenderbuffer;
+__publicField(WEBGLRenderbuffer, "defaultProps", {
+  id: void 0,
+  handle: void 0,
+  userData: void 0,
+  format: void 0,
+  // 'depth16unorm'
+  width: 1,
+  height: 1,
+  samples: 0
+});
 //# sourceMappingURL=index.cjs.map