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

package/dist/dist.dev.js

@@ -57,7 +57,6 @@ var __exports__ = (() => {
     WEBGLFramebuffer: () => WEBGLFramebuffer,
     WEBGLRenderPass: () => WEBGLRenderPass,
     WEBGLRenderPipeline: () => WEBGLRenderPipeline,
-    WEBGLRenderbuffer: () => WEBGLRenderbuffer,
     WEBGLResource: () => WebGLResource,
     WEBGLSampler: () => WEBGLSampler,
     WEBGLShader: () => WEBGLShader,
@@ -68,6 +67,7 @@ var __exports__ = (() => {
     WebGLDevice: () => WebGLDevice,
     WebGLResource: () => WebGLResource,
     _TEXTURE_FORMATS: () => TEXTURE_FORMATS,
+    _WEBGLRenderbuffer: () => WEBGLRenderbuffer,
     convertGLToTextureFormat: () => convertGLToTextureFormat,
     getGLParameters: () => getGLParameters,
     getShaderLayout: () => getShaderLayout,
@@ -83,10 +83,12 @@ var __exports__ = (() => {
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
-    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+    if (typeof window !== "undefined" && typeof window.process === "object" && // @ts-expect-error
+    window.process.type === "renderer") {
       return true;
     }
-    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
+    if (typeof process !== "undefined" && typeof process.versions === "object" && // eslint-disable-next-line
+    Boolean(process.versions["electron"])) {
       return true;
     }
     const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
@@ -99,7 +101,10 @@ var __exports__ = (() => {
 
   // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser() {
-    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    const isNode = (
+      // @ts-expect-error
+      typeof process === "object" && String(process) === "[object process]" && !process.browser
+    );
     return !isNode || isElectron();
   }
 
@@ -112,7 +117,7 @@ var __exports__ = (() => {
   var navigator_ = globalThis.navigator || {};
 
   // ../../node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+  var VERSION = true ? "4.0.6" : "untranspiled source";
   var isBrowser2 = isBrowser();
 
   // ../../node_modules/@probe.gl/env/dist/lib/get-browser.js
@@ -158,11 +163,7 @@ var __exports__ = (() => {
     }
   }
   var LocalStorage = class {
-    constructor(id, defaultConfig) {
-      let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
-      this.storage = void 0;
-      this.id = void 0;
-      this.config = void 0;
+    constructor(id, defaultConfig, type = "sessionStorage") {
       this.storage = getStorage(type);
       this.id = id;
       this.config = defaultConfig;
@@ -178,6 +179,7 @@ var __exports__ = (() => {
         this.storage.setItem(this.id, serialized);
       }
     }
+    // Get config from persistent store, if available
     _loadConfiguration() {
       let configuration = {};
       if (this.storage) {
@@ -203,20 +205,25 @@ var __exports__ = (() => {
     }
     return formatted;
   }
-  function leftPad(string) {
-    let length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
+  function leftPad(string, length = 8) {
     const padLength = Math.max(length - string.length, 0);
     return `${" ".repeat(padLength)}${string}`;
   }
-  function formatImage(image, message2, scale) {
-    let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
+  function formatImage(image, message2, scale, maxWidth = 600) {
     const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
     if (image.width > maxWidth) {
       scale = Math.min(scale, maxWidth / image.width);
     }
     const width = image.width * scale;
     const height = image.height * scale;
-    const style = ["font-size:1px;", `padding:${Math.floor(height / 2)}px ${Math.floor(width / 2)}px;`, `line-height:${height}px;`, `background:url(${imageUrl});`, `background-size:${width}px ${height}px;`, "color:transparent;"].join("");
+    const style = [
+      "font-size:1px;",
+      `padding:${Math.floor(height / 2)}px ${Math.floor(width / 2)}px;`,
+      `line-height:${height}px;`,
+      `background:url(${imageUrl});`,
+      `background-size:${width}px ${height}px;`,
+      "color:transparent;"
+    ].join("");
     return [`${message2} %c+`, style];
   }
 
@@ -263,8 +270,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
-  function autobind(obj) {
-    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
+  function autobind(obj, predefined = ["constructor"]) {
     const proto = Object.getPrototypeOf(obj);
     const propNames = Object.getOwnPropertyNames(proto);
     const object = obj;
@@ -289,11 +295,9 @@ var __exports__ = (() => {
   function getHiResTimestamp() {
     let timestamp;
     if (isBrowser() && window_.performance) {
-      var _window$performance, _window$performance$n;
-      timestamp = window_ === null || window_ === void 0 ? void 0 : (_window$performance = window_.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
+      timestamp = window_?.performance?.now?.();
     } else if ("hrtime" in process_) {
-      var _process$hrtime;
-      const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_);
+      const timeParts = process_?.hrtime?.();
       timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
     } else {
       timestamp = Date.now();
@@ -316,21 +320,12 @@ var __exports__ = (() => {
   function noop() {
   }
   var cache = {};
-  var ONCE = {
-    once: true
-  };
+  var ONCE = { once: true };
   var Log = class {
-    constructor() {
-      let {
-        id
-      } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
-        id: ""
-      };
-      this.id = void 0;
+    constructor({ id } = { id: "" }) {
       this.VERSION = VERSION;
       this._startTs = getHiResTimestamp();
       this._deltaTs = getHiResTimestamp();
-      this._storage = void 0;
       this.userData = {};
       this.LOG_THROTTLE_TIMEOUT = 0;
       this.id = id;
@@ -352,42 +347,44 @@ var __exports__ = (() => {
     getLevel() {
       return this._storage.config.level;
     }
+    /** @return milliseconds, with fractions */
     getTotal() {
       return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
     }
+    /** @return milliseconds, with fractions */
     getDelta() {
       return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
     }
+    /** @deprecated use logLevel */
     set priority(newPriority) {
       this.level = newPriority;
     }
+    /** @deprecated use logLevel */
     get priority() {
       return this.level;
     }
+    /** @deprecated use logLevel */
     getPriority() {
       return this.level;
     }
-    enable() {
-      let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
-      this._storage.setConfiguration({
-        enabled
-      });
+    // Configure
+    enable(enabled = true) {
+      this._storage.setConfiguration({ enabled });
       return this;
     }
     setLevel(level) {
-      this._storage.setConfiguration({
-        level
-      });
+      this._storage.setConfiguration({ level });
       return this;
     }
+    /** return the current status of the setting */
     get(setting) {
       return this._storage.config[setting];
     }
+    // update the status of the setting
     set(setting, value) {
-      this._storage.setConfiguration({
-        [setting]: value
-      });
+      this._storage.setConfiguration({ [setting]: value });
     }
+    /** Logs the current settings as a table */
     settings() {
       if (console.table) {
         console.table(this._storage.config);
@@ -395,6 +392,7 @@ var __exports__ = (() => {
         console.log(this._storage.config);
       }
     }
+    // Unconditional logging
     assert(condition, message2) {
       assert(condition, message2);
     }
@@ -404,9 +402,11 @@ var __exports__ = (() => {
     error(message2) {
       return this._getLogFunction(0, message2, originalConsole.error, arguments);
     }
+    /** Print a deprecation warning */
     deprecated(oldUsage, newUsage) {
       return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`);
     }
+    /** Print a removal warning */
     removed(oldUsage, newUsage) {
       return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`);
     }
@@ -425,6 +425,7 @@ var __exports__ = (() => {
     once(logLevel, message2) {
       return this._getLogFunction(logLevel, message2, originalConsole.debug || originalConsole.info, arguments, ONCE);
     }
+    /** Logs an object as a table */
     table(logLevel, table, columns) {
       if (table) {
         return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
@@ -433,26 +434,12 @@ var __exports__ = (() => {
       }
       return noop;
     }
-    image(_ref) {
-      let {
-        logLevel,
-        priority,
-        image,
-        message: message2 = "",
-        scale = 1
-      } = _ref;
+    /** logs an image under Chrome */
+    image({ logLevel, priority, image, message: message2 = "", scale = 1 }) {
       if (!this._shouldLog(logLevel || priority)) {
         return noop;
       }
-      return isBrowser() ? logImageInBrowser({
-        image,
-        message: message2,
-        scale
-      }) : logImageInNode({
-        image,
-        message: message2,
-        scale
-      });
+      return isBrowser() ? logImageInBrowser({ image, message: message2, scale }) : logImageInNode({ image, message: message2, scale });
     }
     time(logLevel, message2) {
       return this._getLogFunction(logLevel, message2, console.time ? console.time : console.info);
@@ -463,30 +450,19 @@ var __exports__ = (() => {
     timeStamp(logLevel, message2) {
       return this._getLogFunction(logLevel, message2, console.timeStamp || noop);
     }
-    group(logLevel, message2) {
-      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
-        collapsed: false
-      };
-      const options = normalizeArguments({
-        logLevel,
-        message: message2,
-        opts
-      });
-      const {
-        collapsed
-      } = opts;
+    group(logLevel, message2, opts = { collapsed: false }) {
+      const options = normalizeArguments({ logLevel, message: message2, opts });
+      const { collapsed } = opts;
       options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
       return this._getLogFunction(options);
     }
-    groupCollapsed(logLevel, message2) {
-      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-      return this.group(logLevel, message2, Object.assign({}, opts, {
-        collapsed: true
-      }));
+    groupCollapsed(logLevel, message2, opts = {}) {
+      return this.group(logLevel, message2, Object.assign({}, opts, { collapsed: true }));
     }
     groupEnd(logLevel) {
       return this._getLogFunction(logLevel, "", console.groupEnd || noop);
     }
+    // EXPERIMENTAL
     withGroup(logLevel, message2, func) {
       this.group(logLevel, message2)();
       try {
@@ -500,17 +476,14 @@ var __exports__ = (() => {
         console.trace();
       }
     }
+    // PRIVATE METHODS
+    /** Deduces log level from a variety of arguments */
     _shouldLog(logLevel) {
       return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
     }
     _getLogFunction(logLevel, message2, method, args, opts) {
       if (this._shouldLog(logLevel)) {
-        opts = normalizeArguments({
-          logLevel,
-          message: message2,
-          args,
-          opts
-        });
+        opts = normalizeArguments({ logLevel, message: message2, args, opts });
         method = method || opts.method;
         assert(method);
         opts.total = this.getTotal();
@@ -550,10 +523,7 @@ var __exports__ = (() => {
     return resolvedLevel;
   }
   function normalizeArguments(opts) {
-    const {
-      logLevel,
-      message: message2
-    } = opts;
+    const { logLevel, message: message2 } = opts;
     opts.logLevel = normalizeLogLevel(logLevel);
     const args = opts.args ? Array.from(opts.args) : [];
     while (args.length && args.shift() !== message2) {
@@ -576,9 +546,7 @@ var __exports__ = (() => {
     }
     const messageType = typeof opts.message;
     assert(messageType === "string" || messageType === "object");
-    return Object.assign(opts, {
-      args
-    }, opts.opts);
+    return Object.assign(opts, { args }, opts.opts);
   }
   function decorateMessage(id, message2, opts) {
     if (typeof message2 === "string") {
@@ -588,21 +556,11 @@ var __exports__ = (() => {
     }
     return message2;
   }
-  function logImageInNode(_ref2) {
-    let {
-      image,
-      message: message2 = "",
-      scale = 1
-    } = _ref2;
+  function logImageInNode({ image, message: message2 = "", scale = 1 }) {
     console.warn("removed");
     return noop;
   }
-  function logImageInBrowser(_ref3) {
-    let {
-      image,
-      message: message2 = "",
-      scale = 1
-    } = _ref3;
+  function logImageInBrowser({ image, message: message2 = "", scale = 1 }) {
     if (typeof image === "string") {
       const img = new Image();
       img.onload = () => {
@@ -638,9 +596,7 @@ var __exports__ = (() => {
   globalThis.probe = {};
 
   // ../../node_modules/@probe.gl/log/dist/index.js
-  var dist_default = new Log({
-    id: "@probe.gl/log"
-  });
+  var dist_default = new Log({ id: "@probe.gl/log" });
 
   // ../core/src/utils/log.ts
   var log = new Log({ id: "luma.gl" });
@@ -662,8 +618,6 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat = class {
     constructor(name2, type) {
-      this.name = void 0;
-      this.type = void 0;
       this.sampleSize = 1;
       this.time = 0;
       this.count = 0;
@@ -698,26 +652,31 @@ var __exports__ = (() => {
       this.sampleSize = samples;
       return this;
     }
+    /** Call to increment count (+1) */
     incrementCount() {
       this.addCount(1);
       return this;
     }
+    /** Call to decrement count (-1) */
     decrementCount() {
       this.subtractCount(1);
       return this;
     }
+    /** Increase count */
     addCount(value) {
       this._count += value;
       this._samples++;
       this._checkSampling();
       return this;
     }
+    /** Decrease count */
     subtractCount(value) {
       this._count -= value;
       this._samples++;
       this._checkSampling();
       return this;
     }
+    /** Add an arbitrary timing and bump the count */
     addTime(time) {
       this._time += time;
       this.lastTiming = time;
@@ -725,11 +684,13 @@ var __exports__ = (() => {
       this._checkSampling();
       return this;
     }
+    /** Start a timer */
     timeStart() {
       this._startTime = getHiResTimestamp2();
       this._timerPending = true;
       return this;
     }
+    /** End a timer. Adds to time and bumps the timing count. */
     timeEnd() {
       if (!this._timerPending) {
         return this;
@@ -742,18 +703,22 @@ var __exports__ = (() => {
     getSampleAverageCount() {
       return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
     }
+    /** Calculate average time / count for the previous window */
     getSampleAverageTime() {
       return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
     }
+    /** Calculate counts per second for the previous window */
     getSampleHz() {
       return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
     }
     getAverageCount() {
       return this.samples > 0 ? this.count / this.samples : 0;
     }
+    /** Calculate average time / count */
     getAverageTime() {
       return this.samples > 0 ? this.time / this.samples : 0;
     }
+    /** Calculate counts per second */
     getHz() {
       return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
     }
@@ -774,23 +739,20 @@ var __exports__ = (() => {
   // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
   var Stats = class {
     constructor(options) {
-      this.id = void 0;
       this.stats = {};
       this.id = options.id;
       this.stats = {};
       this._initializeStats(options.stats);
       Object.seal(this);
     }
-    get(name2) {
-      let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
-      return this._getOrCreate({
-        name: name2,
-        type
-      });
+    /** Acquire a stat. Create if it doesn't exist. */
+    get(name2, type = "count") {
+      return this._getOrCreate({ name: name2, type });
     }
     get size() {
       return Object.keys(this.stats).length;
     }
+    /** Reset all stats */
     reset() {
       for (const stat of Object.values(this.stats)) {
         stat.reset();
@@ -814,15 +776,11 @@ var __exports__ = (() => {
       });
       return table;
     }
-    _initializeStats() {
-      let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    _initializeStats(stats = []) {
       stats.forEach((stat) => this._getOrCreate(stat));
     }
     _getOrCreate(stat) {
-      const {
-        name: name2,
-        type
-      } = stat;
+      const { name: name2, type } = stat;
       let result = this.stats[name2];
       if (!result) {
         if (stat instanceof Stat) {
@@ -1043,6 +1001,8 @@ var __exports__ = (() => {
     usage;
     /** For index buffers, whether indices are 16 or 32 bit */
     indexType;
+    /** "Time" of last update */
+    updateTimestamp;
     constructor(device, props) {
       const deducedProps = { ...props };
       if ((props.usage || 0) & _Buffer.INDEX && !props.indexType) {
@@ -1055,6 +1015,7 @@ var __exports__ = (() => {
       super(device, deducedProps, _Buffer.defaultProps);
       this.usage = props.usage || 0;
       this.indexType = deducedProps.indexType;
+      this.updateTimestamp = device.incrementTimestamp();
     }
     /** Read data synchronously. @note WebGL2 only */
     readSyncWebGL(byteOffset, byteLength) {
@@ -1232,14 +1193,16 @@ var __exports__ = (() => {
   };
   var DeviceFeatures = class {
     features;
-    constructor(features = []) {
+    disabledFeatures;
+    constructor(features = [], disabledFeatures) {
       this.features = new Set(features);
+      this.disabledFeatures = disabledFeatures || {};
     }
     *[Symbol.iterator]() {
       yield* this.features;
     }
     has(feature) {
-      return this.features.has(feature);
+      return !this.disabledFeatures[feature] && this.features.has(feature);
     }
   };
   var _Device = class {
@@ -1252,12 +1215,12 @@ var __exports__ = (() => {
     }
     /** id of this device, primarily for debugging */
     id;
-    /** stats */
-    statsManager = lumaStats;
     /** A copy of the device props  */
     props;
     /** Available for the application to store data on the device */
     userData = {};
+    /** stats */
+    statsManager = lumaStats;
     /** Used by other luma.gl modules to store data on the device */
     _lumaData = {};
     /** Check if a specific texture format is GPU compressed */
@@ -1314,12 +1277,17 @@ var __exports__ = (() => {
     clearWebGL(options) {
       throw new Error("not implemented");
     }
-    // IMPLEMENTATION
+    timestamp = 0;
+    /** A monotonic counter for tracking buffer and texture updates */
+    incrementTimestamp() {
+      return this.timestamp++;
+    }
     // Error Handling
     /** Report unhandled device errors */
     onError(error) {
       this.props.onError(error);
     }
+    // IMPLEMENTATION
     _getBufferProps(props) {
       if (props instanceof ArrayBuffer || ArrayBuffer.isView(props)) {
         props = { data: props };
@@ -1340,19 +1308,23 @@ var __exports__ = (() => {
   var Device = _Device;
   __publicField(Device, "defaultProps", {
     id: null,
-    type: "best-available",
     canvas: null,
     container: null,
     manageState: true,
     width: 800,
     // width are height are only used by headless gl
     height: 600,
-    requestMaximalLimits: true,
+    requestMaxLimits: true,
     debug: Boolean(log.get("debug")),
     // Instrument context (at the expense of performance)
     spector: Boolean(log.get("spector")),
     // Initialize the SpectorJS WebGL debugger
     break: [],
+    // TODO - Change these after confirming things work as expected
+    initalizeFeatures: true,
+    disabledFeatures: {
+      "compilation-status-async-webgl": true
+    },
     // alpha: undefined,
     // depth: undefined,
     // stencil: undefined,
@@ -1663,6 +1635,9 @@ var __exports__ = (() => {
     height;
     /** depth of this texture */
     depth;
+    /** "Time" of last update. Monotonically increasing timestamp */
+    updateTimestamp;
+    /** Do not use directly. Create with device.createTexture() */
     constructor(device, props, defaultProps = _Texture.defaultProps) {
       super(device, props, defaultProps);
       this.dimension = this.props.dimension;
@@ -1670,6 +1645,7 @@ var __exports__ = (() => {
       this.width = this.props.width;
       this.height = this.props.height;
       this.depth = this.props.depth;
+      this.updateTimestamp = device.incrementTimestamp();
     }
   };
   var Texture = _Texture;
@@ -1898,7 +1874,7 @@ ${htmlLog}
   __publicField(Shader, "defaultProps", {
     ...Resource.defaultProps,
     language: "auto",
-    stage: "vertex",
+    stage: void 0,
     source: "",
     sourceMap: null,
     entryPoint: "main",
@@ -1967,6 +1943,9 @@ ${htmlLog}
     }
     /** Auto creates any textures */
     autoCreateAttachmentTextures() {
+      if (this.props.colorAttachments.length === 0 && !this.props.depthStencilAttachment) {
+        throw new Error("Framebuffer has noattachments");
+      }
       this.colorAttachments = this.props.colorAttachments.map((attachment2) => {
         if (typeof attachment2 === "string") {
           const texture = this.createColorTexture(attachment2);
@@ -2047,7 +2026,7 @@ ${htmlLog}
     width: 1,
     height: 1,
     colorAttachments: [],
-    // ['rgba8unorm-unsized'],
+    // ['rgba8unorm'],
     depthStencilAttachment: null
     // 'depth24plus-stencil8'
   });
@@ -2085,12 +2064,10 @@ ${htmlLog}
   __publicField(RenderPipeline, "defaultProps", {
     ...Resource.defaultProps,
     vs: null,
-    vsEntryPoint: "",
-    // main
+    vertexEntryPoint: "vertexMain",
     vsConstants: {},
     fs: null,
-    fsEntryPoint: "",
-    // main
+    fragmentEntryPoint: "fragmentMain",
     fsConstants: {},
     shaderLayout: null,
     bufferLayout: [],
@@ -3098,9 +3075,7 @@ ${htmlLog}
   ]);
 
   // src/context/parameters/unified-parameter-api.ts
-  function setGLParameters(device, parameters) {
-    const webglDevice = WebGLDevice.attach(device);
-    const gl = webglDevice.gl;
+  function setGLParameters(gl, parameters) {
     if (isObjectEmpty2(parameters)) {
       return;
     }
@@ -3124,9 +3099,7 @@ ${htmlLog}
       }
     }
   }
-  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];
@@ -3140,8 +3113,8 @@ ${htmlLog}
     }
     return state;
   }
-  function resetGLParameters(device) {
-    setGLParameters(device, GL_PARAMETER_DEFAULTS);
+  function resetGLParameters(gl) {
+    setGLParameters(gl, GL_PARAMETER_DEFAULTS);
   }
   function isObjectEmpty2(object) {
     for (const key in object) {
@@ -3519,9 +3492,7 @@ ${htmlLog}
     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,
       b: 4,
@@ -3538,27 +3509,28 @@ ${htmlLog}
       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]
     },
+    // '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 },
+    "r8unorm": { gl: import_constants4.GL.R8, b: 1, c: 1, rb: true },
     "r8snorm": { gl: import_constants4.GL.R8_SNORM, b: 1, c: 1, render: snorm8_renderable },
-    "r8uint": { gl: import_constants4.GL.R8UI, b: 1, c: 1, renderbuffer: true },
-    "r8sint": { gl: import_constants4.GL.R8I, b: 1, c: 1, renderbuffer: true },
+    "r8uint": { gl: import_constants4.GL.R8UI, b: 1, c: 1, rb: true },
+    "r8sint": { gl: import_constants4.GL.R8I, b: 1, c: 1, rb: true },
     // 16-bit formats
-    "rg8unorm": { gl: import_constants4.GL.RG8, b: 2, c: 2, renderbuffer: true },
+    "rg8unorm": { gl: import_constants4.GL.RG8, b: 2, c: 2, rb: true },
     "rg8snorm": { gl: import_constants4.GL.RG8_SNORM, b: 2, c: 2, render: snorm8_renderable },
-    "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, filter: "float16-filterable-webgl", renderbuffer: true },
-    "r16unorm-webgl": { gl: import_constants4.GL.R16_EXT, b: 2, c: 1, f: norm16_renderable, renderbuffer: true },
+    "rg8uint": { gl: import_constants4.GL.RG8UI, b: 2, c: 2, rb: true },
+    "rg8sint": { gl: import_constants4.GL.RG8I, b: 2, c: 2, rb: true },
+    "r16uint": { gl: import_constants4.GL.R16UI, b: 2, c: 1, rb: true },
+    "r16sint": { gl: import_constants4.GL.R16I, b: 2, c: 1, rb: true },
+    "r16float": { gl: import_constants4.GL.R16F, b: 2, c: 1, render: float16_renderable, filter: "float16-filterable-webgl", rb: true },
+    "r16unorm-webgl": { gl: import_constants4.GL.R16_EXT, b: 2, c: 1, f: norm16_renderable, rb: true },
     "r16snorm-webgl": { gl: import_constants4.GL.R16_SNORM_EXT, 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: import_constants4.GL.RGBA4, b: 2, c: 4, wgpu: false, rb: true },
+    "rgb565unorm-webgl": { gl: import_constants4.GL.RGB565, b: 2, c: 4, wgpu: false, rb: true },
+    "rgb5a1unorm-webgl": { gl: import_constants4.GL.RGB5_A1, 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 },
@@ -3574,31 +3546,31 @@ ${htmlLog}
     "rg16uint": { gl: import_constants4.GL.RG16UI, b: 4, c: 1, bpp: 4 },
     "rg16sint": { gl: import_constants4.GL.RG16I, 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, filter: float16_filterable, renderbuffer: true },
+    "rg16float": { gl: import_constants4.GL.RG16F, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true },
     "rg16unorm-webgl": { gl: import_constants4.GL.RG16_EXT, b: 2, c: 2, render: norm16_renderable },
     "rg16snorm-webgl": { gl: import_constants4.GL.RG16_SNORM_EXT, b: 2, c: 2, render: snorm16_renderable },
-    "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 },
+    "r32uint": { gl: import_constants4.GL.R32UI, b: 4, c: 1, bpp: 4, rb: true },
+    "r32sint": { gl: import_constants4.GL.R32I, b: 4, c: 1, bpp: 4, rb: true },
     "r32float": { gl: import_constants4.GL.R32F, 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: rgb9e5ufloat_renderable },
     // , filter: true},
-    "rg11b10ufloat": { gl: import_constants4.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: float32_renderable, renderbuffer: true },
-    "rgb10a2unorm": { gl: import_constants4.GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
-    "rgb10a2uint-webgl": { b: 4, c: 4, gl: import_constants4.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
+    "rg11b10ufloat": { gl: import_constants4.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: float32_renderable, rb: true },
+    "rgb10a2unorm": { gl: import_constants4.GL.RGB10_A2, b: 4, c: 4, p: 1, rb: true },
+    "rgb10a2uint-webgl": { b: 4, c: 4, gl: import_constants4.GL.RGB10_A2UI, 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 },
     // rgb not renderable
     "rgb16snorm-webgl": { gl: import_constants4.GL.RGB16_SNORM_EXT, 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, filter: float32_filterable, 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 },
+    "rg32uint": { gl: import_constants4.GL.RG32UI, b: 8, c: 2, rb: true },
+    "rg32sint": { gl: import_constants4.GL.RG32I, b: 8, c: 2, rb: true },
+    "rg32float": { gl: import_constants4.GL.RG32F, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, rb: true },
+    "rgba16uint": { gl: import_constants4.GL.RGBA16UI, b: 8, c: 4, rb: true },
+    "rgba16sint": { gl: import_constants4.GL.RGBA16I, b: 8, c: 4, rb: true },
     "rgba16float": { gl: import_constants4.GL.RGBA16F, b: 8, c: 4, render: float16_renderable, filter: float16_filterable },
-    "rgba16unorm-webgl": { gl: import_constants4.GL.RGBA16_EXT, b: 2, c: 4, render: norm16_renderable, renderbuffer: true },
+    "rgba16unorm-webgl": { gl: import_constants4.GL.RGBA16_EXT, b: 2, c: 4, render: norm16_renderable, rb: true },
     "rgba16snorm-webgl": { gl: import_constants4.GL.RGBA16_SNORM_EXT, b: 2, c: 4, render: snorm16_renderable },
     // 96-bit formats (deprecated!)
     "rgb32float-webgl": {
@@ -3610,22 +3582,73 @@ ${htmlLog}
       types: [import_constants4.GL.FLOAT]
     },
     // 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, filter: float32_filterable, renderbuffer: true },
+    "rgba32uint": { gl: import_constants4.GL.RGBA32UI, b: 16, c: 4, rb: true },
+    "rgba32sint": { gl: import_constants4.GL.RGBA32I, b: 16, c: 4, rb: true },
+    "rgba32float": { gl: import_constants4.GL.RGBA32F, 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: import_constants4.GL.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants4.GL.STENCIL_ATTACHMENT, 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: import_constants4.GL.DEPTH_COMPONENT16,
+      b: 2,
+      c: 1,
+      attachment: import_constants4.GL.DEPTH_ATTACHMENT,
+      dataFormat: import_constants4.GL.DEPTH_COMPONENT,
+      types: [import_constants4.GL.UNSIGNED_SHORT],
+      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: import_constants4.GL.DEPTH_COMPONENT24,
+      b: 3,
+      c: 1,
+      attachment: import_constants4.GL.DEPTH_ATTACHMENT,
+      dataFormat: import_constants4.GL.DEPTH_COMPONENT,
+      types: [import_constants4.GL.UNSIGNED_INT]
+    },
+    "depth32float": {
+      gl: import_constants4.GL.DEPTH_COMPONENT32F,
+      b: 4,
+      c: 1,
+      attachment: import_constants4.GL.DEPTH_ATTACHMENT,
+      dataFormat: import_constants4.GL.DEPTH_COMPONENT,
+      types: [import_constants4.GL.FLOAT],
+      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: import_constants4.GL.DEPTH24_STENCIL8,
+      b: 4,
+      c: 2,
+      p: 1,
+      attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT,
+      rb: true,
+      depthTexture: true,
+      dataFormat: import_constants4.GL.DEPTH_STENCIL,
+      types: [import_constants4.GL.UNSIGNED_INT_24_8]
+    },
     // "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: import_constants4.GL.DEPTH24_STENCIL8,
+      b: 4,
+      c: 2,
+      p: 1,
+      attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT,
+      dataFormat: import_constants4.GL.DEPTH_STENCIL,
+      types: [import_constants4.GL.UNSIGNED_INT_24_8],
+      rb: true
+    },
+    // "depth32float-stencil8" feature - TODO below is render buffer only?
+    "depth32float-stencil8": {
+      gl: import_constants4.GL.DEPTH32F_STENCIL8,
+      b: 5,
+      c: 2,
+      p: 1,
+      attachment: import_constants4.GL.DEPTH_STENCIL_ATTACHMENT,
+      dataFormat: import_constants4.GL.DEPTH_STENCIL,
+      types: [import_constants4.GL.FLOAT_32_UNSIGNED_INT_24_8_REV],
+      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 },
@@ -3721,8 +3744,7 @@ ${htmlLog}
     [import_constants4.GL.BYTE]: 1,
     [import_constants4.GL.UNSIGNED_BYTE]: 1
   };
-  function isTextureFormatSupported(gl, formatOrGL, extensions) {
-    const format = convertGLToTextureFormat(formatOrGL);
+  function isTextureFormatSupported(gl, format, extensions) {
     const info = TEXTURE_FORMATS[format];
     if (!info) {
       return false;
@@ -3737,7 +3759,7 @@ ${htmlLog}
     return true;
   }
   function isRenderbufferFormatSupported(gl, format, extensions) {
-    return isTextureFormatSupported(gl, format, extensions) && TEXTURE_FORMATS[format]?.renderbuffer;
+    return isTextureFormatSupported(gl, format, extensions) && TEXTURE_FORMATS[format]?.rb;
   }
   function convertGLToTextureFormat(format) {
     if (typeof format === "string") {
@@ -3757,11 +3779,13 @@ ${htmlLog}
     }
     return webglFormat;
   }
-  function isTextureFormatFilterable(gl, formatOrGL, extensions) {
-    const format = convertGLToTextureFormat(formatOrGL);
+  function isTextureFormatFilterable(gl, format, extensions) {
     if (!isTextureFormatSupported(gl, format, extensions)) {
       return false;
     }
+    if (format.startsWith("depth") || format.startsWith("stencil")) {
+      return false;
+    }
     try {
       const decoded = decodeTextureFormat(format);
       if (decoded.signed) {
@@ -3778,8 +3802,7 @@ ${htmlLog}
     }
     return true;
   }
-  function isTextureFormatRenderable(gl, formatOrGL, extensions) {
-    const format = convertGLToTextureFormat(formatOrGL);
+  function isTextureFormatRenderable(gl, format, extensions) {
     if (!isTextureFormatSupported(gl, format, extensions)) {
       return false;
     }
@@ -3788,20 +3811,15 @@ ${htmlLog}
     }
     return true;
   }
-  function getWebGLTextureParameters(formatOrGL) {
-    const format = convertGLToTextureFormat(formatOrGL);
+  function getWebGLTextureParameters(format) {
+    const formatData = TEXTURE_FORMATS[format];
     const webglFormat = convertTextureFormatToGL(format);
     const decoded = decodeTextureFormat(format);
     return {
       format: webglFormat,
-      dataFormat: getWebGLPixelDataFormat(
-        decoded.format,
-        decoded.integer,
-        decoded.normalized,
-        webglFormat
-      ),
+      dataFormat: 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) : formatData?.types?.[0] || import_constants4.GL.UNSIGNED_BYTE,
       // @ts-expect-error
       compressed: decoded.compressed
     };
@@ -3813,8 +3831,7 @@ ${htmlLog}
     }
     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_SIZES3[params.type] || 1;
@@ -3862,8 +3879,8 @@ ${htmlLog}
     gl;
     extensions;
     testedFeatures = /* @__PURE__ */ new Set();
-    constructor(gl, extensions) {
-      super();
+    constructor(gl, extensions, disabledFeatures) {
+      super([], disabledFeatures);
       this.gl = gl;
       this.extensions = extensions;
       getWebGLExtension(gl, "EXT_color_buffer_float", extensions);
@@ -3882,6 +3899,9 @@ ${htmlLog}
       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)) {
@@ -3893,6 +3913,12 @@ ${htmlLog}
       }
       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];
@@ -4012,17 +4038,15 @@ ${htmlLog}
   };
 
   // src/adapter/resources/webgl-framebuffer.ts
-  var import_constants12 = __toESM(require_constants(), 1);
+  var import_constants11 = __toESM(require_constants(), 1);
 
   // src/adapter/resources/webgl-texture.ts
   var import_constants10 = __toESM(require_constants(), 1);
 
   // src/context/state-tracker/with-parameters.ts
-  function withGLParameters(device, parameters, func) {
-    const webglDevice = WebGLDevice.attach(device);
-    const gl = webglDevice.gl;
+  function withGLParameters(gl, parameters, func) {
     if (isObjectEmpty3(parameters)) {
-      return func(device);
+      return func(gl);
     }
     const { nocatch = true } = parameters;
     pushContextState(gl);
@@ -4056,13 +4080,14 @@ ${htmlLog}
     if (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) {
@@ -4078,7 +4103,7 @@ ${htmlLog}
     }
   }
   function setDeviceParameters(device, parameters) {
-    const webglDevice = WebGLDevice.attach(device);
+    const webglDevice = device;
     const { gl } = webglDevice;
     if (parameters.cullMode) {
       switch (parameters.cullMode) {
@@ -4600,6 +4625,9 @@ ${htmlLog}
     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") {
@@ -4665,8 +4693,8 @@ ${htmlLog}
       });
       this.setSampler(props.sampler);
       this._setSamplerParameters(parameters);
-      this.view = new WEBGLTextureView(this.device, { ...this.props, texture: this });
-      if (mipmaps) {
+      this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 });
+      if (mipmaps && this.device.isTextureFormatFilterable(props.format)) {
         this.generateMipmap();
       }
       if (isVideo) {
@@ -5221,398 +5249,184 @@ ${htmlLog}
     log.log(1, "texture sampler parameters", parameters)();
   }
 
-  // src/adapter/objects/webgl-renderbuffer.ts
-  var import_constants11 = __toESM(require_constants(), 1);
-
-  // src/adapter/objects/webgl-resource.ts
-  var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
-  var WebGLResource = class extends Resource {
+  // src/adapter/resources/webgl-framebuffer.ts
+  var WEBGLFramebuffer = class extends 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 || uid(this.constructor.name);
-      this._handle = props?.handle;
-      if (this._handle === void 0) {
-        this._handle = this._createHandle();
+    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_constants11.GL.FRAMEBUFFER, this.handle);
+        for (let i = 0; i < this.colorAttachments.length; ++i) {
+          const attachment = this.colorAttachments[i];
+          const attachmentPoint = import_constants11.GL.COLOR_ATTACHMENT0 + 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(import_constants11.GL.FRAMEBUFFER);
+          if (status !== import_constants11.GL.FRAMEBUFFER_COMPLETE) {
+            throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
+          }
+        }
+        this.gl.bindFramebuffer(import_constants11.GL.FRAMEBUFFER, null);
       }
-      this.byteLength = 0;
     }
-    toString() {
-      return `${this.constructor.name}(${this.id})`;
+    /** destroys any auto created resources etc. */
+    destroy() {
+      super.destroy();
+      if (!this.destroyed && this.handle !== null) {
+        this.gl.deleteFramebuffer(this.handle);
+      }
     }
-    get handle() {
-      return this._handle;
+    // 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
+      });
     }
-    delete({ deleteChildren = false } = {}) {
-      const children = this._handle && this._deleteHandle(this._handle);
-      if (this._handle) {
-        this.removeStats();
+    /**
+     * 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;
       }
-      this._handle = null;
-      if (children && deleteChildren) {
-        children.filter(Boolean).forEach((child) => child.destroy());
+      if (width === void 0) {
+        width = this.gl.drawingBufferWidth;
+      }
+      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;
     }
-    bind(funcOrHandle = this.handle) {
-      if (typeof funcOrHandle !== "function") {
-        this._bindHandle(funcOrHandle);
-        return this;
+    /** Attach one attachment */
+    _attachOne(attachmentPoint, attachment) {
+      if (Array.isArray(attachment)) {
+        const [texture, layer = 0, level = 0] = attachment;
+        this._attachTexture(attachmentPoint, texture, layer, level);
+        return texture;
       }
-      let value;
-      if (!this._bound) {
-        this._bindHandle(this.handle);
-        this._bound = true;
-        value = funcOrHandle();
-        this._bound = false;
-        this._bindHandle(null);
-      } else {
-        value = funcOrHandle();
+      if (attachment instanceof WEBGLTexture) {
+        this._attachTexture(attachmentPoint, attachment, 0, 0);
+        return attachment;
       }
-      return value;
-    }
-    unbind() {
-      this.bind(null);
-    }
-    // Install stubs for removed methods
-    stubRemovedMethods(className, version, methodNames) {
-      return stubRemovedMethods(this, className, version, methodNames);
+      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");
     }
-    // PUBLIC VIRTUAL METHODS
-    initialize(props) {
+    // 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
+     * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap`
+     * @param level = 0 - mipmapLevel
+     */
+    _attachTexture(attachment, texture, layer, level) {
+      const { gl } = this.device;
+      gl.bindTexture(texture.target, texture.handle);
+      switch (texture.target) {
+        case import_constants11.GL.TEXTURE_2D_ARRAY:
+        case import_constants11.GL.TEXTURE_3D:
+          gl.framebufferTextureLayer(import_constants11.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+          break;
+        case import_constants11.GL.TEXTURE_CUBE_MAP:
+          const face = mapIndexToCubeMapFace(layer);
+          gl.framebufferTexture2D(import_constants11.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+          break;
+        case import_constants11.GL.TEXTURE_2D:
+          gl.framebufferTexture2D(import_constants11.GL.FRAMEBUFFER, attachment, import_constants11.GL.TEXTURE_2D, texture.handle, level);
+          break;
+        default:
+          assert2(false, "Illegal texture type");
+      }
+      gl.bindTexture(texture.target, null);
     }
-    // PROTECTED METHODS - These must be overridden by subclass
-    _createHandle() {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  };
+  function mapIndexToCubeMapFace(layer) {
+    return layer < import_constants11.GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants11.GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
+  }
+  function _getFrameBufferStatus(status) {
+    switch (status) {
+      case import_constants11.GL.FRAMEBUFFER_COMPLETE:
+        return "success";
+      case import_constants11.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+        return "Mismatched attachments";
+      case import_constants11.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+        return "No attachments";
+      case import_constants11.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+        return "Height/width mismatch";
+      case import_constants11.GL.FRAMEBUFFER_UNSUPPORTED:
+        return "Unsupported or split attachments";
+      case import_constants11.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+        return "Samples mismatch";
+      default:
+        return `${status}`;
     }
-    _deleteHandle() {
-      throw new Error(ERR_RESOURCE_METHOD_UNDEFINED);
+  }
+
+  // src/adapter/webgl-canvas-context.ts
+  var WebGLCanvasContext = class extends CanvasContext {
+    device;
+    presentationSize;
+    _framebuffer = null;
+    constructor(device, props) {
+      super(props);
+      this.device = device;
+      this.presentationSize = [-1, -1];
+      this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
+      this.update();
     }
-    _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);
-    }
-    // PRIVATE METHODS
-    /*
-      _addStats() {
-        const name = this.constructor.name;
-        const stats = lumaStats.get('Resource Counts');
-    
-        stats.get('Resources Created').incrementCount();
-        stats.get(`${name}s Created`).incrementCount();
-        stats.get(`${name}s Active`).incrementCount();
-      }
-    
-      _removeStats() {
-        const name = this.constructor.name;
-        const stats = lumaStats.get('Resource Counts');
-    
-        stats.get(`${name}s Active`).decrementCount();
-      }
-    
-      trackAllocatedMemory(bytes, name = this.constructor.name) {
-        const stats = lumaStats.get('Memory Usage');
-    
-        stats.get('GPU Memory').addCount(bytes);
-        stats.get(`${name} Memory`).addCount(bytes);
-        this.byteLength = bytes;
-      }
-    
-      trackDeallocatedMemory(name = this.constructor.name) {
-        const stats = lumaStats.get('Memory Usage');
-    
-        stats.get('GPU Memory').subtractCount(this.byteLength);
-        stats.get(`${name} Memory`).subtractCount(this.byteLength);
-        this.byteLength = 0;
-      }
-      */
-  };
-
-  // src/adapter/objects/webgl-renderbuffer.ts
-  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;
-      assert2(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
-  });
-
-  // src/adapter/resources/webgl-framebuffer.ts
-  var WEBGLFramebuffer = class extends 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.props.format),
-            this.depthStencilAttachment
-          );
-        }
-        if (props.check !== false) {
-          const status = this.gl.checkFramebufferStatus(import_constants12.GL.FRAMEBUFFER);
-          if (status !== import_constants12.GL.FRAMEBUFFER_COMPLETE) {
-            throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
-          }
-        }
-        this.gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, null);
-      }
-    }
-    /** destroys any auto created resources etc. */
-    destroy() {
-      super.destroy();
-      if (!this.destroyed && this.handle !== null) {
-        this.gl.deleteFramebuffer(this.handle);
-      }
-    }
-    // PRIVATE
-    /** 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.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)) {
-        const [texture, layer = 0, level = 0] = attachment;
-        this._attachTexture(attachmentPoint, texture, layer, level);
-        return texture;
-      } else if (attachment instanceof WEBGLTexture) {
-        this._attachTexture(attachmentPoint, attachment, 0, 0);
-        return attachment;
-      } else 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
-      );
-    }
-    /**
-     * @param attachment
-     * @param texture
-     * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap`
-     * @param level = 0 - mipmapLevel
-     */
-    _attachTexture(attachment, texture, layer, level) {
-      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);
-          break;
-        case import_constants12.GL.TEXTURE_CUBE_MAP:
-          const face = mapIndexToCubeMapFace(layer);
-          gl.framebufferTexture2D(import_constants12.GL.FRAMEBUFFER, 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);
-          break;
-        default:
-          assert2(false, "Illegal texture type");
-      }
-      gl.bindTexture(texture.target, null);
-    }
-  };
-  function mapIndexToCubeMapFace(layer) {
-    return layer < import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
-  }
-  function _getFrameBufferStatus(status) {
-    switch (status) {
-      case import_constants12.GL.FRAMEBUFFER_COMPLETE:
-        return "success";
-      case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
-        return "Mismatched attachments";
-      case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
-        return "No attachments";
-      case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
-        return "Height/width mismatch";
-      case import_constants12.GL.FRAMEBUFFER_UNSUPPORTED:
-        return "Unsupported or split attachments";
-      case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
-        return "Samples mismatch";
-      default:
-        return `${status}`;
-    }
-  }
-
-  // src/adapter/webgl-canvas-context.ts
-  var WebGLCanvasContext = class extends CanvasContext {
-    device;
-    presentationSize;
-    _framebuffer = null;
-    constructor(device, props) {
-      super(props);
-      this.device = device;
-      this.presentationSize = [-1, -1];
-      this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
-      this.update();
-    }
-    getCurrentFramebuffer() {
-      this.update();
-      this._framebuffer = this._framebuffer || new WEBGLFramebuffer(this.device, { handle: null });
-      return this._framebuffer;
+    getCurrentFramebuffer() {
+      this.update();
+      this._framebuffer = this._framebuffer || new WEBGLFramebuffer(this.device, { handle: null });
+      return this._framebuffer;
     }
     /** Resizes and updates render targets if necessary */
     update() {
@@ -5707,7 +5521,7 @@ ${htmlLog}
   }
 
   // src/context/debug/webgl-developer-tools.ts
-  var import_constants13 = __toESM(require_constants(), 1);
+  var import_constants12 = __toESM(require_constants(), 1);
   var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
   function getWebGLContextData(gl) {
     gl.luma = gl.luma || {};
@@ -5739,15 +5553,15 @@ ${htmlLog}
     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 {
@@ -5806,7 +5620,7 @@ ${htmlLog}
   }
 
   // src/adapter/resources/webgl-shader.ts
-  var import_constants14 = __toESM(require_constants(), 1);
+  var import_constants13 = __toESM(require_constants(), 1);
 
   // src/adapter/helpers/parse-shader-compiler-log.ts
   function parseShaderCompilerLog(errLog) {
@@ -5861,10 +5675,10 @@ ${htmlLog}
       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(import_constants13.GL.VERTEX_SHADER);
           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(import_constants13.GL.FRAGMENT_SHADER);
           break;
         default:
           throw new Error(this.props.stage);
@@ -5928,7 +5742,7 @@ ${source2}`;
       }
       const { gl } = this.device;
       for (; ; ) {
-        const complete = gl.getShaderParameter(this.handle, import_constants14.GL.COMPLETION_STATUS_KHR);
+        const complete = gl.getShaderParameter(this.handle, import_constants13.GL.COMPLETION_STATUS_KHR);
         if (complete) {
           return;
         }
@@ -5941,12 +5755,12 @@ ${source2}`;
      * 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, import_constants13.GL.COMPILE_STATUS) ? "success" : "error";
     }
   };
 
   // src/adapter/resources/webgl-render-pass.ts
-  var import_constants15 = __toESM(require_constants(), 1);
+  var import_constants14 = __toESM(require_constants(), 1);
   var GL_DEPTH_BUFFER_BIT = 256;
   var GL_STENCIL_BUFFER_BIT = 1024;
   var GL_COLOR_BUFFER_BIT = 16384;
@@ -5965,7 +5779,7 @@ ${source2}`;
     end() {
       popContextState(this.device.gl);
       if (this.props.framebuffer) {
-        setGLParameters(this.device, { framebuffer: null });
+        setGLParameters(this.device.gl, { framebuffer: null });
       }
     }
     pushDebugGroup(groupLabel) {
@@ -5989,7 +5803,7 @@ ${source2}`;
         glParameters.depthMask = !this.props.depthReadOnly;
       }
       glParameters.stencilMask = this.props.stencilReadOnly ? 0 : 1;
-      glParameters[import_constants15.GL.RASTERIZER_DISCARD] = this.props.discard;
+      glParameters[import_constants14.GL.RASTERIZER_DISCARD] = this.props.discard;
       if (parameters.viewport) {
         if (parameters.viewport.length >= 6) {
           glParameters.viewport = parameters.viewport.slice(0, 4);
@@ -6007,10 +5821,10 @@ ${source2}`;
       }
       if (parameters.stencilReference) {
         console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
-        parameters[import_constants15.GL.STENCIL_REF] = parameters.stencilReference;
+        parameters[import_constants14.GL.STENCIL_REF] = parameters.stencilReference;
       }
       this.glParameters = glParameters;
-      setGLParameters(this.device, glParameters);
+      setGLParameters(this.device.gl, glParameters);
     }
     beginOcclusionQuery(queryIndex) {
       const webglQuerySet = this.props.occlusionQuerySet;
@@ -6040,7 +5854,7 @@ ${source2}`;
         glParameters.clearStencil = this.props.clearStencil;
       }
       if (clearMask !== 0) {
-        withGLParameters(this.device, glParameters, () => {
+        withGLParameters(this.device.gl, glParameters, () => {
           this.device.gl.clear(clearMask);
         });
       }
@@ -6085,36 +5899,36 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-render-pipeline.ts
-  var import_constants22 = __toESM(require_constants(), 1);
+  var import_constants21 = __toESM(require_constants(), 1);
 
   // src/adapter/helpers/get-shader-layout.ts
-  var import_constants19 = __toESM(require_constants(), 1);
+  var import_constants18 = __toESM(require_constants(), 1);
 
   // src/classic/accessor.ts
-  var import_constants17 = __toESM(require_constants(), 1);
+  var import_constants16 = __toESM(require_constants(), 1);
 
   // src/classic/typed-array-utils.ts
-  var import_constants16 = __toESM(require_constants(), 1);
+  var import_constants15 = __toESM(require_constants(), 1);
   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 import_constants15.GL.FLOAT;
       case Uint16Array:
-        return import_constants16.GL.UNSIGNED_SHORT;
+        return import_constants15.GL.UNSIGNED_SHORT;
       case Uint32Array:
-        return import_constants16.GL.UNSIGNED_INT;
+        return import_constants15.GL.UNSIGNED_INT;
       case Uint8Array:
-        return import_constants16.GL.UNSIGNED_BYTE;
+        return import_constants15.GL.UNSIGNED_BYTE;
       case Uint8ClampedArray:
-        return import_constants16.GL.UNSIGNED_BYTE;
+        return import_constants15.GL.UNSIGNED_BYTE;
       case Int8Array:
-        return import_constants16.GL.BYTE;
+        return import_constants15.GL.BYTE;
       case Int16Array:
-        return import_constants16.GL.SHORT;
+        return import_constants15.GL.SHORT;
       case Int32Array:
-        return import_constants16.GL.INT;
+        return import_constants15.GL.INT;
       default:
         throw new Error(ERR_TYPE_DEDUCTION);
     }
@@ -6122,22 +5936,22 @@ ${source2}`;
   function getTypedArrayFromGLType(glType, options) {
     const { clamped = true } = options || {};
     switch (glType) {
-      case import_constants16.GL.FLOAT:
+      case import_constants15.GL.FLOAT:
         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 import_constants15.GL.UNSIGNED_SHORT:
+      case import_constants15.GL.UNSIGNED_SHORT_5_6_5:
+      case import_constants15.GL.UNSIGNED_SHORT_4_4_4_4:
+      case import_constants15.GL.UNSIGNED_SHORT_5_5_5_1:
         return Uint16Array;
-      case import_constants16.GL.UNSIGNED_INT:
+      case import_constants15.GL.UNSIGNED_INT:
         return Uint32Array;
-      case import_constants16.GL.UNSIGNED_BYTE:
+      case import_constants15.GL.UNSIGNED_BYTE:
         return clamped ? Uint8ClampedArray : Uint8Array;
-      case import_constants16.GL.BYTE:
+      case import_constants15.GL.BYTE:
         return Int8Array;
-      case import_constants16.GL.SHORT:
+      case import_constants15.GL.SHORT:
         return Int16Array;
-      case import_constants16.GL.INT:
+      case import_constants15.GL.INT:
         return Int32Array;
       default:
         throw new Error("Failed to deduce typed array type from GL constant");
@@ -6148,7 +5962,7 @@ ${source2}`;
   var DEFAULT_ACCESSOR_VALUES = {
     offset: 0,
     stride: 0,
-    type: import_constants17.GL.FLOAT,
+    type: import_constants16.GL.FLOAT,
     size: 1,
     divisor: 0,
     normalized: false,
@@ -6171,12 +5985,12 @@ ${source2}`;
     buffer;
     index;
     static getBytesPerElement(accessor) {
-      const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
+      const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.GL.FLOAT);
       return ArrayType.BYTES_PER_ELEMENT;
     }
     static getBytesPerVertex(accessor) {
       assert2(accessor.size);
-      const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
+      const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants16.GL.FLOAT);
       return ArrayType.BYTES_PER_ELEMENT * accessor.size;
     }
     // Combines (merges) a list of accessors. On top of default values
@@ -6207,7 +6021,7 @@ ${source2}`;
       props = 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 === import_constants16.GL.INT || props.type === import_constants16.GL.UNSIGNED_INT) {
           this.integer = true;
         }
       }
@@ -6271,62 +6085,62 @@ ${source2}`;
   };
 
   // src/adapter/helpers/decode-webgl-types.ts
-  var import_constants18 = __toESM(require_constants(), 1);
+  var import_constants17 = __toESM(require_constants(), 1);
   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
+    import_constants17.GL.SAMPLER_2D,
+    import_constants17.GL.SAMPLER_CUBE,
+    import_constants17.GL.SAMPLER_3D,
+    import_constants17.GL.SAMPLER_2D_SHADOW,
+    import_constants17.GL.SAMPLER_2D_ARRAY,
+    import_constants17.GL.SAMPLER_2D_ARRAY_SHADOW,
+    import_constants17.GL.SAMPLER_CUBE_SHADOW,
+    import_constants17.GL.INT_SAMPLER_2D,
+    import_constants17.GL.INT_SAMPLER_3D,
+    import_constants17.GL.INT_SAMPLER_CUBE,
+    import_constants17.GL.INT_SAMPLER_2D_ARRAY,
+    import_constants17.GL.UNSIGNED_INT_SAMPLER_2D,
+    import_constants17.GL.UNSIGNED_INT_SAMPLER_3D,
+    import_constants17.GL.UNSIGNED_INT_SAMPLER_CUBE,
+    import_constants17.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
   ];
   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"],
+    [import_constants17.GL.FLOAT]: [import_constants17.GL.FLOAT, 1, "float", "f32", "float32"],
+    [import_constants17.GL.FLOAT_VEC2]: [import_constants17.GL.FLOAT, 2, "vec2", "vec2<f32>", "float32x2"],
+    [import_constants17.GL.FLOAT_VEC3]: [import_constants17.GL.FLOAT, 3, "vec3", "vec3<f32>", "float32x3"],
+    [import_constants17.GL.FLOAT_VEC4]: [import_constants17.GL.FLOAT, 4, "vec4", "vec4<f32>", "float32x4"],
+    [import_constants17.GL.INT]: [import_constants17.GL.INT, 1, "int", "i32", "sint32"],
+    [import_constants17.GL.INT_VEC2]: [import_constants17.GL.INT, 2, "ivec2", "vec2<i32>", "sint32x2"],
+    [import_constants17.GL.INT_VEC3]: [import_constants17.GL.INT, 3, "ivec3", "vec3<i32>", "sint32x3"],
+    [import_constants17.GL.INT_VEC4]: [import_constants17.GL.INT, 4, "ivec4", "vec4<i32>", "sint32x4"],
+    [import_constants17.GL.UNSIGNED_INT]: [import_constants17.GL.UNSIGNED_INT, 1, "uint", "u32", "uint32"],
+    [import_constants17.GL.UNSIGNED_INT_VEC2]: [import_constants17.GL.UNSIGNED_INT, 2, "uvec2", "vec2<u32>", "uint32x2"],
+    [import_constants17.GL.UNSIGNED_INT_VEC3]: [import_constants17.GL.UNSIGNED_INT, 3, "uvec3", "vec3<u32>", "uint32x3"],
+    [import_constants17.GL.UNSIGNED_INT_VEC4]: [import_constants17.GL.UNSIGNED_INT, 4, "uvec4", "vec4<u32>", "uint32x4"],
+    [import_constants17.GL.BOOL]: [import_constants17.GL.FLOAT, 1, "bool", "f32", "float32"],
+    [import_constants17.GL.BOOL_VEC2]: [import_constants17.GL.FLOAT, 2, "bvec2", "vec2<f32>", "float32x2"],
+    [import_constants17.GL.BOOL_VEC3]: [import_constants17.GL.FLOAT, 3, "bvec3", "vec3<f32>", "float32x3"],
+    [import_constants17.GL.BOOL_VEC4]: [import_constants17.GL.FLOAT, 4, "bvec4", "vec4<f32>", "float32x4"],
     // TODO - are sizes/components below correct?
-    [import_constants18.GL.FLOAT_MAT2]: [import_constants18.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
+    [import_constants17.GL.FLOAT_MAT2]: [import_constants17.GL.FLOAT, 8, "mat2", "mat2x2<f32>"],
     // 4
-    [import_constants18.GL.FLOAT_MAT2x3]: [import_constants18.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
+    [import_constants17.GL.FLOAT_MAT2x3]: [import_constants17.GL.FLOAT, 8, "mat2x3", "mat2x3<f32>"],
     // 6
-    [import_constants18.GL.FLOAT_MAT2x4]: [import_constants18.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
+    [import_constants17.GL.FLOAT_MAT2x4]: [import_constants17.GL.FLOAT, 8, "mat2x4", "mat2x4<f32>"],
     // 8
-    [import_constants18.GL.FLOAT_MAT3x2]: [import_constants18.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
+    [import_constants17.GL.FLOAT_MAT3x2]: [import_constants17.GL.FLOAT, 12, "mat3x2", "mat3x2<f32>"],
     // 6
-    [import_constants18.GL.FLOAT_MAT3]: [import_constants18.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
+    [import_constants17.GL.FLOAT_MAT3]: [import_constants17.GL.FLOAT, 12, "mat3", "mat3x3<f32>"],
     // 9
-    [import_constants18.GL.FLOAT_MAT3x4]: [import_constants18.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
+    [import_constants17.GL.FLOAT_MAT3x4]: [import_constants17.GL.FLOAT, 12, "mat3x4", "mat3x4<f32>"],
     // 12
-    [import_constants18.GL.FLOAT_MAT4x2]: [import_constants18.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
+    [import_constants17.GL.FLOAT_MAT4x2]: [import_constants17.GL.FLOAT, 16, "mat4x2", "mat4x2<f32>"],
     // 8
-    [import_constants18.GL.FLOAT_MAT4x3]: [import_constants18.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
+    [import_constants17.GL.FLOAT_MAT4x3]: [import_constants17.GL.FLOAT, 16, "mat4x3", "mat4x3<f32>"],
     // 12
-    [import_constants18.GL.FLOAT_MAT4]: [import_constants18.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
+    [import_constants17.GL.FLOAT_MAT4]: [import_constants17.GL.FLOAT, 16, "mat4", "mat4x4<f32>"]
     // 16
   };
   function decodeGLUniformType(glUniformType) {
@@ -6428,7 +6242,7 @@ ${source2}`;
   }
   function readVaryings(gl, program) {
     const varyings = [];
-    const count = gl.getProgramParameter(program, import_constants19.GL.TRANSFORM_FEEDBACK_VARYINGS);
+    const count = gl.getProgramParameter(program, import_constants18.GL.TRANSFORM_FEEDBACK_VARYINGS);
     for (let location = 0; location < count; location++) {
       const activeInfo = gl.getTransformFeedbackVarying(program, location);
       if (!activeInfo) {
@@ -6445,7 +6259,7 @@ ${source2}`;
   }
   function readUniformBindings(gl, program) {
     const uniforms = [];
-    const uniformCount = gl.getProgramParameter(program, import_constants19.GL.ACTIVE_UNIFORMS);
+    const uniformCount = gl.getProgramParameter(program, import_constants18.GL.ACTIVE_UNIFORMS);
     for (let i = 0; i < uniformCount; i++) {
       const activeInfo = gl.getActiveUniform(program, i);
       if (!activeInfo) {
@@ -6481,22 +6295,22 @@ ${source2}`;
   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, import_constants18.GL.ACTIVE_UNIFORM_BLOCKS);
     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, import_constants18.GL.UNIFORM_BLOCK_BINDING),
+        byteLength: getBlockParameter(blockIndex, import_constants18.GL.UNIFORM_BLOCK_DATA_SIZE),
+        vertex: getBlockParameter(blockIndex, import_constants18.GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
+        fragment: getBlockParameter(blockIndex, import_constants18.GL.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),
+        uniformCount: getBlockParameter(blockIndex, import_constants18.GL.UNIFORM_BLOCK_ACTIVE_UNIFORMS),
         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, import_constants18.GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) || [];
+      const uniformType = gl.getActiveUniforms(program, uniformIndices, import_constants18.GL.UNIFORM_TYPE);
+      const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, import_constants18.GL.UNIFORM_SIZE);
+      const uniformOffset = gl.getActiveUniforms(program, uniformIndices, import_constants18.GL.UNIFORM_OFFSET);
+      const uniformStride = gl.getActiveUniforms(program, uniformIndices, import_constants18.GL.UNIFORM_ARRAY_STRIDE);
       for (let i = 0; i < blockInfo.uniformCount; ++i) {
         const activeInfo = gl.getActiveUniform(program, uniformIndices[i]);
         if (!activeInfo) {
@@ -6519,21 +6333,21 @@ ${source2}`;
     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"]
+    [import_constants18.GL.SAMPLER_2D]: ["2d", "float"],
+    [import_constants18.GL.SAMPLER_CUBE]: ["cube", "float"],
+    [import_constants18.GL.SAMPLER_3D]: ["3d", "float"],
+    [import_constants18.GL.SAMPLER_2D_SHADOW]: ["3d", "depth"],
+    [import_constants18.GL.SAMPLER_2D_ARRAY]: ["2d-array", "float"],
+    [import_constants18.GL.SAMPLER_2D_ARRAY_SHADOW]: ["2d-array", "depth"],
+    [import_constants18.GL.SAMPLER_CUBE_SHADOW]: ["cube", "float"],
+    [import_constants18.GL.INT_SAMPLER_2D]: ["2d", "sint"],
+    [import_constants18.GL.INT_SAMPLER_3D]: ["3d", "sint"],
+    [import_constants18.GL.INT_SAMPLER_CUBE]: ["cube", "sint"],
+    [import_constants18.GL.INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"],
+    [import_constants18.GL.UNSIGNED_INT_SAMPLER_2D]: ["2d", "uint"],
+    [import_constants18.GL.UNSIGNED_INT_SAMPLER_3D]: ["3d", "uint"],
+    [import_constants18.GL.UNSIGNED_INT_SAMPLER_CUBE]: ["cube", "uint"],
+    [import_constants18.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY]: ["2d-array", "uint"]
   };
   function getSamplerInfo(type) {
     const sampler = SAMPLER_UNIFORMS_GL_TO_GPU[type];
@@ -6564,7 +6378,7 @@ ${source2}`;
   }
 
   // src/adapter/helpers/set-uniform.ts
-  var import_constants20 = __toESM(require_constants(), 1);
+  var import_constants19 = __toESM(require_constants(), 1);
   function setUniform(gl, location, type, value) {
     const gl2 = gl;
     let uniformValue = value;
@@ -6576,97 +6390,97 @@ ${source2}`;
     }
     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 import_constants19.GL.SAMPLER_2D:
+      case import_constants19.GL.SAMPLER_CUBE:
+      case import_constants19.GL.SAMPLER_3D:
+      case import_constants19.GL.SAMPLER_2D_SHADOW:
+      case import_constants19.GL.SAMPLER_2D_ARRAY:
+      case import_constants19.GL.SAMPLER_2D_ARRAY_SHADOW:
+      case import_constants19.GL.SAMPLER_CUBE_SHADOW:
+      case import_constants19.GL.INT_SAMPLER_2D:
+      case import_constants19.GL.INT_SAMPLER_3D:
+      case import_constants19.GL.INT_SAMPLER_CUBE:
+      case import_constants19.GL.INT_SAMPLER_2D_ARRAY:
+      case import_constants19.GL.UNSIGNED_INT_SAMPLER_2D:
+      case import_constants19.GL.UNSIGNED_INT_SAMPLER_3D:
+      case import_constants19.GL.UNSIGNED_INT_SAMPLER_CUBE:
+      case import_constants19.GL.UNSIGNED_INT_SAMPLER_2D_ARRAY:
         if (typeof value !== "number") {
           throw new Error("samplers must be set to integers");
         }
         return gl.uniform1i(location, value);
-      case import_constants20.GL.FLOAT:
+      case import_constants19.GL.FLOAT:
         return gl.uniform1fv(location, arrayValue);
-      case import_constants20.GL.FLOAT_VEC2:
+      case import_constants19.GL.FLOAT_VEC2:
         return gl.uniform2fv(location, arrayValue);
-      case import_constants20.GL.FLOAT_VEC3:
+      case import_constants19.GL.FLOAT_VEC3:
         return gl.uniform3fv(location, arrayValue);
-      case import_constants20.GL.FLOAT_VEC4:
+      case import_constants19.GL.FLOAT_VEC4:
         return gl.uniform4fv(location, arrayValue);
-      case import_constants20.GL.INT:
+      case import_constants19.GL.INT:
         return gl.uniform1iv(location, arrayValue);
-      case import_constants20.GL.INT_VEC2:
+      case import_constants19.GL.INT_VEC2:
         return gl.uniform2iv(location, arrayValue);
-      case import_constants20.GL.INT_VEC3:
+      case import_constants19.GL.INT_VEC3:
         return gl.uniform3iv(location, arrayValue);
-      case import_constants20.GL.INT_VEC4:
+      case import_constants19.GL.INT_VEC4:
         return gl.uniform4iv(location, arrayValue);
-      case import_constants20.GL.BOOL:
+      case import_constants19.GL.BOOL:
         return gl.uniform1iv(location, arrayValue);
-      case import_constants20.GL.BOOL_VEC2:
+      case import_constants19.GL.BOOL_VEC2:
         return gl.uniform2iv(location, arrayValue);
-      case import_constants20.GL.BOOL_VEC3:
+      case import_constants19.GL.BOOL_VEC3:
         return gl.uniform3iv(location, arrayValue);
-      case import_constants20.GL.BOOL_VEC4:
+      case import_constants19.GL.BOOL_VEC4:
         return gl.uniform4iv(location, arrayValue);
-      case import_constants20.GL.UNSIGNED_INT:
+      case import_constants19.GL.UNSIGNED_INT:
         return gl2.uniform1uiv(location, arrayValue, 1);
-      case import_constants20.GL.UNSIGNED_INT_VEC2:
+      case import_constants19.GL.UNSIGNED_INT_VEC2:
         return gl2.uniform2uiv(location, arrayValue, 2);
-      case import_constants20.GL.UNSIGNED_INT_VEC3:
+      case import_constants19.GL.UNSIGNED_INT_VEC3:
         return gl2.uniform3uiv(location, arrayValue, 3);
-      case import_constants20.GL.UNSIGNED_INT_VEC4:
+      case import_constants19.GL.UNSIGNED_INT_VEC4:
         return gl2.uniform4uiv(location, arrayValue, 4);
-      case import_constants20.GL.FLOAT_MAT2:
+      case import_constants19.GL.FLOAT_MAT2:
         return gl.uniformMatrix2fv(location, false, arrayValue);
-      case import_constants20.GL.FLOAT_MAT3:
+      case import_constants19.GL.FLOAT_MAT3:
         return gl.uniformMatrix3fv(location, false, arrayValue);
-      case import_constants20.GL.FLOAT_MAT4:
+      case import_constants19.GL.FLOAT_MAT4:
         return gl.uniformMatrix4fv(location, false, arrayValue);
-      case import_constants20.GL.FLOAT_MAT2x3:
+      case import_constants19.GL.FLOAT_MAT2x3:
         return gl2.uniformMatrix2x3fv(location, false, arrayValue);
-      case import_constants20.GL.FLOAT_MAT2x4:
+      case import_constants19.GL.FLOAT_MAT2x4:
         return gl2.uniformMatrix2x4fv(location, false, arrayValue);
-      case import_constants20.GL.FLOAT_MAT3x2:
+      case import_constants19.GL.FLOAT_MAT3x2:
         return gl2.uniformMatrix3x2fv(location, false, arrayValue);
-      case import_constants20.GL.FLOAT_MAT3x4:
+      case import_constants19.GL.FLOAT_MAT3x4:
         return gl2.uniformMatrix3x4fv(location, false, arrayValue);
-      case import_constants20.GL.FLOAT_MAT4x2:
+      case import_constants19.GL.FLOAT_MAT4x2:
         return gl2.uniformMatrix4x2fv(location, false, arrayValue);
-      case import_constants20.GL.FLOAT_MAT4x3:
+      case import_constants19.GL.FLOAT_MAT4x3:
         return gl2.uniformMatrix4x3fv(location, false, arrayValue);
     }
     throw new Error("Illegal uniform");
   }
 
   // src/adapter/helpers/webgl-topology-utils.ts
-  var import_constants21 = __toESM(require_constants(), 1);
+  var import_constants20 = __toESM(require_constants(), 1);
   function getGLDrawMode(topology) {
     switch (topology) {
       case "point-list":
-        return import_constants21.GL.POINTS;
+        return import_constants20.GL.POINTS;
       case "line-list":
-        return import_constants21.GL.LINES;
+        return import_constants20.GL.LINES;
       case "line-strip":
-        return import_constants21.GL.LINE_STRIP;
+        return import_constants20.GL.LINE_STRIP;
       case "line-loop-webgl":
-        return import_constants21.GL.LINE_LOOP;
+        return import_constants20.GL.LINE_LOOP;
       case "triangle-list":
-        return import_constants21.GL.TRIANGLES;
+        return import_constants20.GL.TRIANGLES;
       case "triangle-strip":
-        return import_constants21.GL.TRIANGLE_STRIP;
+        return import_constants20.GL.TRIANGLE_STRIP;
       case "triangle-fan-webgl":
-        return import_constants21.GL.TRIANGLE_FAN;
+        return import_constants20.GL.TRIANGLE_FAN;
       default:
         throw new Error(topology);
     }
@@ -6674,19 +6488,19 @@ ${source2}`;
   function getGLPrimitive(topology) {
     switch (topology) {
       case "point-list":
-        return import_constants21.GL.POINTS;
+        return import_constants20.GL.POINTS;
       case "line-list":
-        return import_constants21.GL.LINES;
+        return import_constants20.GL.LINES;
       case "line-strip":
-        return import_constants21.GL.LINES;
+        return import_constants20.GL.LINES;
       case "line-loop-webgl":
-        return import_constants21.GL.LINES;
+        return import_constants20.GL.LINES;
       case "triangle-list":
-        return import_constants21.GL.TRIANGLES;
+        return import_constants20.GL.TRIANGLES;
       case "triangle-strip":
-        return import_constants21.GL.TRIANGLES;
+        return import_constants20.GL.TRIANGLES;
       case "triangle-fan-webgl":
-        return import_constants21.GL.TRIANGLES;
+        return import_constants20.GL.TRIANGLES;
       default:
         throw new Error(topology);
     }
@@ -6721,7 +6535,7 @@ ${source2}`;
       this.device.setSpectorMetadata(this.handle, { id: this.props.id });
       this.vs = cast(props.vs);
       this.fs = cast(props.fs);
-      const { varyings, bufferMode = import_constants22.GL.SEPARATE_ATTRIBS } = props;
+      const { varyings, bufferMode = import_constants21.GL.SEPARATE_ATTRIBS } = props;
       if (varyings && varyings.length > 0) {
         this.varyings = varyings;
         this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
@@ -6789,9 +6603,6 @@ ${source2}`;
      * This function unifies those ways into a single call using common parameters with sane defaults
      */
     draw(options) {
-      if (this.linkStatus !== "success") {
-        return false;
-      }
       const {
         renderPass,
         vertexArray,
@@ -6808,9 +6619,18 @@ ${source2}`;
       const isIndexed = Boolean(vertexArray.indexBuffer);
       const glIndexType = vertexArray.indexBuffer?.glIndexType;
       const isInstanced = Number(instanceCount) > 0;
+      if (this.linkStatus !== "success") {
+        log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+        return false;
+      }
       if (!this._areTexturesRenderable() || vertexCount === 0) {
+        log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
         return false;
       }
+      if (vertexCount === 0) {
+        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) {
@@ -6936,7 +6756,7 @@ ${source2}`;
       }
       const { gl } = this.device;
       for (; ; ) {
-        const complete = gl.getProgramParameter(this.handle, import_constants22.GL.COMPLETION_STATUS_KHR);
+        const complete = gl.getProgramParameter(this.handle, import_constants21.GL.COMPLETION_STATUS_KHR);
         if (complete) {
           return;
         }
@@ -6976,15 +6796,15 @@ ${source2}`;
           case "uniform":
             const { name: name2 } = binding;
             const location = gl.getUniformBlockIndex(this.handle, name2);
-            if (location === import_constants22.GL.INVALID_INDEX) {
+            if (location === import_constants21.GL.INVALID_INDEX) {
               throw new Error(`Invalid uniform block name ${name2}`);
             }
             gl.uniformBlockBinding(this.handle, uniformBufferIndex, location);
             if (value instanceof WEBGLBuffer) {
-              gl.bindBufferBase(import_constants22.GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
+              gl.bindBufferBase(import_constants21.GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
             } else {
               gl.bindBufferRange(
-                import_constants22.GL.UNIFORM_BUFFER,
+                import_constants21.GL.UNIFORM_BUFFER,
                 uniformBufferIndex,
                 // @ts-expect-error
                 value.buffer.handle,
@@ -7013,7 +6833,7 @@ ${source2}`;
             } else {
               throw new Error("No texture");
             }
-            gl.activeTexture(import_constants22.GL.TEXTURE0 + textureUnit);
+            gl.activeTexture(import_constants21.GL.TEXTURE0 + textureUnit);
             gl.bindTexture(texture.target, texture.handle);
             textureUnit += 1;
             break;
@@ -7041,7 +6861,7 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-command-buffer.ts
-  var import_constants23 = __toESM(require_constants(), 1);
+  var import_constants22 = __toESM(require_constants(), 1);
   function cast2(value) {
     return value;
   }
@@ -7074,17 +6894,17 @@ ${source2}`;
   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.bindBuffer(import_constants22.GL.COPY_READ_BUFFER, source.handle);
+    device.gl.bindBuffer(import_constants22.GL.COPY_WRITE_BUFFER, destination.handle);
     device.gl.copyBufferSubData(
-      import_constants23.GL.COPY_READ_BUFFER,
-      import_constants23.GL.COPY_WRITE_BUFFER,
+      import_constants22.GL.COPY_READ_BUFFER,
+      import_constants22.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(import_constants22.GL.COPY_READ_BUFFER, null);
+    device.gl.bindBuffer(import_constants22.GL.COPY_WRITE_BUFFER, null);
   }
   function _copyBufferToTexture(device, options) {
     throw new Error("Not implemented");
@@ -7134,8 +6954,8 @@ ${source2}`;
       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(import_constants22.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
+      device.gl.bindFramebuffer(import_constants22.GL.FRAMEBUFFER, framebuffer.handle);
       device.gl.readPixels(
         origin[0],
         origin[1],
@@ -7146,8 +6966,8 @@ ${source2}`;
         byteOffset
       );
     } finally {
-      device.gl.bindBuffer(import_constants23.GL.PIXEL_PACK_BUFFER, null);
-      device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, null);
+      device.gl.bindBuffer(import_constants22.GL.PIXEL_PACK_BUFFER, null);
+      device.gl.bindFramebuffer(import_constants22.GL.FRAMEBUFFER, null);
       if (destroyFramebuffer) {
         framebuffer.destroy();
       }
@@ -7178,11 +6998,11 @@ ${source2}`;
       // depthOrArrayLayers = 0
     } = options;
     const destinationMipmaplevel = 0;
-    const destinationInternalFormat = import_constants23.GL.RGBA;
+    const destinationInternalFormat = import_constants22.GL.RGBA;
     const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
     const [sourceX, sourceY] = origin;
     const isSubCopy = false;
-    device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, framebuffer.handle);
+    device.gl.bindFramebuffer(import_constants22.GL.FRAMEBUFFER, framebuffer.handle);
     let texture = null;
     let textureTarget;
     if (destination instanceof WEBGLTexture) {
@@ -7270,7 +7090,7 @@ ${source2}`;
   };
 
   // src/adapter/resources/webgl-vertex-array.ts
-  var import_constants24 = __toESM(require_constants(), 1);
+  var import_constants23 = __toESM(require_constants(), 1);
   var WEBGLVertexArray = class extends VertexArray {
     get [Symbol.toStringTag]() {
       return "VertexArray";
@@ -7308,22 +7128,22 @@ ${source2}`;
      */
     setIndexBuffer(indexBuffer) {
       const buffer = indexBuffer;
-      if (buffer && buffer.glTarget !== import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
+      if (buffer && buffer.glTarget !== import_constants23.GL.ELEMENT_ARRAY_BUFFER) {
         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(import_constants23.GL.ELEMENT_ARRAY_BUFFER, 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 === import_constants23.GL.ELEMENT_ARRAY_BUFFER) {
         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(import_constants23.GL.ARRAY_BUFFER, buffer.handle);
       if (integer) {
         this.device.gl.vertexAttribIPointer(location, size, type, stride, offset);
       } else {
@@ -7343,7 +7163,7 @@ ${source2}`;
       this.device.gl.bindVertexArray(this.handle);
       if (!this.init) {
         const webglBuffer = this.indexBuffer;
-        this.device.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, webglBuffer?.handle || null);
+        this.device.gl.bindBuffer(import_constants23.GL.ELEMENT_ARRAY_BUFFER, webglBuffer?.handle || null);
         this.init = true;
       }
       this._applyConstantAttributes();
@@ -7469,7 +7289,7 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-transform-feedback.ts
-  var import_constants25 = __toESM(require_constants(), 1);
+  var import_constants24 = __toESM(require_constants(), 1);
   var WEBGLTransformFeedback = class extends TransformFeedback {
     device;
     gl;
@@ -7505,7 +7325,7 @@ ${source2}`;
       super.destroy();
     }
     begin(topology = "point-list") {
-      this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, this.handle);
+      this.gl.bindTransformFeedback(import_constants24.GL.TRANSFORM_FEEDBACK, this.handle);
       if (this.bindOnUse) {
         this._bindBuffers();
       }
@@ -7516,7 +7336,7 @@ ${source2}`;
       if (!this.bindOnUse) {
         this._unbindBuffers();
       }
-      this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, null);
+      this.gl.bindTransformFeedback(import_constants24.GL.TRANSFORM_FEEDBACK, null);
     }
     // SUBCLASS
     setBuffers(buffers) {
@@ -7550,16 +7370,16 @@ ${source2}`;
     }
     bind(funcOrHandle = this.handle) {
       if (typeof funcOrHandle !== "function") {
-        this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, funcOrHandle);
+        this.gl.bindTransformFeedback(import_constants24.GL.TRANSFORM_FEEDBACK, funcOrHandle);
         return this;
       }
       let value;
       if (!this._bound) {
-        this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, this.handle);
+        this.gl.bindTransformFeedback(import_constants24.GL.TRANSFORM_FEEDBACK, this.handle);
         this._bound = true;
         value = funcOrHandle();
         this._bound = false;
-        this.gl.bindTransformFeedback(import_constants25.GL.TRANSFORM_FEEDBACK, null);
+        this.gl.bindTransformFeedback(import_constants24.GL.TRANSFORM_FEEDBACK, null);
       } else {
         value = funcOrHandle();
       }
@@ -7600,15 +7420,15 @@ ${source2}`;
     }
     _unbindBuffers() {
       for (const bufferIndex in this.buffers) {
-        this.gl.bindBufferBase(import_constants25.GL.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);
+        this.gl.bindBufferBase(import_constants24.GL.TRANSFORM_FEEDBACK_BUFFER, 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(import_constants24.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);
       } else {
-        this.gl.bindBufferRange(import_constants25.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
+        this.gl.bindBufferRange(import_constants24.GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
       }
     }
   };
@@ -7620,7 +7440,7 @@ ${source2}`;
   }
 
   // src/adapter/resources/webgl-query-set.ts
-  var import_constants26 = __toESM(require_constants(), 1);
+  var import_constants25 = __toESM(require_constants(), 1);
   var WEBGLQuerySet = class extends QuerySet {
     device;
     handle;
@@ -7650,7 +7470,7 @@ ${source2}`;
      * GPU instruction stream.
      */
     beginTimestampQuery() {
-      return this._begin(import_constants26.GL.TIME_ELAPSED_EXT);
+      return this._begin(import_constants25.GL.TIME_ELAPSED_EXT);
     }
     endTimestampQuery() {
       this._end();
@@ -7658,7 +7478,7 @@ ${source2}`;
     // Shortcut for occlusion queries
     beginOcclusionQuery(options) {
       return this._begin(
-        options?.conservative ? import_constants26.GL.ANY_SAMPLES_PASSED_CONSERVATIVE : import_constants26.GL.ANY_SAMPLES_PASSED
+        options?.conservative ? import_constants25.GL.ANY_SAMPLES_PASSED_CONSERVATIVE : import_constants25.GL.ANY_SAMPLES_PASSED
       );
     }
     endOcclusionQuery() {
@@ -7666,7 +7486,7 @@ ${source2}`;
     }
     // Shortcut for transformFeedbackQuery
     beginTransformFeedbackQuery() {
-      return this._begin(import_constants26.GL.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
+      return this._begin(import_constants25.GL.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
     }
     endTransformFeedbackQuery() {
       this._end();
@@ -7710,7 +7530,7 @@ ${source2}`;
       }
       const resultAvailable = this.device.gl.getQueryParameter(
         this.handle,
-        import_constants26.GL.QUERY_RESULT_AVAILABLE
+        import_constants25.GL.QUERY_RESULT_AVAILABLE
       );
       if (resultAvailable) {
         this._queryPending = false;
@@ -7719,11 +7539,11 @@ ${source2}`;
     }
     // Timing query is disjoint, i.e. results are invalid
     isTimerDisjoint() {
-      return this.device.gl.getParameter(import_constants26.GL.GPU_DISJOINT_EXT);
+      return this.device.gl.getParameter(import_constants25.GL.GPU_DISJOINT_EXT);
     }
     // Returns query result.
     getResult() {
-      return this.device.gl.getQueryParameter(this.handle, import_constants26.GL.QUERY_RESULT);
+      return this.device.gl.getQueryParameter(this.handle, import_constants25.GL.QUERY_RESULT);
     }
     // Returns the query result, converted to milliseconds to match JavaScript conventions.
     getTimerMilliseconds() {
@@ -7754,24 +7574,24 @@ ${source2}`;
   };
 
   // src/classic/copy-and-blit.ts
-  var import_constants28 = __toESM(require_constants(), 1);
+  var import_constants27 = __toESM(require_constants(), 1);
 
   // src/classic/format-utils.ts
-  var import_constants27 = __toESM(require_constants(), 1);
+  var import_constants26 = __toESM(require_constants(), 1);
   function glFormatToComponents(format) {
     switch (format) {
-      case import_constants27.GL.ALPHA:
-      case import_constants27.GL.R32F:
-      case import_constants27.GL.RED:
+      case import_constants26.GL.ALPHA:
+      case import_constants26.GL.R32F:
+      case import_constants26.GL.RED:
         return 1;
-      case import_constants27.GL.RG32F:
-      case import_constants27.GL.RG:
+      case import_constants26.GL.RG32F:
+      case import_constants26.GL.RG:
         return 2;
-      case import_constants27.GL.RGB:
-      case import_constants27.GL.RGB32F:
+      case import_constants26.GL.RGB:
+      case import_constants26.GL.RGB32F:
         return 3;
-      case import_constants27.GL.RGBA:
-      case import_constants27.GL.RGBA32F:
+      case import_constants26.GL.RGBA:
+      case import_constants26.GL.RGBA32F:
         return 4;
       default:
         assert2(false);
@@ -7780,13 +7600,13 @@ ${source2}`;
   }
   function glTypeToBytes(type) {
     switch (type) {
-      case import_constants27.GL.UNSIGNED_BYTE:
+      case import_constants26.GL.UNSIGNED_BYTE:
         return 1;
-      case import_constants27.GL.UNSIGNED_SHORT_5_6_5:
-      case import_constants27.GL.UNSIGNED_SHORT_4_4_4_4:
-      case import_constants27.GL.UNSIGNED_SHORT_5_5_5_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:
         return 2;
-      case import_constants27.GL.FLOAT:
+      case import_constants26.GL.FLOAT:
         return 4;
       default:
         assert2(false);
@@ -7799,8 +7619,8 @@ ${source2}`;
     const {
       sourceX = 0,
       sourceY = 0,
-      sourceFormat = import_constants28.GL.RGBA,
-      sourceAttachment = import_constants28.GL.COLOR_ATTACHMENT0
+      sourceFormat = import_constants27.GL.RGBA,
+      sourceAttachment = import_constants27.GL.COLOR_ATTACHMENT0
       // TODO - support gl.readBuffer
     } = options || {};
     let {
@@ -7815,13 +7635,13 @@ ${source2}`;
     const { gl, handle } = framebuffer;
     sourceWidth = sourceWidth || framebuffer.width;
     sourceHeight = sourceHeight || framebuffer.height;
-    const attachment = sourceAttachment - import_constants28.GL.COLOR_ATTACHMENT0;
-    sourceType = sourceType || framebuffer.colorAttachments[attachment]?.texture?.type || import_constants28.GL.UNSIGNED_BYTE;
+    const attachment = sourceAttachment - import_constants27.GL.COLOR_ATTACHMENT0;
+    sourceType = sourceType || framebuffer.colorAttachments[attachment]?.texture?.type || import_constants27.GL.UNSIGNED_BYTE;
     target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
     sourceType = sourceType || getGLTypeFromTypedArray(target);
-    const prevHandle = gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
+    const prevHandle = gl.bindFramebuffer(import_constants27.GL.FRAMEBUFFER, handle);
     gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-    gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle || null);
+    gl.bindFramebuffer(import_constants27.GL.FRAMEBUFFER, prevHandle || null);
     if (deleteFramebuffer) {
       framebuffer.destroy();
     }
@@ -7832,7 +7652,7 @@ ${source2}`;
       target,
       sourceX = 0,
       sourceY = 0,
-      sourceFormat = import_constants28.GL.RGBA,
+      sourceFormat = import_constants27.GL.RGBA,
       targetByteOffset = 0
     } = options || {};
     let { sourceWidth, sourceHeight, sourceType } = options || {};
@@ -7841,7 +7661,7 @@ ${source2}`;
     sourceWidth = sourceWidth || framebuffer.width;
     sourceHeight = sourceHeight || framebuffer.height;
     const webglFramebuffer = framebuffer;
-    sourceType = sourceType || import_constants28.GL.UNSIGNED_BYTE;
+    sourceType = sourceType || import_constants27.GL.UNSIGNED_BYTE;
     let webglBufferTarget = target;
     if (!webglBufferTarget) {
       const components = glFormatToComponents(sourceFormat);
@@ -7885,7 +7705,7 @@ ${source2}`;
     if (pixelArray) {
       return pixelArray;
     }
-    type = type || import_constants28.GL.UNSIGNED_BYTE;
+    type = type || import_constants27.GL.UNSIGNED_BYTE;
     const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
     const components = glFormatToComponents(format);
     return new ArrayType(width * height * components);
@@ -7922,8 +7742,8 @@ ${source2}`;
       }
     }
     assert2(clearFlags !== 0, ERR_ARGUMENTS);
-    withGLParameters(device, parameters, () => {
-      const gl = device.gl;
+    const gl = device.gl;
+    withGLParameters(gl, parameters, () => {
       gl.clear(clearFlags);
     });
   }
@@ -7931,9 +7751,8 @@ ${source2}`;
   // src/adapter/webgl-device.ts
   var LOG_LEVEL2 = 1;
   var _WebGLDevice = class extends Device {
-    static isSupported() {
-      return typeof WebGL2RenderingContext !== "undefined";
-    }
+    /** type of this device */
+    type = "webgl";
     /** The underlying WebGL context */
     handle;
     features;
@@ -7945,6 +7764,10 @@ ${source2}`;
     //
     // 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
@@ -7975,13 +7798,19 @@ ${source2}`;
       if (typeof props.canvas === "string") {
         promises.push(CanvasContext.pageLoaded);
       }
-      await Promise.all(promises);
+      const results = await Promise.allSettled(promises);
+      for (const result of results) {
+        if (result.status === "rejected") {
+          log.error(`Failed to initialize debug libraries ${result.reason}`)();
+        }
+      }
       log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
       if (props.gl?.device) {
+        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}`;
+      const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
       log.probe(LOG_LEVEL2, message2)();
       log.table(LOG_LEVEL2, device.info)();
       log.groupEnd(LOG_LEVEL2)();
@@ -8017,8 +7846,11 @@ ${source2}`;
       this.gl.device = this;
       this.gl._version = 2;
       this.info = getDeviceInfo(this.gl, this._extensions);
-      this.features = new WebGLDeviceFeatures(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, {
@@ -8102,12 +7934,6 @@ ${source2}`;
       throw new Error("ComputePass not supported in WebGL");
     }
     renderPass = null;
-    getDefaultRenderPass() {
-      this.renderPass = this.renderPass || this.beginRenderPass({
-        framebuffer: this.canvasContext.getCurrentFramebuffer()
-      });
-      return this.renderPass;
-    }
     createCommandEncoder(props) {
       return new WEBGLCommandEncoder(this, props);
     }
@@ -8132,13 +7958,13 @@ ${source2}`;
       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);
@@ -8247,6 +8073,7 @@ ${source2}`;
   //
   // Public `Device` API
   //
+  /** type of this device */
   __publicField(WebGLDevice, "type", "webgl");
   function isWebGL(gl) {
     if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
@@ -8289,6 +8116,216 @@ ${source2}`;
     }
     return true;
   }
+
+  // src/adapter/objects/webgl-resource.ts
+  var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
+  var WebGLResource = class extends 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 || uid(this.constructor.name);
+      this._handle = 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 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);
+    }
+    // PRIVATE METHODS
+    /*
+      _addStats() {
+        const name = this.constructor.name;
+        const stats = lumaStats.get('Resource Counts');
+    
+        stats.get('Resources Created').incrementCount();
+        stats.get(`${name}s Created`).incrementCount();
+        stats.get(`${name}s Active`).incrementCount();
+      }
+    
+      _removeStats() {
+        const name = this.constructor.name;
+        const stats = lumaStats.get('Resource Counts');
+    
+        stats.get(`${name}s Active`).decrementCount();
+      }
+    
+      trackAllocatedMemory(bytes, name = this.constructor.name) {
+        const stats = lumaStats.get('Memory Usage');
+    
+        stats.get('GPU Memory').addCount(bytes);
+        stats.get(`${name} Memory`).addCount(bytes);
+        this.byteLength = bytes;
+      }
+    
+      trackDeallocatedMemory(name = this.constructor.name) {
+        const stats = lumaStats.get('Memory Usage');
+    
+        stats.get('GPU Memory').subtractCount(this.byteLength);
+        stats.get(`${name} Memory`).subtractCount(this.byteLength);
+        this.byteLength = 0;
+      }
+      */
+  };
+
+  // src/adapter/objects/webgl-renderbuffer.ts
+  var import_constants28 = __toESM(require_constants(), 1);
+  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;
+      assert2(format, "Needs format");
+      this.trackDeallocatedMemory();
+      this.gl.bindRenderbuffer(import_constants28.GL.RENDERBUFFER, this.handle);
+      if (samples !== 0) {
+        this.gl.renderbufferStorageMultisample(
+          import_constants28.GL.RENDERBUFFER,
+          samples,
+          this.glFormat,
+          width,
+          height
+        );
+      } else {
+        this.gl.renderbufferStorage(import_constants28.GL.RENDERBUFFER, this.glFormat, width, height);
+      }
+      this.gl.bindRenderbuffer(import_constants28.GL.RENDERBUFFER, 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(import_constants28.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
+  });
   return __toCommonJS(src_exports);
 })();
       return __exports__;