@luma.gl/webgl 9.0.0-beta.5 → 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) {
@@ -856,7 +814,9 @@ var __exports__ = (() => {
     const VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "running from source";
     const STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering";
     if (globalThis.luma && globalThis.luma.VERSION !== VERSION3) {
-      throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION3}`);
+      throw new Error(
+        `luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION3}`
+      );
     }
     if (!globalThis.luma) {
       if (isBrowser()) {
@@ -952,20 +912,20 @@ var __exports__ = (() => {
       return this.props;
     }
     // ATTACHED RESOURCES
-    /** 
+    /**
      * Attaches a resource. Attached resources are auto destroyed when this resource is destroyed
      * Called automatically when sub resources are auto created but can be called by application
      */
     attachResource(resource) {
       this._attachedResources.add(resource);
     }
-    /** 
+    /**
      * Detach an attached resource. The resource will no longer be auto-destroyed when this resource is destroyed.
      */
     detachResource(resource) {
       this._attachedResources.delete(resource);
     }
-    /** 
+    /**
      * Destroys a resource (only if owned), and removes from the owned (auto-destroy) list for this resource.
      */
     destroyAttachedResource(resource) {
@@ -1041,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) {
@@ -1053,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) {
@@ -1063,7 +1026,10 @@ var __exports__ = (() => {
     /** This doesn't handle partial non-zero offset updates correctly */
     _setDebugData(data, byteOffset, byteLength) {
       const buffer = ArrayBuffer.isView(data) ? data.buffer : data;
-      const debugDataLength = Math.min(data ? data.byteLength : byteLength, _Buffer.DEBUG_DATA_MAX_LENGTH);
+      const debugDataLength = Math.min(
+        data ? data.byteLength : byteLength,
+        _Buffer.DEBUG_DATA_MAX_LENGTH
+      );
       if (data === null) {
         this.debugData = new ArrayBuffer(debugDataLength);
       } else if (byteOffset === 0 && byteLength === data.byteLength) {
@@ -1103,7 +1069,142 @@ var __exports__ = (() => {
   /** Max amount of debug data saved. Two vec4's */
   __publicField(Buffer2, "DEBUG_DATA_MAX_LENGTH", 32);
 
+  // ../core/src/adapter/type-utils/decode-data-type.ts
+  function decodeVertexType(type) {
+    const dataType = TYPE_MAP[type];
+    const bytes = getDataTypeBytes(dataType);
+    const normalized = type.includes("norm");
+    const integer = !normalized && !type.startsWith("float");
+    const signed = type.startsWith("s");
+    return {
+      dataType: TYPE_MAP[type],
+      byteLength: bytes,
+      integer,
+      signed,
+      normalized
+    };
+  }
+  function getDataTypeBytes(type) {
+    const bytes = TYPE_SIZES[type];
+    return bytes;
+  }
+  var TYPE_MAP = {
+    uint8: "uint8",
+    sint8: "sint8",
+    unorm8: "uint8",
+    snorm8: "sint8",
+    uint16: "uint16",
+    sint16: "sint16",
+    unorm16: "uint16",
+    snorm16: "sint16",
+    float16: "float16",
+    float32: "float32",
+    uint32: "uint32",
+    sint32: "sint32"
+  };
+  var TYPE_SIZES = {
+    uint8: 1,
+    sint8: 1,
+    uint16: 2,
+    sint16: 2,
+    float16: 2,
+    float32: 4,
+    uint32: 4,
+    sint32: 4
+  };
+
+  // ../core/src/adapter/type-utils/decode-texture-format.ts
+  var COMPRESSED_TEXTURE_FORMAT_PREFIXES = [
+    "bc1",
+    "bc2",
+    "bc3",
+    "bc4",
+    "bc5",
+    "bc6",
+    "bc7",
+    "etc1",
+    "etc2",
+    "eac",
+    "atc",
+    "astc",
+    "pvrtc"
+  ];
+  var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;
+  function isTextureFormatCompressed(textureFormat) {
+    return COMPRESSED_TEXTURE_FORMAT_PREFIXES.some((prefix) => textureFormat.startsWith(prefix));
+  }
+  function decodeTextureFormat(format) {
+    const matches = REGEX.exec(format);
+    if (matches) {
+      const [, format2, length, type, srgb, suffix] = matches;
+      if (format2) {
+        const dataType = `${type}${length}`;
+        const decodedType = decodeVertexType(dataType);
+        return {
+          format: format2,
+          components: format2.length,
+          // dataType - overwritten by decodedType
+          srgb: srgb === "-srgb",
+          unsized: suffix === "-unsized",
+          webgl: suffix === "-webgl",
+          ...decodedType
+        };
+      }
+    }
+    return decodeNonStandardFormat(format);
+  }
+  var EXCEPTIONS = {
+    // Packed 16 bit formats
+    "rgba4unorm-webgl": { format: "rgba", bpp: 2 },
+    "rgb565unorm-webgl": { format: "rgb", bpp: 2 },
+    "rgb5a1unorm-webgl": { format: "rgba", bbp: 2 },
+    // Packed 32 bit formats
+    rgb9e5ufloat: { format: "rgb", bbp: 4 },
+    rg11b10ufloat: { format: "rgb", bbp: 4 },
+    rgb10a2unorm: { format: "rgba", bbp: 4 },
+    "rgb10a2uint-webgl": { format: "rgba", bbp: 4 },
+    // Depth/stencil
+    stencil8: { components: 1, bpp: 1, a: "stencil" },
+    depth16unorm: { components: 1, bpp: 2, a: "depth" },
+    depth24plus: { components: 1, bpp: 3, a: "depth" },
+    depth32float: { components: 1, bpp: 4, a: "depth" },
+    "depth24plus-stencil8": { components: 2, bpp: 4, a: "depth-stencil" },
+    // "depth24unorm-stencil8" feature
+    "depth24unorm-stencil8": { components: 2, bpp: 4, a: "depth-stencil" },
+    // "depth32float-stencil8" feature
+    "depth32float-stencil8": { components: 2, bpp: 4, a: "depth-stencil" }
+  };
+  function decodeNonStandardFormat(format) {
+    const data = EXCEPTIONS[format];
+    if (!data) {
+      throw new Error(`Unknown format ${format}`);
+    }
+    return {
+      format: data.format || "",
+      components: data.components || data.format?.length || 1,
+      byteLength: data.bpp || 1,
+      srgb: false,
+      unsized: false
+    };
+  }
+
   // ../core/src/adapter/device.ts
+  var DeviceLimits = class {
+  };
+  var DeviceFeatures = class {
+    features;
+    disabledFeatures;
+    constructor(features = [], disabledFeatures) {
+      this.features = new Set(features);
+      this.disabledFeatures = disabledFeatures || {};
+    }
+    *[Symbol.iterator]() {
+      yield* this.features;
+    }
+    has(feature) {
+      return !this.disabledFeatures[feature] && this.features.has(feature);
+    }
+  };
   var _Device = class {
     get [Symbol.toStringTag]() {
       return "Device";
@@ -1114,14 +1215,18 @@ 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 */
+    isTextureFormatCompressed(format) {
+      return isTextureFormatCompressed(format);
+    }
     /**
      * Trigger device loss.
      * @returns `true` if context loss could actually be triggered.
@@ -1172,7 +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 };
@@ -1193,16 +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,
+    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,
@@ -1210,7 +1332,9 @@ var __exports__ = (() => {
     // premultipliedAlpha: undefined,
     // preserveDrawingBuffer: undefined,
     // failIfMajorPerformanceCaveat: undefined
-    gl: null
+    gl: null,
+    // Callbacks
+    onError: (error) => log.error(error.message)
   });
   __publicField(Device, "VERSION", VERSION2);
 
@@ -1511,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;
@@ -1518,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;
@@ -1530,7 +1658,6 @@ var __exports__ = (() => {
     height: void 0,
     depth: 1,
     mipmaps: true,
-    sampler: {},
     // type: undefined,
     compressed: false,
     // mipLevels: 1,
@@ -1538,7 +1665,9 @@ var __exports__ = (() => {
     // usage: GPUTextureUsage.COPY_DST
     mipLevels: void 0,
     samples: void 0,
-    type: void 0
+    type: void 0,
+    sampler: {},
+    view: void 0
   });
   __publicField(Texture, "COPY_SRC", 1);
   __publicField(Texture, "COPY_DST", 2);
@@ -1546,6 +1675,28 @@ var __exports__ = (() => {
   __publicField(Texture, "STORAGE_BINDING", 8);
   __publicField(Texture, "RENDER_ATTACHMENT", 16);
 
+  // ../core/src/adapter/resources/texture-view.ts
+  var _TextureView = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "TextureView";
+    }
+    /** Should not be constructed directly. Use `texture.createView(props)` */
+    constructor(device, props) {
+      super(device, props, _TextureView.defaultProps);
+    }
+  };
+  var TextureView = _TextureView;
+  __publicField(TextureView, "defaultProps", {
+    ...Resource.defaultProps,
+    format: void 0,
+    dimension: void 0,
+    aspect: "all",
+    baseMipLevel: 0,
+    mipLevelCount: void 0,
+    baseArrayLayer: 0,
+    arrayLayerCount: void 0
+  });
+
   // ../core/src/lib/compiler-log/format-compiler-log.ts
   function formatCompilerLog(shaderLog, source, options) {
     let formattedLog = "";
@@ -1658,10 +1809,14 @@ ${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.m
     getCompilationInfoSync() {
       return null;
     }
+    /** Get translated shader source in host platform's native language (HLSL, GLSL, and even GLSL ES), if available */
+    getTranslatedSource() {
+      return null;
+    }
     // PORTABLE HELPERS
     /** In browser logging of errors */
-    async debugShader() {
-      switch (this.props.debug) {
+    async debugShader(trigger = this.props.debug) {
+      switch (trigger) {
         case "never":
           return;
         case "errors":
@@ -1687,7 +1842,11 @@ ${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.m
       }
       const shaderName = getShaderInfo(this.source).name;
       const shaderTitle = `${this.stage} ${shaderName}`;
-      const htmlLog = formatCompilerLog(messages, this.source, { showSourceCode: "all", html: true });
+      let htmlLog = formatCompilerLog(messages, this.source, { showSourceCode: "all", html: true });
+      const translatedSource = this.getTranslatedSource();
+      if (translatedSource) {
+        htmlLog += `<br /><br /><h1>Translated Source</h1><br /><br /><code style="user-select:text;"><pre>${translatedSource}</pre></code>`;
+      }
       const button = document.createElement("Button");
       button.innerHTML = `
 <h1>Shader Compilation Error in ${shaderTitle}</h1><br /><br />
@@ -1715,7 +1874,7 @@ ${htmlLog}
   __publicField(Shader, "defaultProps", {
     ...Resource.defaultProps,
     language: "auto",
-    stage: "vertex",
+    stage: void 0,
     source: "",
     sourceMap: null,
     entryPoint: "main",
@@ -1782,67 +1941,32 @@ ${htmlLog}
         this.resizeAttachments(this.width, this.height);
       }
     }
-    // /** Returns fully populated attachment object. */
-    // protected normalizeColorAttachment(
-    //   attachment: Texture | ColorTextureFormat
-    // ): Required<ColorAttachment> {
-    //   const COLOR_ATTACHMENT_DEFAULTS: Required<ColorAttachment> = {
-    //     texture: undefined!,
-    //     format: undefined!,
-    //     clearValue: [0.0, 0.0, 0.0, 0.0],
-    //     loadOp: 'clear',
-    //     storeOp: 'store'
-    //   };
-    //   if (attachment instanceof Texture) {
-    //     return {...COLOR_ATTACHMENT_DEFAULTS, texture: attachment};
-    //   }
-    //   if (typeof attachment === 'string') {
-    //     return {...COLOR_ATTACHMENT_DEFAULTS, format: attachment};
-    //   }
-    //   return {...COLOR_ATTACHMENT_DEFAULTS, ...attachment};
-    // }
-    // /** Wraps texture inside fully populated attachment object. */
-    // protected normalizeDepthStencilAttachment(
-    //   attachment: DepthStencilAttachment | Texture | DepthStencilTextureFormat
-    // ): Required<DepthStencilAttachment> {
-    //   const DEPTH_STENCIL_ATTACHMENT_DEFAULTS: Required<DepthStencilAttachment> = {
-    //     texture: undefined!,
-    //     format: undefined!,
-    //     depthClearValue: 1.0,
-    //     depthLoadOp: 'clear',
-    //     depthStoreOp: 'store',
-    //     depthReadOnly: false,
-    //     stencilClearValue: 0,
-    //     stencilLoadOp: 'clear',
-    //     stencilStoreOp: 'store',
-    //     stencilReadOnly: false
-    //   };
-    //   if (typeof attachment === 'string') {
-    //     return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, format: attachment};
-    //   }
-    //   // @ts-expect-error attachment instanceof Texture doesn't cover Renderbuffer
-    //   if (attachment.handle || attachment instanceof Texture) {
-    //     return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, texture: attachment as Texture};
-    //   }
-    //   return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, ...attachment};
-    // }
     /** Auto creates any textures */
     autoCreateAttachmentTextures() {
-      this.colorAttachments = this.props.colorAttachments.map((attachment) => {
-        if (typeof attachment === "string") {
-          const texture = this.createColorTexture(attachment);
+      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);
           this.attachResource(texture);
-          return texture;
+          return texture.view;
         }
-        return attachment;
+        if (attachment2 instanceof Texture) {
+          return attachment2.view;
+        }
+        return attachment2;
       });
-      if (this.props.depthStencilAttachment) {
-        if (typeof this.props.depthStencilAttachment === "string") {
-          const texture = this.createDepthStencilTexture(this.props.depthStencilAttachment);
+      const attachment = this.props.depthStencilAttachment;
+      if (attachment) {
+        if (typeof attachment === "string") {
+          const texture = this.createDepthStencilTexture(attachment);
           this.attachResource(texture);
-          this.depthStencilAttachment = texture;
+          this.depthStencilAttachment = texture.view;
+        } else if (attachment instanceof Texture) {
+          this.depthStencilAttachment = attachment.view;
         } else {
-          this.depthStencilAttachment = this.props.depthStencilAttachment;
+          this.depthStencilAttachment = attachment;
         }
       }
     }
@@ -1880,8 +2004,8 @@ ${htmlLog}
             height
           });
           this.destroyAttachedResource(this.colorAttachments[i]);
-          this.colorAttachments[i] = resizedTexture;
-          this.attachResource(resizedTexture);
+          this.colorAttachments[i] = resizedTexture.view;
+          this.attachResource(resizedTexture.view);
         }
       }
       if (this.depthStencilAttachment) {
@@ -1891,41 +2015,10 @@ ${htmlLog}
           height
         });
         this.destroyAttachedResource(this.depthStencilAttachment);
