@deck.gl/core 9.3.0-alpha.5 → 9.3.0-beta.1

package/dist/dist.dev.js

@@ -1569,12 +1569,51 @@ var __exports__ = (() => {
               }
               return `${dataType}x${components}`;
             case "snorm8":
+              if (components === 1) {
+                return "snorm8";
+              }
+              if (components === 3) {
+                return "snorm8x3-webgl";
+              }
+              return `${dataType}x${components}`;
             case "uint8":
             case "sint8":
+              if (components === 1 || components === 3) {
+                throw new Error(`size: ${components}`);
+              }
+              return `${dataType}x${components}`;
             case "uint16":
+              if (components === 1) {
+                return "uint16";
+              }
+              if (components === 3) {
+                return "uint16x3-webgl";
+              }
+              return `${dataType}x${components}`;
             case "sint16":
+              if (components === 1) {
+                return "sint16";
+              }
+              if (components === 3) {
+                return "sint16x3-webgl";
+              }
+              return `${dataType}x${components}`;
             case "unorm16":
+              if (components === 1) {
+                return "unorm16";
+              }
+              if (components === 3) {
+                return "unorm16x3-webgl";
+              }
+              return `${dataType}x${components}`;
             case "snorm16":
+              if (components === 1) {
+                return "snorm16";
+              }
+              if (components === 3) {
+                return "snorm16x3-webgl";
+              }
+              return `${dataType}x${components}`;
             case "float16":
               if (components === 1 || components === 3) {
                 throw new Error(`size: ${components}`);
@@ -2308,7 +2347,7 @@ or create a device with the 'debug: true' prop.`;
           throw new Error("_createBindGroupLayoutWebGPU() not implemented");
         }
         /** Internal WebGPU-only helper for creating a native bind group. */
-        _createBindGroupWebGPU(_bindGroupLayout, _shaderLayout, _bindings, _group) {
+        _createBindGroupWebGPU(_bindGroupLayout, _shaderLayout, _bindings, _group, _label) {
           throw new Error("_createBindGroupWebGPU() not implemented");
         }
         /**
@@ -2522,7 +2561,7 @@ or create a device with the 'debug: true' prop.`;
         VERSION = (
           // Version detection using build plugin
           // @ts-expect-error no-undef
-          true ? "9.3.0-alpha.10" : "running from source"
+          true ? "9.3.2" : "running from source"
         );
         spector;
         preregisteredAdapters = /* @__PURE__ */ new Map();
@@ -2820,11 +2859,11 @@ or create a device with the 'debug: true' prop.`;
     return document.body;
   }
   function getCanvasFromDOM(canvasId) {
-    const canvas2 = document.getElementById(canvasId);
-    if (!CanvasSurface.isHTMLCanvas(canvas2)) {
+    const canvas = document.getElementById(canvasId);
+    if (!CanvasSurface.isHTMLCanvas(canvas)) {
       throw new Error("Object is not a canvas element");
     }
-    return canvas2;
+    return canvas;
   }
   function createCanvasElement(props) {
     const { width, height } = props;
@@ -2878,11 +2917,11 @@ or create a device with the 'debug: true' prop.`;
       init_promise_utils();
       init_assert2();
       _CanvasSurface = class {
-        static isHTMLCanvas(canvas2) {
-          return typeof HTMLCanvasElement !== "undefined" && canvas2 instanceof HTMLCanvasElement;
+        static isHTMLCanvas(canvas) {
+          return typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement;
         }
-        static isOffscreenCanvas(canvas2) {
-          return typeof OffscreenCanvas !== "undefined" && canvas2 instanceof OffscreenCanvas;
+        static isOffscreenCanvas(canvas) {
+          return typeof OffscreenCanvas !== "undefined" && canvas instanceof OffscreenCanvas;
         }
         id;
         props;
@@ -7465,7 +7504,7 @@ ${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.m
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/context/helpers/create-browser-context.js
-  function createBrowserContext(canvas2, props, webglContextAttributes) {
+  function createBrowserContext(canvas, props, webglContextAttributes) {
     let errorMessage = "";
     const onCreateError = (event) => {
       const statusMessage = event.statusMessage;
@@ -7473,7 +7512,7 @@ ${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.m
         errorMessage ||= statusMessage;
       }
     };
-    canvas2.addEventListener("webglcontextcreationerror", onCreateError, false);
+    canvas.addEventListener("webglcontextcreationerror", onCreateError, false);
     const allowSoftwareRenderer = webglContextAttributes.failIfMajorPerformanceCaveat !== true;
     const webglProps = {
       preserveDrawingBuffer: true,
@@ -7483,18 +7522,18 @@ ${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.m
     };
     let gl = null;
     try {
-      gl ||= canvas2.getContext("webgl2", webglProps);
+      gl ||= canvas.getContext("webgl2", webglProps);
       if (!gl && webglProps.failIfMajorPerformanceCaveat) {
         errorMessage ||= "Only software GPU is available. Set `failIfMajorPerformanceCaveat: false` to allow.";
       }
       let softwareRenderer = false;
       if (!gl && allowSoftwareRenderer) {
         webglProps.failIfMajorPerformanceCaveat = false;
-        gl = canvas2.getContext("webgl2", webglProps);
+        gl = canvas.getContext("webgl2", webglProps);
         softwareRenderer = true;
       }
       if (!gl) {
-        gl = canvas2.getContext("webgl", {});
+        gl = canvas.getContext("webgl", {});
         if (gl) {
           gl = null;
           errorMessage ||= "Your browser only supports WebGL1";
@@ -7507,11 +7546,11 @@ ${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.m
       const luma2 = getWebGLContextData(gl);
       luma2.softwareRenderer = softwareRenderer;
       const { onContextLost, onContextRestored } = props;
-      canvas2.addEventListener("webglcontextlost", (event) => onContextLost(event), false);
-      canvas2.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
+      canvas.addEventListener("webglcontextlost", (event) => onContextLost(event), false);
+      canvas.addEventListener("webglcontextrestored", (event) => onContextRestored(event), false);
       return gl;
     } finally {
-      canvas2.removeEventListener("webglcontextcreationerror", onCreateError, false);
+      canvas.removeEventListener("webglcontextcreationerror", onCreateError, false);
     }
   }
   var init_create_browser_context = __esm({
@@ -8610,11 +8649,11 @@ ${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.m
         continue;
       }
       let lineNum = parseInt(lineNumber, 10);
-      if (isNaN(lineNum)) {
+      if (Number.isNaN(lineNum)) {
         lineNum = 0;
       }
       let linePos = parseInt(linePosition, 10);
-      if (isNaN(linePos)) {
+      if (Number.isNaN(linePos)) {
         linePos = 0;
       }
       messages.push({
@@ -9884,29 +9923,29 @@ ${source3}`;
               if (!options?.disableWarnings) {
                 log.warn(`No binding "${name2}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
               }
-              continue;
-            }
-            if (!value) {
-              log.warn(`Unsetting binding "${name2}" in render pipeline "${this.id}"`)();
-            }
-            switch (binding.type) {
-              case "uniform":
-                if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) {
-                  throw new Error("buffer value");
-                }
-                break;
-              case "texture":
-                if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
-                  throw new Error(`${this} Bad texture binding for ${name2}`);
-                }
-                break;
-              case "sampler":
-                log.warn(`Ignoring sampler ${name2}`)();
-                break;
-              default:
-                throw new Error(binding.type);
+            } else {
+              if (!value) {
+                log.warn(`Unsetting binding "${name2}" in render pipeline "${this.id}"`)();
+              }
+              switch (binding.type) {
+                case "uniform":
+                  if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) {
+                    throw new Error("buffer value");
+                  }
+                  break;
+                case "texture":
+                  if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+                    throw new Error(`${this} Bad texture binding for ${name2}`);
+                  }
+                  break;
+                case "sampler":
+                  log.warn(`Ignoring sampler ${name2}`)();
+                  break;
+                default:
+                  throw new Error(binding.type);
+              }
+              this.bindings[name2] = value;
             }
-            this.bindings[name2] = value;
           }
         }
         /** @todo needed for portable model
@@ -11963,7 +12002,10 @@ ${source3}`;
           this.spectorJS = initializeSpectorJS({ ...this.props, gl: this.handle });
           const contextData = getWebGLContextData(this.handle);
           contextData.device = this;
-          this.extensions = contextData.extensions || (contextData.extensions = {});
+          if (!contextData.extensions) {
+            contextData.extensions = {};
+          }
+          this.extensions = contextData.extensions;
           this.info = getDeviceInfo(this.gl, this.extensions);
           this.limits = new WebGLDeviceLimits(this.gl);
           this.features = new WebGLDeviceFeatures(this.gl, this.extensions, this.props._disabledFeatures);
@@ -12775,13 +12817,13 @@ ${source3}`;
       if (!this.device || !canvasContext) {
         throw new Error("loop");
       }
-      const canvas2 = canvasContext?.canvas;
+      const canvas = canvasContext?.canvas;
       const useDevicePixels = canvasContext.props.useDevicePixels;
       this.animationProps = {
         animationLoop: this,
         device: this.device,
         canvasContext,
-        canvas: canvas2,
+        canvas,
         // @ts-expect-error Deprecated
         useDevicePixels,
         timeline: this.timeline,
@@ -13373,9 +13415,27 @@ ${source3}`;
     return true;
   }
   function formatShaderModuleUniformLayoutError(validationResult) {
-    return `${validationResult.moduleName}: ${validationResult.stage} shader uniform block ${validationResult.uniformBlockName} does not match module.uniformTypes.
-Expected: ${validationResult.expectedUniformNames.join(", ")}
-Actual: ${validationResult.actualUniformNames.join(", ")}`;
+    const { expectedUniformNames, actualUniformNames } = validationResult;
+    const missingUniformNames = expectedUniformNames.filter((uniformName) => !actualUniformNames.includes(uniformName));
+    const unexpectedUniformNames = actualUniformNames.filter((uniformName) => !expectedUniformNames.includes(uniformName));
+    const mismatchDetails = [
+      `Expected ${expectedUniformNames.length} fields, found ${actualUniformNames.length}.`
+    ];
+    const firstMismatchDescription = getFirstUniformMismatchDescription(expectedUniformNames, actualUniformNames);
+    if (firstMismatchDescription) {
+      mismatchDetails.push(firstMismatchDescription);
+    }
+    if (missingUniformNames.length) {
+      mismatchDetails.push(`Missing from shader block (${missingUniformNames.length}): ${formatUniformNameList(missingUniformNames)}.`);
+    }
+    if (unexpectedUniformNames.length) {
+      mismatchDetails.push(`Unexpected in shader block (${unexpectedUniformNames.length}): ${formatUniformNameList(unexpectedUniformNames)}.`);
+    }
+    if (expectedUniformNames.length <= 12 && actualUniformNames.length <= 12 && (missingUniformNames.length || unexpectedUniformNames.length)) {
+      mismatchDetails.push(`Expected: ${expectedUniformNames.join(", ")}.`);
+      mismatchDetails.push(`Actual: ${actualUniformNames.join(", ")}.`);
+    }
+    return `${validationResult.moduleName}: ${validationResult.stage} shader uniform block ${validationResult.uniformBlockName} does not match module.uniformTypes. ${mismatchDetails.join(" ")}`;
   }
   function stripShaderComments(shaderSource) {
     return shaderSource.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
@@ -13383,6 +13443,28 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
   function normalizeWhitespace(value) {
     return value.replace(/\s+/g, " ").trim();
   }
+  function getFirstUniformMismatchDescription(expectedUniformNames, actualUniformNames) {
+    const minimumLength = Math.min(expectedUniformNames.length, actualUniformNames.length);
+    for (let index = 0; index < minimumLength; index++) {
+      if (expectedUniformNames[index] !== actualUniformNames[index]) {
+        return `First mismatch at field ${index + 1}: expected ${expectedUniformNames[index]}, found ${actualUniformNames[index]}.`;
+      }
+    }
+    if (expectedUniformNames.length > actualUniformNames.length) {
+      return `Shader block ends after field ${actualUniformNames.length}; expected next field ${expectedUniformNames[actualUniformNames.length]}.`;
+    }
+    if (actualUniformNames.length > expectedUniformNames.length) {
+      return `Shader block has extra field ${actualUniformNames.length}: ${actualUniformNames[expectedUniformNames.length]}.`;
+    }
+    return null;
+  }
+  function formatUniformNameList(uniformNames, maxNames = 8) {
+    if (uniformNames.length <= maxNames) {
+      return uniformNames.join(", ");
+    }
+    const remainingCount = uniformNames.length - maxNames;
+    return `${uniformNames.slice(0, maxNames).join(", ")}, ... (${remainingCount} more)`;
+  }
 
   // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/platform-defines.js
   function getPlatformShaderDefines(platformInfo) {
@@ -13568,12 +13650,156 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
     return version2;
   }
 
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/wgsl-binding-scan.js
+  var WGSL_BINDABLE_VARIABLE_PATTERN = "(?:var<\\s*(uniform|storage(?:\\s*,\\s*[A-Za-z_][A-Za-z0-9_]*)?)\\s*>|var)\\s+([A-Za-z_][A-Za-z0-9_]*)";
+  var WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN = "\\s*";
+  var MODULE_WGSL_BINDING_DECLARATION_REGEXES = [
+    new RegExp(`@binding\\(\\s*(auto|\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g"),
+    new RegExp(`@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@binding\\(\\s*(auto|\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g")
+  ];
+  var WGSL_BINDING_DECLARATION_REGEXES = [
+    new RegExp(`@binding\\(\\s*(auto|\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g"),
+    new RegExp(`@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@binding\\(\\s*(auto|\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g")
+  ];
+  var WGSL_EXPLICIT_BINDING_DECLARATION_REGEXES = [
+    new RegExp(`@binding\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g"),
+    new RegExp(`@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@binding\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g")
+  ];
+  var WGSL_AUTO_BINDING_DECLARATION_REGEXES = [
+    new RegExp(`@binding\\(\\s*(auto)\\s*\\)\\s*@group\\(\\s*(\\d+)\\s*\\)\\s*${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g"),
+    new RegExp(`@group\\(\\s*(\\d+)\\s*\\)\\s*@binding\\(\\s*(auto)\\s*\\)\\s*${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g"),
+    new RegExp(`@binding\\(\\s*(auto)\\s*\\)\\s*@group\\(\\s*(\\d+)\\s*\\)(?:[\\s\\n\\r]*@[A-Za-z_][^\\n\\r]*)*[\\s\\n\\r]*${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g"),
+    new RegExp(`@group\\(\\s*(\\d+)\\s*\\)\\s*@binding\\(\\s*(auto)\\s*\\)(?:[\\s\\n\\r]*@[A-Za-z_][^\\n\\r]*)*[\\s\\n\\r]*${WGSL_BINDABLE_VARIABLE_PATTERN}`, "g")
+  ];
+  function maskWGSLComments(source3) {
+    const maskedCharacters = source3.split("");
+    let index = 0;
+    let blockCommentDepth = 0;
+    let inLineComment = false;
+    let inString = false;
+    let isEscaped = false;
+    while (index < source3.length) {
+      const character = source3[index];
+      const nextCharacter = source3[index + 1];
+      if (inString) {
+        if (isEscaped) {
+          isEscaped = false;
+        } else if (character === "\\") {
+          isEscaped = true;
+        } else if (character === '"') {
+          inString = false;
+        }
+        index++;
+        continue;
+      }
+      if (inLineComment) {
+        if (character === "\n" || character === "\r") {
+          inLineComment = false;
+        } else {
+          maskedCharacters[index] = " ";
+        }
+        index++;
+        continue;
+      }
+      if (blockCommentDepth > 0) {
+        if (character === "/" && nextCharacter === "*") {
+          maskedCharacters[index] = " ";
+          maskedCharacters[index + 1] = " ";
+          blockCommentDepth++;
+          index += 2;
+          continue;
+        }
+        if (character === "*" && nextCharacter === "/") {
+          maskedCharacters[index] = " ";
+          maskedCharacters[index + 1] = " ";
+          blockCommentDepth--;
+          index += 2;
+          continue;
+        }
+        if (character !== "\n" && character !== "\r") {
+          maskedCharacters[index] = " ";
+        }
+        index++;
+        continue;
+      }
+      if (character === '"') {
+        inString = true;
+        index++;
+        continue;
+      }
+      if (character === "/" && nextCharacter === "/") {
+        maskedCharacters[index] = " ";
+        maskedCharacters[index + 1] = " ";
+        inLineComment = true;
+        index += 2;
+        continue;
+      }
+      if (character === "/" && nextCharacter === "*") {
+        maskedCharacters[index] = " ";
+        maskedCharacters[index + 1] = " ";
+        blockCommentDepth = 1;
+        index += 2;
+        continue;
+      }
+      index++;
+    }
+    return maskedCharacters.join("");
+  }
+  function getWGSLBindingDeclarationMatches(source3, regexes) {
+    const maskedSource = maskWGSLComments(source3);
+    const matches3 = [];
+    for (const regex of regexes) {
+      regex.lastIndex = 0;
+      let match;
+      match = regex.exec(maskedSource);
+      while (match) {
+        const isBindingFirst = regex === regexes[0];
+        const index = match.index;
+        const length4 = match[0].length;
+        matches3.push({
+          match: source3.slice(index, index + length4),
+          index,
+          length: length4,
+          bindingToken: match[isBindingFirst ? 1 : 2],
+          groupToken: match[isBindingFirst ? 2 : 1],
+          accessDeclaration: match[3]?.trim(),
+          name: match[4]
+        });
+        match = regex.exec(maskedSource);
+      }
+    }
+    return matches3.sort((left, right) => left.index - right.index);
+  }
+  function replaceWGSLBindingDeclarationMatches(source3, regexes, replacer) {
+    const matches3 = getWGSLBindingDeclarationMatches(source3, regexes);
+    if (!matches3.length) {
+      return source3;
+    }
+    let relocatedSource = "";
+    let lastIndex = 0;
+    for (const match of matches3) {
+      relocatedSource += source3.slice(lastIndex, match.index);
+      relocatedSource += replacer(match);
+      lastIndex = match.index + match.length;
+    }
+    relocatedSource += source3.slice(lastIndex);
+    return relocatedSource;
+  }
+  function hasWGSLAutoBinding(source3) {
+    return /@binding\(\s*auto\s*\)/.test(maskWGSLComments(source3));
+  }
+  function getFirstWGSLAutoBindingDeclarationMatch(source3, regexes) {
+    const autoBindingRegexes = regexes === MODULE_WGSL_BINDING_DECLARATION_REGEXES || regexes === WGSL_BINDING_DECLARATION_REGEXES ? WGSL_AUTO_BINDING_DECLARATION_REGEXES : regexes;
+    return getWGSLBindingDeclarationMatches(source3, autoBindingRegexes).find((declarationMatch) => declarationMatch.bindingToken === "auto");
+  }
+
   // ../../node_modules/@luma.gl/shadertools/dist/lib/shader-assembly/wgsl-binding-debug.js
   var WGSL_BINDING_DEBUG_REGEXES = [
-    /@binding\(\s*(\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*var(?:<([^>]+)>)?\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^;]+);/g,
-    /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(\d+)\s*\)\s*var(?:<([^>]+)>)?\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^;]+);/g
+    new RegExp(`@binding\\(\\s*(\\d+)\\s*\\)\\s*@group\\(\\s*(\\d+)\\s*\\)\\s*${WGSL_BINDABLE_VARIABLE_PATTERN}\\s*:\\s*([^;]+);`, "g"),
+    new RegExp(`@group\\(\\s*(\\d+)\\s*\\)\\s*@binding\\(\\s*(\\d+)\\s*\\)\\s*${WGSL_BINDABLE_VARIABLE_PATTERN}\\s*:\\s*([^;]+);`, "g")
   ];
   function getShaderBindingDebugRowsFromWGSL(source3, bindingAssignments = []) {
+    const maskedSource = maskWGSLComments(source3);
     const assignmentMap = /* @__PURE__ */ new Map();
     for (const bindingAssignment of bindingAssignments) {
       assignmentMap.set(getBindingAssignmentKey(bindingAssignment.name, bindingAssignment.group, bindingAssignment.location), bindingAssignment.moduleName);
@@ -13582,7 +13808,8 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
     for (const regex of WGSL_BINDING_DEBUG_REGEXES) {
       regex.lastIndex = 0;
       let match;
-      while (match = regex.exec(source3)) {
+      match = regex.exec(maskedSource);
+      while (match) {
         const isBindingFirst = regex === WGSL_BINDING_DEBUG_REGEXES[0];
         const binding = Number(match[isBindingFirst ? 1 : 2]);
         const group = Number(match[isBindingFirst ? 2 : 1]);
@@ -13599,6 +13826,7 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
           accessDeclaration,
           resourceType
         }));
+        match = regex.exec(maskedSource);
       }
     }
     return rows.sort((left, right) => {
@@ -13710,14 +13938,6 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
 
 ${DECLARATION_INJECT_MARKER}
 `;
-  var MODULE_WGSL_BINDING_DECLARATION_REGEXES = [
-    /@binding\(\s*(auto|\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g,
-    /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(auto|\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g
-  ];
-  var WGSL_BINDING_DECLARATION_REGEXES = [
-    /@binding\(\s*(\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g,
-    /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g
-  ];
   var RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
   var FRAGMENT_SHADER_PROLOGUE = (
     /* glsl */
@@ -13797,7 +14017,8 @@ ${DECLARATION_INJECT_MARKER}
       }
     }
     const modulesToInject = modules;
-    const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(coreSource);
+    const applicationRelocation = relocateWGSLApplicationBindings(coreSource);
+    const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(applicationRelocation.source);
     const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(modulesToInject, options._bindingRegistry, usedBindingsByGroup);
     const bindingAssignments = [];
     for (const module of modulesToInject) {
@@ -13830,7 +14051,7 @@ ${DECLARATION_INJECT_MARKER}
     assembledSource = injectShader(assembledSource, stage, declInjections);
     assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
     assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
-    assembledSource += coreSource;
+    assembledSource += applicationRelocation.source;
     assembledSource = injectShader(assembledSource, stage, mainInjections);
     assertNoUnresolvedAutoBindings(assembledSource);
     return { source: assembledSource, bindingAssignments };
@@ -13980,43 +14201,56 @@ ${getApplicationDefines(allDefines)}
   }
   function getUsedBindingsByGroupFromApplicationWGSL(source3) {
     const usedBindingsByGroup = /* @__PURE__ */ new Map();
-    for (const regex of WGSL_BINDING_DECLARATION_REGEXES) {
-      regex.lastIndex = 0;
-      let match;
-      while (match = regex.exec(source3)) {
-        const isBindingFirst = regex === WGSL_BINDING_DECLARATION_REGEXES[0];
-        const location = Number(match[isBindingFirst ? 1 : 2]);
-        const group = Number(match[isBindingFirst ? 2 : 1]);
-        const name2 = match[4];
-        validateApplicationWGSLBinding(group, location, name2);
-        registerUsedBindingLocation(usedBindingsByGroup, group, location, `application binding "${name2}"`);
-      }
+    for (const match of getWGSLBindingDeclarationMatches(source3, WGSL_EXPLICIT_BINDING_DECLARATION_REGEXES)) {
+      const location = Number(match.bindingToken);
+      const group = Number(match.groupToken);
+      validateApplicationWGSLBinding(group, location, match.name);
+      registerUsedBindingLocation(usedBindingsByGroup, group, location, `application binding "${match.name}"`);
     }
     return usedBindingsByGroup;
   }
+  function relocateWGSLApplicationBindings(source3) {
+    const declarationMatches = getWGSLBindingDeclarationMatches(source3, WGSL_BINDING_DECLARATION_REGEXES);
+    const usedBindingsByGroup = /* @__PURE__ */ new Map();
+    for (const declarationMatch of declarationMatches) {
+      if (declarationMatch.bindingToken === "auto") {
+        continue;
+      }
+      const location = Number(declarationMatch.bindingToken);
+      const group = Number(declarationMatch.groupToken);
+      validateApplicationWGSLBinding(group, location, declarationMatch.name);
+      registerUsedBindingLocation(usedBindingsByGroup, group, location, `application binding "${declarationMatch.name}"`);
+    }
+    const relocationState = {
+      sawSupportedBindingDeclaration: declarationMatches.length > 0
+    };
+    const relocatedSource = replaceWGSLBindingDeclarationMatches(source3, WGSL_BINDING_DECLARATION_REGEXES, (declarationMatch) => relocateWGSLApplicationBindingMatch(declarationMatch, usedBindingsByGroup, relocationState));
+    if (hasWGSLAutoBinding(source3) && !relocationState.sawSupportedBindingDeclaration) {
+      throw new Error('Unsupported @binding(auto) declaration form in application WGSL. Use adjacent "@group(N)" and "@binding(auto)" decorators followed by a bindable "var" declaration.');
+    }
+    return { source: relocatedSource };
+  }
   function relocateWGSLModuleBindings(moduleSource, module, context) {
     const bindingAssignments = [];
+    const declarationMatches = getWGSLBindingDeclarationMatches(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES);
     const relocationState = {
-      sawSupportedBindingDeclaration: false,
+      sawSupportedBindingDeclaration: declarationMatches.length > 0,
       nextHintedBindingLocation: typeof module.firstBindingSlot === "number" ? module.firstBindingSlot : null
     };
-    let relocatedSource = relocateWGSLModuleBindingsWithRegex(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES[0], { isBindingFirst: true, module, context, bindingAssignments, relocationState });
-    relocatedSource = relocateWGSLModuleBindingsWithRegex(relocatedSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES[1], { isBindingFirst: false, module, context, bindingAssignments, relocationState });
-    if (moduleSource.includes("@binding(auto)") && !relocationState.sawSupportedBindingDeclaration) {
-      throw new Error(`Unsupported @binding(auto) declaration form in module "${module.name}". Use "@group(N) @binding(auto) var ..." or "@binding(auto) @group(N) var ..." on a single line.`);
+    const relocatedSource = replaceWGSLBindingDeclarationMatches(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES, (declarationMatch) => relocateWGSLModuleBindingMatch(declarationMatch, {
+      module,
+      context,
+      bindingAssignments,
+      relocationState
+    }));
+    if (hasWGSLAutoBinding(moduleSource) && !relocationState.sawSupportedBindingDeclaration) {
+      throw new Error(`Unsupported @binding(auto) declaration form in module "${module.name}". Use adjacent "@group(N)" and "@binding(auto)" decorators followed by a bindable "var" declaration.`);
     }
     return { source: relocatedSource, bindingAssignments };
   }
-  function relocateWGSLModuleBindingsWithRegex(source3, regex, params) {
-    return source3.replace(regex, (...replaceArguments) => relocateWGSLModuleBindingMatch(replaceArguments, params));
-  }
-  function relocateWGSLModuleBindingMatch(replaceArguments, params) {
-    const { isBindingFirst, module, context, bindingAssignments, relocationState } = params;
-    relocationState.sawSupportedBindingDeclaration = true;
-    const match = replaceArguments[0];
-    const bindingToken = replaceArguments[isBindingFirst ? 1 : 2];
-    const groupToken = replaceArguments[isBindingFirst ? 2 : 1];
-    const name2 = replaceArguments[4];
+  function relocateWGSLModuleBindingMatch(declarationMatch, params) {
+    const { module, context, bindingAssignments, relocationState } = params;
+    const { match, bindingToken, groupToken, name: name2 } = declarationMatch;
     const group = Number(groupToken);
     if (bindingToken === "auto") {
       const registryKey = getBindingRegistryKey(group, module.name, name2);
@@ -14041,6 +14275,18 @@ ${getApplicationDefines(allDefines)}
     bindingAssignments.push({ moduleName: module.name, name: name2, group, location });
     return match;
   }
+  function relocateWGSLApplicationBindingMatch(declarationMatch, usedBindingsByGroup, relocationState) {
+    const { match, bindingToken, groupToken, name: name2 } = declarationMatch;
+    const group = Number(groupToken);
+    if (bindingToken === "auto") {
+      const location = allocateApplicationAutoBindingLocation(group, usedBindingsByGroup);
+      validateApplicationWGSLBinding(group, location, name2);
+      registerUsedBindingLocation(usedBindingsByGroup, group, location, `application binding "${name2}"`);
+      return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location})`);
+    }
+    relocationState.sawSupportedBindingDeclaration = true;
+    return match;
+  }
   function reserveRegisteredModuleBindings(modules, bindingRegistry, usedBindingsByGroup) {
     const reservedBindingKeysByGroup = /* @__PURE__ */ new Map();
     if (!bindingRegistry) {
@@ -14081,16 +14327,11 @@ ${getApplicationDefines(allDefines)}
   function getModuleWGSLBindingDeclarations(module) {
     const declarations = [];
     const moduleSource = module.source || "";
-    for (const regex of MODULE_WGSL_BINDING_DECLARATION_REGEXES) {
-      regex.lastIndex = 0;
-      let match;
-      while (match = regex.exec(moduleSource)) {
-        const isBindingFirst = regex === MODULE_WGSL_BINDING_DECLARATION_REGEXES[0];
-        declarations.push({
-          name: match[4],
-          group: Number(match[isBindingFirst ? 2 : 1])
-        });
-      }
+    for (const match of getWGSLBindingDeclarationMatches(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES)) {
+      declarations.push({
+        name: match.name,
+        group: Number(match.groupToken)
+      });
     }
     return declarations;
   }
@@ -14120,10 +14361,27 @@ ${getApplicationDefines(allDefines)}
     }
     return nextBinding;
   }
+  function allocateApplicationAutoBindingLocation(group, usedBindingsByGroup) {
+    const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+    let nextBinding = 0;
+    while (usedBindings.has(nextBinding)) {
+      nextBinding++;
+    }
+    return nextBinding;
+  }
   function assertNoUnresolvedAutoBindings(source3) {
-    if (/@binding\(\s*auto\s*\)/.test(source3)) {
-      throw new Error("Unresolved @binding(auto) remained in assembled WGSL source.");
+    const unresolvedBinding = getFirstWGSLAutoBindingDeclarationMatch(source3, MODULE_WGSL_BINDING_DECLARATION_REGEXES);
+    if (!unresolvedBinding) {
+      return;
+    }
+    const moduleName = getWGSLModuleNameAtIndex(source3, unresolvedBinding.index);
+    if (moduleName) {
+      throw new Error(`Unresolved @binding(auto) for module "${moduleName}" binding "${unresolvedBinding.name}" remained in assembled WGSL source.`);
     }
+    if (isInApplicationWGSLSection(source3, unresolvedBinding.index)) {
+      throw new Error(`Unresolved @binding(auto) for application binding "${unresolvedBinding.name}" remained in assembled WGSL source.`);
+    }
+    throw new Error(`Unresolved @binding(auto) remained in assembled WGSL source near "${formatWGSLSourceSnippet(unresolvedBinding.match)}".`);
   }
   function formatWGSLBindingAssignmentComments(bindingAssignments) {
     if (bindingAssignments.length === 0) {
@@ -14140,6 +14398,24 @@ ${getApplicationDefines(allDefines)}
   function getBindingRegistryKey(group, moduleName, bindingName) {
     return `${group}:${moduleName}:${bindingName}`;
   }
+  function getWGSLModuleNameAtIndex(source3, index) {
+    const moduleHeaderRegex = /^\/\/ ----- MODULE ([^\n]+) ---------------$/gm;
+    let moduleName;
+    let match;
+    match = moduleHeaderRegex.exec(source3);
+    while (match && match.index <= index) {
+      moduleName = match[1];
+      match = moduleHeaderRegex.exec(source3);
+    }
+    return moduleName;
+  }
+  function isInApplicationWGSLSection(source3, index) {
+    const injectionMarkerIndex = source3.indexOf(INJECT_SHADER_DECLARATIONS);
+    return injectionMarkerIndex >= 0 ? index > injectionMarkerIndex : true;
+  }
+  function formatWGSLSourceSnippet(source3) {
+    return source3.replace(/\s+/g, " ").trim();
+  }
 
   // ../../node_modules/@luma.gl/shadertools/dist/lib/preprocessor/preprocessor.js
   var DEFINE_NAME_PATTERN = "([a-zA-Z_][a-zA-Z0-9_]*)";
@@ -18280,6 +18556,28 @@ void main() {
     return matrixFP64;
   }
 
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/color/normalize-byte-colors.js
+  function resolveUseByteColors(useByteColors, defaultUseByteColors = true) {
+    return useByteColors ?? defaultUseByteColors;
+  }
+  function normalizeByteColor3(color = [0, 0, 0], useByteColors = true) {
+    if (!useByteColors) {
+      return [...color];
+    }
+    return color.map((component) => component / 255);
+  }
+  function normalizeByteColor4(color, useByteColors = true) {
+    const normalizedColor = normalizeByteColor3(color.slice(0, 3), useByteColors);
+    const hasAlpha = Number.isFinite(color[3]);
+    const alpha = hasAlpha ? color[3] : 1;
+    return [
+      normalizedColor[0],
+      normalizedColor[1],
+      normalizedColor[2],
+      useByteColors && hasAlpha ? alpha / 255 : alpha
+    ];
+  }
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules/math/fp32/fp32.js
   var fp32shader = (
     /* glsl */
@@ -18878,6 +19176,90 @@ fn sqrt_fp64(a: vec2f) -> vec2f {
     fp64ifyMatrix4
   };
 
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/color/float-colors.js
+  var GLSL_UNIFORMS = (
+    /* glsl */
+    `layout(std140) uniform floatColorsUniforms {
+  float useByteColors;
+} floatColors;
+
+vec3 floatColors_normalize(vec3 inputColor) {
+  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+}
+
+vec4 floatColors_normalize(vec4 inputColor) {
+  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+}
+
+vec4 floatColors_premultiplyAlpha(vec4 inputColor) {
+  return vec4(inputColor.rgb * inputColor.a, inputColor.a);
+}
+
+vec4 floatColors_unpremultiplyAlpha(vec4 inputColor) {
+  return inputColor.a > 0.0 ? vec4(inputColor.rgb / inputColor.a, inputColor.a) : vec4(0.0);
+}
+
+vec4 floatColors_premultiply_alpha(vec4 inputColor) {
+  return floatColors_premultiplyAlpha(inputColor);
+}
+
+vec4 floatColors_unpremultiply_alpha(vec4 inputColor) {
+  return floatColors_unpremultiplyAlpha(inputColor);
+}
+`
+  );
+  var WGSL_UNIFORMS = (
+    /* wgsl */
+    `struct floatColorsUniforms {
+  useByteColors: f32
+};
+
+@group(0) @binding(auto) var<uniform> floatColors : floatColorsUniforms;
+
+fn floatColors_normalize(inputColor: vec3<f32>) -> vec3<f32> {
+  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+}
+
+fn floatColors_normalize4(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+}
+
+fn floatColors_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return vec4<f32>(inputColor.rgb * inputColor.a, inputColor.a);
+}
+
+fn floatColors_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(
+    vec4<f32>(0.0),
+    vec4<f32>(inputColor.rgb / inputColor.a, inputColor.a),
+    inputColor.a > 0.0
+  );
+}
+
+fn floatColors_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return floatColors_premultiplyAlpha(inputColor);
+}
+
+fn floatColors_unpremultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return floatColors_unpremultiplyAlpha(inputColor);
+}
+`
+  );
+  var floatColors = {
+    name: "floatColors",
+    props: {},
+    uniforms: {},
+    vs: GLSL_UNIFORMS,
+    fs: GLSL_UNIFORMS,
+    source: WGSL_UNIFORMS,
+    uniformTypes: {
+      useByteColors: "f32"
+    },
+    defaultUniforms: {
+      useByteColors: true
+    }
+  };
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules/engine/picking/picking.js
   var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
   var vs = (
@@ -18886,7 +19268,7 @@ fn sqrt_fp64(a: vec2f) -> vec2f {
   float isActive;
   float isAttribute;
   float isHighlightActive;
-  float useFloatColors;
+  float useByteColors;
   vec3 highlightedObjectColor;
   vec4 highlightColor;
 } picking;
@@ -18895,12 +19277,12 @@ out vec4 picking_vRGBcolor_Avalid;
 
 // Normalize unsigned byte color to 0-1 range
 vec3 picking_normalizeColor(vec3 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
 }
 
 // Normalize unsigned byte color to 0-1 range
 vec4 picking_normalizeColor(vec4 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
 }
 
 bool picking_isColorZero(vec3 color) {
@@ -18961,7 +19343,7 @@ void picking_setPickingAttribute(vec3 value) {
   float isActive;
   float isAttribute;
   float isHighlightActive;
-  float useFloatColors;
+  float useByteColors;
   vec3 highlightedObjectColor;
   vec4 highlightColor;
 } picking;
@@ -19023,7 +19405,7 @@ vec4 picking_filterColor(vec4 color) {
       isActive: "f32",
       isAttribute: "f32",
       isHighlightActive: "f32",
-      useFloatColors: "f32",
+      useByteColors: "f32",
       highlightedObjectColor: "vec3<f32>",
       highlightColor: "vec4<f32>"
     },
@@ -19031,7 +19413,7 @@ vec4 picking_filterColor(vec4 color) {
       isActive: false,
       isAttribute: false,
       isHighlightActive: false,
-      useFloatColors: true,
+      useByteColors: true,
       highlightedObjectColor: [0, 0, 0],
       highlightColor: DEFAULT_HIGHLIGHT_COLOR
     },
@@ -19041,6 +19423,7 @@ vec4 picking_filterColor(vec4 color) {
   };
   function getUniforms(opts = {}, prevUniforms) {
     const uniforms = {};
+    const useByteColors = resolveUseByteColors(opts.useByteColors, true);
     if (opts.highlightedObjectColor === void 0) {
     } else if (opts.highlightedObjectColor === null) {
       uniforms.isHighlightActive = false;
@@ -19050,18 +19433,14 @@ vec4 picking_filterColor(vec4 color) {
       uniforms.highlightedObjectColor = highlightedObjectColor;
     }
     if (opts.highlightColor) {
-      const color = Array.from(opts.highlightColor, (x) => x / 255);
-      if (!Number.isFinite(color[3])) {
-        color[3] = 1;
-      }
-      uniforms.highlightColor = color;
+      uniforms.highlightColor = normalizeByteColor4(opts.highlightColor, useByteColors);
     }
     if (opts.isActive !== void 0) {
       uniforms.isActive = Boolean(opts.isActive);
       uniforms.isAttribute = Boolean(opts.isAttribute);
     }
-    if (opts.useFloatColors !== void 0) {
-      uniforms.useFloatColors = Boolean(opts.useFloatColors);
+    if (opts.useByteColors !== void 0) {
+      uniforms.useByteColors = Boolean(opts.useByteColors);
     }
     return uniforms;
   }
@@ -19242,7 +19621,6 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
   var MAX_LIGHTS = 5;
-  var COLOR_FACTOR = 255;
   var LIGHT_UNIFORM_TYPE = {
     color: "vec3<f32>",
     position: "vec3<f32>",
@@ -19281,7 +19659,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     if (props.lights) {
       props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
     }
-    const { ambientLight, pointLights, spotLights, directionalLights } = props || {};
+    const { useByteColors, ambientLight, pointLights, spotLights, directionalLights } = props || {};
     const hasLights = ambientLight || pointLights && pointLights.length > 0 || spotLights && spotLights.length > 0 || directionalLights && directionalLights.length > 0;
     if (!hasLights) {
       return {
@@ -19291,14 +19669,20 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     }
     const uniforms = {
       ...createDefaultLightingUniforms(),
-      ...getLightSourceUniforms({ ambientLight, pointLights, spotLights, directionalLights })
+      ...getLightSourceUniforms({
+        useByteColors,
+        ambientLight,
+        pointLights,
+        spotLights,
+        directionalLights
+      })
     };
     if (props.enabled !== void 0) {
       uniforms.enabled = props.enabled ? 1 : 0;
     }
     return uniforms;
   }
-  function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
+  function getLightSourceUniforms({ useByteColors, ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
     const lights = createDefaultLightUniforms();
     let currentLight = 0;
     let pointLightCount = 0;
@@ -19310,7 +19694,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(pointLight),
+        color: convertColor(pointLight, useByteColors),
         position: pointLight.position,
         attenuation: pointLight.attenuation || [1, 0, 0]
       };
@@ -19323,7 +19707,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(spotLight),
+        color: convertColor(spotLight, useByteColors),
         position: spotLight.position,
         direction: spotLight.direction,
         attenuation: spotLight.attenuation || [1, 0, 0],
@@ -19338,7 +19722,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(directionalLight),
+        color: convertColor(directionalLight, useByteColors),
         direction: directionalLight.direction
       };
       currentLight++;
@@ -19348,7 +19732,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
     }
     return {
-      ambientColor: convertColor(ambientLight),
+      ambientColor: convertColor(ambientLight, useByteColors),
       directionalLightCount,
       pointLightCount,
       spotLightCount,
@@ -19376,9 +19760,10 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     }
     return lightSources;
   }
-  function convertColor(colorDef = {}) {
+  function convertColor(colorDef = {}, useByteColors) {
     const { color = [0, 0, 0], intensity = 1 } = colorDef;
-    return color.map((component) => component * intensity / COLOR_FACTOR);
+    const normalizedColor = normalizeByteColor3(color, resolveUseByteColors(useByteColors, true));
+    return normalizedColor.map((component) => component * intensity);
   }
   function createDefaultLightingUniforms() {
     return {
@@ -19439,7 +19824,7 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
     specular = pow(specular_angle, material.shininess);
   }
   lambertian = max(lambertian, 0.0);
-  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+  return (lambertian * material.diffuse * surfaceColor + specular * floatColors_normalize(material.specularColor)) * color;
 }
 
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
@@ -19504,7 +19889,10 @@ fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, v
     specular = pow(specular_angle, phongMaterial.shininess);
   }
   lambertian = max(lambertian, 0.0);
-  return (lambertian * phongMaterial.diffuse * surfaceColor + specular * phongMaterial.specularColor) * color;
+  return (
+    lambertian * phongMaterial.diffuse * surfaceColor +
+    specular * floatColors_normalize(phongMaterial.specularColor)
+  ) * color;
 }
 
 fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
@@ -19609,6 +19997,7 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
   );
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/gouraud-material/gouraud-material.js
+  var DEFAULT_SPECULAR_COLOR = [38.25, 38.25, 38.25];
   var gouraudMaterial = {
     props: {},
     name: "gouraudMaterial",
@@ -19620,7 +20009,7 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
     defines: {
       LIGHTING_VERTEX: true
     },
-    dependencies: [lighting],
+    dependencies: [lighting, floatColors],
     uniformTypes: {
       unlit: "i32",
       ambient: "f32",
@@ -19633,23 +20022,20 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       ambient: 0.35,
       diffuse: 0.6,
       shininess: 32,
-      specularColor: [0.15, 0.15, 0.15]
+      specularColor: DEFAULT_SPECULAR_COLOR
     },
     getUniforms(props) {
-      const uniforms = { ...props };
-      if (uniforms.specularColor) {
-        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
-      }
-      return { ...gouraudMaterial.defaultUniforms, ...uniforms };
+      return { ...gouraudMaterial.defaultUniforms, ...props };
     }
   };
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/phong-material/phong-material.js
+  var DEFAULT_SPECULAR_COLOR2 = [38.25, 38.25, 38.25];
   var phongMaterial = {
     name: "phongMaterial",
     firstBindingSlot: 0,
     bindingLayout: [{ name: "phongMaterial", group: 3 }],
-    dependencies: [lighting],
+    dependencies: [lighting, floatColors],
     // Note these are switched between phong and gouraud
     source: PHONG_WGSL,
     vs: PHONG_VS,
@@ -19669,14 +20055,10 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       ambient: 0.35,
       diffuse: 0.6,
       shininess: 32,
-      specularColor: [0.15, 0.15, 0.15]
+      specularColor: DEFAULT_SPECULAR_COLOR2
     },
     getUniforms(props) {
-      const uniforms = { ...props };
-      if (uniforms.specularColor) {
-        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
-      }
-      return { ...phongMaterial.defaultUniforms, ...uniforms };
+      return { ...phongMaterial.defaultUniforms, ...props };
     }
   };
 
@@ -19770,6 +20152,9 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
         case "TEXCOORD_0":
           name2 = "texCoords";
           break;
+        case "TEXCOORD_1":
+          name2 = "texCoords1";
+          break;
         case "COLOR_0":
           name2 = "colors";
           break;
@@ -19814,41 +20199,93 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
   }
 
   // ../../node_modules/@luma.gl/engine/dist/debug/debug-framebuffer.js
-  var canvas = null;
-  var ctx = null;
-  function debugFramebuffer(fbo, { id, minimap, opaque, top = "0", left = "0", rgbaScale = 1 }) {
-    if (!canvas) {
-      canvas = document.createElement("canvas");
-      canvas.id = id;
-      canvas.title = id;
-      canvas.style.zIndex = "100";
-      canvas.style.position = "absolute";
-      canvas.style.top = top;
-      canvas.style.left = left;
-      canvas.style.border = "blue 5px solid";
-      canvas.style.transform = "scaleY(-1)";
-      document.body.appendChild(canvas);
-      ctx = canvas.getContext("2d");
-    }
-    if (canvas.width !== fbo.width || canvas.height !== fbo.height) {
-      canvas.width = fbo.width / 2;
-      canvas.height = fbo.height / 2;
-      canvas.style.width = "400px";
-      canvas.style.height = "400px";
-    }
-    const color = fbo.device.readPixelsToArrayWebGL(fbo);
-    const imageData = ctx?.createImageData(fbo.width, fbo.height);
-    if (imageData) {
-      const offset = 0;
-      for (let i = 0; i < color.length; i += 4) {
-        imageData.data[offset + i + 0] = color[i + 0] * rgbaScale;
-        imageData.data[offset + i + 1] = color[i + 1] * rgbaScale;
-        imageData.data[offset + i + 2] = color[i + 2] * rgbaScale;
-        imageData.data[offset + i + 3] = opaque ? 255 : color[i + 3] * rgbaScale;
-      }
-      ctx?.putImageData(imageData, 0, 0);
+  var DEBUG_FRAMEBUFFER_STATE_KEY = "__debugFramebufferState";
+  var DEFAULT_MARGIN_PX = 8;
+  function debugFramebuffer(renderPass, source3, options) {
+    if (renderPass.device.type !== "webgl") {
+      return;
+    }
+    const state = getDebugFramebufferState(renderPass.device);
+    if (state.flushing) {
+      return;
+    }
+    if (isDefaultRenderPass(renderPass)) {
+      flushDebugFramebuffers(renderPass, options, state);
+      return;
+    }
+    if (source3 && isFramebuffer(source3) && source3.handle !== null) {
+      if (!state.queuedFramebuffers.includes(source3)) {
+        state.queuedFramebuffers.push(source3);
+      }
     }
   }
+  function flushDebugFramebuffers(renderPass, options, state) {
+    if (state.queuedFramebuffers.length === 0) {
+      return;
+    }
+    const webglDevice = renderPass.device;
+    const { gl } = webglDevice;
+    const previousReadFramebuffer = gl.getParameter(36010);
+    const previousDrawFramebuffer = gl.getParameter(36006);
+    const [targetWidth, targetHeight] = renderPass.device.getDefaultCanvasContext().getDrawingBufferSize();
+    let topPx = parseCssPixel(options.top, DEFAULT_MARGIN_PX);
+    const leftPx = parseCssPixel(options.left, DEFAULT_MARGIN_PX);
+    state.flushing = true;
+    try {
+      for (const framebuffer of state.queuedFramebuffers) {
+        const [targetX0, targetY0, targetX1, targetY1, previewHeight] = getOverlayRect({
+          framebuffer,
+          targetWidth,
+          targetHeight,
+          topPx,
+          leftPx,
+          minimap: options.minimap
+        });
+        gl.bindFramebuffer(36008, framebuffer.handle);
+        gl.bindFramebuffer(36009, null);
+        gl.blitFramebuffer(0, 0, framebuffer.width, framebuffer.height, targetX0, targetY0, targetX1, targetY1, 16384, 9728);
+        topPx += previewHeight + DEFAULT_MARGIN_PX;
+      }
+    } finally {
+      gl.bindFramebuffer(36008, previousReadFramebuffer);
+      gl.bindFramebuffer(36009, previousDrawFramebuffer);
+      state.flushing = false;
+    }
+  }
+  function getOverlayRect(options) {
+    const { framebuffer, targetWidth, targetHeight, topPx, leftPx, minimap } = options;
+    const maxWidth = minimap ? Math.max(Math.floor(targetWidth / 4), 1) : targetWidth;
+    const maxHeight = minimap ? Math.max(Math.floor(targetHeight / 4), 1) : targetHeight;
+    const scale5 = Math.min(maxWidth / framebuffer.width, maxHeight / framebuffer.height);
+    const previewWidth = Math.max(Math.floor(framebuffer.width * scale5), 1);
+    const previewHeight = Math.max(Math.floor(framebuffer.height * scale5), 1);
+    const targetX0 = leftPx;
+    const targetY0 = Math.max(targetHeight - topPx - previewHeight, 0);
+    const targetX1 = targetX0 + previewWidth;
+    const targetY1 = targetY0 + previewHeight;
+    return [targetX0, targetY0, targetX1, targetY1, previewHeight];
+  }
+  function getDebugFramebufferState(device) {
+    device.userData[DEBUG_FRAMEBUFFER_STATE_KEY] ||= {
+      flushing: false,
+      queuedFramebuffers: []
+    };
+    return device.userData[DEBUG_FRAMEBUFFER_STATE_KEY];
+  }
+  function isFramebuffer(value) {
+    return "colorAttachments" in value;
+  }
+  function isDefaultRenderPass(renderPass) {
+    const framebuffer = renderPass.props.framebuffer;
+    return !framebuffer || framebuffer.handle === null;
+  }
+  function parseCssPixel(value, defaultValue) {
+    if (!value) {
+      return defaultValue;
+    }
+    const parsedValue = Number.parseInt(value, 10);
+    return Number.isFinite(parsedValue) ? parsedValue : defaultValue;
+  }
 
   // ../../node_modules/@luma.gl/engine/dist/utils/deep-equal.js
   function deepEqual(a, b, depth) {
@@ -20057,12 +20494,11 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       this.moduleUniforms = {};
       this.moduleBindings = {};
       for (const [name2, module] of Object.entries(modules)) {
-        if (!module) {
-          continue;
-        }
-        this._addModule(module);
-        if (module.name && name2 !== module.name && !this.options.disableWarnings) {
-          log.warn(`Module name: ${name2} vs ${module.name}`)();
+        if (module) {
+          this._addModule(module);
+          if (module.name && name2 !== module.name && !this.options.disableWarnings) {
+            log.warn(`Module name: ${name2} vs ${module.name}`)();
+          }
         }
       }
     }
@@ -20081,14 +20517,14 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
           if (!this.options.disableWarnings) {
             log.warn(`Module ${name2} not found`)();
           }
-          continue;
+        } else {
+          const oldUniforms = this.moduleUniforms[moduleName];
+          const oldBindings = this.moduleBindings[moduleName];
+          const uniformsAndBindings = module.getUniforms?.(moduleProps, oldUniforms) || moduleProps;
+          const { uniforms, bindings } = splitUniformsAndBindings(uniformsAndBindings, module.uniformTypes);
+          this.moduleUniforms[moduleName] = mergeModuleUniforms(oldUniforms, uniforms, module.uniformTypes);
+          this.moduleBindings[moduleName] = { ...oldBindings, ...bindings };
         }
-        const oldUniforms = this.moduleUniforms[moduleName];
-        const oldBindings = this.moduleBindings[moduleName];
-        const uniformsAndBindings = module.getUniforms?.(moduleProps, oldUniforms) || moduleProps;
-        const { uniforms, bindings } = splitUniformsAndBindings(uniformsAndBindings, module.uniformTypes);
-        this.moduleUniforms[moduleName] = mergeModuleUniforms(oldUniforms, uniforms, module.uniformTypes);
-        this.moduleBindings[moduleName] = { ...oldBindings, ...bindings };
       }
     }
     /**
@@ -20133,10 +20569,9 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
   function mergeModuleUniforms(currentUniforms = {}, nextUniforms = {}, uniformTypes = {}) {
     const mergedUniforms = { ...currentUniforms };
     for (const [key, value] of Object.entries(nextUniforms)) {
-      if (value === void 0) {
-        continue;
+      if (value !== void 0) {
+        mergedUniforms[key] = mergeModuleUniformValue(currentUniforms[key], value, uniformTypes[key]);
       }
-      mergedUniforms[key] = mergeModuleUniformValue(currentUniforms[key], value, uniformTypes[key]);
     }
     return mergedUniforms;
   }
@@ -20152,10 +20587,9 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       const mergedArray = currentArray.slice();
       for (let index = 0; index < nextValue.length; index++) {
         const elementValue = nextValue[index];
-        if (elementValue === void 0) {
-          continue;
+        if (elementValue !== void 0) {
+          mergedArray[index] = mergeModuleUniformValue(currentArray[index], elementValue, uniformType[0]);
         }
-        mergedArray[index] = mergeModuleUniformValue(currentArray[index], elementValue, uniformType[0]);
       }
       return mergedArray;
     }
@@ -20166,10 +20600,9 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
     const currentObject = isPlainUniformObject(currentValue) ? currentValue : {};
     const mergedObject = { ...currentObject };
     for (const [key, value] of Object.entries(nextValue)) {
-      if (value === void 0) {
-        continue;
+      if (value !== void 0) {
+        mergedObject[key] = mergeModuleUniformValue(currentObject[key], value, uniformStruct[key]);
       }
-      mergedObject[key] = mergeModuleUniformValue(currentObject[key], value, uniformStruct[key]);
     }
     return mergedObject;
   }
@@ -20406,7 +20839,9 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       return "DynamicTexture";
     }
     toString() {
-      return `DynamicTexture:"${this.id}":${this.texture.width}x${this.texture.height}px:(${this.isReady ? "ready" : "loading..."})`;
+      const width = this._texture?.width ?? this.props.width ?? "?";
+      const height = this._texture?.height ?? this.props.height ?? "?";
+      return `DynamicTexture:"${this.id}":${width}x${height}px:(${this.isReady ? "ready" : "loading..."})`;
     }
     constructor(device, props) {
       this.device = device;
@@ -20839,6 +21274,7 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
   // ../../node_modules/@luma.gl/engine/dist/model/model.js
   var LOG_DRAW_PRIORITY = 2;
   var LOG_DRAW_TIMEOUT = 1e4;
+  var PIPELINE_INITIALIZATION_FAILED = "render pipeline initialization failed";
   var _Model = class {
     /** Device that created this model */
     device;
@@ -21047,35 +21483,42 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
         renderPass.popDebugGroup();
       }
       let drawSuccess;
+      let pipelineErrored = this.pipeline.isErrored;
       try {
         renderPass.pushDebugGroup(`${this}.draw(${renderPass})`);
         this._logDrawCallStart();
         this.pipeline = this._updatePipeline();
-        const syncBindings = this._getBindings();
-        const syncBindGroups = this._getBindGroups();
-        const { indexBuffer } = this.vertexArray;
-        const indexCount = indexBuffer ? indexBuffer.byteLength / (indexBuffer.indexType === "uint32" ? 4 : 2) : void 0;
-        drawSuccess = this.pipeline.draw({
-          renderPass,
-          vertexArray: this.vertexArray,
-          isInstanced: this.isInstanced,
-          vertexCount: this.vertexCount,
-          instanceCount: this.instanceCount,
-          indexCount,
-          transformFeedback: this.transformFeedback || void 0,
-          // Pipelines may be shared across models when caching is enabled, so bindings
-          // and WebGL uniforms must be supplied on every draw instead of being stored
-          // on the pipeline instance.
-          bindings: syncBindings,
-          bindGroups: syncBindGroups,
-          _bindGroupCacheKeys: this._getBindGroupCacheKeys(),
-          uniforms: this.props.uniforms,
-          // WebGL shares underlying cached pipelines even for models that have different parameters and topology,
-          // so we must provide our unique parameters to each draw
-          // (In WebGPU most parameters are encoded in the pipeline and cannot be changed per draw call)
-          parameters: this.parameters,
-          topology: this.topology
-        });
+        pipelineErrored = this.pipeline.isErrored;
+        if (pipelineErrored) {
+          log.info(LOG_DRAW_PRIORITY, `>>> DRAWING ABORTED ${this.id}: ${PIPELINE_INITIALIZATION_FAILED}`)();
+          drawSuccess = false;
+        } else {
+          const syncBindings = this._getBindings();
+          const syncBindGroups = this._getBindGroups();
+          const { indexBuffer } = this.vertexArray;
+          const indexCount = indexBuffer ? indexBuffer.byteLength / (indexBuffer.indexType === "uint32" ? 4 : 2) : void 0;
+          drawSuccess = this.pipeline.draw({
+            renderPass,
+            vertexArray: this.vertexArray,
+            isInstanced: this.isInstanced,
+            vertexCount: this.vertexCount,
+            instanceCount: this.instanceCount,
+            indexCount,
+            transformFeedback: this.transformFeedback || void 0,
+            // Pipelines may be shared across models when caching is enabled, so bindings
+            // and WebGL uniforms must be supplied on every draw instead of being stored
+            // on the pipeline instance.
+            bindings: syncBindings,
+            bindGroups: syncBindGroups,
+            _bindGroupCacheKeys: this._getBindGroupCacheKeys(),
+            uniforms: this.props.uniforms,
+            // WebGL shares underlying cached pipelines even for models that have different parameters and topology,
+            // so we must provide our unique parameters to each draw
+            // (In WebGPU most parameters are encoded in the pipeline and cannot be changed per draw call)
+            parameters: this.parameters,
+            topology: this.topology
+          });
+        }
       } finally {
         renderPass.popDebugGroup();
         this._logDrawCallEnd();
@@ -21084,6 +21527,8 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       if (drawSuccess) {
         this._lastDrawTimestamp = this.device.timestamp;
         this._needsRedraw = false;
+      } else if (pipelineErrored) {
+        this._needsRedraw = PIPELINE_INITIALIZATION_FAILED;
       } else {
         this._needsRedraw = "waiting for resource initialization";
       }
@@ -21434,9 +21879,10 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
         return;
       }
       const framebuffer = renderPass.props.framebuffer;
-      if (framebuffer) {
-        debugFramebuffer(framebuffer, { id: framebuffer.id, minimap: true });
-      }
+      debugFramebuffer(renderPass, framebuffer, {
+        id: framebuffer?.id || `${this.id}-framebuffer`,
+        minimap: true
+      });
     }
     _getAttributeDebugTable() {
       const table = {};
@@ -22864,7 +23310,7 @@ ${props.source}` };
 
   // ../../node_modules/@loaders.gl/loader-utils/dist/lib/log-utils/log.js
   init_dist3();
-  var VERSION2 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION2 = true ? "4.4.1" : "latest";
   var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
   function createLog() {
     const log3 = new ProbeLog({ id: "loaders.gl" });
@@ -22912,7 +23358,7 @@ ${props.source}` };
   }
 
   // ../../node_modules/@loaders.gl/worker-utils/dist/lib/npm-tag.js
-  var NPM_TAG = "beta";
+  var NPM_TAG = "latest";
 
   // ../../node_modules/@loaders.gl/worker-utils/dist/lib/env-utils/version.js
   function getVersion() {
@@ -22923,7 +23369,7 @@ ${props.source}` };
         globalThis._loadersgl_.version = NPM_TAG;
         warningIssued = true;
       } else {
-        globalThis._loadersgl_.version = "4.4.0-alpha.18";
+        globalThis._loadersgl_.version = "4.4.1";
       }
     }
     return globalThis._loadersgl_.version;
@@ -24043,8 +24489,8 @@ ${props.source}` };
   // ../../node_modules/@loaders.gl/core/dist/lib/loader-utils/option-defaults.js
   var DEFAULT_LOADER_OPTIONS = {
     core: {
-      baseUri: void 0,
-      // baseUri
+      baseUrl: void 0,
+      // baseUrl
       fetch: null,
       mimeType: void 0,
       fallbackMimeType: void 0,
@@ -24076,8 +24522,8 @@ ${props.source}` };
     }
   };
   var REMOVED_LOADER_OPTIONS = {
-    // baseUri
-    baseUri: "core.baseUri",
+    // deprecated top-level alias
+    baseUri: "core.baseUrl",
     fetch: "core.fetch",
     mimeType: "core.mimeType",
     fallbackMimeType: "core.fallbackMimeType",
@@ -24102,7 +24548,7 @@ ${props.source}` };
     // Older deprecations
     throws: "nothrow",
     dataType: "(no longer used)",
-    uri: "baseUri",
+    uri: "core.baseUrl",
     // Warn if fetch options are used on toplevel
     method: "core.fetch.method",
     headers: "core.fetch.headers",
@@ -24120,7 +24566,7 @@ ${props.source}` };
 
   // ../../node_modules/@loaders.gl/core/dist/lib/loader-utils/option-utils.js
   var CORE_LOADER_OPTION_KEYS = [
-    "baseUri",
+    "baseUrl",
     "fetch",
     "mimeType",
     "fallbackMimeType",
@@ -24260,11 +24706,10 @@ ${props.source}` };
     if (!url) {
       return;
     }
-    const hasTopLevelBaseUri = options.baseUri !== void 0;
-    const hasCoreBaseUri = options.core?.baseUri !== void 0;
-    if (!hasTopLevelBaseUri && !hasCoreBaseUri) {
+    const hasCoreBaseUrl = options.core?.baseUrl !== void 0;
+    if (!hasCoreBaseUrl) {
       options.core ||= {};
-      options.core.baseUri = url;
+      options.core.baseUrl = path_exports.dirname(stripQueryString(url));
     }
   }
   function cloneLoaderOptions(options) {
@@ -24275,6 +24720,12 @@ ${props.source}` };
     return clonedOptions;
   }
   function moveDeprecatedTopLevelOptionsToCore(options) {
+    if (options.baseUri !== void 0) {
+      options.core ||= {};
+      if (options.core.baseUrl === void 0) {
+        options.core.baseUrl = options.baseUri;
+      }
+    }
     for (const key of CORE_LOADER_OPTION_KEYS) {
       if (options[key] !== void 0) {
         const coreOptions = options.core = options.core || {};
@@ -24364,6 +24815,13 @@ ${props.source}` };
     }
     const normalizedOptions = normalizeLoaderOptions(options || {});
     normalizedOptions.core ||= {};
+    if (data instanceof Response && mayContainText(data)) {
+      const text = await data.clone().text();
+      const textLoader = selectLoaderSync(text, loaders, { ...normalizedOptions, core: { ...normalizedOptions.core, nothrow: true } }, context);
+      if (textLoader) {
+        return textLoader;
+      }
+    }
     let loader = selectLoaderSync(data, loaders, { ...normalizedOptions, core: { ...normalizedOptions.core, nothrow: true } }, context);
     if (loader) {
       return loader;
@@ -24372,11 +24830,19 @@ ${props.source}` };
       data = await data.slice(0, 10).arrayBuffer();
       loader = selectLoaderSync(data, loaders, normalizedOptions, context);
     }
+    if (!loader && data instanceof Response && mayContainText(data)) {
+      const text = await data.clone().text();
+      loader = selectLoaderSync(text, loaders, normalizedOptions, context);
+    }
     if (!loader && !normalizedOptions.core.nothrow) {
       throw new Error(getNoValidLoaderMessage(data));
     }
     return loader;
   }
+  function mayContainText(response) {
+    const mimeType = getResourceMIMEType(response);
+    return Boolean(mimeType && (mimeType.startsWith("text/") || mimeType === "application/json" || mimeType.endsWith("+json")));
+  }
   function selectLoaderSync(data, loaders = [], options, context) {
     if (!validHTTPResponse(data)) {
       return null;
@@ -24805,11 +25271,23 @@ ${props.source}` };
     if (isBlob(url)) {
       data = await fetch2(url);
     }
+    if (typeof url === "string") {
+      const normalizedOptions = normalizeLoaderOptions(resolvedOptions || {});
+      if (!normalizedOptions.core?.baseUrl) {
+        resolvedOptions = {
+          ...resolvedOptions,
+          core: {
+            ...resolvedOptions?.core,
+            baseUrl: url
+          }
+        };
+      }
+    }
     return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
   }
 
   // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
-  var VERSION4 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION4 = true ? "4.4.1" : "latest";
 
   // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -24858,13 +25336,13 @@ ${props.source}` };
         return image;
       case "image":
       case "imagebitmap":
-        const canvas2 = document.createElement("canvas");
-        const context = canvas2.getContext("2d");
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
         if (!context) {
           throw new Error("getImageData");
         }
-        canvas2.width = image.width;
-        canvas2.height = image.height;
+        canvas.width = image.width;
+        canvas.height = image.height;
         context.drawImage(image, 0, 0);
         return context.getImageData(0, 0, image.width, image.height);
       default:
@@ -27270,33 +27748,33 @@ float smoothedge(float edge, float x) {
     /**
      * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
      */
-    DEFAULT: -1,
+    DEFAULT: "default",
     /**
      * Positions are interpreted as [longitude, latitude, elevation]
      * longitude/latitude are in degrees, elevation is in meters.
      * Dimensions are in meters.
      */
-    LNGLAT: 1,
+    LNGLAT: "lnglat",
     /**
      * Positions are interpreted as [x, y, z] in meter offsets from the coordinate origin.
      * Dimensions are in meters.
      */
-    METER_OFFSETS: 2,
+    METER_OFFSETS: "meter-offsets",
     /**
      * Positions are interpreted as [deltaLng, deltaLat, elevation] from the coordinate origin.
      * deltaLng/deltaLat are in degrees, elevation is in meters.
      * Dimensions are in meters.
      */
-    LNGLAT_OFFSETS: 3,
+    LNGLAT_OFFSETS: "lnglat-offsets",
     /**
      * Positions and dimensions are in the common units of the viewport.
      */
-    CARTESIAN: 0
+    CARTESIAN: "cartesian"
   };
   Object.defineProperty(COORDINATE_SYSTEM, "IDENTITY", {
     get: () => {
       log_default.deprecated("COORDINATE_SYSTEM.IDENTITY", "COORDINATE_SYSTEM.CARTESIAN")();
-      return 0;
+      return COORDINATE_SYSTEM.CARTESIAN;
     }
   });
   var PROJECTION_MODE = {
@@ -27382,6 +27860,20 @@ float smoothedge(float edge, float x) {
   var IDENTITY_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
   var DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0];
   var DEFAULT_COORDINATE_ORIGIN = [0, 0, 0];
+  var COORDINATE_SYSTEM_NUMBERS = {
+    default: -1,
+    cartesian: 0,
+    lnglat: 1,
+    "meter-offsets": 2,
+    "lnglat-offsets": 3
+  };
+  function getShaderCoordinateSystem(coordinateSystem) {
+    const shaderCoordinateSystem = COORDINATE_SYSTEM_NUMBERS[coordinateSystem];
+    if (shaderCoordinateSystem === void 0) {
+      throw new Error(`Invalid coordinateSystem: ${coordinateSystem}`);
+    }
+    return shaderCoordinateSystem;
+  }
   var getMemoizedViewportUniforms = memoize(calculateViewportUniforms);
   function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN) {
     if (coordinateOrigin.length < 3) {
@@ -27390,7 +27882,7 @@ float smoothedge(float edge, float x) {
     let shaderCoordinateOrigin = coordinateOrigin;
     let geospatialOrigin;
     let offsetMode = true;
-    if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS || coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {
+    if (coordinateSystem === "lnglat-offsets" || coordinateSystem === "meter-offsets") {
       geospatialOrigin = coordinateOrigin;
     } else {
       geospatialOrigin = viewport.isGeospatial ? (
@@ -27400,15 +27892,15 @@ float smoothedge(float edge, float x) {
     }
     switch (viewport.projectionMode) {
       case PROJECTION_MODE.WEB_MERCATOR:
-        if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {
+        if (coordinateSystem === "lnglat" || coordinateSystem === "cartesian") {
           geospatialOrigin = [0, 0, 0];
           offsetMode = false;
         }
         break;
       case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET:
-        if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) {
+        if (coordinateSystem === "lnglat") {
           shaderCoordinateOrigin = geospatialOrigin;
-        } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {
+        } else if (coordinateSystem === "cartesian") {
           shaderCoordinateOrigin = [
             Math.fround(viewport.center[0]),
             Math.fround(viewport.center[1]),
@@ -27472,12 +27964,12 @@ float smoothedge(float edge, float x) {
     devicePixelRatio: devicePixelRatio2 = 1,
     modelMatrix = null,
     // Match Layer.defaultProps
-    coordinateSystem = COORDINATE_SYSTEM.DEFAULT,
+    coordinateSystem = "default",
     coordinateOrigin = DEFAULT_COORDINATE_ORIGIN,
     autoWrapLongitude = false
   }) {
-    if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
-      coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN;
+    if (coordinateSystem === "default") {
+      coordinateSystem = viewport.isGeospatial ? "lnglat" : "cartesian";
     }
     const uniforms = getMemoizedViewportUniforms({
       viewport,
@@ -27511,7 +28003,7 @@ float smoothedge(float edge, float x) {
     const focalDistance = vec4_exports.transformMat4([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1;
     const uniforms = {
       // Projection mode values
-      coordinateSystem,
+      coordinateSystem: getShaderCoordinateSystem(coordinateSystem),
       projectionMode: viewport.projectionMode,
       coordinateOrigin: shaderCoordinateOrigin,
       commonOrigin: originCommon.slice(0, 3),
@@ -27538,19 +28030,19 @@ float smoothedge(float edge, float x) {
     if (geospatialOrigin) {
       const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin);
       switch (coordinateSystem) {
-        case COORDINATE_SYSTEM.METER_OFFSETS:
+        case "meter-offsets":
           uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter;
           uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2;
           break;
-        case COORDINATE_SYSTEM.LNGLAT:
-        case COORDINATE_SYSTEM.LNGLAT_OFFSETS:
+        case "lnglat":
+        case "lnglat-offsets":
           if (!viewport._pseudoMeters) {
             uniforms.commonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter;
           }
           uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree;
           uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2;
           break;
-        case COORDINATE_SYSTEM.CARTESIAN:
+        case "cartesian":
           uniforms.commonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]];
           uniforms.commonUnitsPerWorldUnit2 = [0, 0, distanceScalesAtOrigin.unitsPerMeter2[2]];
           break;
@@ -27562,7 +28054,16 @@ float smoothedge(float edge, float x) {
   }
 
   // src/shaderlib/project/project.wgsl.ts
-  var COORDINATE_SYSTEM_WGSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => `const COORDINATE_SYSTEM_${key}: i32 = ${COORDINATE_SYSTEM[key]};`).join("");
+  var SHADER_COORDINATE_SYSTEMS = [
+    "default",
+    "lnglat",
+    "meter-offsets",
+    "lnglat-offsets",
+    "cartesian"
+  ];
+  var COORDINATE_SYSTEM_WGSL_CONSTANTS = SHADER_COORDINATE_SYSTEMS.map(
+    (coordinateSystem) => `const COORDINATE_SYSTEM_${coordinateSystem.toUpperCase().replaceAll("-", "_")}: i32 = ${getShaderCoordinateSystem(coordinateSystem)};`
+  ).join("");
   var PROJECTION_MODE_WGSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const PROJECTION_MODE_${key}: i32 = ${PROJECTION_MODE[key]};`).join("");
   var UNIT_WGSL_CONSTANTS = Object.keys(UNIT).map((key) => `const UNIT_${key.toUpperCase()}: i32 = ${UNIT[key]};`).join("");
   var projectWGSLHeader = (
@@ -27856,7 +28357,16 @@ fn project_pixel_size_vec2(pixels: vec2<f32>) -> vec2<f32> {
   );
 
   // src/shaderlib/project/project.glsl.ts
-  var COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => `const int COORDINATE_SYSTEM_${key} = ${COORDINATE_SYSTEM[key]};`).join("");
+  var SHADER_COORDINATE_SYSTEMS2 = [
+    "default",
+    "lnglat",
+    "meter-offsets",
+    "lnglat-offsets",
+    "cartesian"
+  ];
+  var COORDINATE_SYSTEM_GLSL_CONSTANTS = SHADER_COORDINATE_SYSTEMS2.map(
+    (coordinateSystem) => `const int COORDINATE_SYSTEM_${coordinateSystem.toUpperCase().replaceAll("-", "_")} = ${getShaderCoordinateSystem(coordinateSystem)};`
+  ).join("");
   var PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`).join("");
   var UNIT_GLSL_CONSTANTS = Object.keys(UNIT).map((key) => `const int UNIT_${key.toUpperCase()} = ${UNIT[key]};`).join("");
   var projectGLSL = (
@@ -28764,7 +29274,7 @@ ${fragment}
     for (let i = 0; i < opts.shadowMatrices.length; i++) {
       const viewProjectionMatrix = viewProjectionMatrices[i];
       const viewProjectionMatrixCentered = viewProjectionMatrix.clone().translate(new Vector3(projectProps.viewport.center).negate());
-      if (projectUniforms.coordinateSystem === COORDINATE_SYSTEM.LNGLAT && projectUniforms.projectionMode === PROJECTION_MODE.WEB_MERCATOR) {
+      if (projectUniforms.coordinateSystem === getShaderCoordinateSystem("lnglat") && projectUniforms.projectionMode === PROJECTION_MODE.WEB_MERCATOR) {
         viewProjectionMatrices[i] = viewProjectionMatrixCentered;
         projectCenters[i] = center;
       } else {
@@ -28824,7 +29334,7 @@ ${fragment}
   isActive: f32,
   isAttribute: f32,
   isHighlightActive: f32,
-  useFloatColors: f32,
+  useByteColors: f32,
   highlightedObjectColor: vec3<f32>,
   highlightColor: vec4<f32>,
 };
@@ -28832,11 +29342,11 @@ ${fragment}
 @group(0) @binding(auto) var<uniform> picking: pickingUniforms;
 
 fn picking_normalizeColor(color: vec3<f32>) -> vec3<f32> {
-  return select(color / 255.0, color, picking.useFloatColors > 0.5);
+  return select(color, color / 255.0, picking.useByteColors > 0.5);
 }
 
 fn picking_normalizeColor4(color: vec4<f32>) -> vec4<f32> {
-  return select(color / 255.0, color, picking.useFloatColors > 0.5);
+  return select(color, color / 255.0, picking.useByteColors > 0.5);
 }
 
 fn picking_isColorZero(color: vec3<f32>) -> bool {
@@ -28851,7 +29361,7 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
   var picking_default = {
     ...picking,
     source: sourceWGSL,
-    defaultUniforms: { ...picking.defaultUniforms, useFloatColors: false },
+    defaultUniforms: { ...picking.defaultUniforms, useByteColors: true },
     inject: {
       "vs:DECKGL_FILTER_GL_POSITION": `
     // for picking depth values
@@ -28957,6 +29467,16 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
   };
 
   // src/passes/layers-pass.ts
+  var WEBGPU_DEFAULT_DRAW_PARAMETERS = {
+    depthWriteEnabled: true,
+    depthCompare: "less-equal",
+    blendColorOperation: "add",
+    blendColorSrcFactor: "src-alpha",
+    blendColorDstFactor: "one",
+    blendAlphaOperation: "add",
+    blendAlphaSrcFactor: "one-minus-dst-alpha",
+    blendAlphaDstFactor: "one"
+  };
   var LayersPass = class extends Pass {
     constructor() {
       super(...arguments);
@@ -29073,7 +29593,9 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
             pass,
             shaderModuleProps
           );
+          const defaultParams = layer.context.device.type === "webgpu" ? WEBGPU_DEFAULT_DRAW_PARAMETERS : null;
           layerParam.layerParameters = {
+            ...defaultParams,
             ...layer.context.deck?.props.parameters,
             ...this.getLayerParameters(layer, layerIndex, viewport)
           };
@@ -30219,11 +30741,13 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
   function normalizeParameters(opts) {
     const { viewport, modelMatrix, coordinateOrigin } = opts;
     let { coordinateSystem, fromCoordinateSystem, fromCoordinateOrigin } = opts;
-    if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
-      coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN;
+    if (coordinateSystem === "default") {
+      coordinateSystem = viewport.isGeospatial ? "lnglat" : "cartesian";
     }
     if (fromCoordinateSystem === void 0) {
       fromCoordinateSystem = coordinateSystem;
+    } else if (fromCoordinateSystem === "default") {
+      fromCoordinateSystem = viewport.isGeospatial ? "lnglat" : "cartesian";
     }
     if (fromCoordinateOrigin === void 0) {
       fromCoordinateOrigin = coordinateOrigin;
@@ -30249,23 +30773,32 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
       [x, y, z] = vec4_exports.transformMat4([], [x, y, z, 1], modelMatrix);
     }
     switch (coordinateSystem) {
-      case COORDINATE_SYSTEM.LNGLAT:
+      case "default":
+        return getWorldPosition(position, {
+          viewport,
+          modelMatrix,
+          coordinateSystem: viewport.isGeospatial ? "lnglat" : "cartesian",
+          coordinateOrigin,
+          offsetMode
+        });
+      case "lnglat":
         return lngLatZToWorldPosition([x, y, z], viewport, offsetMode);
-      case COORDINATE_SYSTEM.LNGLAT_OFFSETS:
+      case "lnglat-offsets":
         return lngLatZToWorldPosition(
           [x + coordinateOrigin[0], y + coordinateOrigin[1], z + (coordinateOrigin[2] || 0)],
           viewport,
           offsetMode
         );
-      case COORDINATE_SYSTEM.METER_OFFSETS:
+      case "meter-offsets":
         return lngLatZToWorldPosition(
           addMetersToLngLat(coordinateOrigin, [x, y, z]),
           viewport,
           offsetMode
         );
-      case COORDINATE_SYSTEM.CARTESIAN:
-      default:
+      case "cartesian":
         return viewport.isGeospatial ? [x + coordinateOrigin[0], y + coordinateOrigin[1], z + coordinateOrigin[2]] : viewport.projectPosition([x, y, z]);
+      default:
+        throw new Error(`Invalid coordinateSystem: ${coordinateSystem}`);
     }
   }
   function projectPosition(position, params) {
@@ -34014,9 +34547,9 @@ void main() {
           this.depthFBO = depthFBO;
         }
       }
-      const { canvas: canvas2 } = this.device.getDefaultCanvasContext();
-      this.pickingFBO?.resize({ width: canvas2.width, height: canvas2.height });
-      this.depthFBO?.resize({ width: canvas2.width, height: canvas2.height });
+      const { canvas } = this.device.getDefaultCanvasContext();
+      this.pickingFBO?.resize({ width: canvas.width, height: canvas.height });
+      this.depthFBO?.resize({ width: canvas.width, height: canvas.height });
     }
     /** Preliminary filtering of the layers list. Skid picking pass if no layer is pickable. */
     _getPickable(layers) {
@@ -35660,25 +36193,25 @@ void main() {
     }
     /** Resolve props.canvas to element */
     _createCanvas(props) {
-      let canvas2 = props.canvas;
-      if (typeof canvas2 === "string") {
-        canvas2 = document.getElementById(canvas2);
-        assert9(canvas2);
-      }
-      if (!canvas2) {
-        canvas2 = document.createElement("canvas");
-        canvas2.id = props.id || "deckgl-overlay";
+      let canvas = props.canvas;
+      if (typeof canvas === "string") {
+        canvas = document.getElementById(canvas);
+        assert9(canvas);
+      }
+      if (!canvas) {
+        canvas = document.createElement("canvas");
+        canvas.id = props.id || "deckgl-overlay";
         if (props.width && typeof props.width === "number") {
-          canvas2.width = props.width;
+          canvas.width = props.width;
         }
         if (props.height && typeof props.height === "number") {
-          canvas2.height = props.height;
+          canvas.height = props.height;
         }
         const parent = props.parent || document.body;
-        parent.appendChild(canvas2);
+        parent.appendChild(canvas);
       }
-      Object.assign(canvas2.style, props.style);
-      return canvas2;
+      Object.assign(canvas.style, props.style);
+      return canvas;
     }
     /** Updates canvas width and/or height, if provided as props */
     _setCanvasSize(props) {
@@ -35698,12 +36231,12 @@ void main() {
     }
     /** If canvas size has changed, reads out the new size and update */
     _updateCanvasSize() {
-      const { canvas: canvas2 } = this;
-      if (!canvas2) {
+      const { canvas } = this;
+      if (!canvas) {
         return;
       }
-      const newWidth = canvas2.clientWidth ?? canvas2.width;
-      const newHeight = canvas2.clientHeight ?? canvas2.height;
+      const newWidth = canvas.clientWidth ?? canvas.width;
+      const newHeight = canvas.clientHeight ?? canvas.height;
       if (newWidth !== this.width || newHeight !== this.height) {
         this.width = newWidth;
         this.height = newHeight;
@@ -36714,10 +37247,14 @@ void main() {
         }
         if (!this.value) {
         } else if (this.constant || !this.buffer || this.buffer.byteLength < this.value.byteLength + this.byteOffset) {
-          this.setData({
-            value: this.value,
-            constant: this.constant
-          });
+          if (this.constant) {
+            this.setConstantValue(context, this.value);
+          } else {
+            this.setData({
+              value: this.value,
+              constant: this.constant
+            });
+          }
           this.constant = false;
         } else {
           for (const [startRow, endRow] of updateRanges) {
@@ -36737,17 +37274,13 @@ void main() {
     // Use generic value
     // Returns true if successful
     setConstantValue(context, value) {
-      const isWebGPU = this.device.type === "webgpu";
-      if (isWebGPU || value === void 0 || typeof value === "function") {
-        if (isWebGPU && typeof value !== "function") {
-          const normalisedValue = this._normalizeValue(value, [], 0);
-          if (!this._areValuesEqual(normalisedValue, this.value)) {
-            this.setNeedsUpdate("WebGPU constant updated");
-          }
-        }
+      if (value === void 0 || typeof value === "function") {
         return false;
       }
       const transformedValue = this.settings.transform && context ? this.settings.transform.call(context, value) : value;
+      if (this.device.type === "webgpu") {
+        return this.setConstantBufferValue(transformedValue, this.numInstances);
+      }
       const hasChanged = this.setData({ constant: true, value: transformedValue });
       if (hasChanged) {
         this.setNeedsRedraw();
@@ -36755,6 +37288,41 @@ void main() {
       this.clearNeedsUpdate();
       return true;
     }
+    setConstantBufferValue(value, numInstances) {
+      const ArrayType = this.settings.defaultType;
+      const constantValue = this._normalizeValue(value, new ArrayType(this.size), 0);
+      if (this._hasConstantBufferValue(constantValue, numInstances)) {
+        this.constant = false;
+        this.clearNeedsUpdate();
+        return false;
+      }
+      const repeatedValue = new ArrayType(Math.max(numInstances, 1) * this.size);
+      for (let i = 0; i < repeatedValue.length; i += this.size) {
+        repeatedValue.set(constantValue, i);
+      }
+      const hasChanged = this.setData({ value: repeatedValue });
+      this.constant = false;
+      this.clearNeedsUpdate();
+      if (hasChanged) {
+        this.setNeedsRedraw();
+      }
+      return hasChanged;
+    }
+    _hasConstantBufferValue(value, numInstances) {
+      const currentValue = this.value;
+      const expectedLength = Math.max(numInstances, 1) * this.size;
+      if (!ArrayBuffer.isView(currentValue) || currentValue.length !== expectedLength || currentValue.length % this.size !== 0) {
+        return false;
+      }
+      for (let i = 0; i < currentValue.length; i += this.size) {
+        for (let j = 0; j < this.size; j++) {
+          if (currentValue[i + j] !== value[j]) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
     // Use external buffer
     // Returns true if successful
     // eslint-disable-next-line max-statements
@@ -36863,18 +37431,10 @@ void main() {
       props,
       numInstances
     }) {
-      if (attribute.constant) {
-        if (this.context.device.type !== "webgpu") {
-          return;
-        }
-      }
       const { settings, state, value, size, startIndices } = attribute;
       const { accessor, transform } = settings;
-      let accessorFunc = state.binaryAccessor || // @ts-ignore
+      const accessorFunc = state.binaryAccessor || // @ts-ignore
       (typeof accessor === "function" ? accessor : props[accessor]);
-      if (typeof accessorFunc !== "function" && typeof accessor === "string") {
-        accessorFunc = () => props[accessor];
-      }
       assert9(typeof accessorFunc === "function", `accessor "${accessor}" is not a function`);
       let i = attribute.getVertexOffset(startRow);
       const { iterable, objectInfo } = createIterable(data, startRow, endRow);
@@ -38318,6 +38878,8 @@ void main(void) {
     });
     if (device.type === "webgl") {
       texture.generateMipmapsWebGL();
+    } else if (device.type === "webgpu") {
+      device.generateMipmapsWebGPU(texture);
     }
     internalTextures[texture.id] = owner;
     return texture;
@@ -39028,7 +39590,7 @@ void main(void) {
     onDragStart: { type: "function", value: null, optional: true },
     onDrag: { type: "function", value: null, optional: true },
     onDragEnd: { type: "function", value: null, optional: true },
-    coordinateSystem: COORDINATE_SYSTEM.DEFAULT,
+    coordinateSystem: "default",
     coordinateOrigin: { type: "array", value: [0, 0, 0], compare: true },
     modelMatrix: { type: "array", value: null, compare: true, optional: true },
     wrapLongitude: false,
@@ -39172,7 +39734,7 @@ void main(void) {
     }
     use64bitPositions() {
       const { coordinateSystem } = this.props;
-      return coordinateSystem === COORDINATE_SYSTEM.DEFAULT || coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN;
+      return coordinateSystem === "default" || coordinateSystem === "lnglat" || coordinateSystem === "cartesian";
     }
     // Event handling
     onHover(info, pickingEvent) {
@@ -39552,7 +40114,6 @@ void main(void) {
     /* (Internal) Called by layer manager when a new layer is found */
     _initialize() {
       assert9(!this.internalState);
-      assert9(Number.isFinite(this.props.coordinateSystem));
       debug(TRACE_INITIALIZE, this);
       const attributeManager = this._getAttributeManager();
       if (attributeManager) {