@luma.gl/core 9.0.17 → 9.1.0-alpha.10

package/dist/dist.dev.js

@@ -32,6 +32,7 @@ var __exports__ = (() => {
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
+    Adapter: () => Adapter,
     Buffer: () => Buffer2,
     CanvasContext: () => CanvasContext,
     CommandBuffer: () => CommandBuffer,
@@ -49,54 +50,234 @@ var __exports__ = (() => {
     Resource: () => Resource,
     Sampler: () => Sampler,
     Shader: () => Shader,
-    StatsManager: () => StatsManager,
     Texture: () => Texture,
     TextureView: () => TextureView,
     TransformFeedback: () => TransformFeedback,
     UniformBlock: () => UniformBlock,
     UniformBufferLayout: () => UniformBufferLayout,
     UniformStore: () => UniformStore,
-    VERSION: () => VERSION2,
     VertexArray: () => VertexArray,
-    assert: () => assert2,
-    cancelAnimationFrame: () => cancelAnimationFrame,
-    cast: () => cast,
-    checkProps: () => checkProps,
     decodeShaderAttributeType: () => decodeShaderAttributeType,
     decodeShaderUniformType: () => decodeShaderUniformType,
     decodeTextureFormat: () => decodeTextureFormat,
     decodeVertexFormat: () => decodeVertexFormat,
-    deepEqual: () => deepEqual,
-    fillArray: () => fillArray,
-    formatCompilerLog: () => formatCompilerLog,
-    formatValue: () => formatValue,
     getAttributeInfosFromLayouts: () => getAttributeInfosFromLayouts,
     getDataTypeFromTypedArray: () => getDataTypeFromTypedArray,
     getScratchArray: () => getScratchArray,
-    getScratchArrayBuffer: () => getScratchArrayBuffer,
     getTypedArrayFromDataType: () => getTypedArrayFromDataType,
     getVertexFormatFromAttribute: () => getVertexFormatFromAttribute,
-    glsl: () => glsl,
-    isNumberArray: () => isNumberArray,
-    isObjectEmpty: () => isObjectEmpty,
-    isTypedArray: () => isTypedArray,
-    isUniformValue: () => isUniformValue,
-    loadFile: () => loadFile,
-    loadImage: () => loadImage,
-    loadImageBitmap: () => loadImageBitmap,
-    loadScript: () => loadScript,
     log: () => log,
-    luma: () => luma,
-    makeRandomNumberGenerator: () => makeRandomNumberGenerator,
-    mergeShaderLayout: () => mergeShaderLayout,
-    random: () => random,
-    requestAnimationFrame: () => requestAnimationFrame,
-    setPathPrefix: () => setPathPrefix,
-    splitUniformsAndBindings: () => splitUniformsAndBindings,
-    stubRemovedMethods: () => stubRemovedMethods,
-    uid: () => uid
+    luma: () => luma
   });
 
+  // ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp() {
+    let timestamp;
+    if (typeof window !== "undefined" && window.performance) {
+      timestamp = window.performance.now();
+    } else if (typeof process !== "undefined" && process.hrtime) {
+      const timeParts = process.hrtime();
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
+  var Stat = class {
+    constructor(name2, type) {
+      this.sampleSize = 1;
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      this.name = name2;
+      this.type = type;
+      this.reset();
+    }
+    reset() {
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      return this;
+    }
+    setSampleSize(samples) {
+      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;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Start a timer */
+    timeStart() {
+      this._startTime = getHiResTimestamp();
+      this._timerPending = true;
+      return this;
+    }
+    /** End a timer. Adds to time and bumps the timing count. */
+    timeEnd() {
+      if (!this._timerPending) {
+        return this;
+      }
+      this.addTime(getHiResTimestamp() - this._startTime);
+      this._timerPending = false;
+      this._checkSampling();
+      return this;
+    }
+    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;
+    }
+    _checkSampling() {
+      if (this._samples === this.sampleSize) {
+        this.lastSampleTime = this._time;
+        this.lastSampleCount = this._count;
+        this.count += this._count;
+        this.time += this._time;
+        this.samples += this._samples;
+        this._time = 0;
+        this._count = 0;
+        this._samples = 0;
+      }
+    }
+  };
+
+  // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
+  var Stats = class {
+    constructor(options) {
+      this.stats = {};
+      this.id = options.id;
+      this.stats = {};
+      this._initializeStats(options.stats);
+      Object.seal(this);
+    }
+    /** 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();
+      }
+      return this;
+    }
+    forEach(fn) {
+      for (const stat of Object.values(this.stats)) {
+        fn(stat);
+      }
+    }
+    getTable() {
+      const table = {};
+      this.forEach((stat) => {
+        table[stat.name] = {
+          time: stat.time || 0,
+          count: stat.count || 0,
+          average: stat.getAverageTime() || 0,
+          hz: stat.getHz() || 0
+        };
+      });
+      return table;
+    }
+    _initializeStats(stats = []) {
+      stats.forEach((stat) => this._getOrCreate(stat));
+    }
+    _getOrCreate(stat) {
+      const { name: name2, type } = stat;
+      let result = this.stats[name2];
+      if (!result) {
+        if (stat instanceof Stat) {
+          result = stat;
+        } else {
+          result = new Stat(name2, type);
+        }
+        this.stats[name2] = result;
+      }
+      return result;
+    }
+  };
+
+  // src/utils/stats-manager.ts
+  var StatsManager = class {
+    stats = /* @__PURE__ */ new Map();
+    getStats(name2) {
+      return this.get(name2);
+    }
+    get(name2) {
+      if (!this.stats.has(name2)) {
+        this.stats.set(name2, new Stats({ id: name2 }));
+      }
+      return this.stats.get(name2);
+    }
+  };
+  var lumaStats = new StatsManager();
+
   // ../../node_modules/@probe.gl/env/dist/lib/globals.js
   var window_ = globalThis;
   var document_ = globalThis.document || {};
@@ -254,7 +435,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
-  function getHiResTimestamp() {
+  function getHiResTimestamp2() {
     let timestamp;
     if (isBrowser() && window_.performance) {
       timestamp = window_?.performance?.now?.();
@@ -286,8 +467,8 @@ var __exports__ = (() => {
   var Log = class {
     constructor({ id } = { id: "" }) {
       this.VERSION = VERSION;
-      this._startTs = getHiResTimestamp();
-      this._deltaTs = getHiResTimestamp();
+      this._startTs = getHiResTimestamp2();
+      this._deltaTs = getHiResTimestamp2();
       this.userData = {};
       this.LOG_THROTTLE_TIMEOUT = 0;
       this.id = id;
@@ -311,11 +492,11 @@ var __exports__ = (() => {
     }
     /** @return milliseconds, with fractions */
     getTotal() {
-      return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
+      return Number((getHiResTimestamp2() - this._startTs).toPrecision(10));
     }
     /** @return milliseconds, with fractions */
     getDelta() {
-      return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
+      return Number((getHiResTimestamp2() - this._deltaTs).toPrecision(10));
     }
     /** @deprecated use logLevel */
     set priority(newPriority) {
@@ -445,11 +626,11 @@ var __exports__ = (() => {
         assert(method);
         opts.total = this.getTotal();
         opts.delta = this.getDelta();
-        this._deltaTs = getHiResTimestamp();
+        this._deltaTs = getHiResTimestamp2();
         const tag = opts.tag || opts.message;
         if (opts.once && tag) {
           if (!cache[tag]) {
-            cache[tag] = getHiResTimestamp();
+            cache[tag] = getHiResTimestamp2();
           } else {
             return noop;
           }
@@ -489,308 +670,55 @@ var __exports__ = (() => {
       case "string":
       case "function":
         if (message !== void 0) {
-          args.unshift(message);
-        }
-        opts.message = logLevel;
-        break;
-      case "object":
-        Object.assign(opts, logLevel);
-        break;
-      default:
-    }
-    if (typeof opts.message === "function") {
-      opts.message = opts.message();
-    }
-    const messageType = typeof opts.message;
-    assert(messageType === "string" || messageType === "object");
-    return Object.assign(opts, { args }, opts.opts);
-  }
-  function decorateMessage(id, message, opts) {
-    if (typeof message === "string") {
-      const time = opts.time ? leftPad(formatTime(opts.total)) : "";
-      message = opts.time ? `${id}: ${time}  ${message}` : `${id}: ${message}`;
-      message = addColor(message, opts.color, opts.background);
-    }
-    return message;
-  }
-  function getTableHeader(table) {
-    for (const key in table) {
-      for (const title in table[key]) {
-        return title || "untitled";
-      }
-    }
-    return "empty";
-  }
-
-  // ../../node_modules/@probe.gl/log/dist/init.js
-  globalThis.probe = {};
-
-  // ../../node_modules/@probe.gl/log/dist/index.js
-  var dist_default = new Log({ id: "@probe.gl/log" });
-
-  // src/utils/log.ts
-  var log = new Log({ id: "luma.gl" });
-
-  // ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
-  function getHiResTimestamp2() {
-    let timestamp;
-    if (typeof window !== "undefined" && window.performance) {
-      timestamp = window.performance.now();
-    } else if (typeof process !== "undefined" && process.hrtime) {
-      const timeParts = process.hrtime();
-      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
-    } else {
-      timestamp = Date.now();
-    }
-    return timestamp;
-  }
-
-  // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
-  var Stat = class {
-    constructor(name2, type) {
-      this.sampleSize = 1;
-      this.time = 0;
-      this.count = 0;
-      this.samples = 0;
-      this.lastTiming = 0;
-      this.lastSampleTime = 0;
-      this.lastSampleCount = 0;
-      this._count = 0;
-      this._time = 0;
-      this._samples = 0;
-      this._startTime = 0;
-      this._timerPending = false;
-      this.name = name2;
-      this.type = type;
-      this.reset();
-    }
-    reset() {
-      this.time = 0;
-      this.count = 0;
-      this.samples = 0;
-      this.lastTiming = 0;
-      this.lastSampleTime = 0;
-      this.lastSampleCount = 0;
-      this._count = 0;
-      this._time = 0;
-      this._samples = 0;
-      this._startTime = 0;
-      this._timerPending = false;
-      return this;
-    }
-    setSampleSize(samples) {
-      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;
-      this._samples++;
-      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;
-      }
-      this.addTime(getHiResTimestamp2() - this._startTime);
-      this._timerPending = false;
-      this._checkSampling();
-      return this;
-    }
-    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;
-    }
-    _checkSampling() {
-      if (this._samples === this.sampleSize) {
-        this.lastSampleTime = this._time;
-        this.lastSampleCount = this._count;
-        this.count += this._count;
-        this.time += this._time;
-        this.samples += this._samples;
-        this._time = 0;
-        this._count = 0;
-        this._samples = 0;
-      }
-    }
-  };
-
-  // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
-  var Stats = class {
-    constructor(options) {
-      this.stats = {};
-      this.id = options.id;
-      this.stats = {};
-      this._initializeStats(options.stats);
-      Object.seal(this);
-    }
-    /** 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();
-      }
-      return this;
-    }
-    forEach(fn) {
-      for (const stat of Object.values(this.stats)) {
-        fn(stat);
-      }
-    }
-    getTable() {
-      const table = {};
-      this.forEach((stat) => {
-        table[stat.name] = {
-          time: stat.time || 0,
-          count: stat.count || 0,
-          average: stat.getAverageTime() || 0,
-          hz: stat.getHz() || 0
-        };
-      });
-      return table;
-    }
-    _initializeStats(stats = []) {
-      stats.forEach((stat) => this._getOrCreate(stat));
-    }
-    _getOrCreate(stat) {
-      const { name: name2, type } = stat;
-      let result = this.stats[name2];
-      if (!result) {
-        if (stat instanceof Stat) {
-          result = stat;
-        } else {
-          result = new Stat(name2, type);
-        }
-        this.stats[name2] = result;
-      }
-      return result;
-    }
-  };
-
-  // src/utils/stats-manager.ts
-  var StatsManager = class {
-    stats = /* @__PURE__ */ new Map();
-    getStats(name2) {
-      return this.get(name2);
-    }
-    get(name2) {
-      if (!this.stats.has(name2)) {
-        this.stats.set(name2, new Stats({ id: name2 }));
-      }
-      return this.stats.get(name2);
-    }
-  };
-  var lumaStats = new StatsManager();
-
-  // src/init.ts
-  function initializeLuma() {
-    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}`
-      );
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
     }
-    if (!globalThis.luma) {
-      if (isBrowser()) {
-        log.log(1, `${VERSION3} - ${STARTUP_MESSAGE}`)();
-      }
-      globalThis.luma = globalThis.luma || {
-        VERSION: VERSION3,
-        version: VERSION3,
-        log,
-        // A global stats object that various components can add information to
-        // E.g. see webgl/resource.js
-        stats: lumaStats
-      };
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
     }
-    return VERSION3;
+    const messageType = typeof opts.message;
+    assert(messageType === "string" || messageType === "object");
+    return Object.assign(opts, { args }, opts.opts);
   }
-  var VERSION2 = initializeLuma();
-
-  // src/utils/is-array.ts
-  function isTypedArray(value) {
-    return ArrayBuffer.isView(value) && !(value instanceof DataView) ? value : null;
+  function decorateMessage(id, message, opts) {
+    if (typeof message === "string") {
+      const time = opts.time ? leftPad(formatTime(opts.total)) : "";
+      message = opts.time ? `${id}: ${time}  ${message}` : `${id}: ${message}`;
+      message = addColor(message, opts.color, opts.background);
+    }
+    return message;
   }
-  function isNumberArray(value) {
-    if (Array.isArray(value)) {
-      return value.length === 0 || typeof value[0] === "number" ? value : null;
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
     }
-    return isTypedArray(value);
+    return "empty";
   }
 
-  // src/utils/utils.ts
+  // ../../node_modules/@probe.gl/log/dist/init.js
+  globalThis.probe = {};
+
+  // ../../node_modules/@probe.gl/log/dist/index.js
+  var dist_default = new Log({ id: "@probe.gl/log" });
+
+  // src/utils/log.ts
+  var log = new Log({ id: "luma.gl" });
+
+  // src/utils/uid.ts
   var uidCounters = {};
   function uid(id = "id") {
     uidCounters[id] = uidCounters[id] || 1;
     const count = uidCounters[id]++;
     return `${id}-${count}`;
   }
-  function isObjectEmpty(obj) {
-    let isEmpty = true;
-    for (const key in obj) {
-      isEmpty = false;
-      break;
-    }
-    return isEmpty;
-  }
 
   // src/adapter/resources/resource.ts
   var Resource = class {
@@ -955,17 +883,17 @@ var __exports__ = (() => {
     debugData = new ArrayBuffer(0);
     /** This doesn't handle partial non-zero offset updates correctly */
     _setDebugData(data, byteOffset, byteLength) {
-      const buffer = ArrayBuffer.isView(data) ? data.buffer : data;
+      const arrayBuffer2 = ArrayBuffer.isView(data) ? data.buffer : data;
       const debugDataLength = Math.min(
         data ? data.byteLength : byteLength,
         _Buffer.DEBUG_DATA_MAX_LENGTH
       );
-      if (data === null) {
+      if (arrayBuffer2 === null) {
         this.debugData = new ArrayBuffer(debugDataLength);
-      } else if (byteOffset === 0 && byteLength === data.byteLength) {
-        this.debugData = buffer.slice(0, debugDataLength);
+      } else if (byteOffset === 0 && byteLength === arrayBuffer2.byteLength) {
+        this.debugData = arrayBuffer2.slice(0, debugDataLength);
       } else {
-        this.debugData = buffer.slice(byteOffset, byteOffset + debugDataLength);
+        this.debugData = arrayBuffer2.slice(byteOffset, byteOffset + debugDataLength);
       }
     }
   };
@@ -999,7 +927,7 @@ var __exports__ = (() => {
   /** Max amount of debug data saved. Two vec4's */
   __publicField(Buffer2, "DEBUG_DATA_MAX_LENGTH", 32);
 
-  // src/adapter/type-utils/decode-data-type.ts
+  // src/gpu-type-utils/decode-data-type.ts
   function decodeVertexType(type) {
     const dataType = TYPE_MAP[type];
     const bytes = getDataTypeBytes(dataType);
@@ -1043,7 +971,7 @@ var __exports__ = (() => {
     sint32: 4
   };
 
-  // src/adapter/type-utils/decode-texture-format.ts
+  // src/gpu-type-utils/decode-texture-format.ts
   var COMPRESSED_TEXTURE_FORMAT_PREFIXES = [
     "bc1",
     "bc2",
@@ -1059,63 +987,97 @@ var __exports__ = (() => {
     "astc",
     "pvrtc"
   ];
-  var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;
+  var REGEX = /^(r|rg|rgb|rgba|bgra)([0-9]*)([a-z]*)(-srgb)?(-webgl)?$/;
   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 [, channels, length, type, srgb, suffix] = matches;
+      if (format) {
         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
+        const info = {
+          channels,
+          components: channels.length,
+          bitsPerChannel: decodedType.byteLength * 8,
+          bytesPerPixel: decodedType.byteLength * channels.length,
+          dataType: decodedType.dataType,
+          integer: decodedType.integer,
+          signed: decodedType.signed,
+          normalized: decodedType.normalized
         };
+        if (suffix === "-webgl") {
+          info.webgl = true;
+        }
+        if (srgb === "-srgb") {
+          info.srgb = true;
+        }
+        return info;
       }
     }
     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 },
+    "rgba4unorm-webgl": { channels: "rgba", bytesPerPixel: 2, packed: true },
+    "rgb565unorm-webgl": { channels: "rgb", bytesPerPixel: 2, packed: true },
+    "rgb5a1unorm-webgl": { channels: "rgba", bytesPerPixel: 2, packed: true },
     // 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 },
+    rgb9e5ufloat: { channels: "rgb", bytesPerPixel: 4, packed: true },
+    rg11b10ufloat: { channels: "rgb", bytesPerPixel: 4, packed: true },
+    rgb10a2unorm: { channels: "rgba", bytesPerPixel: 4, packed: true },
+    "rgb10a2uint-webgl": { channels: "rgba", bytesPerPixel: 4, packed: true },
     // 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" },
+    stencil8: { components: 1, bytesPerPixel: 1, a: "stencil", dataType: "uint8" },
+    depth16unorm: { components: 1, bytesPerPixel: 2, a: "depth", dataType: "uint16" },
+    depth24plus: { components: 1, bytesPerPixel: 3, a: "depth", dataType: "uint32" },
+    depth32float: { components: 1, bytesPerPixel: 4, a: "depth", dataType: "float32" },
+    "depth24plus-stencil8": { components: 2, bytesPerPixel: 4, a: "depth-stencil", packed: true },
     // "depth32float-stencil8" feature
-    "depth32float-stencil8": { components: 2, bpp: 4, a: "depth-stencil" }
+    "depth32float-stencil8": { components: 2, bytesPerPixel: 4, a: "depth-stencil", packed: true }
   };
   function decodeNonStandardFormat(format) {
+    if (isTextureFormatCompressed(format)) {
+      const info2 = {
+        channels: "rgb",
+        components: 3,
+        bytesPerPixel: 1,
+        srgb: false,
+        compressed: true
+      };
+      const blockSize = getCompressedTextureBlockSize(format);
+      if (blockSize) {
+        info2.blockWidth = blockSize.blockWidth;
+        info2.blockHeight = blockSize.blockHeight;
+      }
+      return info2;
+    }
     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
+    const info = {
+      ...data,
+      channels: data.channels || "",
+      components: data.components || data.channels?.length || 1,
+      bytesPerPixel: data.bytesPerPixel || 1,
+      srgb: false
     };
+    if (data.packed) {
+      info.packed = data.packed;
+    }
+    return info;
+  }
+  function getCompressedTextureBlockSize(format) {
+    const REGEX2 = /.*-(\d+)x(\d+)-.*/;
+    const matches = REGEX2.exec(format);
+    if (matches) {
+      const [, blockWidth, blockHeight] = matches;
+      return { blockWidth: Number(blockWidth), blockHeight: Number(blockHeight) };
+    }
+    return null;
   }
 
   // src/adapter/device.ts
@@ -1132,7 +1094,7 @@ var __exports__ = (() => {
       yield* this.features;
     }
     has(feature) {
-      return !this.disabledFeatures[feature] && this.features.has(feature);
+      return !this.disabledFeatures?.[feature] && this.features.has(feature);
     }
   };
   var _Device = class {
@@ -1165,6 +1127,10 @@ var __exports__ = (() => {
     loseDevice() {
       return false;
     }
+    /** Report error (normally for unhandled device errors) */
+    error(error) {
+      this.props.onError(error);
+    }
     /** Returns the default / primary canvas context. Throws an error if no canvas context is available (a WebGPU compute device) */
     getCanvasContext() {
       if (!this.canvasContext) {
@@ -1172,10 +1138,8 @@ var __exports__ = (() => {
       }
       return this.canvasContext;
     }
+    // createTexture(data: Promise<TextureData>): Texture;
     createTexture(props) {
-      if (props instanceof Promise || typeof props === "string") {
-        props = { data: props };
-      }
       return this._createTexture(props);
     }
     createCommandEncoder(props = {}) {
@@ -1249,16 +1213,9 @@ var __exports__ = (() => {
     // 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") || log.get("spectorjs")),
-    // Initialize the SpectorJS WebGL debugger
-    break: [],
-    // TODO - Change these after confirming things work as expected
-    initalizeFeatures: true,
-    disabledFeatures: {
-      "compilation-status-async-webgl": true
-    },
+    // Callbacks
+    onError: (error) => log.error(error.message),
+    gl: null,
     // alpha: undefined,
     // depth: undefined,
     // stencil: undefined,
@@ -1266,133 +1223,154 @@ var __exports__ = (() => {
     // premultipliedAlpha: undefined,
     // preserveDrawingBuffer: undefined,
     // failIfMajorPerformanceCaveat: undefined
-    gl: null,
-    // Callbacks
-    onError: (error) => log.error(error.message)
+    debug: Boolean(log.get("debug")),
+    // Instrument context (at the expense of performance)
+    break: log.get("break") || [],
+    // WebGL specific debugging
+    debugWithSpectorJS: void 0,
+    spectorUrl: void 0,
+    // TODO - Change these after confirming things work as expected
+    initalizeFeatures: true,
+    disabledFeatures: {
+      "compilation-status-async-webgl": true
+    },
+    _factoryDestroyPolicy: "unused"
   });
-  __publicField(Device, "VERSION", VERSION2);
 
-  // src/utils/assert.ts
-  function assert2(condition, message) {
-    if (!condition) {
-      throw new Error(message || "luma.gl: assertion failed.");
+  // src/adapter/luma.ts
+  var STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering";
+  var ERROR_MESSAGE = "No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.";
+  var _Luma = class {
+    /** Global stats for all devices */
+    stats = lumaStats;
+    /**
+     * Global log
+     *
+     * Assign luma.log.level in console to control logging: \
+     * 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs
+     * luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;
+     */
+    log = log;
+    /** Version of luma.gl */
+    VERSION = (
+      // Version detection using build plugin
+      // @ts-expect-error no-undef
+      typeof __VERSION__ !== "undefined" ? __VERSION__ : "running from source"
+    );
+    spector;
+    preregisteredAdapters = /* @__PURE__ */ new Map();
+    constructor() {
+      if (globalThis.luma) {
+        if (globalThis.luma.VERSION !== this.VERSION) {
+          log.error(`Found luma.gl ${globalThis.luma.VERSION} while initialzing ${this.VERSION}`)();
+          log.error(`'yarn why @luma.gl/core' can help identify the source of the conflict`)();
+          throw new Error(`luma.gl - multiple versions detected: see console log`);
+        }
+        log.error("This version of luma.gl has already been initialized")();
+      }
+      log.log(1, `${this.VERSION} - ${STARTUP_MESSAGE}`)();
+      globalThis.luma = this;
     }
-  }
-
-  // src/lib/luma.ts
-  var deviceMap = /* @__PURE__ */ new Map();
-  var _luma = class {
-    static registerDevices(deviceClasses) {
-      for (const deviceClass of deviceClasses) {
-        assert2(deviceClass.type && deviceClass.isSupported && deviceClass.create);
-        deviceMap.set(deviceClass.type, deviceClass);
+    registerAdapters(adapters) {
+      for (const deviceClass of adapters) {
+        this.preregisteredAdapters.set(deviceClass.type, deviceClass);
       }
     }
-    static getAvailableDevices() {
-      return Array.from(deviceMap).map((Device2) => Device2.type);
+    /** Get type strings for supported Devices */
+    getSupportedAdapters(adapters = []) {
+      const adapterMap = this.getAdapterMap(adapters);
+      return Array.from(adapterMap).map(([, adapter]) => adapter).filter((adapter) => adapter.isSupported?.()).map((adapter) => adapter.type);
+    }
+    /** Get type strings for best available Device */
+    getBestAvailableAdapter(adapters = []) {
+      const adapterMap = this.getAdapterMap(adapters);
+      if (adapterMap.get("webgpu")?.isSupported?.()) {
+        return "webgpu";
+      }
+      if (adapterMap.get("webgl")?.isSupported?.()) {
+        return "webgl";
+      }
+      return null;
     }
-    static getSupportedDevices() {
-      return Array.from(deviceMap).filter((Device2) => Device2.isSupported()).map((Device2) => Device2.type);
+    setDefaultDeviceProps(props) {
+      Object.assign(_Luma.defaultProps, props);
     }
-    static setDefaultDeviceProps(props) {
-      Object.assign(Device.defaultProps, props);
+    /** Creates a device. Asynchronously. */
+    async createDevice(props = {}) {
+      props = { ..._Luma.defaultProps, ...props };
+      const adapterMap = this.getAdapterMap(props.adapters);
+      let type = props.type || "";
+      if (type === "best-available") {
+        type = this.getBestAvailableAdapter(props.adapters) || type;
+      }
+      const adapters = this.getAdapterMap(props.adapters) || adapterMap;
+      const adapter = adapters.get(type);
+      const device = await adapter?.create?.(props);
+      if (device) {
+        return device;
+      }
+      throw new Error(ERROR_MESSAGE);
     }
     /** Attach to an existing GPU API handle (WebGL2RenderingContext or GPUDevice). */
-    static async attachDevice(props) {
-      const devices = getDeviceMap(props.devices) || deviceMap;
+    async attachDevice(props) {
+      const adapters = this.getAdapterMap(props.adapters);
+      let type = "";
       if (props.handle instanceof WebGL2RenderingContext) {
-        const WebGLDevice = devices.get("webgl");
-        if (WebGLDevice) {
-          return await WebGLDevice.attach(props.handle);
-        }
+        type = "webgl";
       }
       if (props.handle === null) {
-        const UnknownDevice = devices.get("unknown");
-        if (UnknownDevice) {
-          return await UnknownDevice.attach(null);
-        }
+        type = "unknown";
       }
-      throw new Error(
-        "Failed to attach device. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported."
-      );
-    }
-    /** Creates a device. Asynchronously. */
-    static async createDevice(props = {}) {
-      props = { ..._luma.defaultProps, ...props };
-      if (props.gl) {
-        props.type = "webgl";
-      }
-      const devices = getDeviceMap(props.devices) || deviceMap;
-      switch (props.type) {
-        case "webgpu":
-          let WebGPUDevice = devices.get("webgpu");
-          if (WebGPUDevice) {
-            return await WebGPUDevice.create(props);
-          }
-          break;
-        case "webgl":
-          let WebGLDevice = devices.get("webgl");
-          if (WebGLDevice) {
-            return await WebGLDevice.create(props);
-          }
-          break;
-        case "unknown":
-          const UnknownDevice = devices.get("unknown");
-          if (UnknownDevice) {
-            return await UnknownDevice.create(props);
-          }
-          break;
-        case "best-available":
-          WebGPUDevice = devices.get("webgpu");
-          if (WebGPUDevice?.isSupported?.()) {
-            return await WebGPUDevice.create(props);
-          }
-          WebGLDevice = devices.get("webgl");
-          if (WebGLDevice?.isSupported?.()) {
-            return await WebGLDevice.create(props);
-          }
-          break;
+      const adapter = adapters.get(type);
+      const device = await adapter?.attach?.(null);
+      if (device) {
+        return device;
       }
-      throw new Error(
-        "No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported."
-      );
+      throw new Error(ERROR_MESSAGE);
     }
-    static enforceWebGL2(enforce = true) {
-      const prototype = HTMLCanvasElement.prototype;
-      if (!enforce && prototype.originalGetContext) {
-        prototype.getContext = prototype.originalGetContext;
-        prototype.originalGetContext = void 0;
-        return;
-      }
-      prototype.originalGetContext = prototype.getContext;
-      prototype.getContext = function(contextId, options) {
-        if (contextId === "webgl" || contextId === "experimental-webgl") {
-          return this.originalGetContext("webgl2", options);
+    /**
+     * Override `HTMLCanvasContext.getCanvas()` to always create WebGL2 contexts with additional WebGL1 compatibility.
+     * Useful when attaching luma to a context from an external library does not support creating WebGL2 contexts.
+     */
+    enforceWebGL2(enforce = true, adapters = []) {
+      const adapterMap = this.getAdapterMap(adapters);
+      const webgl2Adapter = adapterMap.get("webgl");
+      if (!webgl2Adapter) {
+        log.warn("enforceWebGL2: webgl adapter not found")();
+      }
+      webgl2Adapter?.enforceWebGL2?.(enforce);
+    }
+    /** Convert a list of adapters to a map */
+    getAdapterMap(adapters = []) {
+      const map = new Map(this.preregisteredAdapters);
+      for (const adapter of adapters) {
+        map.set(adapter.type, adapter);
+      }
+      return map;
+    }
+    // DEPRECATED
+    /** @deprecated Use registerAdapters */
+    registerDevices(deviceClasses) {
+      log.warn("luma.registerDevices() is deprecated, use luma.registerAdapters() instead");
+      for (const deviceClass of deviceClasses) {
+        const adapter = deviceClass.adapter;
+        if (adapter) {
+          this.preregisteredAdapters.set(adapter.type, adapter);
         }
-        return this.originalGetContext(contextId, options);
-      };
+      }
     }
   };
-  var luma = _luma;
-  __publicField(luma, "defaultProps", {
+  var Luma = _Luma;
+  __publicField(Luma, "defaultProps", {
     ...Device.defaultProps,
     type: "best-available",
-    devices: void 0
+    adapters: void 0
   });
-  /** Global stats for all devices */
-  __publicField(luma, "stats", lumaStats);
-  /** Global log */
-  __publicField(luma, "log", log);
-  function getDeviceMap(deviceClasses) {
-    if (!deviceClasses || deviceClasses?.length === 0) {
-      return null;
-    }
-    const map = /* @__PURE__ */ new Map();
-    for (const deviceClass of deviceClasses) {
-      map.set(deviceClass.type, deviceClass);
-    }
-    return map;
-  }
+  var luma = new Luma();
+
+  // src/adapter/adapter.ts
+  var Adapter = class {
+  };
 
   // src/adapter/canvas-context.ts
   var isPage = isBrowser() && typeof document !== "undefined";
@@ -1684,20 +1662,106 @@ var __exports__ = (() => {
     height;
     /** depth of this texture */
     depth;
+    /** mip levels in this texture */
+    mipLevels;
     /** "Time" of last update. Monotonically increasing timestamp */
     updateTimestamp;
+    /** Check if data is an external image */
+    static isExternalImage(data) {
+      return typeof ImageData !== "undefined" && data instanceof ImageData || typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap || typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement || typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement || typeof VideoFrame !== "undefined" && data instanceof VideoFrame || typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && data instanceof OffscreenCanvas;
+    }
+    /** Determine size (width and height) of provided image data */
+    static getExternalImageSize(data) {
+      if (typeof ImageData !== "undefined" && data instanceof ImageData || typeof ImageBitmap !== "undefined" && data instanceof ImageBitmap || typeof HTMLCanvasElement !== "undefined" && data instanceof HTMLCanvasElement || typeof OffscreenCanvas !== "undefined" && data instanceof OffscreenCanvas) {
+        return { width: data.width, height: data.height };
+      }
+      if (typeof HTMLImageElement !== "undefined" && data instanceof HTMLImageElement) {
+        return { width: data.naturalWidth, height: data.naturalHeight };
+      }
+      if (typeof HTMLVideoElement !== "undefined" && data instanceof HTMLVideoElement) {
+        return { width: data.videoWidth, height: data.videoHeight };
+      }
+      if (typeof VideoFrame !== "undefined" && data instanceof VideoFrame) {
+        return { width: data.displayWidth, height: data.displayHeight };
+      }
+      throw new Error("Unknown image type");
+    }
+    /** Check if texture data is a typed array */
+    static isTextureLevelData(data) {
+      const typedArray = data?.data;
+      return ArrayBuffer.isView(typedArray);
+    }
+    /** Get the size of the texture described by the provided TextureData */
+    static getTextureDataSize(data) {
+      if (!data) {
+        return null;
+      }
+      if (ArrayBuffer.isView(data)) {
+        return null;
+      }
+      if (Array.isArray(data)) {
+        return _Texture.getTextureDataSize(data[0]);
+      }
+      if (_Texture.isExternalImage(data)) {
+        return _Texture.getExternalImageSize(data);
+      }
+      if (data && typeof data === "object" && data.constructor === Object) {
+        const textureDataArray = Object.values(data);
+        const untypedData = textureDataArray[0];
+        return { width: untypedData.width, height: untypedData.height };
+      }
+      throw new Error("texture size deduction failed");
+    }
+    /** Calculate the number of mip levels for a texture of width and height */
+    static getMipLevelCount(width, height) {
+      return Math.floor(Math.log2(Math.max(width, height))) + 1;
+    }
+    /** Convert luma.gl cubemap face constants to depth index */
+    static getCubeFaceDepth(face) {
+      switch (face) {
+        case "+X":
+          return 0;
+        case "-X":
+          return 1;
+        case "+Y":
+          return 2;
+        case "-Y":
+          return 3;
+        case "+Z":
+          return 4;
+        case "-Z":
+          return 5;
+        default:
+          throw new Error(face);
+      }
+    }
     /** Do not use directly. Create with device.createTexture() */
-    constructor(device, props, defaultProps = _Texture.defaultProps) {
-      super(device, props, defaultProps);
+    constructor(device, props) {
+      super(device, props, _Texture.defaultProps);
       this.dimension = this.props.dimension;
       this.format = this.props.format;
       this.width = this.props.width;
       this.height = this.props.height;
       this.depth = this.props.depth;
+      if (this.props.width === void 0 || this.props.height === void 0) {
+        const size = _Texture.getTextureDataSize(this.props.data);
+        this.width = size?.width || 1;
+        this.height = size?.height || 1;
+      }
+      if (this.props.mipmaps && this.props.mipLevels === void 0) {
+        this.props.mipLevels = "pyramid";
+      }
+      this.mipLevels = this.props.mipLevels === "pyramid" ? _Texture.getMipLevelCount(this.width, this.height) : this.props.mipLevels || 1;
       this.updateTimestamp = device.incrementTimestamp();
     }
   };
   var Texture = _Texture;
+  __publicField(Texture, "COPY_SRC", 1);
+  __publicField(Texture, "COPY_DST", 2);
+  __publicField(Texture, "TEXTURE", 4);
+  __publicField(Texture, "STORAGE", 8);
+  __publicField(Texture, "RENDER_ATTACHMENT", 16);
+  __publicField(Texture, "CubeFaces", ["+X", "-X", "+Y", "-Y", "+Z", "-Z"]);
   __publicField(Texture, "defaultProps", {
     ...Resource.defaultProps,
     data: null,
@@ -1706,23 +1770,30 @@ var __exports__ = (() => {
     width: void 0,
     height: void 0,
     depth: 1,
-    mipmaps: true,
-    // type: undefined,
+    mipmaps: false,
     compressed: false,
-    // mipLevels: 1,
     usage: 0,
-    // usage: GPUTextureUsage.COPY_DST
     mipLevels: void 0,
     samples: void 0,
-    type: void 0,
     sampler: {},
     view: void 0
   });
-  __publicField(Texture, "COPY_SRC", 1);
-  __publicField(Texture, "COPY_DST", 2);
-  __publicField(Texture, "TEXTURE_BINDING", 4);
-  __publicField(Texture, "STORAGE_BINDING", 8);
-  __publicField(Texture, "RENDER_ATTACHMENT", 16);
+  /** Default options */
+  __publicField(Texture, "defaultCopyExternalImageOptions", {
+    image: void 0,
+    sourceX: 0,
+    sourceY: 0,
+    width: void 0,
+    height: void 0,
+    depth: 1,
+    mipLevel: 0,
+    x: 0,
+    y: 0,
+    z: 0,
+    aspect: "all",
+    colorSpace: "srgb",
+    premultipliedAlpha: false
+  });
 
   // src/adapter/resources/texture-view.ts
   var _TextureView = class extends Resource {
@@ -1758,11 +1829,11 @@ var __exports__ = (() => {
   var ExternalTexture = _ExternalTexture;
   __publicField(ExternalTexture, "defaultProps", {
     ...Resource.defaultProps,
-    source: null,
+    source: void 0,
     colorSpace: "srgb"
   });
 
-  // src/lib/compiler-log/format-compiler-log.ts
+  // src/adapter-utils/format-compiler-log.ts
   function formatCompilerLog(shaderLog, source, options) {
     let formattedLog = "";
     const lines = source.split(/\r?\n/);
@@ -1828,31 +1899,6 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
     return unsafe.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#039;");
   }
 
-  // src/lib/compiler-log/get-shader-info.ts
-  function getShaderInfo(source, defaultName) {
-    return {
-      name: getShaderName(source, defaultName),
-      language: "glsl",
-      version: getShaderVersion(source)
-    };
-  }
-  function getShaderName(shader, defaultName = "unnamed") {
-    const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
-    const match = SHADER_NAME_REGEXP.exec(shader);
-    return match ? match[1] : defaultName;
-  }
-  function getShaderVersion(source) {
-    let version = 100;
-    const words = source.match(/[^\s]+/g);
-    if (words && words.length >= 2 && words[0] === "#version") {
-      const v = parseInt(words[1], 10);
-      if (Number.isFinite(v)) {
-        version = v;
-      }
-    }
-    return version;
-  }
-
   // src/adapter/resources/shader.ts
   var _Shader = class extends Resource {
     get [Symbol.toStringTag]() {
@@ -1900,12 +1946,15 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       this._displayShaderLog(messages);
     }
     // PRIVATE
-    /** In-browser UI logging of errors */
+    /**
+     * In-browser UI logging of errors
+     * TODO - this HTML formatting code should not be in Device, should be pluggable
+     */
     _displayShaderLog(messages) {
       if (typeof document === "undefined" || !document?.createElement) {
         return;
       }
-      const shaderName = getShaderInfo(this.source).name;
+      const shaderName = getShaderName(this.source);
       const shaderTitle = `${this.stage} ${shaderName}`;
       let htmlLog = formatCompilerLog(messages, this.source, { showSourceCode: "all", html: true });
       const translatedSource = this.getTranslatedSource();
@@ -1926,9 +1975,7 @@ ${htmlLog}
       button.style.textAlign = "left";
       document.body.appendChild(button);
       const errors = document.getElementsByClassName("luma-compiler-log-error");
-      if (errors[0]?.scrollIntoView) {
-        errors[0].scrollIntoView();
-      }
+      errors[0]?.scrollIntoView();
       button.onclick = () => {
         const dataURI = `data:text/plain,${encodeURIComponent(this.source)}`;
         navigator.clipboard.writeText(dataURI);
@@ -1946,7 +1993,12 @@ ${htmlLog}
     debug: "errors"
   });
   function getShaderIdFromProps(props) {
-    return getShaderInfo(props.source).name || props.id || uid(`unnamed ${props.stage}-shader`);
+    return getShaderName(props.source) || props.id || uid(`unnamed ${props.stage}-shader`);
+  }
+  function getShaderName(shader, defaultName = "unnamed") {
+    const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+    const match = SHADER_NAME_REGEXP.exec(shader);
+    return match ? match[1] : defaultName;
   }
 
   // src/adapter/resources/sampler.ts
@@ -1984,10 +2036,6 @@ ${htmlLog}
     width;
     /** Height of all attachments in this framebuffer */
     height;
-    /** Color attachments */
-    colorAttachments = [];
-    /** Depth-stencil attachment, if provided */
-    depthStencilAttachment = null;
     constructor(device, props = {}) {
       super(device, props, _Framebuffer.defaultProps);
       this.width = this.props.width;
@@ -2064,7 +2112,7 @@ ${htmlLog}
       for (let i = 0; i < this.colorAttachments.length; ++i) {
         if (this.colorAttachments[i]) {
           const resizedTexture = this.device._createTexture({
-            ...this.colorAttachments[i].props,
+            ...this.colorAttachments[i].texture.props,
             width,
             height
           });
@@ -2075,7 +2123,7 @@ ${htmlLog}
       }
       if (this.depthStencilAttachment) {
         const resizedTexture = this.device._createTexture({
-          ...this.depthStencilAttachment.props,
+          ...this.depthStencilAttachment.texture.props,
           width,
           height
         });
@@ -2189,8 +2237,11 @@ ${htmlLog}
       return "ComputePipeline";
     }
     hash = "";
+    /** The merged shader layout */
+    shaderLayout;
     constructor(device, props) {
       super(device, props, _ComputePipeline.defaultProps);
+      this.shaderLayout = props.shaderLayout;
     }
   };
   var ComputePipeline = _ComputePipeline;
@@ -2251,7 +2302,7 @@ ${htmlLog}
     ...Resource.defaultProps
   });
 
-  // src/adapter/type-utils/decode-attribute-type.ts
+  // src/gpu-type-utils/decode-attribute-type.ts
   function decodeShaderAttributeType(attributeType) {
     const [dataType, components] = TYPE_INFO[attributeType];
     const integer = dataType === "i32" || dataType === "u32";
@@ -2313,7 +2364,7 @@ ${htmlLog}
     // 'bool-webgl': 4,
   };
 
-  // src/adapter/type-utils/decode-vertex-format.ts
+  // src/gpu-type-utils/decode-vertex-format.ts
   function decodeVertexFormat(format) {
     let webglOnly;
     if (format.endsWith("-webgl")) {
@@ -2338,15 +2389,14 @@ ${htmlLog}
     return result;
   }
 
-  // src/adapter/attribute-utils/get-attribute-from-layouts.ts
+  // src/adapter-utils/get-attribute-from-layouts.ts
   function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) {
     const attributeInfos = {};
     for (const attribute of shaderLayout.attributes) {
-      attributeInfos[attribute.name] = getAttributeInfoFromLayouts(
-        shaderLayout,
-        bufferLayout,
-        attribute.name
-      );
+      const attributeInfo = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
+      if (attributeInfo) {
+        attributeInfos[attribute.name] = attributeInfo;
+      }
     }
     return attributeInfos;
   }
@@ -2360,7 +2410,10 @@ ${htmlLog}
   }
   function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) {
     const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name2);
-    const bufferMapping = getAttributeFromBufferLayout(bufferLayout, name2);
+    const bufferMapping = getAttributeFromBufferLayout(
+      bufferLayout,
+      name2
+    );
     if (!shaderDeclaration) {
       return null;
     }
@@ -2381,7 +2434,7 @@ ${htmlLog}
       normalized: vertexFormatInfo.normalized,
       // integer is a property of the shader declaration
       integer: attributeTypeInfo.integer,
-      stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode,
+      stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode || "vertex",
       byteOffset: bufferMapping?.byteOffset || 0,
       byteStride: bufferMapping?.byteStride || 0
     };
@@ -2446,28 +2499,13 @@ ${htmlLog}
           stepMode: bufferLayout.stepMode,
           vertexFormat: attributeMapping.format,
           byteOffset: attributeMapping.byteOffset,
+          // @ts-ignore
           byteStride
         };
       }
     }
     return null;
   }
-  function mergeShaderLayout(baseLayout, overrideLayout) {
-    const mergedLayout = {
-      ...baseLayout,
-      attributes: baseLayout.attributes.map((attribute) => ({ ...attribute }))
-    };
-    for (const attribute of overrideLayout?.attributes || []) {
-      const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
-      if (!baseAttribute) {
-        log.warn(`shader layout attribute ${attribute.name} not present in shader`);
-      } else {
-        baseAttribute.type = attribute.type || baseAttribute.type;
-        baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
-      }
-    }
-    return mergedLayout;
-  }
 
   // src/adapter/resources/vertex-array.ts
   var _VertexArray = class extends Resource {
@@ -2486,9 +2524,13 @@ ${htmlLog}
       super(device, props, _VertexArray.defaultProps);
       this.maxVertexAttributes = device.limits.maxVertexAttributes;
       this.attributes = new Array(this.maxVertexAttributes).fill(null);
+      const { shaderLayout, bufferLayout } = props.renderPipeline || {};
+      if (!shaderLayout || !bufferLayout) {
+        throw new Error("VertexArray");
+      }
       this.attributeInfos = getAttributeInfosByLocation(
-        props.renderPipeline.shaderLayout,
-        props.renderPipeline.bufferLayout,
+        shaderLayout,
+        bufferLayout,
         this.maxVertexAttributes
       );
     }
@@ -2536,7 +2578,7 @@ ${htmlLog}
     count: void 0
   });
 
-  // src/adapter/type-utils/decode-shader-types.ts
+  // src/gpu-type-utils/decode-shader-types.ts
   var UNIFORM_FORMATS = {
     f32: { type: "f32", components: 1 },
     i32: { type: "i32", components: 1 },
@@ -2563,7 +2605,6 @@ ${htmlLog}
   };
   function decodeShaderUniformType(format) {
     const decoded = UNIFORM_FORMATS[format];
-    assert2(format);
     return decoded;
   }
   function alignTo(size, count) {
@@ -2589,27 +2630,19 @@ ${htmlLog}
     const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
     return new Type(scratchArrayBuffer, 0, length);
   }
-  function fillArray(options) {
-    const { target, source, start = 0, count = 1 } = options;
-    const length = source.length;
-    const total = count * length;
-    let copied = 0;
-    for (let i = start; copied < length; copied++) {
-      target[i++] = source[copied];
-    }
-    while (copied < total) {
-      if (copied < total - copied) {
-        target.copyWithin(start + copied, start, start + copied);
-        copied *= 2;
-      } else {
-        target.copyWithin(start + copied, start, start + total - copied);
-        copied = total;
-      }
+
+  // src/utils/is-array.ts
+  function isTypedArray(value) {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function isNumberArray(value) {
+    if (Array.isArray(value)) {
+      return value.length === 0 || typeof value[0] === "number";
     }
-    return options.target;
+    return isTypedArray(value);
   }
 
-  // src/lib/uniforms/uniform-buffer-layout.ts
+  // src/portable/uniform-buffer-layout.ts
   var minBufferSize = 1024;
   var UniformBufferLayout = class {
     layout = {};
@@ -2658,14 +2691,13 @@ ${htmlLog}
           }
           typedArray[offset] = Number(value);
         } else {
-          const numericArray = isNumberArray(value);
-          if (!numericArray) {
+          if (!isNumberArray(value)) {
             log.warn(
               `Supplied value for multi component / array uniform ${name2} is not a numeric array: ${value}`
             )();
             continue;
           }
-          typedArray.set(numericArray, offset);
+          typedArray.set(value, offset);
         }
       }
       return new Uint8Array(arrayBuffer2);
@@ -2686,12 +2718,12 @@ ${htmlLog}
     if (a !== b) {
       return false;
     }
-    const arrayA = isNumberArray(a);
-    if (!arrayA) {
+    const arrayA = a;
+    const arrayB = b;
+    if (!isNumberArray(arrayA)) {
       return false;
     }
-    const arrayB = isNumberArray(b);
-    if (arrayB && arrayA.length === arrayB.length) {
+    if (isNumberArray(arrayB) && arrayA.length === arrayB.length) {
       for (let i = 0; i < arrayA.length; ++i) {
         if (arrayB[i] !== arrayA[i]) {
           return false;
@@ -2701,14 +2733,13 @@ ${htmlLog}
     return true;
   }
   function arrayCopy(a) {
-    const numberArray = isNumberArray(a);
-    if (numberArray) {
-      return numberArray.slice();
+    if (isNumberArray(a)) {
+      return a.slice();
     }
     return a;
   }
 
-  // src/lib/uniforms/uniform-block.ts
+  // src/portable/uniform-block.ts
   var UniformBlock = class {
     name;
     uniforms = {};
@@ -2717,7 +2748,7 @@ ${htmlLog}
     bindingLayout = {};
     needsRedraw = "initialized";
     constructor(props) {
-      this.name = props?.name;
+      this.name = props?.name || "unnamed";
       if (props?.name && props?.shaderLayout) {
         const binding = props?.shaderLayout.bindings?.find(
           (binding2) => binding2.type === "uniform" && binding2.name === props?.name
@@ -2760,7 +2791,7 @@ ${htmlLog}
     }
   };
 
-  // src/lib/uniforms/uniform-store.ts
+  // src/portable/uniform-store.ts
   var UniformStore = class {
     /** Stores the uniform values for each uniform block */
     uniformBlocks = /* @__PURE__ */ new Map();
@@ -2794,18 +2825,18 @@ ${htmlLog}
      */
     setUniforms(uniforms) {
       for (const [blockName, uniformValues] of Object.entries(uniforms)) {
-        this.uniformBlocks.get(blockName).setUniforms(uniformValues);
+        this.uniformBlocks.get(blockName)?.setUniforms(uniformValues);
       }
       this.updateUniformBuffers();
     }
     /** Get the required minimum length of the uniform buffer */
     getUniformBufferByteLength(uniformBufferName) {
-      return this.uniformBufferLayouts.get(uniformBufferName).byteLength;
+      return this.uniformBufferLayouts.get(uniformBufferName)?.byteLength || 0;
     }
     /** Get formatted binary memory that can be uploaded to a buffer */
     getUniformBufferData(uniformBufferName) {
-      const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms();
-      return this.uniformBufferLayouts.get(uniformBufferName).getData(uniformValues);
+      const uniformValues = this.uniformBlocks.get(uniformBufferName)?.getAllUniforms() || {};
+      return this.uniformBufferLayouts.get(uniformBufferName)?.getData(uniformValues);
     }
     /**
      * Creates an unmanaged uniform buffer (umnanaged means that application is responsible for destroying it)
@@ -2853,12 +2884,12 @@ ${htmlLog}
       const uniformBlock = this.uniformBlocks.get(uniformBufferName);
       const uniformBuffer = this.uniformBuffers.get(uniformBufferName);
       let reason = false;
-      if (uniformBuffer && uniformBlock.needsRedraw) {
+      if (uniformBuffer && uniformBlock?.needsRedraw) {
         reason ||= uniformBlock.needsRedraw;
         const uniformBufferData = this.getUniformBufferData(uniformBufferName);
         const uniformBuffer2 = this.uniformBuffers.get(uniformBufferName);
-        uniformBuffer2.write(uniformBufferData);
-        const uniformValues = this.uniformBlocks.get(uniformBufferName).getAllUniforms();
+        uniformBuffer2?.write(uniformBufferData);
+        const uniformValues = this.uniformBlocks.get(uniformBufferName)?.getAllUniforms();
         log.log(
           4,
           `Writing to uniform buffer ${String(uniformBufferName)}`,
@@ -2870,7 +2901,7 @@ ${htmlLog}
     }
   };
 
-  // src/adapter/type-utils/vertex-format-from-attribute.ts
+  // src/gpu-type-utils/vertex-format-from-attribute.ts
   function getDataTypeFromTypedArray(arrayOrType) {
     const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
     switch (type) {
@@ -2946,223 +2977,6 @@ ${htmlLog}
     }
     return `${dataType}x${components}`;
   }
-
-  // src/utils/cast.ts
-  function cast(value) {
-    return value;
-  }
-
-  // src/lib/uniforms/uniform.ts
-  function isUniformValue(value) {
-    return isNumberArray(value) !== null || typeof value === "number" || typeof value === "boolean";
-  }
-  function splitUniformsAndBindings(uniforms) {
-    const result = { bindings: {}, uniforms: {} };
-    Object.keys(uniforms).forEach((name2) => {
-      const uniform = uniforms[name2];
-      if (isUniformValue(uniform)) {
-        result.uniforms[name2] = uniform;
-      } else {
-        result.bindings[name2] = uniform;
-      }
-    });
-    return result;
-  }
-
-  // src/utils/format-value.ts
-  function formatArrayValue(v, opts = {}) {
-    const { maxElts = 16, size = 1 } = opts;
-    let string = "[";
-    for (let i = 0; i < v.length && i < maxElts; ++i) {
-      if (i > 0) {
-        string += `,${i % size === 0 ? " " : ""}`;
-      }
-      string += formatValue(v[i], opts);
-    }
-    const terminator = v.length > maxElts ? "..." : "]";
-    return `${string}${terminator}`;
-  }
-  function formatValue(v, opts = {}) {
-    const EPSILON = 1e-16;
-    const { isInteger = false } = opts;
-    if (Array.isArray(v) || ArrayBuffer.isView(v)) {
-      return formatArrayValue(v, opts);
-    }
-    if (typeof v !== "number") {
-      return String(v);
-    }
-    if (Math.abs(v) < EPSILON) {
-      return isInteger ? "0" : "0.";
-    }
-    if (isInteger) {
-      return v.toFixed(0);
-    }
-    if (Math.abs(v) > 100 && Math.abs(v) < 1e4) {
-      return v.toFixed(0);
-    }
-    const string = v.toPrecision(2);
-    const decimal = string.indexOf(".0");
-    return decimal === string.length - 2 ? string.slice(0, -1) : string;
-  }
-
-  // src/utils/stub-methods.ts
-  function stubRemovedMethods(instance, className, version, methodNames) {
-    const upgradeMessage = `See luma.gl ${version} Upgrade Guide at https://luma.gl/docs/upgrade-guide`;
-    const prototype = Object.getPrototypeOf(instance);
-    methodNames.forEach((methodName) => {
-      if (prototype.methodName) {
-        return;
-      }
-      prototype[methodName] = () => {
-        log.removed(`Calling removed method ${className}.${methodName}: `, upgradeMessage)();
-        throw new Error(methodName);
-      };
-    });
-  }
-
-  // src/utils/check-props.ts
-  function checkProps(className, props, propChecks) {
-    const { removedProps = {}, deprecatedProps = {}, replacedProps = {} } = propChecks;
-    for (const propName in removedProps) {
-      if (propName in props) {
-        const replacementProp = removedProps[propName];
-        const replacement = replacementProp ? `${className}.${removedProps[propName]}` : "N/A";
-        log.removed(`${className}.${propName}`, replacement)();
-      }
-    }
-    for (const propName in deprecatedProps) {
-      if (propName in props) {
-        const replacementProp = deprecatedProps[propName];
-        log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();
-      }
-    }
-    let newProps = null;
-    for (const [propName, replacementProp] of Object.entries(replacedProps)) {
-      if (propName in props) {
-        log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();
-        newProps = newProps || Object.assign({}, props);
-        newProps[replacementProp] = props[propName];
-        delete newProps[propName];
-      }
-    }
-    return newProps || props;
-  }
-
-  // src/utils/load-file.ts
-  var pathPrefix = "";
-  function setPathPrefix(prefix) {
-    pathPrefix = prefix;
-  }
-  async function loadFile(url, options) {
-    url = url.startsWith("http") ? url : pathPrefix + url;
-    const dataType = options?.dataType || "text";
-    const response = await fetch(url, options);
-    return await response[dataType]();
-  }
-  async function loadImageBitmap(url, opts) {
-    const image = new Image();
-    image.crossOrigin = opts?.crossOrigin || "anonymous";
-    image.src = url.startsWith("http") ? url : pathPrefix + url;
-    await image.decode();
-    return await createImageBitmap(image);
-  }
-  async function loadImage(url, opts) {
-    return await new Promise((resolve, reject) => {
-      try {
-        const image = new Image();
-        image.onload = () => resolve(image);
-        image.onerror = () => reject(new Error(`Could not load image ${url}.`));
-        image.crossOrigin = opts?.crossOrigin || "anonymous";
-        image.src = url.startsWith("http") ? url : pathPrefix + url;
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  async function loadScript(scriptUrl, scriptId) {
-    const head = document.getElementsByTagName("head")[0];
-    if (!head) {
-      throw new Error("loadScript");
-    }
-    const script = document.createElement("script");
-    script.setAttribute("type", "text/javascript");
-    script.setAttribute("src", scriptUrl);
-    if (scriptId) {
-      script.id = scriptId;
-    }
-    return new Promise((resolve, reject) => {
-      script.onload = resolve;
-      script.onerror = (error) => reject(new Error(`Unable to load script '${scriptUrl}': ${error}`));
-      head.appendChild(script);
-    });
-  }
-
-  // src/utils/random.ts
-  function makeRandomNumberGenerator() {
-    let s = 1;
-    let c = 1;
-    return () => {
-      s = Math.sin(c * 17.23);
-      c = Math.cos(s * 27.92);
-      return fract(Math.abs(s * c) * 1432.71);
-    };
-  }
-  function fract(n) {
-    return n - Math.floor(n);
-  }
-  var random = makeRandomNumberGenerator();
-
-  // src/utils/deep-equal.ts
-  function deepEqual(a, b, depth) {
-    if (a === b) {
-      return true;
-    }
-    if (!depth || !a || !b) {
-      return false;
-    }
-    if (Array.isArray(a)) {
-      if (!Array.isArray(b) || a.length !== b.length) {
-        return false;
-      }
-      for (let i = 0; i < a.length; i++) {
-        if (!deepEqual(a[i], b[i], depth - 1)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (Array.isArray(b)) {
-      return false;
-    }
-    if (typeof a === "object" && typeof b === "object") {
-      const aKeys = Object.keys(a);
-      const bKeys = Object.keys(b);
-      if (aKeys.length !== bKeys.length) {
-        return false;
-      }
-      for (const key of aKeys) {
-        if (!b.hasOwnProperty(key)) {
-          return false;
-        }
-        if (!deepEqual(a[key], b[key], depth - 1)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    return false;
-  }
-
-  // src/utils/request-animation-frame.ts
-  function requestAnimationFrame(callback) {
-    return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60);
-  }
-  function cancelAnimationFrame(timerId) {
-    return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame(timerId) : clearTimeout(timerId);
-  }
-
-  // src/index.ts
-  var glsl = (x) => `${x}`;
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;