-        this.depthStencilAttachment = resizedTexture;
+        this.depthStencilAttachment = resizedTexture.view;
         this.attachResource(resizedTexture);
       }
     }
-    /** Create a color attachment for WebGL *
-    protected override createColorTexture(colorAttachment: Required<ColorAttachment>): Required<ColorAttachment> {
-      return this.device._createTexture({
-        id: `${this.id}-color`,
-        data: null, // reserves texture memory, but texels are undefined
-        format,
-        // type: GL.UNSIGNED_BYTE,
-        width: this.width,
-        height: this.height,
-        // Note: Mipmapping can be disabled by texture resource when we resize the texture
-        // to a non-power-of-two dimenstion (NPOT texture) under WebGL1. To have consistant
-        // behavior we always disable mipmaps.
-        mipmaps: false,
-        // Set MIN and MAG filtering parameters so mipmaps are not used in sampling.
-        // Use LINEAR so subpixel algos like fxaa work.
-        // Set WRAP modes that support NPOT textures too.
-        sampler: {
-          minFilter: 'linear',
-          magFilter: 'linear',
-          addressModeU: 'clamp-to-edge',
-          addressModeV: 'clamp-to-edge'
-        }
-        // parameters: {
-        //   [GL.TEXTURE_MIN_FILTER]: GL.LINEAR,
-        //   [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,
-        //   [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
-        //   [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE
-        // }
-      });
-    }
-    */
   };
   var Framebuffer = _Framebuffer;
   __publicField(Framebuffer, "defaultProps", {
@@ -1933,7 +2026,7 @@ ${htmlLog}
     width: 1,
     height: 1,
     colorAttachments: [],
-    // ['rgba8unorm-unsized'],
+    // ['rgba8unorm'],
     depthStencilAttachment: null
     // 'depth24plus-stencil8'
   });
@@ -1943,29 +2036,38 @@ ${htmlLog}
     get [Symbol.toStringTag]() {
       return "RenderPipeline";
     }
-    hash = "";
     /** The merged layout */
     shaderLayout;
     /** Buffer map describing buffer interleaving etc */
     bufferLayout;
     /** The linking status of the pipeline. 'pending' if linking is asynchronous, and on production */
     linkStatus = "pending";
+    /** The hash of the pipeline */
+    hash = "";
     constructor(device, props) {
       super(device, props, _RenderPipeline.defaultProps);
       this.shaderLayout = this.props.shaderLayout;
       this.bufferLayout = this.props.bufferLayout || [];
     }
+    // DEPRECATED METHODS
+    /**
+     * Uniforms
+     * @deprecated Use uniforms buffers
+     * @note textures, samplers and uniform buffers should be set via `setBindings()`, these are not considered uniforms.
+     * @note In WebGL uniforms have a performance penalty, they are reset before each call to enable pipeline sharing.
+     */
+    setUniformsWebGL(uniforms) {
+      throw new Error("Use uniform blocks");
+    }
   };
   var RenderPipeline = _RenderPipeline;
   __publicField(RenderPipeline, "defaultProps", {
     ...Resource.defaultProps,
     vs: null,
-    vsEntryPoint: "",
-    // main
+    vertexEntryPoint: "vertexMain",
     vsConstants: {},
     fs: null,
-    fsEntryPoint: "",
-    // main
+    fragmentEntryPoint: "fragmentMain",
     fsConstants: {},
     shaderLayout: null,
     bufferLayout: [],
@@ -1985,41 +2087,17 @@ ${htmlLog}
     constructor(device, props) {
       super(device, props, _RenderPass.defaultProps);
     }
-    // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
-    // beginOcclusionQuery(queryIndex: number): void;
-    // endOcclusionQuery(): void;
-    // executeBundles(bundles: Iterable<GPURenderBundle>): void;
-    // In WebGPU the following methods are on the renderpass.
-    // luma.gl keeps them on the pipeline for now
-    /*
-      setPipeline(pipeline: RenderPipeline): void {}
-    
-      setIndexBuffer(
-        buffer: Buffer,
-        indexFormat: 'uint16' | 'uint32',
-        offset?: number,
-        size?: number
-      ): void {}
-    
-      abstract setVertexBuffer(slot: number, buffer: Buffer, offset: number): void;
-    
-      abstract setBindings(bindings: Record<string, Binding>): void;
-    
-      abstract setParameters(parameters: RenderPassParameters);
-    
-      draw(options: {
-        vertexCount?: number; // Either vertexCount or indexCount must be provided
-        indexCount?: number;  // Activates indexed drawing (call setIndexBuffer())
-        instanceCount?: number; //
-        firstVertex?: number;
-        firstIndex?: number; // requires device.features.has('indirect-first-instance')?
-        firstInstance?: number;
-        baseVertex?: number;
-      }): void {}
-    
-      drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): void;
-      drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): void;
-      */
+    // In WebGPU the following methods are on the renderpass instead of the renderpipeline
+    // luma.gl keeps them on the pipeline for now.
+    // TODO - Can we align WebGL implementation with WebGPU API?
+    // abstract setPipeline(pipeline: RenderPipeline): void {}
+    // abstract setIndexBuffer()
+    // abstract setVertexBuffer(slot: number, buffer: Buffer, offset: number): void;
+    // abstract setBindings(bindings: Record<string, Binding>): void;
+    // abstract setParameters(parameters: RenderPassParameters);
+    // abstract draw(options: {
+    // abstract drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): void;
+    // abstract drawIndexedIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): void;
   };
   var RenderPass = _RenderPass;
   /** Default properties for RenderPass */
@@ -2032,7 +2110,11 @@ ${htmlLog}
     clearStencil: 0,
     depthReadOnly: false,
     stencilReadOnly: false,
-    discard: false
+    discard: false,
+    occlusionQuerySet: void 0,
+    timestampQuerySet: void 0,
+    beginTimestampIndex: void 0,
+    endTimestampIndex: void 0
   });
 
   // ../core/src/adapter/resources/command-encoder.ts
@@ -2043,20 +2125,9 @@ ${htmlLog}
     constructor(device, props) {
       super(device, props, _CommandEncoder.defaultProps);
     }
-    pushDebugGroup(groupLabel) {
-    }
-    popDebugGroup() {
-    }
-    insertDebugMarker(markerLabel) {
-    }
-    // writeTimestamp(querySet: Query, queryIndex: number): void;
-    // resolveQuerySet(options: {
-    //   querySet: GPUQuerySet,
-    //   firstQuery: number,
-    //   queryCount: number,
-    //   destination: Buffer,
-    //   destinationOffset?: number;
-    // }): void;
+    // TODO - luma.gl has these on the device, should we align with WebGPU API?
+    // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
+    // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
   };
   var CommandEncoder = _CommandEncoder;
   __publicField(CommandEncoder, "defaultProps", {
@@ -2083,7 +2154,7 @@ ${htmlLog}
     const [dataType, components] = TYPE_INFO[attributeType];
     const integer = dataType === "i32" || dataType === "u32";
     const signed = dataType !== "u32";
-    const byteLength = TYPE_SIZES[dataType] * components;
+    const byteLength = TYPE_SIZES2[dataType] * components;
     const defaultVertexFormat = getCompatibleVertexFormat(dataType, components);
     return {
       dataType,
@@ -2132,56 +2203,12 @@ ${htmlLog}
     "vec3<u32>": ["u32", 3],
     "vec4<u32>": ["u32", 4]
   };
-  var TYPE_SIZES = {
+  var TYPE_SIZES2 = {
     f32: 4,
     f16: 2,
     i32: 4,
     u32: 4
-    // 'bool-webgl': 4,  
-  };
-
-  // ../core/src/adapter/type-utils/decode-data-type.ts
-  function decodeVertexType(type) {
-    const dataType = TYPE_MAP[type];
-    const bytes = getDataTypeBytes(dataType);
-    const normalized = type.includes("norm");
-    const integer = !normalized && !type.startsWith("float");
-    const signed = type.startsWith("s");
-    return {
-      dataType: TYPE_MAP[type],
-      byteLength: bytes,
-      integer,
-      signed,
-      normalized
-    };
-  }
-  function getDataTypeBytes(type) {
-    const bytes = TYPE_SIZES2[type];
-    return bytes;
-  }
-  var TYPE_MAP = {
-    uint8: "uint8",
-    sint8: "sint8",
-    unorm8: "uint8",
-    snorm8: "sint8",
-    uint16: "uint16",
-    sint16: "sint16",
-    unorm16: "uint16",
-    snorm16: "sint16",
-    float16: "float16",
-    float32: "float32",
-    uint32: "uint32",
-    sint32: "sint32"
-  };
-  var TYPE_SIZES2 = {
-    uint8: 1,
-    sint8: 1,
-    uint16: 2,
-    sint16: 2,
-    float16: 2,
-    float32: 4,
-    uint32: 4,
-    sint32: 4
+    // 'bool-webgl': 4,
   };
 
   // ../core/src/adapter/type-utils/decode-vertex-format.ts
@@ -2363,6 +2390,11 @@ ${htmlLog}
         this.maxVertexAttributes
       );
     }
+    // DEPRECATED METHODS
+    /** @deprecated Set constant attributes (WebGL only) */
+    setConstantWebGL(location, value) {
+      throw new Error("constant attributes not supported");
+    }
   };
   var VertexArray = _VertexArray;
   __publicField(VertexArray, "defaultProps", {
@@ -2386,6 +2418,22 @@ ${htmlLog}
     buffers: {}
   });
 
+  // ../core/src/adapter/resources/query-set.ts
+  var _QuerySet = class extends Resource {
+    get [Symbol.toStringTag]() {
+      return "QuerySet";
+    }
+    constructor(device, props) {
+      super(device, props, _QuerySet.defaultProps);
+    }
+  };
+  var QuerySet = _QuerySet;
+  __publicField(QuerySet, "defaultProps", {
+    ...Resource.defaultProps,
+    type: void 0,
+    count: void 0
+  });
+
   // ../core/src/utils/array-utils-flat.ts
   var arrayBuffer;
   function getScratchArrayBuffer(byteLength) {
@@ -2418,63 +2466,6 @@ ${htmlLog}
     return options.target;
   }
 
