@luma.gl/webgl 9.1.0-alpha.15 → 9.1.0-alpha.16

package/dist/index.cjs

@@ -2,9 +2,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
+var __export = (target2, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+    __defProp(target2, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -137,8 +137,8 @@ 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 === 36006 ? 36009 : 36008;
-  return gl.bindFramebuffer(target, value);
+  const target2 = key === 36006 ? 36009 : 36008;
+  return gl.bindFramebuffer(target2, value);
 };
 var bindBuffer = (gl, value, key) => {
   const bindingMap = {
@@ -340,17 +340,17 @@ var GL_HOOKED_SETTERS = {
   useProgram: (update, value) => update({
     [35725]: value
   }),
-  bindRenderbuffer: (update, target, value) => update({
+  bindRenderbuffer: (update, target2, value) => update({
     [36007]: value
   }),
-  bindTransformFeedback: (update, target, value) => update({
+  bindTransformFeedback: (update, target2, value) => update({
     [36389]: value
   }),
   bindVertexArray: (update, value) => update({
     [34229]: value
   }),
-  bindFramebuffer: (update, target, framebuffer) => {
-    switch (target) {
+  bindFramebuffer: (update, target2, framebuffer) => {
+    switch (target2) {
       case 36160:
         return update({
           [36006]: framebuffer,
@@ -364,14 +364,14 @@ var GL_HOOKED_SETTERS = {
         return null;
     }
   },
-  bindBuffer: (update, target, buffer) => {
+  bindBuffer: (update, target2, buffer) => {
     const pname = {
       [34962]: [34964],
       [36662]: [36662],
       [36663]: [36663],
       [35051]: [35053],
       [35052]: [35055]
-    }[target];
+    }[target2];
     if (pname) {
       return update({ [pname]: buffer });
     }
@@ -719,33 +719,27 @@ function installProgramSpy(gl) {
 }
 
 // dist/context/helpers/create-browser-context.js
-var DEFAULT_CONTEXT_PROPS = {
-  powerPreference: "high-performance",
-  // After all, most apps are using WebGL for performance reasons
-  // eslint-disable-next-line no-console
-  onContextLost: () => console.error("WebGL context lost"),
-  // eslint-disable-next-line no-console
-  onContextRestored: () => console.info("WebGL context restored")
-};
-function createBrowserContext(canvas, props) {
-  props = { ...DEFAULT_CONTEXT_PROPS, ...props };
-  let errorMessage = null;
-  const onCreateError = (error) => errorMessage = error.statusMessage || errorMessage;
-  canvas.addEventListener("webglcontextcreationerror", onCreateError, false);
+function createBrowserContext(canvas, props, webglContextAttributes) {
+  const errorMessage = null;
+  const webglProps = {
+    preserveDrawingBuffer: true,
+    // failIfMajorPerformanceCaveat: true,
+    ...webglContextAttributes
+  };
   let gl = null;
-  gl ||= canvas.getContext("webgl2", props);
-  canvas.removeEventListener("webglcontextcreationerror", onCreateError, false);
+  gl ||= canvas.getContext("webgl2", webglProps);
+  if (!gl && !webglContextAttributes.failIfMajorPerformanceCaveat) {
+    webglProps.failIfMajorPerformanceCaveat = false;
+    gl = canvas.getContext("webgl", webglProps);
+    gl.luma ||= {};
+    gl.luma.softwareRenderer = true;
+  }
   if (!gl) {
     throw new Error(`Failed to create WebGL context: ${errorMessage || "Unknown error"}`);
   }
-  if (props.onContextLost) {
-    const { onContextLost } = props;
-    canvas.addEventListener("webglcontextlost", (event) => onContextLost(event), false);
-  }
-  if (props.onContextRestored) {
-    const { onContextRestored } = props;
-    canvas.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
-  }
+  const { onContextLost, onContextRestored } = props;
+  canvas.addEventListener("webglcontextlost", (event) => onContextLost(event), false);
+  canvas.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
   return gl;
 }
 
@@ -1601,17 +1595,17 @@ var LOG_LEVEL = 1;
 var spector = null;
 var initialized = false;
 var DEFAULT_SPECTOR_PROPS = {
-  debugWithSpectorJS: import_core6.log.get("spector") || import_core6.log.get("spectorjs"),
+  debugSpectorJS: import_core6.log.get("debug-spectorjs"),
   // https://github.com/BabylonJS/Spector.js#basic-usage
   // https://forum.babylonjs.com/t/spectorcdn-is-temporarily-off/48241
   // spectorUrl: 'https://spectorcdn.babylonjs.com/spector.bundle.js';
-  spectorUrl: "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js",
+  debugSpectorJSUrl: "https://cdn.jsdelivr.net/npm/spectorjs@0.9.30/dist/spector.bundle.js",
   gl: void 0
 };
 async function loadSpectorJS(props) {
   if (!globalThis.SPECTOR) {
     try {
-      await loadScript(props.spectorUrl || DEFAULT_SPECTOR_PROPS.spectorUrl);
+      await loadScript(props.debugSpectorJSUrl || DEFAULT_SPECTOR_PROPS.debugSpectorJSUrl);
     } catch (error) {
       import_core6.log.warn(String(error));
     }
@@ -1620,13 +1614,13 @@ async function loadSpectorJS(props) {
 function initializeSpectorJS(props) {
   var _a;
   props = { ...DEFAULT_SPECTOR_PROPS, ...props };
-  if (!props.debugWithSpectorJS) {
+  if (!props.debugSpectorJS) {
     return null;
   }
   if (!spector && globalThis.SPECTOR && !((_a = globalThis.luma) == null ? void 0 : _a.spector)) {
     import_core6.log.probe(LOG_LEVEL, "SPECTOR found and initialized. Start with `luma.spector.displayUI()`")();
-    const { Spector } = globalThis.SPECTOR;
-    spector = new Spector();
+    const { Spector: SpectorJS } = globalThis.SPECTOR;
+    spector = new SpectorJS();
     if (globalThis.luma) {
       globalThis.luma.spector = spector;
     }
@@ -1675,7 +1669,7 @@ async function loadWebGLDeveloperTools() {
   }
 }
 function makeDebugContext(gl, props = {}) {
-  return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
+  return props.debugWebGL ? getDebugContext(gl, props) : getRealContext(gl);
 }
 function getRealContext(gl) {
   const data = getWebGLContextData(gl);
@@ -1720,9 +1714,6 @@ function onGLError(props, err, functionName, args) {
   const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`;
   import_core7.log.error(message2)();
   debugger;
-  if (props.throwOnError) {
-    throw new Error(message2);
-  }
 }
 function onValidateGLFunc(props, functionName, functionArgs) {
   let functionString = "";
@@ -1730,22 +1721,10 @@ function onValidateGLFunc(props, functionName, functionArgs) {
     functionString = getFunctionString(functionName, functionArgs);
     import_core7.log.log(1, functionString)();
   }
-  if (props.break && props.break.length > 0) {
-    functionString = functionString || getFunctionString(functionName, functionArgs);
-    const isBreakpoint = props.break.every((breakOn) => functionString.indexOf(breakOn) !== -1);
-    if (isBreakpoint) {
-      debugger;
-    }
-  }
   for (const arg of functionArgs) {
     if (arg === void 0) {
       functionString = functionString || getFunctionString(functionName, functionArgs);
-      if (props.throwOnError) {
-        throw new Error(`Undefined argument: ${functionString}`);
-      } else {
-        import_core7.log.error(`Undefined argument: ${functionString}`)();
-        debugger;
-      }
+      debugger;
     }
   }
 }
@@ -1957,13 +1936,16 @@ var WEBGLShader = class extends import_core9.Shader {
       this.destroyed = true;
     }
   }
+  get asyncCompilationStatus() {
+    return this._waitForCompilationComplete().then(() => this.compilationStatus);
+  }
   async getCompilationInfo() {
     await this._waitForCompilationComplete();
     return this.getCompilationInfoSync();
   }
   getCompilationInfoSync() {
-    const log12 = this.device.gl.getShaderInfoLog(this.handle);
-    return log12 ? parseShaderCompilerLog(log12) : [];
+    const shaderLog = this.device.gl.getShaderInfoLog(this.handle);
+    return shaderLog ? parseShaderCompilerLog(shaderLog) : [];
   }
   getTranslatedSource() {
     const extensions = this.device.getExtension("WEBGL_debug_shaders");
@@ -1973,9 +1955,8 @@ var WEBGLShader = class extends import_core9.Shader {
   // PRIVATE METHODS
   /** Compile a shader and get compilation status */
   async _compile(source) {
-    const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 300 es
-${source2}`;
-    source = addGLSLVersion(source);
+    source = source.startsWith("#version ") ? source : `#version 300 es
+${source}`;
     const { gl } = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
@@ -2606,7 +2587,7 @@ function readPixelsToArray(source, options) {
     // TODO - support gl.readBuffer
   } = options || {};
   let {
-    target = null,
+    target: target2 = null,
     // following parameters are auto deduced if not provided
     sourceWidth,
     sourceHeight,
@@ -2622,25 +2603,25 @@ function readPixelsToArray(source, options) {
   sourceDepth = ((_b = (_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.texture) == null ? void 0 : _b.depth) || 1;
   sourceFormat ||= ((_d = (_c = framebuffer.colorAttachments[attachment]) == null ? void 0 : _c.texture) == null ? void 0 : _d.glFormat) || 6408;
   sourceType ||= ((_f = (_e = framebuffer.colorAttachments[attachment]) == null ? void 0 : _e.texture) == null ? void 0 : _f.glType) || 5121;
-  target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
-  sourceType = sourceType || getGLTypeFromTypedArray(target);
+  target2 = getPixelArray(target2, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
+  sourceType = sourceType || getGLTypeFromTypedArray(target2);
   const prevHandle = gl.bindFramebuffer(36160, handle);
-  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
+  gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target2);
   gl.bindFramebuffer(36160, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
-  return target;
+  return target2;
 }
 function readPixelsToBuffer(source, options) {
-  const { target, sourceX = 0, sourceY = 0, sourceFormat = 6408, targetByteOffset = 0 } = options || {};
+  const { target: target2, sourceX = 0, sourceY = 0, sourceFormat = 6408, targetByteOffset = 0 } = options || {};
   let { sourceWidth, sourceHeight, sourceType } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer(source);
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
   const webglFramebuffer = framebuffer;
   sourceType = sourceType || 5121;
-  let webglBufferTarget = target;
+  let webglBufferTarget = target2;
   if (!webglBufferTarget) {
     const components = glFormatToComponents(sourceFormat);
     const byteCount = glTypeToBytes(sourceType);
@@ -2649,11 +2630,11 @@ function readPixelsToBuffer(source, options) {
   }
   const commandEncoder = source.device.createCommandEncoder();
   commandEncoder.copyTextureToBuffer({
-    source,
+    sourceTexture: source,
     width: sourceWidth,
     height: sourceHeight,
     origin: [sourceX, sourceY],
-    destination: webglBufferTarget,
+    destinationBuffer: webglBufferTarget,
     byteOffset: targetByteOffset
   });
   commandEncoder.destroy();
@@ -3781,9 +3762,9 @@ var WEBGLRenderPipeline = class extends import_core16.RenderPipeline {
    */
   setBindings(bindings, options) {
     for (const [name, value] of Object.entries(bindings)) {
-      const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name) || this.shaderLayout.bindings.find((binding2) => binding2.name === `${name}Uniforms`);
+      const binding = this.shaderLayout.bindings.find((binding_) => binding_.name === name) || this.shaderLayout.bindings.find((binding_) => binding_.name === `${name}Uniforms`);
       if (!binding) {
-        const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
+        const validBindings = this.shaderLayout.bindings.map((binding_) => `"${binding_.name}"`).join(", ");
         if (!(options == null ? void 0 : options.disableWarnings)) {
           import_core16.log.warn(`No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
         }
@@ -3908,21 +3889,34 @@ var WEBGLRenderPipeline = class extends import_core16.RenderPipeline {
     this._reportLinkStatus(status);
   }
   /** Report link status. First, check for shader compilation failures if linking fails */
-  _reportLinkStatus(status) {
+  async _reportLinkStatus(status) {
     var _a;
     switch (status) {
       case "success":
         return;
       default:
-        if (this.vs.compilationStatus === "error") {
-          this.vs.debugShader();
-          throw new Error(`Error during compilation of shader ${this.vs.id}`);
+        switch (this.vs.compilationStatus) {
+          case "error":
+            this.vs.debugShader();
+            throw new Error(`Error during compilation of shader ${this.vs.id}`);
+          case "pending":
+            this.vs.asyncCompilationStatus.then(() => this.vs.debugShader());
+            break;
+          case "success":
+            break;
         }
-        if (((_a = this.fs) == null ? void 0 : _a.compilationStatus) === "error") {
-          this.fs.debugShader();
-          throw new Error(`Error during compilation of shader ${this.fs.id}`);
+        switch ((_a = this.fs) == null ? void 0 : _a.compilationStatus) {
+          case "error":
+            this.fs.debugShader();
+            throw new Error(`Error during compilation of shader ${this.fs.id}`);
+          case "pending":
+            this.fs.asyncCompilationStatus.then(() => this.fs.debugShader());
+            break;
+          case "success":
+            break;
         }
-        throw new Error(`Error during ${status}: ${this.device.gl.getProgramInfoLog(this.handle)}`);
+        const linkErrorLog = this.device.gl.getProgramInfoLog(this.handle);
+        throw new Error(`Error during ${status}: ${linkErrorLog}`);
     }
   }
   /**
@@ -4112,8 +4106,8 @@ var WEBGLCommandBuffer = class extends import_core17.CommandBuffer {
   }
 };
 function _copyBufferToBuffer(device, options) {
-  const source = options.source;
-  const destination = options.destination;
+  const source = options.sourceBuffer;
+  const destination = options.destinationBuffer;
   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);
@@ -4126,20 +4120,20 @@ function _copyBufferToTexture(device, options) {
 function _copyTextureToBuffer(device, options) {
   const {
     /** Texture to copy to/from. */
-    source,
+    sourceTexture,
     /**  Mip-map level of the texture to copy to/from. (Default 0) */
     mipLevel = 0,
     /** Defines which aspects of the texture to copy to/from. */
     aspect = "all",
     /** Width to copy */
-    width = options.source.width,
+    width = options.sourceTexture.width,
     /** Height to copy */
-    height = options.source.height,
+    height = options.sourceTexture.height,
     depthOrArrayLayers = 0,
     /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
     origin = [0, 0],
     /** Destination buffer */
-    destination,
+    destinationBuffer,
     /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */
     byteOffset = 0,
     /**
@@ -4155,15 +4149,15 @@ function _copyTextureToBuffer(device, options) {
     rowsPerImage
   } = options;
   if (aspect !== "all") {
-    throw new Error("not supported");
+    throw new Error("aspect not supported in WebGL");
   }
   if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) {
     throw new Error("not implemented");
   }
-  const { framebuffer, destroyFramebuffer } = getFramebuffer2(source);
+  const { framebuffer, destroyFramebuffer } = getFramebuffer2(sourceTexture);
   let prevHandle;
   try {
-    const webglBuffer = destination;
+    const webglBuffer = destinationBuffer;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
     const sourceParams = getTextureFormatWebGL(framebuffer.colorAttachments[0].texture.props.format);
@@ -4185,7 +4179,7 @@ function _copyTextureToBuffer(device, options) {
 function _copyTextureToTexture(device, options) {
   const {
     /** Texture to copy to/from. */
-    source,
+    sourceTexture,
     /**  Mip-map level of the texture to copy to (Default 0) */
     destinationMipLevel = 0,
     /** Defines which aspects of the texture to copy to/from. */
@@ -4195,7 +4189,7 @@ function _copyTextureToTexture(device, options) {
     /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to. */
     destinationOrigin = [0, 0],
     /** Texture to copy to/from. */
-    destination
+    destinationTexture
     /**  Mip-map level of the texture to copy to/from. (Default 0) */
     // destinationMipLevel = options.mipLevel,
     /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
@@ -4204,18 +4198,18 @@ function _copyTextureToTexture(device, options) {
     // destinationAspect = options.aspect,
   } = options;
   let {
-    width = options.destination.width,
-    height = options.destination.height
+    width = options.destinationTexture.width,
+    height = options.destinationTexture.height
     // depthOrArrayLayers = 0
   } = options;
-  const { framebuffer, destroyFramebuffer } = getFramebuffer2(source);
+  const { framebuffer, destroyFramebuffer } = getFramebuffer2(sourceTexture);
   const [sourceX, sourceY] = origin;
   const [destinationX, destinationY, destinationZ] = destinationOrigin;
   const prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle);
   let texture = null;
   let textureTarget;
-  if (destination instanceof WEBGLTexture) {
-    texture = destination;
+  if (destinationTexture instanceof WEBGLTexture) {
+    texture = destinationTexture;
     width = Number.isFinite(width) ? width : texture.width;
     height = Number.isFinite(height) ? height : texture.height;
     texture.bind(0);
@@ -4302,19 +4296,19 @@ var import_env2 = require("@probe.gl/env");
 
 // dist/utils/fill-array.js
 function fillArray(options) {
-  const { target, source, start = 0, count = 1 } = options;
+  const { target: target2, source, start = 0, count = 1 } = options;
   const length = source.length;
   const total = count * length;
   let copied = 0;
   for (let i = start; copied < length; copied++) {
-    target[i++] = source[copied];
+    target2[i++] = source[copied];
   }
   while (copied < total) {
     if (copied < total - copied) {
-      target.copyWithin(start + copied, start, start + copied);
+      target2.copyWithin(start + copied, start, start + copied);
       copied *= 2;
     } else {
-      target.copyWithin(start + copied, start, start + total - copied);
+      target2.copyWithin(start + copied, start, start + total - copied);
       copied = total;
     }
   }
@@ -4730,11 +4724,11 @@ var WEBGLQuerySet = class extends import_core21.QuerySet {
    * outstanding queries representing disjoint `begin()`/`end()` intervals.
    * It is not possible to interleave or overlap `begin` and `end` calls.
    */
-  _begin(target) {
+  _begin(target2) {
     if (this._queryPending) {
       return;
     }
-    this.target = target;
+    this.target = target2;
     this.device.gl.beginQuery(this.target, this.handle);
     return;
   }
@@ -4865,36 +4859,52 @@ var WebGLDevice = class extends import_core23.Device {
   constructor(props) {
     var _a, _b;
     super({ ...props, id: props.id || uid("webgl-device") });
-    const device = (_a = props.gl) == null ? void 0 : _a.device;
+    if (!props.createCanvasContext) {
+      throw new Error("WebGLDevice requires props.createCanvasContext to be set");
+    }
+    const canvasContextProps = props.createCanvasContext === true ? {} : props.createCanvasContext;
+    let device = (_b = (_a = canvasContextProps.canvas) == null ? void 0 : _a.gl) == null ? void 0 : _b.device;
     if (device) {
       throw new Error(`WebGL context already attached to device ${device.id}`);
     }
-    const canvas = ((_b = props.gl) == null ? void 0 : _b.canvas) || props.canvas;
-    this.canvasContext = new WebGLCanvasContext(this, { ...props, canvas });
+    this.canvasContext = new WebGLCanvasContext(this, canvasContextProps);
     this.lost = new Promise((resolve) => {
       this._resolveContextLost = resolve;
     });
-    this.handle = createBrowserContext(this.canvasContext.canvas, {
-      ...props,
+    const webglContextAttributes = { ...props.webgl };
+    if (canvasContextProps.alphaMode === "premultiplied") {
+      webglContextAttributes.premultipliedAlpha = true;
+    }
+    if (props.powerPreference !== void 0) {
+      webglContextAttributes.powerPreference = props.powerPreference;
+    }
+    const gl = createBrowserContext(this.canvasContext.canvas, {
       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."
         });
-      }
-    });
-    this.gl = this.handle;
-    if (!this.handle) {
+      },
+      // eslint-disable-next-line no-console
+      onContextRestored: (event) => console.log("WebGL context restored")
+    }, webglContextAttributes);
+    if (!gl) {
       throw new Error("WebGL context creation failed");
     }
+    device = gl.device;
+    if (device) {
+      throw new Error(`WebGL context already attached to device ${device.id}`);
+    }
+    this.handle = gl;
+    this.gl = gl;
     this.spectorJS = initializeSpectorJS({ ...this.props, gl: this.handle });
     this.gl.device = this;
     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 = new WebGLDeviceFeatures(this.gl, this._extensions, this.props._disabledFeatures);
+    if (this.props._initializeFeatures) {
       this.features.initializeFeatures();
     }
     this.canvasContext.resize();
@@ -4902,8 +4912,8 @@ var WebGLDevice = class extends import_core23.Device {
       log: (...args) => import_core23.log.log(1, ...args)()
     });
     glState.trackState(this.gl, { copyState: false });
-    if (props.debug) {
-      this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true });
+    if (props.debugWebGL) {
+      this.gl = makeDebugContext(this.gl, { ...props });
       this.debug = true;
       import_core23.log.level = Math.max(import_core23.log.level, 1);
       import_core23.log.warn("WebGL debug mode activated. Performance reduced.")();
@@ -4932,7 +4942,7 @@ var WebGLDevice = class extends import_core23.Device {
     throw new Error("WebGL only supports a single canvas");
   }
   createBuffer(props) {
-    const newProps = this._getBufferProps(props);
+    const newProps = this._normalizeBufferProps(props);
     return new WEBGLBuffer(this, newProps);
   }
   createTexture(props) {
@@ -5276,27 +5286,23 @@ var WebGLAdapter = class extends import_core24.Adapter {
     if (!isWebGL(gl)) {
       throw new Error("Invalid WebGL2RenderingContext");
     }
-    return new WebGLDevice({ gl });
+    return new WebGLDevice({ _handle: gl });
   }
   async create(props = {}) {
     import_core24.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
     const promises = [];
-    if (props.debug) {
+    if (props.debugWebGL) {
       promises.push(loadWebGLDeveloperTools());
     }
-    if (props.debugWithSpectorJS) {
+    if (props.debugSpectorJS) {
       promises.push(loadSpectorJS(props));
     }
-    if (typeof props.canvas === "string") {
-      promises.push(import_core24.CanvasContext.pageLoaded);
-    }
     const results = await Promise.allSettled(promises);
     for (const result of results) {
       if (result.status === "rejected") {
         import_core24.log.error(`Failed to initialize debug libraries ${result.reason}`)();
       }
     }
-    import_core24.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
     const device = new WebGLDevice(props);
     const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
     import_core24.log.probe(LOG_LEVEL2, message2)();