-  // ../core/src/adapter/type-utils/decode-texture-format.ts
-  var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;
-  function decodeTextureFormat(format) {
-    const matches = REGEX.exec(format);
-    if (matches) {
-      const [, format2, length, type, srgb, suffix] = matches;
-      if (format2) {
-        const dataType = `${type}${length}`;
-        const decodedType = decodeVertexType(dataType);
-        return {
-          format: format2,
-          components: format2.length,
-          // dataType - overwritten by decodedType
-          srgb: srgb === "-srgb",
-          unsized: suffix === "-unsized",
-          webgl: suffix === "-webgl",
-          ...decodedType
-        };
-      }
-    }
-    return decodeNonStandardFormat(format);
-  }
-  var EXCEPTIONS = {
-    // Packed 16 bit formats
-    "rgba4unorm-webgl": { format: "rgba", bpp: 2 },
-    "rgb565unorm-webgl": { format: "rgb", bpp: 2 },
-    "rgb5a1unorm-webgl": { format: "rgba", bbp: 2 },
-    // Packed 32 bit formats
-    "rgb9e5ufloat": { format: "rgb", bbp: 4 },
-    "rg11b10ufloat": { format: "rgb", bbp: 4 },
-    "rgb10a2unorm": { format: "rgba", bbp: 4 },
-    "rgb10a2unorm-webgl": { format: "rgba", bbp: 4 },
-    // Depth/stencil
-    "stencil8": { components: 1, bpp: 1, a: "stencil" },
-    "depth16unorm": { components: 1, bpp: 2, a: "depth" },
-    "depth24plus": { components: 1, bpp: 3, a: "depth" },
-    "depth32float": { components: 1, bpp: 4, a: "depth" },
-    "depth24plus-stencil8": { components: 2, bpp: 4, a: "depth-stencil" },
-    // "depth24unorm-stencil8" feature
-    "depth24unorm-stencil8": { components: 2, bpp: 4, a: "depth-stencil" },
-    // "depth32float-stencil8" feature
-    "depth32float-stencil8": { components: 2, bpp: 4, a: "depth-stencil" }
-  };
-  function decodeNonStandardFormat(format) {
-    const data = EXCEPTIONS[format];
-    if (!data) {
-      throw new Error(`Unknown format ${format}`);
-    }
-    return {
-      format: data.format || "",
-      components: data.components || data.format?.length || 1,
-      byteLength: data.bpp || 1,
-      srgb: false,
-      unsized: false
-    };
-  }
-
   // ../core/src/utils/cast.ts
   function cast(value) {
     return value;
@@ -2543,7 +2534,7 @@ ${htmlLog}
   // ../core/src/utils/load-file.ts
   var pathPrefix = "";
   async function loadImage(url, opts) {
-    return new Promise((resolve, reject) => {
+    return await new Promise((resolve, reject) => {
       try {
         const image = new Image();
         image.onload = () => resolve(image);
@@ -2633,14 +2624,6 @@ ${htmlLog}
     [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: import_constants.GL.KEEP,
     // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame.
     [import_constants.GL.VIEWPORT]: [0, 0, 1024, 1024],
-    // WEBGL1 PIXEL PACK/UNPACK MODES
-    [import_constants.GL.PACK_ALIGNMENT]: 4,
-    [import_constants.GL.UNPACK_ALIGNMENT]: 4,
-    [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: false,
-    [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
-    [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: import_constants.GL.BROWSER_DEFAULT_WEBGL,
-    // WEBGL2 / EXTENSIONS
-    // gl1: 'OES_standard_derivatives'
     [import_constants.GL.TRANSFORM_FEEDBACK_BINDING]: null,
     [import_constants.GL.COPY_READ_BUFFER_BINDING]: null,
     [import_constants.GL.COPY_WRITE_BUFFER_BINDING]: null,
@@ -2649,6 +2632,11 @@ ${htmlLog}
     [import_constants.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: import_constants.GL.DONT_CARE,
     [import_constants.GL.READ_FRAMEBUFFER_BINDING]: null,
     [import_constants.GL.RASTERIZER_DISCARD]: false,
+    [import_constants.GL.PACK_ALIGNMENT]: 4,
+    [import_constants.GL.UNPACK_ALIGNMENT]: 4,
+    [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: false,
+    [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
+    [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: import_constants.GL.BROWSER_DEFAULT_WEBGL,
     [import_constants.GL.PACK_ROW_LENGTH]: 0,
     [import_constants.GL.PACK_SKIP_PIXELS]: 0,
     [import_constants.GL.PACK_SKIP_ROWS]: 0,
@@ -2742,14 +2730,29 @@ ${htmlLog}
     [import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
     [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
     [import_constants.GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
-    // WEBGL1 PIXEL PACK/UNPACK MODES
+    // WEBGL2 EXTENSIONS
+    // EXT_depth_clamp https://registry.khronos.org/webgl/extensions/EXT_depth_clamp/
+    [import_constants.GL.DEPTH_CLAMP_EXT]: enable,
+    // WEBGL_provoking_vertex https://registry.khronos.org/webgl/extensions/WEBGL_provoking_vertex/
+    // [GL.PROVOKING_VERTEX_WEBL]: TODO - extension function needed
+    // WEBGL_polygon_mode https://registry.khronos.org/webgl/extensions/WEBGL_polygon_mode/
+    // POLYGON_MODE_WEBGL  TODO - extension function needed
+    [import_constants.GL.POLYGON_OFFSET_LINE_WEBGL]: enable,
+    // WEBGL_clip_cull_distance https://registry.khronos.org/webgl/extensions/WEBGL_clip_cull_distance/
+    [import_constants.GL.CLIP_DISTANCE0_WEBGL]: enable,
+    [import_constants.GL.CLIP_DISTANCE1_WEBGL]: enable,
+    [import_constants.GL.CLIP_DISTANCE2_WEBGL]: enable,
+    [import_constants.GL.CLIP_DISTANCE3_WEBGL]: enable,
+    [import_constants.GL.CLIP_DISTANCE4_WEBGL]: enable,
+    [import_constants.GL.CLIP_DISTANCE5_WEBGL]: enable,
+    [import_constants.GL.CLIP_DISTANCE6_WEBGL]: enable,
+    [import_constants.GL.CLIP_DISTANCE7_WEBGL]: enable,
+    // PIXEL PACK/UNPACK MODES
     [import_constants.GL.PACK_ALIGNMENT]: pixelStorei,
     [import_constants.GL.UNPACK_ALIGNMENT]: pixelStorei,
     [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: pixelStorei,
     [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,
     [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,
-    // WEBGL2 PIXEL PACK/UNPACK MODES
-    // RASTERIZER_DISCARD ...
     [import_constants.GL.PACK_ROW_LENGTH]: pixelStorei,
     [import_constants.GL.PACK_SKIP_PIXELS]: pixelStorei,
     [import_constants.GL.PACK_SKIP_ROWS]: pixelStorei,
@@ -3072,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;
     }
@@ -3098,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];
@@ -3114,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) {
@@ -3283,7 +3282,7 @@ ${htmlLog}
     };
   }
 
-  // src/context/context/create-browser-context.ts
+  // src/context/helpers/create-browser-context.ts
   var DEFAULT_CONTEXT_PROPS = {
     powerPreference: "high-performance",
     // After all, most apps are using WebGL for performance reasons
@@ -3320,10 +3319,21 @@ ${htmlLog}
 
   // src/adapter/device-helpers/webgl-device-info.ts
   var import_constants2 = __toESM(require_constants(), 1);
-  function getDeviceInfo(gl) {
+
+  // src/context/helpers/webgl-extensions.ts
+  function getWebGLExtension(gl, name2, extensions) {
+    if (extensions[name2] === void 0) {
+      extensions[name2] = gl.getExtension(name2) || null;
+    }
+    return extensions[name2];
+  }
+
+  // src/adapter/device-helpers/webgl-device-info.ts
+  function getDeviceInfo(gl, extensions) {
     const vendorMasked = gl.getParameter(import_constants2.GL.VENDOR);
     const rendererMasked = gl.getParameter(import_constants2.GL.RENDERER);
-    const ext = gl.getExtension("WEBGL_debug_renderer_info");
+    getWebGLExtension(gl, "WEBGL_debug_renderer_info", extensions);
+    const ext = extensions.WEBGL_debug_renderer_info;
     const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants2.GL.VENDOR);
     const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants2.GL.RENDERER);
     const vendor = vendorUnmasked || vendorMasked;
@@ -3432,6 +3442,14 @@ ${htmlLog}
   var texture_compression_etc1_webgl = "texture-compression-etc1-webgl";
   var texture_compression_pvrtc_webgl = "texture-compression-pvrtc-webgl";
   var texture_compression_atc_webgl = "texture-compression-atc-webgl";
+  var float32_renderable = "float32-renderable-webgl";
+  var float16_renderable = "float16-renderable-webgl";
+  var rgb9e5ufloat_renderable = "rgb9e5ufloat_renderable-webgl";
+  var snorm8_renderable = "snorm8-renderable-webgl";
+  var norm16_renderable = "norm16-renderable-webgl";
+  var snorm16_renderable = "snorm16-renderable-webgl";
+  var float32_filterable = "float32-filterable";
+  var float16_filterable = "float16-filterable-webgl";
   var X_S3TC = "WEBGL_compressed_texture_s3tc";
   var X_S3TC_SRGB = "WEBGL_compressed_texture_s3tc_srgb";
   var X_RGTC = "EXT_texture_compression_rgtc";
@@ -3441,15 +3459,18 @@ ${htmlLog}
   var X_ETC1 = "WEBGL_compressed_texture_etc1";
   var X_PVRTC = "WEBGL_compressed_texture_pvrtc";
   var X_ATC = "WEBGL_compressed_texture_atc";
-  var EXT_TEXTURE_NORM16 = "EXT_texture_norm16";
-  var EXT_FLOAT_RENDER_WEBGL2 = "EXT_color_buffer_float";
-  var TEXTURE_FEATURE_CHECKS = {
+  var EXT_texture_norm16 = "EXT_texture_norm16";
+  var EXT_render_snorm = "EXT_render_snorm";
+  var EXT_color_buffer_float = "EXT_color_buffer_float";
+  var TEXTURE_FEATURES = {
     "float32-renderable-webgl": ["EXT_color_buffer_float"],
-    // [false, 'EXT_color_buffer_float'],
     "float16-renderable-webgl": ["EXT_color_buffer_half_float"],
-    "norm16-renderable-webgl": [EXT_TEXTURE_NORM16],
-    "float32-filterable-linear-webgl": ["OES_texture_float_linear"],
-    "float16-filterable-linear-webgl": ["OES_texture_half_float_linear"],
+    "rgb9e5ufloat_renderable-webgl": ["WEBGL_render_shared_exponent"],
+    "snorm8-renderable-webgl": [EXT_render_snorm],
+    "norm16-renderable-webgl": [EXT_texture_norm16],
+    "snorm16-renderable-webgl": [EXT_texture_norm16, EXT_render_snorm],
+    "float32-filterable": ["OES_texture_float_linear"],
+    "float16-filterable-webgl": ["OES_texture_half_float_linear"],
     "texture-filterable-anisotropic-webgl": ["EXT_texture_filter_anisotropic"],
     "texture-blend-float-webgl": ["EXT_float_blend"],
     "texture-compression-bc": [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC],
@@ -3463,18 +3484,15 @@ ${htmlLog}
     "texture-compression-pvrtc-webgl": [X_PVRTC],
     "texture-compression-atc-webgl": [X_ATC]
   };
-  function checkTextureFeature(gl, feature) {
-    const extensions = TEXTURE_FEATURE_CHECKS[feature] || [];
-    return extensions.every((extension) => gl.getExtension(extension));
+  function isTextureFeature(feature) {
+    return feature in TEXTURE_FEATURES;
   }
-  function getTextureFeatures(gl) {
-    const textureFeatures = Object.keys(TEXTURE_FEATURE_CHECKS);
-    return textureFeatures.filter((feature) => checkTextureFeature(gl, feature));
+  function checkTextureFeature(gl, feature, extensions) {
+    const textureExtensions = TEXTURE_FEATURES[feature] || [];
+    return textureExtensions.every((extension) => getWebGLExtension(gl, extension, extensions));
   }
   var TEXTURE_FORMATS = {
-    // Unsized formats that leave the precision up to the driver.
-    // TODO - Fix bpp constants
-    // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
+    // Unsized formats that leave the precision up to the driver. TODO - Fix bpp constants
     "rgb8unorm-unsized": {
       gl: import_constants4.GL.RGB,
       b: 4,
@@ -3491,34 +3509,35 @@ ${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 },
-    "r8snorm": { gl: import_constants4.GL.R8_SNORM, b: 1, c: 1 },
-    "r8uint": { gl: import_constants4.GL.R8UI, b: 1, c: 1, renderbuffer: true },
-    "r8sint": { gl: import_constants4.GL.R8I, b: 1, c: 1, renderbuffer: true },
+    "r8unorm": { gl: 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, 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 },
-    "rg8snorm": { gl: import_constants4.GL.RG8_SNORM, b: 2, c: 2 },
-    "rg8uint": { gl: import_constants4.GL.RG8UI, b: 2, c: 2, renderbuffer: true },
-    "rg8sint": { gl: import_constants4.GL.RG8I, b: 2, c: 2, renderbuffer: true },
-    "r16uint": { gl: import_constants4.GL.R16UI, b: 2, c: 1, renderbuffer: true },
-    "r16sint": { gl: import_constants4.GL.R16I, b: 2, c: 1, renderbuffer: true },
-    "r16float": { gl: import_constants4.GL.R16F, b: 2, c: 1, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl", renderbuffer: true },
-    "r16unorm-webgl": { gl: import_constants4.GL.R16_EXT, b: 2, c: 1, f: "norm16-renderable-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-    "r16snorm-webgl": { gl: import_constants4.GL.R16_SNORM_EXT, b: 2, c: 1, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+    "rg8unorm": { gl: 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, 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 },
     // 32-bit formats  
     "rgba8unorm": { gl: import_constants4.GL.RGBA8, b: 4, c: 2, bpp: 4 },
     "rgba8unorm-srgb": { gl: import_constants4.GL.SRGB8_ALPHA8, b: 4, c: 4, bpp: 4 },
-    "rgba8snorm": { gl: import_constants4.GL.RGBA8_SNORM, b: 4, c: 4 },
+    "rgba8snorm": { gl: import_constants4.GL.RGBA8_SNORM, b: 4, c: 4, render: snorm8_renderable },
     "rgba8uint": { gl: import_constants4.GL.RGBA8UI, b: 4, c: 4, bpp: 4 },
     "rgba8sint": { gl: import_constants4.GL.RGBA8I, b: 4, c: 4, bpp: 4 },
     // reverse colors, webgpu only
@@ -3527,55 +3546,109 @@ ${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-webgl", filter: "float16-filterable-linear-webgl", renderbuffer: true },
-    "rg16unorm-webgl": { gl: import_constants4.GL.RG16_EXT, b: 2, c: 2, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
-    "rg16snorm-webgl": { gl: import_constants4.GL.RG16_SNORM_EXT, b: 2, c: 2, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
-    "r32uint": { gl: import_constants4.GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
-    "r32sint": { gl: import_constants4.GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
-    "r32float": { gl: import_constants4.GL.R32F, bpp: 4, b: 4, c: 1, render: "float32-renderable-webgl", filter: "float32-filterable-linear-webgl" },
+    "rg16float": { gl: 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, 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: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl" },
-    "rg11b10ufloat": { gl: import_constants4.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "float32-renderable-webgl", renderbuffer: true },
-    "rgb10a2unorm": { gl: import_constants4.GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
-    "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants4.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
+    "rgb9e5ufloat": { gl: 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, 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-webgl", x: EXT_TEXTURE_NORM16 },
-    "rgb16snorm-webgl": { gl: import_constants4.GL.RGB16_SNORM_EXT, b: 2, c: 3, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+    "rgb16unorm-webgl": { gl: 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-webgl", filter: "float32-filterable-linear-webgl", renderbuffer: true },
-    "rgba16uint": { gl: import_constants4.GL.RGBA16UI, b: 8, c: 4, renderbuffer: true },
-    "rgba16sint": { gl: import_constants4.GL.RGBA16I, b: 8, c: 4, renderbuffer: true },
-    "rgba16float": { gl: import_constants4.GL.RGBA16F, b: 8, c: 4, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl" },
-    "rgba16unorm-webgl": { gl: import_constants4.GL.RGBA16_EXT, b: 2, c: 4, f: "norm16-renderable-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-    "rgba16snorm-webgl": { gl: import_constants4.GL.RGBA16_SNORM_EXT, b: 2, c: 4, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+    "rg32uint": { gl: 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, rb: true },
+    "rgba16snorm-webgl": { gl: import_constants4.GL.RGBA16_SNORM_EXT, b: 2, c: 4, render: snorm16_renderable },
     // 96-bit formats (deprecated!)
     "rgb32float-webgl": {
       gl: import_constants4.GL.RGB32F,
-      render: "float32-renderable-webgl",
-      filter: "float32-filterable-linear-webgl",
-      gl2ext: EXT_FLOAT_RENDER_WEBGL2,
+      render: float32_renderable,
+      filter: float32_filterable,
+      gl2ext: EXT_color_buffer_float,
       dataFormat: import_constants4.GL.RGB,
       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-webgl", filter: "float32-filterable-linear-webgl", 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 },
@@ -3671,8 +3744,7 @@ ${htmlLog}
     [import_constants4.GL.BYTE]: 1,
     [import_constants4.GL.UNSIGNED_BYTE]: 1
   };
-  function isTextureFormatSupported(gl, formatOrGL) {
-    const format = convertGLToTextureFormat(formatOrGL);
+  function isTextureFormatSupported(gl, format, extensions) {
     const info = TEXTURE_FORMATS[format];
     if (!info) {
       return false;
@@ -3682,12 +3754,12 @@ ${htmlLog}
     }
     const extension = info.x || info.gl2ext;
     if (extension) {
-      return Boolean(gl.getExtension(extension));
+      return Boolean(getWebGLExtension(gl, extension, extensions));
     }
     return true;
   }
-  function isRenderbufferFormatSupported(gl, format) {
-    return isTextureFormatSupported(gl, format) && TEXTURE_FORMATS[format]?.renderbuffer;
+  function isRenderbufferFormatSupported(gl, format, extensions) {
+    return isTextureFormatSupported(gl, format, extensions) && TEXTURE_FORMATS[format]?.rb;
   }
   function convertGLToTextureFormat(format) {
     if (typeof format === "string") {
@@ -3707,9 +3779,11 @@ ${htmlLog}
     }
     return webglFormat;
   }
-  function isTextureFormatFilterable(gl, formatOrGL) {
-    const format = convertGLToTextureFormat(formatOrGL);
-    if (!isTextureFormatSupported(gl, format)) {
+  function isTextureFormatFilterable(gl, format, extensions) {
+    if (!isTextureFormatSupported(gl, format, extensions)) {
+      return false;
+    }
+    if (format.startsWith("depth") || format.startsWith("stencil")) {
       return false;
     }
     try {
@@ -3721,16 +3795,15 @@ ${htmlLog}
       return false;
     }
     if (format.endsWith("32float")) {
-      return Boolean(gl.getExtension("OES_texture_float_linear"));
+      return Boolean(getWebGLExtension(gl, "OES_texture_float_linear, extensions", extensions));
     }
     if (format.endsWith("16float")) {
-      return Boolean(gl.getExtension("OES_texture_half_float_linear"));
+      return Boolean(getWebGLExtension(gl, "OES_texture_half_float_linear, extensions", extensions));
     }
     return true;
   }
-  function isTextureFormatRenderable(gl, formatOrGL) {
-    const format = convertGLToTextureFormat(formatOrGL);
-    if (!isTextureFormatSupported(gl, format)) {
+  function isTextureFormatRenderable(gl, format, extensions) {
+    if (!isTextureFormatSupported(gl, format, extensions)) {
       return false;
     }
     if (typeof format === "number") {
@@ -3738,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
     };
@@ -3763,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;
@@ -3789,196 +3856,197 @@ ${htmlLog}
   }
 
   // src/adapter/device-helpers/webgl-device-features.ts
-  function getDeviceFeatures(gl) {
-    const features = getWebGLFeatures(gl);
-    for (const textureFeature of getTextureFeatures(gl)) {
-      features.add(textureFeature);
-    }
-    return features;
-  }
-  function getWebGLFeatures(gl) {
-    gl.getExtension("EXT_color_buffer_float");
-    const features = /* @__PURE__ */ new Set();
-    for (const feature of Object.keys(WEBGL_FEATURES)) {
-      if (isFeatureSupported(gl, feature)) {
-        features.add(feature);
-      }
-    }
-    return features;
-  }
-  function isFeatureSupported(gl, feature) {
-    const featureInfo = WEBGL_FEATURES[feature];
-    return typeof featureInfo === "string" ? Boolean(gl.getExtension(featureInfo)) : Boolean(featureInfo);
-  }
   var WEBGL_FEATURES = {
-    webgl: true,
-    glsl: true,
-    "uniforms-webgl": true,
-    "transform-feedback-webgl": true,
-    "constant-attributes-webgl": true,
+    // optional WebGPU features
+    "depth-clip-control": "EXT_depth_clamp",
+    // TODO these seem subtly different
+    // 'timestamp-query' // GPUQueryType "timestamp-query"
+    // "indirect-first-instance"
+    // Textures are handled by getTextureFeatures()
+    // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8'
+    // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
+    // optional WebGL features
     "timer-query-webgl": "EXT_disjoint_timer_query_webgl2",
-    "shader-status-async-webgl": "KHR_parallel_shader_compile"
+    "compilation-status-async-webgl": "KHR_parallel_shader_compile",
+    "polygon-mode-webgl": "WEBGL_polygon_mode",
+    "provoking-vertex-webgl": "WEBGL_provoking_vertex",
+    "shader-clip-cull-distance-webgl": "WEBGL_clip_cull_distance",
+    "shader-noperspective-interpolation-webgl": "NV_shader_noperspective_interpolation",
+    "shader-conservative-depth-webgl": "EXT_conservative_depth"
     // Textures are handled by getTextureFeatures()
   };
+  var WebGLDeviceFeatures = class extends DeviceFeatures {
+    gl;
+    extensions;
+    testedFeatures = /* @__PURE__ */ new Set();
+    constructor(gl, extensions, disabledFeatures) {
+      super([], disabledFeatures);
+      this.gl = gl;
+      this.extensions = extensions;
+      getWebGLExtension(gl, "EXT_color_buffer_float", extensions);
+    }
+    *[Symbol.iterator]() {
+      for (const feature of Object.keys(WEBGL_FEATURES)) {
+        if (this.has(feature)) {
+          yield feature;
+        }
+      }
+      for (const feature of Object.keys(TEXTURE_FEATURES)) {
+        if (this.has(feature)) {
+          yield feature;
+        }
+      }
+      return [];
+    }
+    has(feature) {
+      if (this.disabledFeatures[feature]) {
+        return false;
+      }
+      if (!this.testedFeatures.has(feature)) {
+        this.testedFeatures.add(feature);
+        if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) {
+          this.features.add(feature);
+        }
+        if (this.getWebGLFeature(feature)) {
+          this.features.add(feature);
+        }
+      }
+      return this.features.has(feature);
+    }
+    // FOR DEVICE
+    initializeFeatures() {
+      for (const feature of this) {
+      }
+    }
+    // IMPLEMENTATION
+    /** Extract all WebGL features */
+    getWebGLFeature(feature) {
+      const featureInfo = WEBGL_FEATURES[feature];
+      const isSupported = typeof featureInfo === "string" ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions)) : Boolean(featureInfo);
+      return isSupported;
+    }
+  };
 
   // src/adapter/device-helpers/webgl-device-limits.ts
   var import_constants5 = __toESM(require_constants(), 1);
-  function getDeviceLimits(gl) {
-    return {
-      maxTextureDimension1D: 0,
-      // WebGL does not support 1D textures
-      maxTextureDimension2D: gl.getParameter(import_constants5.GL.MAX_TEXTURE_SIZE),
-      maxTextureDimension3D: gl.getParameter(import_constants5.GL.MAX_3D_TEXTURE_SIZE),
-      maxTextureArrayLayers: gl.getParameter(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS),
-      maxBindGroups: 1,
-      // TBD - if we emulate bind groups we could support any number...
-      maxDynamicUniformBuffersPerPipelineLayout: 0,
-      // TBD
-      maxDynamicStorageBuffersPerPipelineLayout: 0,
-      // TBD
-      maxSampledTexturesPerShaderStage: gl.getParameter(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
-      // TBD
-      maxSamplersPerShaderStage: gl.getParameter(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-      maxStorageBuffersPerShaderStage: 0,
-      // TBD
-      maxStorageTexturesPerShaderStage: 0,
-      // TBD
-      maxUniformBuffersPerShaderStage: gl.getParameter(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS),
-      maxUniformBufferBindingSize: gl.getParameter(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE),
-      maxStorageBufferBindingSize: 0,
-      minUniformBufferOffsetAlignment: gl.getParameter(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT),
-      minStorageBufferOffsetAlignment: 0,
-      // TBD
-      maxVertexBuffers: 0,
-      maxVertexAttributes: gl.getParameter(import_constants5.GL.MAX_VERTEX_ATTRIBS),
-      maxVertexBufferArrayStride: 2048,
-      // TBD, this is just the default value from WebGPU
-      maxInterStageShaderComponents: gl.getParameter(import_constants5.GL.MAX_VARYING_COMPONENTS),
-      maxComputeWorkgroupStorageSize: 0,
-      // WebGL does not support compute shaders
-      maxComputeInvocationsPerWorkgroup: 0,
-      // WebGL does not support compute shaders
-      maxComputeWorkgroupSizeX: 0,
-      // WebGL does not support compute shaders
-      maxComputeWorkgroupSizeY: 0,
-      // WebGL does not support compute shaders
-      maxComputeWorkgroupSizeZ: 0,
-      // WebGL does not support compute shaders
-      maxComputeWorkgroupsPerDimension: 0
-      // WebGL does not support compute shaders
-    };
-  }
-  function getWebGLLimits(gl) {
-    function get(pname) {
-      return gl.getParameter(pname);
+  var WebGLDeviceLimits = class extends DeviceLimits {
+    get maxTextureDimension1D() {
+      return 0;
     }
-    function get2(pname, defaultValue) {
-      return gl.getParameter(pname) || defaultValue;
+    // WebGL does not support 1D textures
+    get maxTextureDimension2D() {
+      return this.getParameter(import_constants5.GL.MAX_TEXTURE_SIZE);
     }
-    return {
-      [import_constants5.GL.ALIASED_LINE_WIDTH_RANGE]: get(import_constants5.GL.ALIASED_LINE_WIDTH_RANGE),
-      [import_constants5.GL.ALIASED_POINT_SIZE_RANGE]: get(import_constants5.GL.ALIASED_POINT_SIZE_RANGE),
-      [import_constants5.GL.MAX_TEXTURE_SIZE]: get(import_constants5.GL.MAX_TEXTURE_SIZE),
-      [import_constants5.GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(import_constants5.GL.MAX_CUBE_MAP_TEXTURE_SIZE),
-      // GLint
-      [import_constants5.GL.MAX_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_TEXTURE_IMAGE_UNITS),
-      // GLint
-      [import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-      // GLint
-      [import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
-      // GLint
-      [import_constants5.GL.MAX_RENDERBUFFER_SIZE]: get(import_constants5.GL.MAX_RENDERBUFFER_SIZE),
-      // GLint
-      [import_constants5.GL.MAX_VARYING_VECTORS]: get(import_constants5.GL.MAX_VARYING_VECTORS),
-      // GLint
-      [import_constants5.GL.MAX_VERTEX_ATTRIBS]: get(import_constants5.GL.MAX_VERTEX_ATTRIBS),
-      // GLint
-      [import_constants5.GL.MAX_VERTEX_UNIFORM_VECTORS]: get(import_constants5.GL.MAX_VERTEX_UNIFORM_VECTORS),
-      // GLint
-      [import_constants5.GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(import_constants5.GL.MAX_FRAGMENT_UNIFORM_VECTORS),
-      // GLint
-      [import_constants5.GL.MAX_VIEWPORT_DIMS]: get(import_constants5.GL.MAX_VIEWPORT_DIMS),
-      // Extensions
-      [import_constants5.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(import_constants5.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT),
-      // getMaxAnistropy(),
-      // WebGL2 Limits
-      [import_constants5.GL.MAX_3D_TEXTURE_SIZE]: get2(import_constants5.GL.MAX_3D_TEXTURE_SIZE),
-      //  GLint
-      [import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS),
-      // GLint
-      // [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL), //  GLint64
-      [import_constants5.GL.MAX_COLOR_ATTACHMENTS]: get2(import_constants5.GL.MAX_COLOR_ATTACHMENTS),
-      //  GLint
-      [import_constants5.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(
-        import_constants5.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS
-      ),
-      // GLint64
-      [import_constants5.GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_COMBINED_UNIFORM_BLOCKS),
-      //  GLint
-      [import_constants5.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
-      // GLint64
-      [import_constants5.GL.MAX_DRAW_BUFFERS]: get2(import_constants5.GL.MAX_DRAW_BUFFERS),
-      // GLint
-      [import_constants5.GL.MAX_ELEMENT_INDEX]: get2(import_constants5.GL.MAX_ELEMENT_INDEX),
-      //  GLint64
-      [import_constants5.GL.MAX_ELEMENTS_INDICES]: get2(import_constants5.GL.MAX_ELEMENTS_INDICES),
-      // GLint
-      [import_constants5.GL.MAX_ELEMENTS_VERTICES]: get2(import_constants5.GL.MAX_ELEMENTS_VERTICES),
-      //  GLint
-      [import_constants5.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(import_constants5.GL.MAX_FRAGMENT_INPUT_COMPONENTS),
-      //  GLint
-      [import_constants5.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_FRAGMENT_UNIFORM_BLOCKS),
-      //  GLint
-      [import_constants5.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS),
-      //  GLint
-      [import_constants5.GL.MAX_SAMPLES]: get2(import_constants5.GL.MAX_SAMPLES),
-      //  GLint
-      // [GL.MAX_SERVER_WAIT_TIMEOUT]: get2(GL.MAX_SERVER_WAIT_TIMEOUT), //  GLint64
-      [import_constants5.GL.MAX_TEXTURE_LOD_BIAS]: get2(import_constants5.GL.MAX_TEXTURE_LOD_BIAS),
-      // GLfloat
-      [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(
-        import_constants5.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS
-      ),
-      //  GLint
-      [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
-      //  GLint
-      [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(
-        import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS
-      ),
-      // GLint
-      [import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE]: get2(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE),
-      // GLint64
-      [import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS),
-      //  GLint
-      [import_constants5.GL.MAX_VARYING_COMPONENTS]: get2(import_constants5.GL.MAX_VARYING_COMPONENTS),
-      // GLint
-      [import_constants5.GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(import_constants5.GL.MAX_VERTEX_OUTPUT_COMPONENTS),
-      // GLint
-      [import_constants5.GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_VERTEX_UNIFORM_BLOCKS),
-      //  GLint
-      [import_constants5.GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_VERTEX_UNIFORM_COMPONENTS),
-      //  GLint
-      [import_constants5.GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(import_constants5.GL.MIN_PROGRAM_TEXEL_OFFSET),
-      // GLint
-      [import_constants5.GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(import_constants5.GL.MAX_PROGRAM_TEXEL_OFFSET),
-      // GLint
-      [import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT)
-      // GLint
-    };
-  }
+    get maxTextureDimension3D() {
+      return this.getParameter(import_constants5.GL.MAX_3D_TEXTURE_SIZE);
+    }
+    get maxTextureArrayLayers() {
+      return this.getParameter(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS);
+    }
+    get maxBindGroups() {
+      return 0;
+    }
+    get maxDynamicUniformBuffersPerPipelineLayout() {
+      return 0;
+    }
+    // TBD
+    get maxDynamicStorageBuffersPerPipelineLayout() {
+      return 0;
+    }
+    // TBD
+    get maxSampledTexturesPerShaderStage() {
+      return this.getParameter(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS);
+    }
+    // ) TBD
+    get maxSamplersPerShaderStage() {
+      return this.getParameter(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+    }
+    get maxStorageBuffersPerShaderStage() {
+      return 0;
+    }
+    // TBD
+    get maxStorageTexturesPerShaderStage() {
+      return 0;
+    }
+    // TBD
+    get maxUniformBuffersPerShaderStage() {
+      return this.getParameter(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS);
+    }
+    get maxUniformBufferBindingSize() {
+      return this.getParameter(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE);
+    }
+    get maxStorageBufferBindingSize() {
+      return 0;
+    }
+    get minUniformBufferOffsetAlignment() {
+      return this.getParameter(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT);
+    }
+    get minStorageBufferOffsetAlignment() {
+      return 0;
+    }
+    get maxVertexBuffers() {
+      return 16;
+    }
+    // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
+    get maxVertexAttributes() {
+      return this.getParameter(import_constants5.GL.MAX_VERTEX_ATTRIBS);
+    }
+    get maxVertexBufferArrayStride() {
+      return 2048;
+    }
+    // TBD, this is just the default value from WebGPU
+    get maxInterStageShaderComponents() {
+      return this.getParameter(import_constants5.GL.MAX_VARYING_COMPONENTS);
+    }
+    get maxComputeWorkgroupStorageSize() {
+      return 0;
+    }
+    // WebGL does not support compute shaders
+    get maxComputeInvocationsPerWorkgroup() {
+      return 0;
+    }
+    // WebGL does not support compute shaders
+    get maxComputeWorkgroupSizeX() {
+      return 0;
+    }
+    // WebGL does not support compute shaders
+    get maxComputeWorkgroupSizeY() {
+      return 0;
+    }
+    // WebGL does not support compute shaders
+    get maxComputeWorkgroupSizeZ() {
+      return 0;
+    }
+    // WebGL does not support compute shaders
+    get maxComputeWorkgroupsPerDimension() {
+      return 0;
+    }
+    // WebGL does not support compute shaders
+    // PRIVATE
+    gl;
+    limits = {};
+    constructor(gl) {
+      super();
+      this.gl = gl;
+    }
+    getParameter(parameter) {
+      if (this.limits[parameter] === void 0) {
+        this.limits[parameter] = this.gl.getParameter(parameter);
+      }
+      return this.limits[parameter];
+    }
+  };
 
   // 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);
@@ -4012,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) {
@@ -4034,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) {
@@ -4059,9 +4128,66 @@ ${htmlLog}
         })
       );
     }
+    if (parameters.unclippedDepth) {
+      if (device.features.has("depth-clip-control")) {
+        gl.enable(import_constants6.GL.DEPTH_CLAMP_EXT);
+      }
+    }
     if (parameters.depthBias !== void 0) {
       gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
     }
+    if (device.features.has("provoking-vertex-webgl")) {
+      const extensions = webglDevice.getExtension("WEBGL_provoking_vertex");
+      const ext = extensions.WEBGL_provoking_vertex;
+      if (parameters.provokingVertex) {
+        const vertex = map("provokingVertex", parameters.provokingVertex, {
+          first: import_constants6.GL.FIRST_VERTEX_CONVENTION_WEBGL,
+          last: import_constants6.GL.LAST_VERTEX_CONVENTION_WEBGL
+        });
+        ext?.provokingVertexWEBGL(vertex);
+      }
+    }
+    if (device.features.has("polygon-mode-webgl")) {
+      const extensions = webglDevice.getExtension("WEBGL_polygon_mode");
+      const ext = extensions.WEBGL_polygon_mode;
+      if (parameters.polygonMode) {
+        const mode = map("polygonMode", parameters.provokingVertex, {
+          fill: import_constants6.GL.FILL_WEBGL,
+          lint: import_constants6.GL.LINE_WEBGL
+        });
+        ext?.polygonModeWEBGL(import_constants6.GL.FRONT, mode);
+        ext?.polygonModeWEBGL(import_constants6.GL.BACK, mode);
+      }
+      if (parameters.polygonOffsetLine) {
+        gl.enable(import_constants6.GL.POLYGON_OFFSET_LINE_WEBGL);
+      }
+    }
+    if (device.features.has("shader-clip-cull-distance-webgl")) {
+      if (parameters.clipDistance0) {
+        gl.enable(import_constants6.GL.CLIP_DISTANCE0_WEBGL);
+      }
+      if (parameters.clipDistance1) {
+        gl.enable(import_constants6.GL.CLIP_DISTANCE1_WEBGL);
+      }
+      if (parameters.clipDistance2) {
+        gl.enable(import_constants6.GL.CLIP_DISTANCE2_WEBGL);
+      }
+      if (parameters.clipDistance3) {
+        gl.enable(import_constants6.GL.CLIP_DISTANCE3_WEBGL);
+      }
+      if (parameters.clipDistance4) {
+        gl.enable(import_constants6.GL.CLIP_DISTANCE4_WEBGL);
+      }
+      if (parameters.clipDistance5) {
+        gl.enable(import_constants6.GL.CLIP_DISTANCE5_WEBGL);
+      }
+      if (parameters.clipDistance6) {
+        gl.enable(import_constants6.GL.CLIP_DISTANCE6_WEBGL);
+      }
+      if (parameters.clipDistance7) {
+        gl.enable(import_constants6.GL.CLIP_DISTANCE7_WEBGL);
+      }
+    }
     if (parameters.depthWriteEnabled !== void 0) {
       gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
     }
@@ -4096,13 +4222,31 @@ ${htmlLog}
     }
     if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
       gl.enable(import_constants6.GL.BLEND);
-      const colorEquation = convertBlendOperationToEquation("blendColorOperation", parameters.blendColorOperation || "add");
-      const alphaEquation = convertBlendOperationToEquation("blendAlphaOperation", parameters.blendAlphaOperation || "add");
+      const colorEquation = convertBlendOperationToEquation(
+        "blendColorOperation",
+        parameters.blendColorOperation || "add"
+      );
+      const alphaEquation = convertBlendOperationToEquation(
+        "blendAlphaOperation",
+        parameters.blendAlphaOperation || "add"
+      );
       gl.blendEquationSeparate(colorEquation, alphaEquation);
-      const colorSrcFactor = convertBlendFactorToFunction("blendColorSrcFactor", parameters.blendColorSrcFactor || "one");
-      const colorDstFactor = convertBlendFactorToFunction("blendColorDstFactor", parameters.blendColorDstFactor || "zero");
-      const alphaSrcFactor = convertBlendFactorToFunction("blendAlphaSrcFactor", parameters.blendAlphaSrcFactor || "one");
-      const alphaDstFactor = convertBlendFactorToFunction("blendAlphaDstFactor", parameters.blendAlphaDstFactor || "zero");
+      const colorSrcFactor = convertBlendFactorToFunction(
+        "blendColorSrcFactor",
+        parameters.blendColorSrcFactor || "one"
+      );
+      const colorDstFactor = convertBlendFactorToFunction(
+        "blendColorDstFactor",
+        parameters.blendColorDstFactor || "zero"
+      );
+      const alphaSrcFactor = convertBlendFactorToFunction(
+        "blendAlphaSrcFactor",
+        parameters.blendAlphaSrcFactor || "one"
+      );
+      const alphaDstFactor = convertBlendFactorToFunction(
+        "blendAlphaDstFactor",
+        parameters.blendAlphaDstFactor || "zero"
+      );
       gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);
     }
   }
@@ -4132,17 +4276,17 @@ ${htmlLog}
   }
   function convertBlendOperationToEquation(parameter, value) {
     return map(parameter, value, {
-      "add": import_constants6.GL.FUNC_ADD,
-      "subtract": import_constants6.GL.FUNC_SUBTRACT,
+      add: import_constants6.GL.FUNC_ADD,
+      subtract: import_constants6.GL.FUNC_SUBTRACT,
       "reverse-subtract": import_constants6.GL.FUNC_REVERSE_SUBTRACT,
-      "min": import_constants6.GL.MIN,
-      "max": import_constants6.GL.MAX
+      min: import_constants6.GL.MIN,
+      max: import_constants6.GL.MAX
     });
   }
   function convertBlendFactorToFunction(parameter, value) {
     return map(parameter, value, {
-      "one": import_constants6.GL.ONE,
-      "zero": import_constants6.GL.ZERO,
+      one: import_constants6.GL.ONE,
+      zero: import_constants6.GL.ZERO,
       "src-color": import_constants6.GL.SRC_COLOR,
       "one-minus-src-color": import_constants6.GL.ONE_MINUS_SRC_COLOR,
       "dst-color": import_constants6.GL.DST_COLOR,
@@ -4398,6 +4542,21 @@ ${htmlLog}
     }
   };
 
+  // src/adapter/resources/webgl-texture-view.ts
+  var WEBGLTextureView = class extends TextureView {
+    device;
+    gl;
+    handle;
+    texture;
+    constructor(device, props) {
+      super(device, { ...Texture.defaultProps, ...props });
+      this.device = device;
+      this.gl = this.device.gl;
+      this.handle = null;
+      this.texture = props.texture;
+    }
+  };
+
   // src/adapter/resources/webgl-texture.ts
   var DEFAULT_WEBGL_TEXTURE_PROPS = {
     // deprecated
@@ -4414,8 +4573,9 @@ ${htmlLog}
     device;
     gl;
     handle;
-    /** Sampler object (currently unused) */
+    // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
     sampler = void 0;
+    view = void 0;
     // data;
     glFormat = void 0;
     type = void 0;
@@ -4465,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") {
@@ -4530,7 +4693,8 @@ ${htmlLog}
       });
       this.setSampler(props.sampler);
       this._setSamplerParameters(parameters);
-      if (mipmaps) {
+      this.view = this.createView({ ...this.props, mipLevelCount: 1, arrayLayerCount: 1 });
+      if (mipmaps && this.device.isTextureFormatFilterable(props.format)) {
         this.generateMipmap();
       }
       if (isVideo) {
@@ -5085,372 +5249,66 @@ ${htmlLog}
     log.log(1, "texture sampler parameters", parameters)();
   }
 
-  // src/adapter/objects/webgl-renderbuffer.ts
-  var import_constants11 = __toESM(require_constants(), 1);
-
-  // src/adapter/objects/constants-to-keys.ts
-  function getKeyValue(gl, name2) {
-    if (typeof name2 !== "string") {
-      return name2;
-    }
-    const number = Number(name2);
-    if (!isNaN(number)) {
-      return number;
-    }
-    name2 = name2.replace(/^.*\./, "");
-    const value = gl[name2];
-    assert2(value !== void 0, `Accessing undefined constant GL.${name2}`);
-    return value;
-  }
-
-  // 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();
-      }
-      this.byteLength = 0;
+    handle;
+    get texture() {
+      return this.colorAttachments[0];
     }
-    toString() {
-      return `${this.constructor.name}(${this.id})`;
+    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);
+      }
     }
-    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);
-    }
-    /**
-     * Query a Resource parameter
-     *
-     * @param name
-     * @return param
-     */
-    getParameter(pname, props = {}) {
-      pname = getKeyValue(this.gl, pname);
-      assert2(pname);
-      const parameters = this.constructor.PARAMETERS || {};
-      const parameter = parameters[pname];
-      if (parameter) {
-        const parameterAvailable = !("extension" in parameter) || this.gl.getExtension(parameter.extension);
-        if (!parameterAvailable) {
-          return parameter.webgl2;
-        }
-      }
-      return this._getParameter(pname, props);
-    }
-    // Many resources support a getParameter call -
-    // getParameters will get all parameters - slow but useful for debugging
-    // eslint-disable-next-line complexity
-    getParameters(options = {}) {
-      const { parameters, keys } = options;
-      const PARAMETERS = this.constructor.PARAMETERS || {};
-      const values = {};
-      const parameterKeys = parameters || Object.keys(PARAMETERS);
-      for (const pname of parameterKeys) {
-        const parameter = PARAMETERS[pname];
-        const parameterAvailable = parameter && (!("extension" in parameter) || this.gl.getExtension(parameter.extension));
-        if (parameterAvailable) {
-          const key = keys ? this.device.getGLKey(pname) : pname;
-          values[key] = this.getParameter(pname, options);
-          if (keys && parameter.type === "GLenum") {
-            values[key] = this.device.getGLKey(values[key]);
-          }
-        }
-      }
-      return values;
-    }
-    /**
-     * Update a Resource setting
-     *
-     * @todo - cache parameter to avoid issuing WebGL calls?
-     *
-     * @param pname - parameter (GL constant, value or key)
-     * @param value {GLint|GLfloat|GLenum} 
-     * @return returns self to enable chaining
-     */
-    setParameter(pname, value) {
-      pname = getKeyValue(this.gl, pname);
-      assert2(pname);
-      const parameters = this.constructor.PARAMETERS || {};
-      const parameter = parameters[pname];
-      if (parameter) {
-        const parameterAvailable = !("extension" in parameter) || this.gl.getExtension(parameter.extension);
-        if (!parameterAvailable) {
-          throw new Error("Parameter not available on this platform");
-        }
-        if (parameter.type === "GLenum") {
-          value = getKeyValue(value);
-        }
-      }
-      this._setParameter(pname, value);
-      return this;
-    }
-    /*
-     * Batch update resource parameters
-     * Assumes the subclass supports a setParameter call
-     */
-    setParameters(parameters) {
-      for (const pname in parameters) {
-        this.setParameter(pname, parameters[pname]);
-      }
-      return this;
-    }
-    // Install stubs for removed methods
-    stubRemovedMethods(className, version, methodNames) {
-      return 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 _WEBGLRenderbuffer = class extends WebGLResource {
-    get [Symbol.toStringTag]() {
-      return "Renderbuffer";
-    }
-    get width() {
-      return this.props.width;
-    }
-    get height() {
-      return this.props.height;
-    }
-    get format() {
-      return this.props.format;
-    }
-    get samples() {
-      return this.props.samples;
-    }
-    get attachment() {
-      return;
-    }
-    /** WebGL format constant */
-    glFormat;
-    static isTextureFormatSupported(device, format) {
-      return isRenderbufferFormatSupported(device.gl, format);
-    }
-    constructor(device, props) {
-      if (typeof props.format === "number") {
-        throw new Error("Renderbuffer");
-      }
-      super(device, props, _WEBGLRenderbuffer.defaultProps);
-      this.glFormat = convertTextureFormatToGL(this.props.format);
-      this._initialize(this.props);
-    }
-    resize(size) {
-      if (size.width !== this.width || size.height !== this.height) {
-        Object.assign(this.props, { ...size, format: this.format, samples: this.samples });
-        this._initialize(this.props);
-      }
-    }
-    // PRIVATE METHODS
-    /** Creates and initializes a renderbuffer object's data store */
-    _initialize(props) {
-      const { format, width, height, samples } = props;
-      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.format),
-            this.depthStencilAttachment
-          );
-        }
-        this.gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, null);
-      }
-      if (props.check !== false) {
-        this._checkStatus();
-      }
-    }
-    /** destroys any auto created resources etc. */
-    destroy() {
-      super.destroy();
-      if (!this.destroyed && this.handle !== null) {
-        this.gl.deleteFramebuffer(this.handle);
-      }
+    /** destroys any auto created resources etc. */
+    destroy() {
+      super.destroy();
+      if (!this.destroyed && this.handle !== null) {
+        this.gl.deleteFramebuffer(this.handle);
+      }
     }
     // PRIVATE
-    /** Check the status */
-    _checkStatus() {
-      const { gl } = this;
-      const prevHandle = gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, this.handle);
-      const status = gl.checkFramebufferStatus(import_constants12.GL.FRAMEBUFFER);
-      gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, prevHandle || null);
-      if (status !== gl.FRAMEBUFFER_COMPLETE) {
-        throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
-      }
-    }
     /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
     createDepthStencilTexture(format) {
-      return new WEBGLRenderbuffer(this.device, {
+      return new WEBGLTexture(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
+        height: this.height,
+        mipmaps: false
       });
     }
-    /** 
-     * Attachment resize is expected to be a noop if size is same 
+    /**
+     * Attachment resize is expected to be a noop if size is same
      */
     resizeAttachments(width, height) {
       if (this.handle === null) {
@@ -5465,36 +5323,45 @@ ${htmlLog}
         height = this.gl.drawingBufferHeight;
       }
       for (const colorAttachment of this.colorAttachments) {
-        colorAttachment.resize({ width, height });
+        colorAttachment.texture.resize({ width, height });
       }
       if (this.depthStencilAttachment) {
-        this.depthStencilAttachment.resize({ width, height });
+        this.depthStencilAttachment.texture.resize({ width, height });
       }
       return this;
     }
     /** Attach one attachment */
     _attachOne(attachmentPoint, attachment) {
-      if (attachment instanceof WEBGLRenderbuffer) {
-        this._attachWEBGLRenderbuffer(attachmentPoint, attachment);
-        return attachment;
-      } else if (Array.isArray(attachment)) {
+      if (Array.isArray(attachment)) {
         const [texture, layer = 0, level = 0] = attachment;
         this._attachTexture(attachmentPoint, texture, layer, level);
         return texture;
-      } else if (attachment instanceof WEBGLTexture) {
+      }
+      if (attachment instanceof WEBGLTexture) {
         this._attachTexture(attachmentPoint, attachment, 0, 0);
         return attachment;
       }
+      if (attachment instanceof WEBGLTextureView) {
+        const textureView = attachment;
+        this._attachTexture(
+          attachmentPoint,
+          textureView.texture,
+          textureView.props.baseMipLevel,
+          textureView.props.baseArrayLayer
+        );
+        return attachment.texture;
+      }
       throw new Error("attach");
     }
-    _attachWEBGLRenderbuffer(attachment, renderbuffer) {
-      this.gl.framebufferRenderbuffer(
-        import_constants12.GL.FRAMEBUFFER,
-        attachment,
-        import_constants12.GL.RENDERBUFFER,
-        renderbuffer.handle
-      );
-    }
+    // TODO - we do not seem to need render buffers in WebGL 2
+    // protected _attachWEBGLRenderbuffer(attachment: GL, renderbuffer: WEBGLRenderbuffer): void {
+    //   this.gl.framebufferRenderbuffer(
+    //     GL.FRAMEBUFFER,
+    //     attachment,
+    //     GL.RENDERBUFFER,
+    //     renderbuffer.handle
+    //   );
+    // }
     /**
      * @param attachment
      * @param texture
@@ -5505,16 +5372,16 @@ ${htmlLog}
       const { gl } = this.device;
       gl.bindTexture(texture.target, texture.handle);
       switch (texture.target) {
-        case import_constants12.GL.TEXTURE_2D_ARRAY:
-        case import_constants12.GL.TEXTURE_3D:
-          gl.framebufferTextureLayer(import_constants12.GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+        case 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_constants12.GL.TEXTURE_CUBE_MAP:
+        case import_constants11.GL.TEXTURE_CUBE_MAP:
           const face = mapIndexToCubeMapFace(layer);
-          gl.framebufferTexture2D(import_constants12.GL.FRAMEBUFFER, attachment, face, texture.handle, level);
+          gl.framebufferTexture2D(import_constants11.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);
+        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");
@@ -5523,21 +5390,21 @@ ${htmlLog}
     }
   };
   function mapIndexToCubeMapFace(layer) {
-    return layer < import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X ? layer + import_constants12.GL.TEXTURE_CUBE_MAP_POSITIVE_X : layer;
+    return layer < 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_constants12.GL.FRAMEBUFFER_COMPLETE:
+      case import_constants11.GL.FRAMEBUFFER_COMPLETE:
         return "success";
-      case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+      case import_constants11.GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
         return "Mismatched attachments";
-      case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+      case import_constants11.GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
         return "No attachments";
-      case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+      case import_constants11.GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
         return "Height/width mismatch";
-      case import_constants12.GL.FRAMEBUFFER_UNSUPPORTED:
+      case import_constants11.GL.FRAMEBUFFER_UNSUPPORTED:
         return "Unsupported or split attachments";
-      case import_constants12.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+      case import_constants11.GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
         return "Samples mismatch";
       default:
         return `${status}`;
@@ -5630,7 +5497,9 @@ ${htmlLog}
     if (!initialized) {
       initialized = true;
       spector.spyCanvases();
-      spector?.onCaptureStarted.add((capture) => log.info("Spector capture started:", capture)());
+      spector?.onCaptureStarted.add(
+        (capture) => log.info("Spector capture started:", capture)()
+      );
       spector?.onCapture.add((capture) => {
         log.info("Spector capture complete:", capture)();
         spector?.getResultUI();
@@ -5652,9 +5521,9 @@ ${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 getContextData(gl) {
+  function getWebGLContextData(gl) {
     gl.luma = gl.luma || {};
     return gl.luma;
   }
@@ -5672,7 +5541,7 @@ ${htmlLog}
     return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
   }
   function getRealContext(gl) {
-    const data = getContextData(gl);
+    const data = getWebGLContextData(gl);
     return data.realContext ? data.realContext : gl;
   }
   function getDebugContext(gl, props) {
@@ -5680,19 +5549,19 @@ ${htmlLog}
       log.warn("webgl-debug not loaded")();
       return gl;
     }
-    const data = getContextData(gl);
+    const data = getWebGLContextData(gl);
     if (data.debugContext) {
       return data.debugContext;
     }
-    globalThis.WebGLDebugUtils.init({ ...import_constants13.GL, ...gl });
+    globalThis.WebGLDebugUtils.init({ ...import_constants12.GL, ...gl });
     const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(
       gl,
       onGLError.bind(null, props),
       onValidateGLFunc.bind(null, props)
     );
-    for (const key in import_constants13.GL) {
-      if (!(key in glDebug) && typeof import_constants13.GL[key] === "number") {
-        glDebug[key] = import_constants13.GL[key];
+    for (const key in import_constants12.GL) {
+      if (!(key in glDebug) && typeof import_constants12.GL[key] === "number") {
+        glDebug[key] = import_constants12.GL[key];
       }
     }
     class WebGLDebugContext {
@@ -5730,7 +5599,9 @@ ${htmlLog}
     }
     if (props.break && props.break.length > 0) {
       functionString = functionString || getFunctionString(functionName, functionArgs);
-      const isBreakpoint = props.break.every((breakOn) => functionString.indexOf(breakOn) !== -1);
+      const isBreakpoint = props.break.every(
+        (breakOn) => functionString.indexOf(breakOn) !== -1
+      );
       if (isBreakpoint) {
         debugger;
       }
@@ -5749,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) {
@@ -5804,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);
@@ -5829,6 +5700,11 @@ ${htmlLog}
       const log2 = this.device.gl.getShaderInfoLog(this.handle);
       return parseShaderCompilerLog(log2);
     }
+    getTranslatedSource() {
+      const extensions = this.device.getExtension("WEBGL_debug_shaders");
+      const ext = extensions.WEBGL_debug_shaders;
+      return ext?.getTranslatedShaderSource(this.handle);
+    }
     // PRIVATE METHODS
     /** Compile a shader and get compilation status */
     async _compile(source) {
@@ -5842,7 +5718,7 @@ ${source2}`;
         this.compilationStatus = "pending";
         return;
       }
-      if (!this.device.features.has("shader-status-async-webgl")) {
+      if (!this.device.features.has("compilation-status-async-webgl")) {
         this._getCompilationStatus();
         if (this.compilationStatus === "error") {
           throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);
@@ -5860,13 +5736,13 @@ ${source2}`;
     async _waitForCompilationComplete() {
       const waitMs = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
       const DELAY_MS = 10;
-      if (!this.device.features.has("shader-status-async-webgl")) {
+      if (!this.device.features.has("compilation-status-async-webgl")) {
         await waitMs(DELAY_MS);
         return;
       }
       const { gl } = this.device;
       for (; ; ) {
-        const complete = gl.getShaderParameter(this.handle, import_constants14.GL.COMPLETION_STATUS);
+        const complete = gl.getShaderParameter(this.handle, import_constants13.GL.COMPLETION_STATUS_KHR);
         if (complete) {
           return;
         }
@@ -5877,14 +5753,14 @@ ${source2}`;
      * Get the shader compilation status
      * TODO - Load log even when no error reported, to catch warnings?
      * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
-    */
+     */
     _getCompilationStatus() {
-      this.compilationStatus = this.device.gl.getShaderParameter(this.handle, import_constants14.GL.COMPILE_STATUS) ? "success" : "error";
+      this.compilationStatus = this.device.gl.getShaderParameter(this.handle, 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;
@@ -5903,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) {
@@ -5912,7 +5788,6 @@ ${source2}`;
     }
     insertDebugMarker(markerLabel) {
     }
-    // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
     // beginOcclusionQuery(queryIndex: number): void;
     // endOcclusionQuery(): void;
     // executeBundles(bundles: Iterable<GPURenderBundle>): void;
@@ -5928,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);
@@ -5946,12 +5821,20 @@ ${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);
     }
-    // Internal
+    beginOcclusionQuery(queryIndex) {
+      const webglQuerySet = this.props.occlusionQuerySet;
+      webglQuerySet?.beginOcclusionQuery();
+    }
+    endOcclusionQuery() {
+      const webglQuerySet = this.props.occlusionQuerySet;
+      webglQuerySet?.endOcclusionQuery();
+    }
+    // PRIVATE
     /**
      * Optionally clears depth, color and stencil buffers based on parameters
      */
@@ -5971,13 +5854,13 @@ ${source2}`;
         glParameters.clearStencil = this.props.clearStencil;
       }
       if (clearMask !== 0) {
-        withGLParameters(this.device, glParameters, () => {
+        withGLParameters(this.device.gl, glParameters, () => {
           this.device.gl.clear(clearMask);
         });
       }
     }
-    /** 
-     * WebGL2 - clear a specific color buffer 
+    /**
+     * WebGL2 - clear a specific color buffer
      */
     clearColorBuffer(drawBuffer = 0, value = [0, 0, 0, 0]) {
       withGLParameters(this.device.gl, { framebuffer: this.props.framebuffer }, () => {
@@ -6016,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);
     }
@@ -6053,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");
@@ -6079,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,
@@ -6102,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
@@ -6138,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;
         }
       }
@@ -6202,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) {
@@ -6359,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) {
@@ -6376,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) {
@@ -6412,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) {
@@ -6450,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];
@@ -6495,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;
@@ -6507,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);
     }
@@ -6605,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);
     }
@@ -6652,13 +6535,15 @@ ${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);
       }
       this._linkShaders();
+      log.time(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
       this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
+      log.timeEnd(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
       this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);
       switch (this.props.topology) {
         case "triangle-fan-webgl":
@@ -6700,7 +6585,7 @@ ${source2}`;
             }
             break;
           case "texture":
-            if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+            if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
               throw new Error("texture value");
             }
             break;
@@ -6713,26 +6598,11 @@ ${source2}`;
         this.bindings[name2] = value;
       }
     }
-    /** This function is @deprecated, use uniform buffers */
-    setUniforms(uniforms) {
-      const { bindings } = splitUniformsAndBindings(uniforms);
-      Object.keys(bindings).forEach((name2) => {
-        log.warn(
-          `Unsupported value "${JSON.stringify(
-            bindings[name2]
-          )}" used in setUniforms() for key ${name2}. Use setBindings() instead?`
-        )();
-      });
-      Object.assign(this.uniforms, uniforms);
-    }
     /** @todo needed for portable model
      * @note The WebGL API is offers many ways to draw things
      * This function unifies those ways into a single call using common parameters with sane defaults
      */
     draw(options) {
-      if (this.linkStatus !== "success") {
-        return false;
-      }
       const {
         renderPass,
         vertexArray,
@@ -6749,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) {
@@ -6794,6 +6673,18 @@ ${source2}`;
       vertexArray.unbindAfterRender(renderPass);
       return true;
     }
+    // DEPRECATED METHODS
+    setUniformsWebGL(uniforms) {
+      const { bindings } = splitUniformsAndBindings(uniforms);
+      Object.keys(bindings).forEach((name2) => {
+        log.warn(
+          `Unsupported value "${JSON.stringify(
+            bindings[name2]
+          )}" used in setUniforms() for key ${name2}. Use setBindings() instead?`
+        )();
+      });
+      Object.assign(this.uniforms, uniforms);
+    }
     // PRIVATE METHODS
     // setAttributes(attributes: Record<string, Buffer>): void {}
     // setBindings(bindings: Record<string, Binding>): void {}
@@ -6806,7 +6697,7 @@ ${source2}`;
       log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
       if (log.level === 0) {
       }
-      if (!this.device.features.has("shader-status-async-webgl")) {
+      if (!this.device.features.has("compilation-status-async-webgl")) {
         const status2 = this._getLinkStatus();
         this._reportLinkStatus(status2);
         return;
@@ -6859,13 +6750,13 @@ ${source2}`;
     async _waitForLinkComplete() {
       const waitMs = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
       const DELAY_MS = 10;
-      if (!this.device.features.has("shader-status-async-webgl")) {
+      if (!this.device.features.has("compilation-status-async-webgl")) {
         await waitMs(DELAY_MS);
         return;
       }
       const { gl } = this.device;
       for (; ; ) {
-        const complete = gl.getProgramParameter(this.handle, import_constants22.GL.COMPLETION_STATUS);
+        const complete = gl.getProgramParameter(this.handle, import_constants21.GL.COMPLETION_STATUS_KHR);
         if (complete) {
           return;
         }
@@ -6905,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,
@@ -6926,11 +6817,13 @@ ${source2}`;
             uniformBufferIndex += 1;
             break;
           case "texture":
-            if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+            if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
               throw new Error("texture");
             }
             let texture;
-            if (value instanceof WEBGLTexture) {
+            if (value instanceof WEBGLTextureView) {
+              texture = value.texture;
+            } else if (value instanceof WEBGLTexture) {
               texture = value;
             } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTexture) {
               log.warn(
@@ -6940,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;
@@ -6968,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;
   }
@@ -7001,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");
@@ -7058,11 +6951,11 @@ ${source2}`;
       const webglBuffer = destination;
       const sourceWidth = width || framebuffer.width;
       const sourceHeight = height || framebuffer.height;
-      const sourceParams = getWebGLTextureParameters(framebuffer.texture.format);
+      const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format);
       const sourceFormat = sourceParams.dataFormat;
       const sourceType = sourceParams.type;
-      device.gl.bindBuffer(import_constants23.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
-      device.gl.bindFramebuffer(import_constants23.GL.FRAMEBUFFER, framebuffer.handle);
+      device.gl.bindBuffer(import_constants22.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
+      device.gl.bindFramebuffer(import_constants22.GL.FRAMEBUFFER, framebuffer.handle);
       device.gl.readPixels(
         origin[0],
         origin[1],
@@ -7073,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();
       }
@@ -7105,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) {
@@ -7192,18 +7085,12 @@ ${source2}`;
     }
     insertDebugMarker(markerLabel) {
     }
-    // writeTimestamp(querySet: Query, queryIndex: number): void {}
-    // resolveQuerySet(options: {
-    //   querySet: GPUQuerySet,
-    //   firstQuery: number,
-    //   queryCount: number,
-    //   destination: Buffer,
-    //   destinationOffset?: number;
-    // }): void;
+    resolveQuerySet(querySet, destination, options) {
+    }
   };
 
   // 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";
@@ -7241,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 {
@@ -7267,7 +7154,7 @@ ${source2}`;
       this.attributes[location] = buffer;
     }
     /** Set a location in vertex attributes array to a constant value, disables the location */
-    setConstant(location, value) {
+    setConstantWebGL(location, value) {
       this._enable(location, false);
       this.attributes[location] = value;
     }
@@ -7276,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();
@@ -7295,7 +7182,7 @@ ${source2}`;
       for (let location = 0; location < this.maxVertexAttributes; ++location) {
         const constant = this.attributes[location];
         if (ArrayBuffer.isView(constant)) {
-          this.device.setConstantAttribute(location, constant);
+          this.device.setConstantAttributeWebGL(location, constant);
         }
       }
     }
@@ -7402,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;
@@ -7438,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();
       }
@@ -7449,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) {
@@ -7483,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();
       }
@@ -7533,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);
       }
     }
   };
@@ -7552,6 +7439,140 @@ ${source2}`;
     return /^\d+$/.test(value);
   }
 
+  // src/adapter/resources/webgl-query-set.ts
+  var import_constants25 = __toESM(require_constants(), 1);
+  var WEBGLQuerySet = class extends QuerySet {
+    device;
+    handle;
+    target = null;
+    _queryPending = false;
+    _pollingPromise = null;
+    get [Symbol.toStringTag]() {
+      return "Query";
+    }
+    // Create a query class
+    constructor(device, props) {
+      super(device, props);
+      this.device = device;
+      if (props.count > 1) {
+        throw new Error("WebGL QuerySet can only have one value");
+      }
+      this.handle = this.device.gl.createQuery();
+      Object.seal(this);
+    }
+    destroy() {
+      this.device.gl.deleteQuery(this.handle);
+    }
+    // FOR RENDER PASS AND COMMAND ENCODER
+    /**
+     * Shortcut for timer query (dependent on extension in both WebGL1 and 2)
+     * Measures GPU time delta between this call and a matching `end` call in the
+     * GPU instruction stream.
+     */
+    beginTimestampQuery() {
+      return this._begin(import_constants25.GL.TIME_ELAPSED_EXT);
+    }
+    endTimestampQuery() {
+      this._end();
+    }
+    // Shortcut for occlusion queries
+    beginOcclusionQuery(options) {
+      return this._begin(
+        options?.conservative ? import_constants25.GL.ANY_SAMPLES_PASSED_CONSERVATIVE : import_constants25.GL.ANY_SAMPLES_PASSED
+      );
+    }
+    endOcclusionQuery() {
+      this._end();
+    }
+    // Shortcut for transformFeedbackQuery
+    beginTransformFeedbackQuery() {
+      return this._begin(import_constants25.GL.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
+    }
+    endTransformFeedbackQuery() {
+      this._end();
+    }
+    async resolveQuery() {
+      const value = await this.pollQuery();
+      return [value];
+    }
+    // PRIVATE METHODS
+    /**
+     * Due to OpenGL API limitations, after calling `begin()` on one Query
+     * instance, `end()` must be called on that same instance before
+     * calling `begin()` on another query. While there can be multiple
+     * outstanding queries representing disjoint `begin()`/`end()` intervals.
+     * It is not possible to interleave or overlap `begin` and `end` calls.
+     */
+    _begin(target) {
+      if (this._queryPending) {
+        return;
+      }
+      this.target = target;
+      this.device.gl.beginQuery(this.target, this.handle);
+      return;
+    }
+    // ends the current query
+    _end() {
+      if (this._queryPending) {
+        return;
+      }
+      if (this.target) {
+        this.device.gl.endQuery(this.target);
+        this.target = null;
+        this._queryPending = true;
+      }
+      return;
+    }
+    // Returns true if the query result is available
+    isResultAvailable() {
+      if (!this._queryPending) {
+        return false;
+      }
+      const resultAvailable = this.device.gl.getQueryParameter(
+        this.handle,
+        import_constants25.GL.QUERY_RESULT_AVAILABLE
+      );
+      if (resultAvailable) {
+        this._queryPending = false;
+      }
+      return resultAvailable;
+    }
+    // Timing query is disjoint, i.e. results are invalid
+    isTimerDisjoint() {
+      return this.device.gl.getParameter(import_constants25.GL.GPU_DISJOINT_EXT);
+    }
+    // Returns query result.
+    getResult() {
+      return this.device.gl.getQueryParameter(this.handle, import_constants25.GL.QUERY_RESULT);
+    }
+    // Returns the query result, converted to milliseconds to match JavaScript conventions.
+    getTimerMilliseconds() {
+      return this.getResult() / 1e6;
+    }
+    // Polls the query
+    pollQuery(limit = Number.POSITIVE_INFINITY) {
+      if (this._pollingPromise) {
+        return this._pollingPromise;
+      }
+      let counter = 0;
+      this._pollingPromise = new Promise((resolve, reject) => {
+        const poll = () => {
+          if (this.isResultAvailable()) {
+            resolve(this.getResult());
+            this._pollingPromise = null;
+          } else if (counter++ > limit) {
+            reject("Timed out");
+            this._pollingPromise = null;
+          } else {
+            requestAnimationFrame(poll);
+          }
+        };
+        requestAnimationFrame(poll);
+      });
+      return this._pollingPromise;
+    }
+  };
+
   // src/classic/copy-and-blit.ts
   var import_constants27 = __toESM(require_constants(), 1);
 
@@ -7615,7 +7636,7 @@ ${source2}`;
     sourceWidth = sourceWidth || framebuffer.width;
     sourceHeight = sourceHeight || framebuffer.height;
     const attachment = sourceAttachment - import_constants27.GL.COLOR_ATTACHMENT0;
-    sourceType = sourceType || framebuffer.colorAttachments[attachment]?.type || import_constants27.GL.UNSIGNED_BYTE;
+    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_constants27.GL.FRAMEBUFFER, handle);
@@ -7627,7 +7648,13 @@ ${source2}`;
     return target;
   }
   function readPixelsToBuffer(source, options) {
-    const { target, sourceX = 0, sourceY = 0, sourceFormat = import_constants27.GL.RGBA, targetByteOffset = 0 } = options || {};
+    const {
+      target,
+      sourceX = 0,
+      sourceY = 0,
+      sourceFormat = import_constants27.GL.RGBA,
+      targetByteOffset = 0
+    } = options || {};
     let { sourceWidth, sourceHeight, sourceType } = options || {};
     const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
     assert2(framebuffer);
@@ -7715,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);
     });
   }
@@ -7724,27 +7751,23 @@ ${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;
+    limits;
     info;
     canvasContext;
-    handle;
-    get features() {
-      this._features = this._features || getDeviceFeatures(this.gl);
-      return this._features;
-    }
-    get limits() {
-      this._limits = this._limits || getDeviceLimits(this.gl);
-      return this._limits;
-    }
     lost;
     _resolveContextLost;
-    _features;
-    _limits;
     //
     // Static methods, expected to be present by `luma.createDevice()`
     //
+    /** Check if WebGL 2 is available */
+    static isSupported() {
+      return typeof WebGL2RenderingContext !== "undefined";
+    }
     /**
      * Get a device instance from a GL context
      * Creates and instruments the device if not already created
@@ -7765,22 +7788,29 @@ ${source2}`;
     }
     static async create(props = {}) {
       log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
-      if (typeof props.canvas === "string") {
-        await CanvasContext.pageLoaded;
+      const promises = [];
+      if (props.debug) {
+        promises.push(loadWebGLDeveloperTools());
       }
-      if (log.get("debug") || props.debug) {
-        await loadWebGLDeveloperTools();
+      if (props.spector) {
+        promises.push(loadSpectorJS());
       }
-      const { spector: spector2 } = props;
-      if (log.get("spector") || spector2) {
-        await loadSpectorJS();
+      if (typeof props.canvas === "string") {
+        promises.push(CanvasContext.pageLoaded);
+      }
+      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 && props.gl.device) {
+      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)();
@@ -7795,46 +7825,52 @@ ${source2}`;
       if (device) {
         throw new Error(`WebGL context already attached to device ${device.id}`);
       }
-      const canvas = props.canvas || props.gl?.canvas;
+      const canvas = props.gl?.canvas || props.canvas;
       this.canvasContext = new WebGLCanvasContext(this, { ...props, canvas });
       this.lost = new Promise((resolve) => {
         this._resolveContextLost = resolve;
       });
-      const onContextLost = (event) => this._resolveContextLost?.({
-        reason: "destroyed",
-        message: "Computer entered sleep mode, or too many apps or browser tabs are using the GPU."
-      });
       let gl = props.gl || null;
-      gl = gl || (isBrowser() ? createBrowserContext(this.canvasContext.canvas, { ...props, onContextLost }) : null);
+      gl ||= createBrowserContext(this.canvasContext.canvas, {
+        ...props,
+        onContextLost: (event) => this._resolveContextLost?.({
+          reason: "destroyed",
+          message: "Entered sleep mode, or too many apps or browser tabs are using the GPU."
+        })
+      });
       if (!gl) {
         throw new Error("WebGL context creation failed");
       }
       this.handle = gl;
-      this.gl = this.handle;
-      this.canvasContext.resize();
-      this.info = getDeviceInfo(this.gl);
+      this.gl = gl;
       this.gl.device = this;
-      this.gl._version = this.isWebGL2 ? 2 : 1;
+      this.gl._version = 2;
+      this.info = getDeviceInfo(this.gl, this._extensions);
+      this.limits = new WebGLDeviceLimits(this.gl);
+      this.features = new WebGLDeviceFeatures(this.gl, this._extensions, this.props.disabledFeatures);
+      if (this.props.initalizeFeatures) {
+        this.features.initializeFeatures();
+      }
+      this.canvasContext.resize();
       const { enable: enable2 = true, copyState = false } = props;
       trackContextState(this.gl, {
         enable: enable2,
         copyState,
         log: (...args) => log.log(1, ...args)()
       });
-      if (isBrowser() && props.debug) {
+      if (props.debug) {
         this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true });
         this.debug = true;
         log.level = Math.max(log.level, 1);
         log.warn("WebGL debug mode activated. Performance reduced.")();
       }
-      if (isBrowser() && props.spector) {
-        const canvas2 = this.handle.canvas || props.canvas;
-        this.spector = initializeSpectorJS({ ...this.props, canvas: canvas2 });
+      if (props.spector) {
+        this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas });
       }
     }
     /**
      * Destroys the context
-     * @note Has no effect for browser contexts, there is no browser API for destroying contexts
+     * @note Has no effect for WebGL browser contexts, there is no browser API for destroying contexts
      */
     destroy() {
     }
@@ -7845,13 +7881,13 @@ ${source2}`;
       return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight];
     }
     isTextureFormatSupported(format) {
-      return isTextureFormatSupported(this.gl, format);
+      return isTextureFormatSupported(this.gl, format, this._extensions);
     }
     isTextureFormatFilterable(format) {
-      return isTextureFormatFilterable(this.gl, format);
+      return isTextureFormatFilterable(this.gl, format, this._extensions);
     }
     isTextureFormatRenderable(format) {
-      return isTextureFormatRenderable(this.gl, format);
+      return isTextureFormatRenderable(this.gl, format, this._extensions);
     }
     // IMPLEMENTATION OF ABSTRACT DEVICE
     createCanvasContext(props) {
@@ -7876,12 +7912,18 @@ ${source2}`;
     createFramebuffer(props) {
       return new WEBGLFramebuffer(this, props);
     }
-    createRenderPipeline(props) {
-      return new WEBGLRenderPipeline(this, props);
-    }
     createVertexArray(props) {
       return new WEBGLVertexArray(this, props);
     }
+    createTransformFeedback(props) {
+      return new WEBGLTransformFeedback(this, props);
+    }
+    createQuerySet(props) {
+      return new WEBGLQuerySet(this, props);
+    }
+    createRenderPipeline(props) {
+      return new WEBGLRenderPipeline(this, props);
+    }
     beginRenderPass(props) {
       return new WEBGLRenderPass(this, props);
     }
@@ -7891,16 +7933,7 @@ ${source2}`;
     beginComputePass(props) {
       throw new Error("ComputePass not supported in WebGL");
     }
-    createTransformFeedback(props) {
-      return new WEBGLTransformFeedback(this, props);
-    }
     renderPass = null;
-    getDefaultRenderPass() {
-      this.renderPass = this.renderPass || this.beginRenderPass({
-        framebuffer: this.canvasContext.getCurrentFramebuffer()
-      });
-      return this.renderPass;
-    }
     createCommandEncoder(props) {
       return new WEBGLCommandEncoder(this, props);
     }
@@ -7915,7 +7948,7 @@ ${source2}`;
     }
     //
     // TEMPORARY HACKS - will be removed in v9.1
-    // 
+    //
     /** @deprecated - should use command encoder */
     readPixelsToArrayWebGL(source, options) {
       return readPixelsToArray(source, options);
@@ -7925,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);
@@ -7948,20 +7981,15 @@ ${source2}`;
     _extensions = {};
     _polyfilled = false;
     /** Instance of Spector.js (if initialized) */
-    spector;
-    _webglLimits;
-    /** Return WebGL specific limits */
-    get webglLimits() {
-      this._webglLimits = this._webglLimits || getWebGLLimits(this.gl);
-      return this._webglLimits;
-    }
+    spectorJS;
     /**
      * Triggers device (or WebGL context) loss.
      * @note primarily intended for testing how application reacts to device loss
      */
     loseDevice() {
       let deviceLossTriggered = false;
-      const ext = this.gl.getExtension("WEBGL_lose_context");
+      const extensions = this.getExtension("WEBGL_lose_context");
+      const ext = extensions.WEBGL_lose_context;
       if (ext) {
         deviceLossTriggered = true;
         ext.loseContext();
@@ -8010,11 +8038,15 @@ ${source2}`;
      * so they need to be updated before every render
      * @todo - remember/cache values to avoid setting them unnecessarily?
      */
-    setConstantAttribute(location, constant) {
-      this._constants = this._constants || new Array(this.limits.maxVertexAttributes).fill(null);
+    setConstantAttributeWebGL(location, constant) {
+      const maxVertexAttributes = this.limits.maxVertexAttributes;
+      this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
       const currentConstant = this._constants[location];
       if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-        log.info(1, `setConstantAttribute(${location}) could have been skipped, value unchanged`)();
+        log.info(
+          1,
+          `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`
+        )();
       }
       this._constants[location] = constant;
       switch (constant.constructor) {
@@ -8031,11 +8063,17 @@ ${source2}`;
           assert2(false);
       }
     }
+    /** Ensure extensions are only requested once */
+    getExtension(name2) {
+      getWebGLExtension(this.gl, name2, this._extensions);
+      return this._extensions;
+    }
   };
   var WebGLDevice = _WebGLDevice;
   //
   // Public `Device` API
   //
+  /** type of this device */
   __publicField(WebGLDevice, "type", "webgl");
   function isWebGL(gl) {
     if (typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext) {
@@ -8078,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__;