@loaders.gl/scene 5.0.0-beta.7 → 5.0.0-beta.8

package/dist/dist.dev.js

@@ -2319,6 +2319,12 @@ var __exports__ = (() => {
     }
   });
 
+  // ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-helpers.js
+  var init_indexed_arrow_helpers = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-helpers.js"() {
+    }
+  });
+
   // ../../node_modules/tslib/tslib.es6.mjs
   function __rest(s, e) {
     var t = {};
@@ -10121,8 +10127,8 @@ return true;`);
         static startFooter(builder) {
           builder.startObject(5);
         }
-        static addVersion(builder, version) {
-          builder.addFieldInt16(0, version, MetadataVersion.V1);
+        static addVersion(builder, version2) {
+          builder.addFieldInt16(0, version2, MetadataVersion.V1);
         }
         static addSchema(builder, schemaOffset) {
           builder.addFieldOffset(1, schemaOffset, 0);
@@ -10368,9 +10374,9 @@ return true;`);
         get numDictionaries() {
           return this._dictionaryBatches.length;
         }
-        constructor(schema, version = MetadataVersion.V5, recordBatches, dictionaryBatches) {
+        constructor(schema, version2 = MetadataVersion.V5, recordBatches, dictionaryBatches) {
           this.schema = schema;
-          this.version = version;
+          this.version = version2;
           recordBatches && (this._recordBatches = recordBatches);
           dictionaryBatches && (this._dictionaryBatches = dictionaryBatches);
         }
@@ -10498,8 +10504,8 @@ return true;`);
         static startMessage(builder) {
           builder.startObject(5);
         }
-        static addVersion(builder, version) {
-          builder.addFieldInt16(0, version, MetadataVersion.V1);
+        static addVersion(builder, version2) {
+          builder.addFieldInt16(0, version2, MetadataVersion.V1);
         }
         static addHeaderType(builder, headerType) {
           builder.addFieldInt8(1, headerType, MessageHeader.NONE);
@@ -10533,9 +10539,9 @@ return true;`);
         static finishSizePrefixedMessageBuffer(builder, offset) {
           builder.finish(offset, void 0, true);
         }
-        static createMessage(builder, version, headerType, headerOffset, bodyLength, customMetadataOffset) {
+        static createMessage(builder, version2, headerType, headerOffset, bodyLength, customMetadataOffset) {
           _Message.startMessage(builder);
-          _Message.addVersion(builder, version);
+          _Message.addVersion(builder, version2);
           _Message.addHeaderType(builder, headerType);
           _Message.addHeader(builder, headerOffset);
           _Message.addBodyLength(builder, bodyLength);
@@ -10907,16 +10913,16 @@ return true;`);
       throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);
     });
   }
-  function decodeSchema(_schema, dictionaries = /* @__PURE__ */ new Map(), version = MetadataVersion.V5) {
+  function decodeSchema(_schema, dictionaries = /* @__PURE__ */ new Map(), version2 = MetadataVersion.V5) {
     const fields = decodeSchemaFields(_schema, dictionaries);
-    return new Schema2(fields, decodeCustomMetadata(_schema), dictionaries, version);
+    return new Schema2(fields, decodeCustomMetadata(_schema), dictionaries, version2);
   }
-  function decodeRecordBatch(batch, version = MetadataVersion.V5) {
-    const recordBatch = new RecordBatch2(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version), decodeBodyCompression(batch.compression()), decodeVariadicBufferCounts(batch));
+  function decodeRecordBatch(batch, version2 = MetadataVersion.V5) {
+    const recordBatch = new RecordBatch2(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version2), decodeBodyCompression(batch.compression()), decodeVariadicBufferCounts(batch));
     return recordBatch;
   }
-  function decodeDictionaryBatch(batch, version = MetadataVersion.V5) {
-    return new DictionaryBatch2(RecordBatch2.decode(batch.data(), version), batch.id(), batch.isDelta());
+  function decodeDictionaryBatch(batch, version2 = MetadataVersion.V5) {
+    return new DictionaryBatch2(RecordBatch2.decode(batch.data(), version2), batch.id(), batch.isDelta());
   }
   function decodeBufferRegion(b) {
     return new BufferRegion(b.offset(), b.length());
@@ -10933,11 +10939,11 @@ return true;`);
     }
     return nodes;
   }
-  function decodeBuffers(batch, version) {
+  function decodeBuffers(batch, version2) {
     const bufferRegions = [];
     for (let b, i = -1, j = -1, n = batch.buffersLength(); ++i < n; ) {
       if (b = batch.buffers(i)) {
-        if (version < MetadataVersion.V4) {
+        if (version2 < MetadataVersion.V4) {
           b.bb_pos += 8 * (i + 1);
         }
         bufferRegions[++j] = BufferRegion.decode(b);
@@ -11262,10 +11268,10 @@ return true;`);
           buf = new ByteBuffer3(toUint8Array(buf));
           const _message = Message.getRootAsMessage(buf);
           const bodyLength = _message.bodyLength();
-          const version = _message.version();
+          const version2 = _message.version();
           const headerType = _message.headerType();
           const metadata3 = decodeMessageCustomMetadata(_message);
-          const message = new _Message(bodyLength, version, headerType, void 0, metadata3);
+          const message = new _Message(bodyLength, version2, headerType, void 0, metadata3);
           message._createHeader = decodeMessageHeader(_message, headerType);
           return message;
         }
@@ -11342,8 +11348,8 @@ return true;`);
         isDictionaryBatch() {
           return this.headerType === MessageHeader.DictionaryBatch;
         }
-        constructor(bodyLength, version, headerType, header, metadata3) {
-          this._version = version;
+        constructor(bodyLength, version2, headerType, header, metadata3) {
+          this._version = version2;
           this._headerType = headerType;
           this.body = new Uint8Array(0);
           this._compression = header === null || header === void 0 ? void 0 : header.compression;
@@ -17219,6 +17225,12 @@ return true;`);
     }
   });
 
+  // ../../node_modules/@math.gl/arrow/dist/arrow/arrow-schema-utils.js
+  var init_arrow_schema_utils = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/arrow-schema-utils.js"() {
+    }
+  });
+
   // ../../node_modules/@math.gl/arrow/dist/arrow/arrow-data.js
   function getArrowVariadicBuffers(data) {
     return data.variadicBuffers ?? [];
@@ -17322,27 +17334,43 @@ return true;`);
     }
   });
 
+  // ../../node_modules/@math.gl/arrow/dist/arrow/take-arrow-rows.js
+  var init_take_arrow_rows = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/take-arrow-rows.js"() {
+      init_arrow_data();
+      init_split_arrow_buffers();
+    }
+  });
+
   // ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-vector.js
   var init_indexed_arrow_vector = __esm({
     "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-vector.js"() {
+      init_indexed_arrow_helpers();
     }
   });
 
   // ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-table.js
   var init_indexed_arrow_table = __esm({
     "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-table.js"() {
+      init_indexed_arrow_helpers();
+      init_arrow_schema_utils();
+      init_take_arrow_rows();
+      init_indexed_arrow_vector();
     }
   });
 
   // ../../node_modules/@math.gl/arrow/dist/arrow/mapped-arrow-table.js
   var init_mapped_arrow_table = __esm({
     "../../node_modules/@math.gl/arrow/dist/arrow/mapped-arrow-table.js"() {
+      init_indexed_arrow_helpers();
+      init_indexed_arrow_table();
     }
   });
 
   // ../../node_modules/@math.gl/arrow/dist/arrow/rename-arrow-columns.js
   var init_rename_arrow_columns = __esm({
     "../../node_modules/@math.gl/arrow/dist/arrow/rename-arrow-columns.js"() {
+      init_arrow_schema_utils();
     }
   });
 
@@ -17396,15 +17424,23 @@ return true;`);
     }
   });
 
+  // ../../node_modules/@math.gl/arrow/dist/arrow/arrow-column-utils.js
+  var init_arrow_column_utils = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/arrow-column-utils.js"() {
+    }
+  });
+
   // ../../node_modules/@math.gl/arrow/dist/arrow/index.js
   var init_arrow = __esm({
     "../../node_modules/@math.gl/arrow/dist/arrow/index.js"() {
       init_indexed_arrow_table();
       init_indexed_arrow_vector();
       init_mapped_arrow_table();
+      init_arrow_schema_utils();
       init_rename_arrow_columns();
       init_split_arrow_buffers();
       init_arrow_table_transport();
+      init_arrow_column_utils();
     }
   });
 
@@ -17512,6 +17548,738 @@ return true;`);
     }
   });
 
+  // ../../node_modules/probe.gl/dist/env/lib/globals.js
+  var window_2, document_2, process_, console_, navigator_;
+  var init_globals2 = __esm({
+    "../../node_modules/probe.gl/dist/env/lib/globals.js"() {
+      window_2 = globalThis;
+      document_2 = globalThis.document || {};
+      process_ = globalThis.process || {};
+      console_ = globalThis.console;
+      navigator_ = globalThis.navigator || {};
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/env/lib/is-electron.js
+  function isElectron(mockUserAgent) {
+    if (typeof window !== "undefined" && window.process?.type === "renderer") {
+      return true;
+    }
+    if (typeof process !== "undefined" && Boolean(process.versions?.["electron"])) {
+      return true;
+    }
+    const realUserAgent = typeof navigator !== "undefined" && navigator.userAgent;
+    const userAgent = mockUserAgent || realUserAgent;
+    return Boolean(userAgent && userAgent.indexOf("Electron") >= 0);
+  }
+  var init_is_electron = __esm({
+    "../../node_modules/probe.gl/dist/env/lib/is-electron.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/env/lib/is-browser.js
+  function isBrowser2() {
+    const isNode = (
+      // @ts-expect-error
+      typeof process === "object" && String(process) === "[object process]" && !process?.browser
+    );
+    return !isNode || isElectron();
+  }
+  var init_is_browser = __esm({
+    "../../node_modules/probe.gl/dist/env/lib/is-browser.js"() {
+      init_is_electron();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/env/lib/get-browser.js
+  var init_get_browser = __esm({
+    "../../node_modules/probe.gl/dist/env/lib/get-browser.js"() {
+      init_is_browser();
+      init_is_electron();
+      init_globals2();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/env/utils/assert.js
+  var init_assert2 = __esm({
+    "../../node_modules/probe.gl/dist/env/utils/assert.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/env/index.js
+  var VERSION2;
+  var init_env = __esm({
+    "../../node_modules/probe.gl/dist/env/index.js"() {
+      init_globals2();
+      init_is_browser();
+      init_get_browser();
+      init_is_electron();
+      init_assert2();
+      VERSION2 = true ? "5.0.0" : "untranspiled source";
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/utils/assert.js
+  function assert3(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+  var init_assert3 = __esm({
+    "../../node_modules/probe.gl/dist/log/utils/assert.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/loggers/log-utils.js
+  function normalizeLogLevel(logLevel) {
+    if (!logLevel) {
+      return 0;
+    }
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    assert3(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
+  }
+  function normalizeArguments(opts) {
+    const { logLevel, message } = opts;
+    opts.logLevel = normalizeLogLevel(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
+    }
+    switch (typeof logLevel) {
+      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;
+    assert3(messageType === "string" || messageType === "object");
+    return Object.assign(opts, { args }, opts.opts);
+  }
+  var init_log_utils = __esm({
+    "../../node_modules/probe.gl/dist/log/loggers/log-utils.js"() {
+      init_assert3();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/loggers/base-log.js
+  var noop, BaseLog;
+  var init_base_log = __esm({
+    "../../node_modules/probe.gl/dist/log/loggers/base-log.js"() {
+      init_log_utils();
+      noop = () => {
+      };
+      BaseLog = class {
+        constructor({ level = 0 } = {}) {
+          this.userData = {};
+          this._onceCache = /* @__PURE__ */ new Set();
+          this._level = level;
+        }
+        set level(newLevel) {
+          this.setLevel(newLevel);
+        }
+        get level() {
+          return this.getLevel();
+        }
+        setLevel(level) {
+          this._level = level;
+          return this;
+        }
+        getLevel() {
+          return this._level;
+        }
+        // Unconditional logging
+        warn(message, ...args) {
+          return this._log("warn", 0, message, args, { once: true });
+        }
+        error(message, ...args) {
+          return this._log("error", 0, message, args);
+        }
+        // Conditional logging
+        log(logLevel, message, ...args) {
+          return this._log("log", logLevel, message, args);
+        }
+        info(logLevel, message, ...args) {
+          return this._log("info", logLevel, message, args);
+        }
+        once(logLevel, message, ...args) {
+          return this._log("once", logLevel, message, args, { once: true });
+        }
+        _log(type, logLevel, message, args, options = {}) {
+          const normalized = normalizeArguments({
+            logLevel,
+            message,
+            args: this._buildArgs(logLevel, message, args),
+            opts: options
+          });
+          return this._createLogFunction(type, normalized, options);
+        }
+        _buildArgs(logLevel, message, args) {
+          return [logLevel, message, ...args];
+        }
+        _createLogFunction(type, normalized, options) {
+          if (!this._shouldLog(normalized.logLevel)) {
+            return noop;
+          }
+          const tag = this._getOnceTag(options.tag ?? normalized.tag ?? normalized.message);
+          if ((options.once || normalized.once) && tag !== void 0) {
+            if (this._onceCache.has(tag)) {
+              return noop;
+            }
+            this._onceCache.add(tag);
+          }
+          return this._emit(type, normalized);
+        }
+        _shouldLog(logLevel) {
+          return this.getLevel() >= normalizeLogLevel(logLevel);
+        }
+        _getOnceTag(tag) {
+          if (tag === void 0) {
+            return void 0;
+          }
+          try {
+            return typeof tag === "string" ? tag : String(tag);
+          } catch {
+            return void 0;
+          }
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/utils/local-storage.js
+  function getStorage(type) {
+    try {
+      const storage = window[type];
+      const x = "__storage_test__";
+      storage.setItem(x, x);
+      storage.removeItem(x);
+      return storage;
+    } catch (e) {
+      return null;
+    }
+  }
+  var LocalStorage;
+  var init_local_storage = __esm({
+    "../../node_modules/probe.gl/dist/log/utils/local-storage.js"() {
+      LocalStorage = class {
+        constructor(id, defaultConfig, type = "sessionStorage") {
+          this.storage = getStorage(type);
+          this.id = id;
+          this.config = defaultConfig;
+          this._loadConfiguration();
+        }
+        getConfiguration() {
+          return this.config;
+        }
+        setConfiguration(configuration) {
+          Object.assign(this.config, configuration);
+          if (this.storage) {
+            const serialized = JSON.stringify(this.config);
+            this.storage.setItem(this.id, serialized);
+          }
+        }
+        // Get config from persistent store, if available
+        _loadConfiguration() {
+          let configuration = {};
+          if (this.storage) {
+            const serializedConfiguration = this.storage.getItem(this.id);
+            configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+          }
+          Object.assign(this.config, configuration);
+          return this;
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/utils/formatters.js
+  function formatTime(ms) {
+    let formatted;
+    if (ms < 10) {
+      formatted = `${ms.toFixed(2)}ms`;
+    } else if (ms < 100) {
+      formatted = `${ms.toFixed(1)}ms`;
+    } else if (ms < 1e3) {
+      formatted = `${ms.toFixed(0)}ms`;
+    } else {
+      formatted = `${(ms / 1e3).toFixed(2)}s`;
+    }
+    return formatted;
+  }
+  function leftPad(string, length4 = 8) {
+    const padLength = Math.max(length4 - string.length, 0);
+    return `${" ".repeat(padLength)}${string}`;
+  }
+  var init_formatters = __esm({
+    "../../node_modules/probe.gl/dist/log/utils/formatters.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/utils/color.js
+  function getColor(color) {
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
+  }
+  function addColor(string, color, background) {
+    if (!isBrowser2 && typeof string === "string") {
+      if (color) {
+        const colorCode = getColor(color);
+        string = `\x1B[${colorCode}m${string}\x1B[39m`;
+      }
+      if (background) {
+        const colorCode = getColor(background);
+        string = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string}\x1B[49m`;
+      }
+    }
+    return string;
+  }
+  var COLOR, BACKGROUND_INCREMENT;
+  var init_color = __esm({
+    "../../node_modules/probe.gl/dist/log/utils/color.js"() {
+      init_env();
+      (function(COLOR2) {
+        COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+        COLOR2[COLOR2["RED"] = 31] = "RED";
+        COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+        COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+        COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+        COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+        COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+        COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+        COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+        COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+        COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+        COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+        COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+        COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+        COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+        COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+      })(COLOR || (COLOR = {}));
+      BACKGROUND_INCREMENT = 10;
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/utils/autobind.js
+  function autobind(obj, predefined = ["constructor"]) {
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
+    for (const key of propNames) {
+      const value = object[key];
+      if (typeof value === "function") {
+        if (!predefined.find((name22) => key === name22)) {
+          object[key] = value.bind(obj);
+        }
+      }
+    }
+  }
+  var init_autobind = __esm({
+    "../../node_modules/probe.gl/dist/log/utils/autobind.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/probe.js
+  var Probe, probe;
+  var init_probe = __esm({
+    "../../node_modules/probe.gl/dist/log/probe.js"() {
+      init_env();
+      Probe = class {
+        getHighResolutionTimer() {
+          let timestamp;
+          if (isBrowser2() && window_2.performance) {
+            timestamp = window_2?.performance?.now?.();
+          } else if ("hrtime" in process_) {
+            const timeParts = process_?.hrtime?.();
+            timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+          } else {
+            timestamp = Date.now();
+          }
+          return timestamp;
+        }
+        getMemoryUsageMB() {
+          const performance2 = window_2?.performance;
+          const usedJSHeapSize = performance2?.memory?.usedJSHeapSize;
+          if (usedJSHeapSize === void 0 || usedJSHeapSize === null) {
+            return null;
+          }
+          return Math.trunc(usedJSHeapSize / 1024 / 1024);
+        }
+      };
+      probe = new Probe();
+      globalThis.Probe = Probe;
+      globalThis.probe = probe;
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/loggers/probe-log.js
+  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";
+  }
+  var originalConsole, DEFAULT_LOG_CONFIGURATION, ProbeLog;
+  var init_probe_log = __esm({
+    "../../node_modules/probe.gl/dist/log/loggers/probe-log.js"() {
+      init_env();
+      init_base_log();
+      init_local_storage();
+      init_formatters();
+      init_color();
+      init_autobind();
+      init_assert3();
+      init_probe();
+      init_log_utils();
+      init_log_utils();
+      originalConsole = {
+        debug: isBrowser2() ? console.debug || console.log : console.log,
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error
+      };
+      DEFAULT_LOG_CONFIGURATION = {
+        enabled: true,
+        level: 0
+      };
+      ProbeLog = class extends BaseLog {
+        constructor({ id } = { id: "" }) {
+          super({ level: 0 });
+          this.VERSION = VERSION2;
+          this._startTs = probe.getHighResolutionTimer();
+          this._deltaTs = probe.getHighResolutionTimer();
+          this.userData = {};
+          this.LOG_THROTTLE_TIMEOUT = 0;
+          this.id = id;
+          this.userData = {};
+          this._storage = new LocalStorage(`__probe-${this.id}__`, { [this.id]: DEFAULT_LOG_CONFIGURATION });
+          this.timeStamp(`${this.id} started`);
+          autobind(this);
+          Object.seal(this);
+        }
+        isEnabled() {
+          return this._getConfiguration().enabled;
+        }
+        getLevel() {
+          return this._getConfiguration().level;
+        }
+        /** @return milliseconds, with fractions */
+        getTotal() {
+          return Number((probe.getHighResolutionTimer() - this._startTs).toPrecision(10));
+        }
+        /** @return milliseconds, with fractions */
+        getDelta() {
+          return Number((probe.getHighResolutionTimer() - this._deltaTs).toPrecision(10));
+        }
+        /** @deprecated use logLevel */
+        set priority(newPriority) {
+          this.level = newPriority;
+        }
+        /** @deprecated use logLevel */
+        get priority() {
+          return this.level;
+        }
+        /** @deprecated use logLevel */
+        getPriority() {
+          return this.level;
+        }
+        // Configure
+        enable(enabled = true) {
+          this._updateConfiguration({ enabled });
+          return this;
+        }
+        setLevel(level) {
+          this._updateConfiguration({ level });
+          return this;
+        }
+        /** return the current status of the setting */
+        get(setting) {
+          return this._getConfiguration()[setting];
+        }
+        // update the status of the setting
+        set(setting, value) {
+          this._updateConfiguration({ [setting]: value });
+        }
+        /** Logs the current settings as a table */
+        settings() {
+          if (console.table) {
+            console.table(this._storage.config);
+          } else {
+            console.log(this._storage.config);
+          }
+        }
+        // Unconditional logging
+        assert(condition, message) {
+          if (!condition) {
+            throw new Error(message || "Assertion failed");
+          }
+        }
+        warn(message, ...args) {
+          return this._log("warn", 0, message, args, {
+            method: originalConsole.warn,
+            once: true
+          });
+        }
+        error(message, ...args) {
+          return this._log("error", 0, message, args, {
+            method: originalConsole.error
+          });
+        }
+        /** Print a deprecation warning */
+        deprecated(oldUsage, newUsage) {
+          return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`);
+        }
+        /** Print a removal warning */
+        removed(oldUsage, newUsage) {
+          return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`);
+        }
+        probe(logLevel, message, ...args) {
+          const memoryUsageMB = probe.getMemoryUsageMB();
+          if (memoryUsageMB !== null) {
+            const memoryUsagePrefix = `${memoryUsageMB}MB `;
+            if (typeof message === "function") {
+              message = () => `${memoryUsagePrefix}${message()}`;
+            } else if (typeof message === "string") {
+              message = `${memoryUsagePrefix}${message}`;
+            }
+          }
+          return this._log("log", logLevel, message, args, {
+            method: originalConsole.log,
+            time: true,
+            once: true
+          });
+        }
+        log(logLevel, message, ...args) {
+          return this._log("log", logLevel, message, args, {
+            method: originalConsole.debug
+          });
+        }
+        info(logLevel, message, ...args) {
+          return this._log("info", logLevel, message, args, { method: console.info });
+        }
+        once(logLevel, message, ...args) {
+          return this._log("once", logLevel, message, args, {
+            method: originalConsole.debug || originalConsole.info,
+            once: true
+          });
+        }
+        /** Logs an object as a table */
+        table(logLevel, table, columns) {
+          if (table) {
+            return this._log("table", logLevel, table, columns && [columns] || [], {
+              method: console.table || noop,
+              tag: getTableHeader(table)
+            });
+          }
+          return noop;
+        }
+        time(logLevel, message) {
+          return this._log("time", logLevel, message, [], {
+            method: console.time ? console.time : console.info
+          });
+        }
+        timeEnd(logLevel, message) {
+          return this._log("time", logLevel, message, [], {
+            method: console.timeEnd ? console.timeEnd : console.info
+          });
+        }
+        timeStamp(logLevel, message) {
+          return this._log("time", logLevel, message, [], {
+            method: console.timeStamp || noop
+          });
+        }
+        group(logLevel, message, opts = { collapsed: false }) {
+          const method = (opts.collapsed ? console.groupCollapsed : console.group) || console.info;
+          return this._log("group", logLevel, message, [], { method });
+        }
+        groupCollapsed(logLevel, message, opts = {}) {
+          return this.group(logLevel, message, Object.assign({}, opts, { collapsed: true }));
+        }
+        groupEnd(logLevel) {
+          return this._log("groupEnd", logLevel, "", [], {
+            method: console.groupEnd || noop
+          });
+        }
+        // EXPERIMENTAL
+        withGroup(logLevel, message, func) {
+          this.group(logLevel, message)();
+          try {
+            func();
+          } finally {
+            this.groupEnd(logLevel)();
+          }
+        }
+        trace() {
+          if (console.trace) {
+            console.trace();
+          }
+        }
+        _shouldLog(logLevel) {
+          return this.isEnabled() && super._shouldLog(logLevel);
+        }
+        _emit(_type, normalized) {
+          const method = normalized.method;
+          assert3(method);
+          normalized.total = this.getTotal();
+          normalized.delta = this.getDelta();
+          this._deltaTs = probe.getHighResolutionTimer();
+          const message = decorateMessage(this.id, normalized.message, normalized);
+          return method.bind(console, message, ...normalized.args);
+        }
+        _getConfiguration() {
+          if (!this._storage.config[this.id]) {
+            this._updateConfiguration(DEFAULT_LOG_CONFIGURATION);
+          }
+          return this._storage.config[this.id];
+        }
+        _updateConfiguration(configuration) {
+          const currentConfiguration = this._storage.config[this.id] || {
+            ...DEFAULT_LOG_CONFIGURATION
+          };
+          this._storage.setConfiguration({
+            [this.id]: { ...currentConfiguration, ...configuration }
+          });
+        }
+      };
+      ProbeLog.VERSION = VERSION2;
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/loggers/console-log.js
+  var init_console_log = __esm({
+    "../../node_modules/probe.gl/dist/log/loggers/console-log.js"() {
+      init_base_log();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/loggers/memory-log.js
+  var init_memory_log = __esm({
+    "../../node_modules/probe.gl/dist/log/loggers/memory-log.js"() {
+      init_base_log();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/deprecated/hi-res-timestamp.js
+  var init_hi_res_timestamp = __esm({
+    "../../node_modules/probe.gl/dist/log/deprecated/hi-res-timestamp.js"() {
+      init_probe();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/init.js
+  var init_init = __esm({
+    "../../node_modules/probe.gl/dist/log/init.js"() {
+      init_probe();
+      if (!globalThis.probe) {
+        globalThis.probe = probe;
+      }
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/index.js
+  var log;
+  var init_log = __esm({
+    "../../node_modules/probe.gl/dist/log/index.js"() {
+      init_probe_log();
+      init_probe();
+      init_probe_log();
+      init_console_log();
+      init_base_log();
+      init_memory_log();
+      init_color();
+      init_color();
+      init_formatters();
+      init_autobind();
+      init_local_storage();
+      init_hi_res_timestamp();
+      init_init();
+      log = new ProbeLog({ id: "@probe.gl/log" });
+    }
+  });
+
+  // ../core/src/loader-utils/lib/log-utils/log.ts
+  function createLog() {
+    const log3 = new ProbeLog({ id: "loaders.gl" });
+    globalThis.loaders ||= {};
+    globalThis.loaders.log = log3;
+    globalThis.loaders.version = version;
+    globalThis.probe ||= {};
+    globalThis.probe.loaders = log3;
+    return log3;
+  }
+  function ignoreMessage() {
+  }
+  function getLoaderLog(options) {
+    const logger = options?.core?.log !== void 0 ? options.core.log : options?.log;
+    return logger === null ? nullLog : logger || log2;
+  }
+  var VERSION3, version, log2, NullLog, nullLog;
+  var init_log2 = __esm({
+    "../core/src/loader-utils/lib/log-utils/log.ts"() {
+      "use strict";
+      init_log();
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      version = VERSION3[0] >= "0" && VERSION3[0] <= "9" ? `v${VERSION3}` : "";
+      log2 = createLog();
+      NullLog = class {
+        /** Discards debug messages. */
+        log() {
+          return ignoreMessage;
+        }
+        /** Discards informational messages. */
+        info() {
+          return ignoreMessage;
+        }
+        /** Discards messages marked to be emitted once. */
+        once() {
+          return ignoreMessage;
+        }
+        /** Discards warnings. */
+        warn() {
+          return ignoreMessage;
+        }
+        /** Discards errors. */
+        error() {
+          return ignoreMessage;
+        }
+      };
+      nullLog = new NullLog();
+    }
+  });
+
   // ../core/src/loader-utils/lib/javascript-utils/is-type.ts
   var isSharedArrayBuffer;
   var init_is_type = __esm({
@@ -17594,35 +18362,35 @@ return true;`);
 
   // ../core/src/worker-utils/lib/env-utils/version.ts
   function getVersion() {
-    const version = typeof __VERSION__ === "undefined" ? NPM_TAG : __VERSION__;
+    const version2 = typeof __VERSION__ === "undefined" ? NPM_TAG : __VERSION__;
     globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-    globalThis._loadersgl_.version ||= version;
-    return version;
+    globalThis._loadersgl_.version ||= version2;
+    return version2;
   }
-  var VERSION2;
+  var VERSION4;
   var init_version = __esm({
     "../core/src/worker-utils/lib/env-utils/version.ts"() {
       "use strict";
       init_npm_tag();
-      VERSION2 = getVersion();
+      VERSION4 = getVersion();
     }
   });
 
   // ../core/src/worker-utils/lib/env-utils/assert.ts
-  function assert2(condition, message) {
+  function assert4(condition, message) {
     if (!condition) {
       throw new Error(message || "loaders.gl assertion failed.");
     }
   }
-  var init_assert2 = __esm({
+  var init_assert4 = __esm({
     "../core/src/worker-utils/lib/env-utils/assert.ts"() {
       "use strict";
     }
   });
 
   // ../core/src/worker-utils/lib/env-utils/globals.ts
-  var globals2, self_2, window_2, global_2, document_2, isBrowser2, isWorker, isMobile, matches2, nodeVersion2;
-  var init_globals2 = __esm({
+  var globals2, self_2, window_3, global_3, document_3, isBrowser3, isWorker, isMobile2, matches2, nodeVersion2;
+  var init_globals3 = __esm({
     "../core/src/worker-utils/lib/env-utils/globals.ts"() {
       "use strict";
       globals2 = {
@@ -17632,13 +18400,13 @@ return true;`);
         document: typeof document !== "undefined" && document
       };
       self_2 = globals2.self || globals2.window || globals2.global || {};
-      window_2 = globals2.window || globals2.self || globals2.global || {};
-      global_2 = globals2.global || globals2.self || globals2.window || {};
-      document_2 = globals2.document || {};
-      isBrowser2 = // @ts-ignore process.browser
+      window_3 = globals2.window || globals2.self || globals2.global || {};
+      global_3 = globals2.global || globals2.self || globals2.window || {};
+      document_3 = globals2.document || {};
+      isBrowser3 = // @ts-ignore process.browser
       typeof process !== "object" || String(process) !== "[object process]" || process.browser;
       isWorker = typeof importScripts === "function";
-      isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+      isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "undefined";
       matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
       nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
     }
@@ -17656,28 +18424,28 @@ return true;`);
   function getVersion2() {
     return typeof __VERSION__ === "undefined" ? NPM_TAG2 : __VERSION__;
   }
-  var VERSION3;
+  var VERSION5;
   var init_version2 = __esm({
     "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/version.js"() {
       init_npm_tag2();
-      VERSION3 = getVersion2();
+      VERSION5 = getVersion2();
     }
   });
 
   // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/assert.js
-  function assert3(condition, message) {
+  function assert5(condition, message) {
     if (!condition) {
       throw new Error(message || "loaders.gl assertion failed.");
     }
   }
-  var init_assert3 = __esm({
+  var init_assert5 = __esm({
     "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/assert.js"() {
     }
   });
 
   // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/globals.js
-  var globals3, self_3, window_3, global_3, document_3, isBrowser3, isMobile2, matches3, nodeVersion3;
-  var init_globals3 = __esm({
+  var globals3, self_3, window_4, global_4, document_4, isBrowser4, isMobile3, matches3, nodeVersion3;
+  var init_globals4 = __esm({
     "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/globals.js"() {
       globals3 = {
         self: typeof self !== "undefined" && self,
@@ -17686,12 +18454,12 @@ return true;`);
         document: typeof document !== "undefined" && document
       };
       self_3 = globals3.self || globals3.window || globals3.global || {};
-      window_3 = globals3.window || globals3.self || globals3.global || {};
-      global_3 = globals3.global || globals3.self || globals3.window || {};
-      document_3 = globals3.document || {};
-      isBrowser3 = // @ts-ignore process.browser
+      window_4 = globals3.window || globals3.self || globals3.global || {};
+      global_4 = globals3.global || globals3.self || globals3.window || {};
+      document_4 = globals3.document || {};
+      isBrowser4 = // @ts-ignore process.browser
       typeof process !== "object" || String(process) !== "[object process]" || process.browser;
-      isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+      isMobile3 = typeof window !== "undefined" && typeof window.orientation !== "undefined";
       matches3 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
       nodeVersion3 = matches3 && parseFloat(matches3[1]) || 0;
     }
@@ -17842,7 +18610,7 @@ return true;`);
 
   // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js
   function getLoadableWorkerURL(props) {
-    assert3(props.source && !props.url || !props.source && props.url);
+    assert5(props.source && !props.url || !props.source && props.url);
     if (props.url && props.workerType === "module") {
       const baseUrl = globalThis.document?.baseURI ?? globalThis.location?.href;
       if (!baseUrl)
@@ -17865,7 +18633,7 @@ return true;`);
         workerURLCache.set(props.source, workerURL);
       }
     }
-    assert3(workerURL);
+    assert5(workerURL);
     return workerURL;
   }
   function getLoadableWorkerURLFromURL(url) {
@@ -17890,7 +18658,7 @@ return true;`);
   var workerURLCache;
   var init_get_loadable_worker_url = __esm({
     "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js"() {
-      init_assert3();
+      init_assert5();
       workerURLCache = /* @__PURE__ */ new Map();
     }
   });
@@ -17988,8 +18756,8 @@ return true;`);
   var init_worker_thread = __esm({
     "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-thread.js"() {
       init_worker_threads_browser();
-      init_globals3();
-      init_assert3();
+      init_globals4();
+      init_assert5();
       init_get_loadable_worker_url();
       init_get_transfer_list();
       NOOP = () => {
@@ -17997,14 +18765,14 @@ return true;`);
       WorkerThread = class {
         /** Checks if workers are supported on this platform */
         static isSupported() {
-          return typeof Worker !== "undefined" && isBrowser3 || typeof NodeWorker !== "undefined" && !isBrowser3;
+          return typeof Worker !== "undefined" && isBrowser4 || typeof NodeWorker !== "undefined" && !isBrowser4;
         }
         constructor(props) {
           this.terminated = false;
           this.createdAt = performance.now();
           this._loadableURL = "";
           const { name: name22, source, url, getUrl, loadWorker } = props;
-          assert3(source || url || getUrl || loadWorker);
+          assert5(source || url || getUrl || loadWorker);
           this.name = name22;
           this.source = source;
           this.url = url;
@@ -18014,7 +18782,7 @@ return true;`);
           this.onMessage = NOOP;
           this.onError = (error) => console.log(error);
           const startedAt = performance.now();
-          this.worker = isBrowser3 ? this._createBrowserWorker() : this._createNodeWorker();
+          this.worker = isBrowser4 ? this._createBrowserWorker() : this._createNodeWorker();
           this.creationTimeMs = performance.now() - startedAt;
         }
         /**
@@ -18033,13 +18801,13 @@ return true;`);
         }
         /** Keeps this worker from preventing Node.js process exit while idle. */
         unref() {
-          if (!isBrowser3 && typeof this.worker.unref === "function") {
+          if (!isBrowser4 && typeof this.worker.unref === "function") {
             this.worker.unref();
           }
         }
         /** Keeps this worker alive while it is actively processing a job. */
         ref() {
-          if (!isBrowser3 && typeof this.worker.ref === "function") {
+          if (!isBrowser4 && typeof this.worker.ref === "function") {
             this.worker.ref();
           }
         }
@@ -18178,7 +18946,7 @@ return true;`);
   var WorkerPool;
   var init_worker_pool = __esm({
     "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-pool.js"() {
-      init_globals3();
+      init_globals4();
       init_worker_thread();
       init_worker_job();
       WorkerPool = class {
@@ -18702,7 +19470,7 @@ return true;`);
           return null;
         }
         _getMaxConcurrency() {
-          return isMobile2 ? this.maxMobileConcurrency : this.maxConcurrency;
+          return isMobile3 ? this.maxMobileConcurrency : this.maxConcurrency;
         }
       };
     }
@@ -18910,15 +19678,15 @@ return true;`);
 
   // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/get-worker-url.js
   function getWorkerName(worker) {
-    const warning = worker.version !== VERSION3 ? ` (worker-utils@${VERSION3})` : "";
+    const warning = worker.version !== VERSION5 ? ` (worker-utils@${VERSION5})` : "";
     return `${worker.name}@${worker.version}${warning}`;
   }
   function getCustomWorkerURL(worker, options = {}) {
-    const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+    const workerFile = isBrowser4 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
     let url = getConfiguredWorkerURL(worker, options);
     const workerType = options._workerType || options?.core?._workerType;
     if (!url && workerType === "test") {
-      if (isBrowser3) {
+      if (isBrowser4) {
         url = `modules/${worker.module}/dist/${workerFile}`;
       } else {
         const workerSourceDirectory = worker.module === "tasks" && worker.workerNode?.startsWith("worker-utils/") ? "worker-utils/workers" : "workers";
@@ -18936,16 +19704,16 @@ return true;`);
     const customWorkerUrl = getCustomWorkerURL(worker, options);
     const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
     const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL(worker, true);
-    assert3(url);
+    assert5(url);
     return url;
   }
   function getDefaultWorkerURL(worker, warn = false) {
-    const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
-    let version = worker.version;
-    if (version === "latest") {
-      version = NPM_TAG2;
+    const workerFile = isBrowser4 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+    let version2 = worker.version;
+    if (version2 === "latest") {
+      version2 = NPM_TAG2;
     }
-    const versionTag = version ? `@${version}` : "";
+    const versionTag = version2 ? `@${version2}` : "";
     const packageName = worker.packageName || `@loaders.gl/${worker.module}`;
     const url = `https://unpkg.com/${packageName}${versionTag}/dist/${workerFile}`;
     if (warn) {
@@ -18967,8 +19735,8 @@ return true;`);
   var warnedWorkerVersionFallbacks;
   var init_get_worker_url = __esm({
     "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/get-worker-url.js"() {
-      init_assert3();
-      init_globals3();
+      init_assert5();
+      init_globals4();
       init_version2();
       init_npm_tag2();
       warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
@@ -18983,7 +19751,7 @@ return true;`);
       sharedMemory: false,
       crossOriginIsolated: isolated
     };
-    if (isBrowser3 && isolated !== true) {
+    if (isBrowser4 && isolated !== true) {
       capabilities.sharedMemoryUnavailableReason = "cross-origin-isolation";
     } else if (typeof SharedArrayBuffer === "undefined" || typeof Atomics === "undefined" || typeof structuredClone !== "function") {
       capabilities.sharedMemoryUnavailableReason = "unsupported";
@@ -19024,7 +19792,7 @@ return true;`);
   var init_shared_state = __esm({
     "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js"() {
       init_worker_thread();
-      init_globals3();
+      init_globals4();
       SharedWorkerState = class {
         constructor(buffer) {
           if (typeof SharedArrayBuffer === "undefined" || !(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== 16)
@@ -19336,7 +20104,7 @@ return true;`);
     if (customWorkerUrl) {
       return { name: name22, url: customWorkerUrl, workerType: options.workerType };
     }
-    if (isBrowser3 && worker.loadWorker) {
+    if (isBrowser4 && worker.loadWorker) {
       return {
         name: name22,
         workerType: options.workerType,
@@ -19409,7 +20177,7 @@ return true;`);
       init_get_worker_url();
       init_get_transfer_list();
       init_shared_state();
-      init_globals3();
+      init_globals4();
       init_get_input_byte_length();
       init_validate_output_ownership();
     }
@@ -20716,11 +21484,11 @@ return true;`);
 
   // ../core/src/worker-utils/lib/worker-api/get-worker-url.ts
   function getCustomWorkerURL2(worker, options = {}) {
-    const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+    const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
     let url = getConfiguredWorkerURL2(worker, options);
     const workerType = options._workerType || options?.core?._workerType;
     if (!url && workerType === "test") {
-      if (isBrowser2) {
+      if (isBrowser3) {
         url = `modules/${worker.module}/dist/${workerFile}`;
       } else {
         const workerSourceDirectory = worker.module === "core" && worker.workerNode?.startsWith("worker-utils/") ? "worker-utils/workers" : "workers";
@@ -20738,16 +21506,16 @@ return true;`);
     const customWorkerUrl = getCustomWorkerURL2(worker, options);
     const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
     const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL2(worker, true);
-    assert2(url);
+    assert4(url);
     return url;
   }
   function getDefaultWorkerURL2(worker, warn = false) {
-    const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
-    let version = worker.version;
-    if (version === "latest") {
-      version = NPM_TAG;
+    const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+    let version2 = worker.version;
+    if (version2 === "latest") {
+      version2 = NPM_TAG;
     }
-    const versionTag = version ? `@${version}` : "";
+    const versionTag = version2 ? `@${version2}` : "";
     const url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
     if (warn) {
       warnIfUsingNpmTagFallback2(worker, url);
@@ -20763,16 +21531,17 @@ return true;`);
       return;
     }
     warnedWorkerVersionFallbacks2.add(workerId);
-    console.warn(
+    log2.warn(
       `loaders.gl: ${worker.name} loader worker version is "latest" because __VERSION__ was not injected. Fetching ${url} from CDN.`
-    );
+    )();
   }
   var warnedWorkerVersionFallbacks2;
   var init_get_worker_url2 = __esm({
     "../core/src/worker-utils/lib/worker-api/get-worker-url.ts"() {
       "use strict";
-      init_assert2();
-      init_globals2();
+      init_log2();
+      init_assert4();
+      init_globals3();
       init_npm_tag();
       warnedWorkerVersionFallbacks2 = /* @__PURE__ */ new Set();
     }
@@ -20846,7 +21615,7 @@ return true;`);
 
   // ../core/src/worker-utils/lib/worker-api/process-on-worker.ts
   function canProcessOnWorker2(worker, options = {}) {
-    const supported = isBrowser2 ? typeof Worker !== "undefined" : Boolean(options._nodeWorkers);
+    const supported = isBrowser3 ? typeof Worker !== "undefined" : Boolean(options._nodeWorkers);
     return Boolean(
       supported && options.worker && (worker.worker || worker.loadWorker || getConfiguredWorkerURL2(worker, options))
     );
@@ -20873,7 +21642,7 @@ return true;`);
       throw new Error(
         "Inline legacy worker source is unsupported; use a TaskRunner worker URL or factory"
       );
-    const create2 = !getCustomWorkerURL2(worker, options) && isBrowser2 ? worker.loadWorker : void 0;
+    const create2 = !getCustomWorkerURL2(worker, options) && isBrowser3 ? worker.loadWorker : void 0;
     const url = getWorkerURL2(worker, options);
     return {
       id: `${worker.module}:${worker.id}`,
@@ -20904,7 +21673,7 @@ return true;`);
     if (!state) {
       state = {
         runner: new TaskRunner({
-          maxConcurrency: isMobile ? options.maxMobileConcurrency ?? 1 : options.maxConcurrency ?? 3
+          maxConcurrency: isMobile2 ? options.maxMobileConcurrency ?? 1 : options.maxConcurrency ?? 3
         }),
         requests: 0
       };
@@ -21036,7 +21805,7 @@ return true;`);
       init_get_worker_url2();
       init_task_runtime2();
       init_get_transfer_list2();
-      init_globals2();
+      init_globals3();
       runners = /* @__PURE__ */ new WeakMap();
       activeRunners = /* @__PURE__ */ new Set();
       moduleWorkerUrls = /* @__PURE__ */ new Map();
@@ -21095,15 +21864,15 @@ return true;`);
     if (!options.useLocalLibraries && library.startsWith("http")) {
       return library;
     }
-    if (!isBrowser2) {
+    if (!isBrowser3) {
       return `modules/${moduleName}/dist/libs/${libraryName}`;
     }
     if (options.CDN) {
       if (typeof options.CDN !== "string") {
         throw new Error("loadLibrary: options.CDN must be a string or null");
       }
-      assert2(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${libraryName}`;
+      assert4(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION4}/dist/libs/${libraryName}`;
     }
     if (isWorker) {
       return libraryName.endsWith(".mjs") ? `./libs/${libraryName}` : `../src/libs/${libraryName}`;
@@ -21114,7 +21883,7 @@ return true;`);
     if (libraryUrl.endsWith("wasm")) {
       return await loadAsArrayBuffer(libraryUrl);
     }
-    if (!isBrowser2) {
+    if (!isBrowser3) {
       const { requireFromFile } = globalThis.loaders || {};
       try {
         const result = await requireFromFile?.(libraryUrl);
@@ -21129,7 +21898,7 @@ return true;`);
           } catch {
           }
         }
-        console.error(error);
+        log2.error(String(error))();
         return null;
       }
     }
@@ -21166,7 +21935,7 @@ return true;`);
   }
   async function loadAsArrayBuffer(url) {
     const { readFileAsArrayBuffer } = globalThis.loaders || {};
-    if (isBrowser2 || !readFileAsArrayBuffer || url.startsWith("http")) {
+    if (isBrowser3 || !readFileAsArrayBuffer || url.startsWith("http")) {
       const response = await fetch(url);
       return await response.arrayBuffer();
     }
@@ -21181,7 +21950,7 @@ return true;`);
   }
   async function loadAsText(url) {
     const { readFileAsText } = globalThis.loaders || {};
-    if (isBrowser2 || !readFileAsText || url.startsWith("http")) {
+    if (isBrowser3 || !readFileAsText || url.startsWith("http")) {
       const response = await fetch(url);
       return await response.text();
     }
@@ -21198,8 +21967,9 @@ return true;`);
   var init_library_utils = __esm({
     "../core/src/worker-utils/lib/library-utils/library-utils.ts"() {
       "use strict";
-      init_globals2();
-      init_assert2();
+      init_log2();
+      init_globals3();
+      init_assert4();
       init_version();
       loadLibraryPromises = {};
     }
@@ -21209,7 +21979,7 @@ return true;`);
   var init_worker_utils2 = __esm({
     "../core/src/worker-utils/index.ts"() {
       "use strict";
-      init_globals2();
+      init_globals3();
       init_process_on_worker2();
       init_library_utils();
     }
@@ -21826,12 +22596,12 @@ return true;`);
   });
 
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
-  function assert4(condition, message) {
+  function assert6(condition, message) {
     if (!condition) {
       throw new Error(`math.gl assertion ${message}`);
     }
   }
-  var init_assert4 = __esm({
+  var init_assert6 = __esm({
     "../../node_modules/@math.gl/core/dist/lib/assert.js"() {
     }
   });
@@ -21842,7 +22612,7 @@ return true;`);
     "../../node_modules/@math.gl/core/dist/classes/base/vector.js"() {
       init_math_array();
       init_validators2();
-      init_assert4();
+      init_assert6();
       Vector2 = class extends MathArray {
         // ACCESSORS
         get x() {
@@ -21943,11 +22713,11 @@ return true;`);
           return this.distanceSquared(vector);
         }
         getComponent(i) {
-          assert4(i >= 0 && i < this.ELEMENTS, "index is out of range");
+          assert6(i >= 0 && i < this.ELEMENTS, "index is out of range");
           return checkNumber(this[i]);
         }
         setComponent(i, value) {
-          assert4(i >= 0 && i < this.ELEMENTS, "index is out of range");
+          assert6(i >= 0 && i < this.ELEMENTS, "index is out of range");
           this[i] = value;
           return this.check();
         }
@@ -24547,6 +25317,7 @@ return true;`);
       init_loader_types();
       init_assert();
       init_globals();
+      init_log2();
       init_initialize_wasm_module();
       init_js_module_utils();
       init_js_module_utils();
@@ -26296,18 +27067,18 @@ return true;`);
   function testOBJFile(text) {
     return text[0] === "v";
   }
-  var VERSION4, OBJLoader, OBJWorkerLoader;
+  var VERSION6, OBJLoader, OBJWorkerLoader;
   var init_obj_loader_types = __esm({
     "src/obj/obj-loader-types.ts"() {
       "use strict";
       init_obj_format();
       init_arrow_worker_transport();
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       OBJLoader = {
         ...OBJFormat,
         dataType: null,
         batchType: null,
-        version: VERSION4,
+        version: VERSION6,
         worker: true,
         /** Enables the stateful input/output batch protocol on the built-in worker. */
         workerInBatches: true,
@@ -26454,17 +27225,17 @@ return true;`);
     const { MTLLoaderWithParser: MTLLoaderWithParser2 } = await Promise.resolve().then(() => (init_mtl_loader2(), mtl_loader_exports));
     return MTLLoaderWithParser2;
   }
-  var VERSION5, MTLLoader, MTLWorkerLoader;
+  var VERSION7, MTLLoader, MTLWorkerLoader;
   var init_mtl_loader_types = __esm({
     "src/obj/mtl-loader-types.ts"() {
       "use strict";
       init_mtl_format();
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       MTLLoader = {
         ...MTLFormat,
         dataType: null,
         batchType: null,
-        version: VERSION5,
+        version: VERSION7,
         worker: true,
         text: true,
         testText: (text) => text.includes("newmtl"),
@@ -26478,11 +27249,11 @@ return true;`);
   });
 
   // src/gltf/lib/utils/version.ts
-  var VERSION7;
+  var VERSION9;
   var init_version3 = __esm({
     "src/gltf/lib/utils/version.ts"() {
       "use strict";
-      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -26721,11 +27492,11 @@ return true;`);
   });
 
   // ../images/src/lib/utils/version.ts
-  var VERSION8;
+  var VERSION10;
   var init_version4 = __esm({
     "../images/src/lib/utils/version.ts"() {
       "use strict";
-      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -26819,13 +27590,13 @@ return true;`);
       imageBitmapSource = getBlob(arrayBuffer, url);
     }
     const imageBitmapOptions = options && options.imagebitmap;
-    return await safeCreateImageBitmap(imageBitmapSource, imageBitmapOptions);
+    return await safeCreateImageBitmap(imageBitmapSource, imageBitmapOptions, getLoaderLog(options));
   }
   async function parseBlobToImageBitmap(blob, options) {
     const imageBitmapOptions = options && options.imagebitmap;
-    return await safeCreateImageBitmap(blob, imageBitmapOptions);
+    return await safeCreateImageBitmap(blob, imageBitmapOptions, getLoaderLog(options));
   }
-  async function safeCreateImageBitmap(imageBitmapSource, imageBitmapOptions = null) {
+  async function safeCreateImageBitmap(imageBitmapSource, imageBitmapOptions = null, loaderLog = getLoaderLog()) {
     if (isEmptyObject(imageBitmapOptions) || !imagebitmapOptionsSupported) {
       imageBitmapOptions = null;
     }
@@ -26833,7 +27604,7 @@ return true;`);
       try {
         return await createImageBitmap(imageBitmapSource, imageBitmapOptions);
       } catch (error) {
-        console.warn(error);
+        loaderLog.warn(String(error))();
         imagebitmapOptionsSupported = false;
       }
     }
@@ -26854,6 +27625,7 @@ return true;`);
   var init_parse_to_image_bitmap = __esm({
     "../images/src/lib/parsers/parse-to-image-bitmap.ts"() {
       "use strict";
+      init_loader_utils();
       init_svg_utils();
       init_parse_to_image();
       imagebitmapOptionsSupported = true;
@@ -26963,7 +27735,7 @@ return true;`);
         dataType: null,
         batchType: null,
         ...ImageBitmapFormat,
-        version: VERSION8,
+        version: VERSION10,
         options: DEFAULT_IMAGE_BITMAP_LOADER_OPTIONS,
         preload: preload4
       };
@@ -28045,7 +28817,7 @@ return true;`);
         name: "Basis",
         id: "basis",
         module: "images",
-        version: VERSION8,
+        version: VERSION10,
         worker: true,
         /** Published CommonJS bundle for Node.js workers. */
         workerNode: "basis-worker-node.cjs",
@@ -28078,12 +28850,12 @@ return true;`);
   });
 
   // src/gltf/lib/utils/assert.ts
-  function assert5(condition, message) {
+  function assert7(condition, message) {
     if (!condition) {
       throw new Error(message || "assert failed: gltf");
     }
   }
-  var init_assert5 = __esm({
+  var init_assert7 = __esm({
     "src/gltf/lib/utils/assert.ts"() {
       "use strict";
     }
@@ -28102,8 +28874,8 @@ return true;`);
   function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
     const dataView = new DataView(arrayBuffer);
     const type = getMagicString2(dataView, byteOffset + 0);
-    const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
-    const byteLength = version === 3 ? getSafeUint64(dataView, byteOffset + 8, "GLB byte length") : dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN2);
+    const version2 = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+    const byteLength = version2 === 3 ? getSafeUint64(dataView, byteOffset + 8, "GLB byte length") : dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN2);
     Object.assign(glb, {
       // Put less important stuff in a header, to avoid clutter
       header: {
@@ -28113,7 +28885,7 @@ return true;`);
         hasBinChunk: false
       },
       type,
-      version,
+      version: version2,
       json: {},
       jsonChunkIndex: -1,
       binChunks: []
@@ -28345,7 +29117,7 @@ return true;`);
     const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
     const length4 = accessor.count * components;
     const byteLength = accessor.count * components * bytesPerComponent;
-    assert5(byteLength >= 0 && byteLength <= bufferView.byteLength);
+    assert7(byteLength >= 0 && byteLength <= bufferView.byteLength);
     const componentByteSize = BYTES[accessor.componentType];
     const numberOfComponentsInElement = COMPONENTS[accessor.type];
     return { ArrayType, length: length4, byteLength, componentByteSize, numberOfComponentsInElement };
@@ -28354,7 +29126,7 @@ return true;`);
   var init_gltf_utils = __esm({
     "src/gltf/lib/gltf-utils/gltf-utils.ts"() {
       "use strict";
-      init_assert5();
+      init_assert7();
       init_gltf_constants();
       TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
       ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
@@ -28415,13 +29187,13 @@ return true;`);
   // src/gltf/lib/gltf-utils/get-typed-array.ts
   function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
     const bufferView = typeof bufferViewIndex === "number" ? json.bufferViews[bufferViewIndex] : bufferViewIndex;
-    assert5(bufferView);
+    assert7(bufferView);
     const bufferIndex = bufferView.buffer;
     const binChunk = buffers[bufferIndex];
-    assert5(binChunk);
-    assert5((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);
-    assert5((bufferView.byteOffset || 0) + bufferView.byteLength <= binChunk.byteLength);
-    assert5(
+    assert7(binChunk);
+    assert7((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);
+    assert7((bufferView.byteOffset || 0) + bufferView.byteLength <= binChunk.byteLength);
+    assert7(
       binChunk.byteOffset >= 0 && binChunk.byteOffset + binChunk.byteLength <= binChunk.arrayBuffer.byteLength
     );
     const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
@@ -28436,7 +29208,7 @@ return true;`);
     if (!gltfAccessor) {
       throw new Error(`No gltf accessor ${JSON.stringify(accessor)}`);
     }
-    assert5(Number.isSafeInteger(gltfAccessor.count) && gltfAccessor.count >= 0);
+    assert7(Number.isSafeInteger(gltfAccessor.count) && gltfAccessor.count >= 0);
     const { ArrayType, length: length4, numberOfComponentsInElement } = getAccessorArrayTypeAndLength(
       gltfAccessor,
       { byteLength: Infinity }
@@ -28444,7 +29216,7 @@ return true;`);
     const decodedValue = gltfAccessor.value;
     let result;
     if (ArrayBuffer.isView(decodedValue)) {
-      assert5(decodedValue.length === length4);
+      assert7(decodedValue.length === length4);
       result = decodedValue;
     } else if (gltfAccessor.bufferView === void 0) {
       result = new ArrayType(length4);
@@ -28457,8 +29229,8 @@ return true;`);
     new Uint8Array(copiedValue.buffer).set(
       new Uint8Array(result.buffer, result.byteOffset, result.byteLength)
     );
-    assert5(sparse.count >= 0 && sparse.count <= gltfAccessor.count);
-    assert5([5121, 5123, 5125].includes(sparse.indices.componentType));
+    assert7(sparse.count >= 0 && sparse.count <= gltfAccessor.count);
+    assert7([5121, 5123, 5125].includes(sparse.indices.componentType));
     const indices = readAccessorValues(json, buffers, {
       bufferView: sparse.indices.bufferView,
       byteOffset: sparse.indices.byteOffset,
@@ -28479,7 +29251,7 @@ return true;`);
     const valueBytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
     for (let sparseIndex = 0; sparseIndex < sparse.count; sparseIndex++) {
       const index = Number(indices[sparseIndex]);
-      assert5(index > previousIndex && index < gltfAccessor.count);
+      assert7(index > previousIndex && index < gltfAccessor.count);
       copiedBytes.set(
         valueBytes.subarray(sparseIndex * elementByteLength, (sparseIndex + 1) * elementByteLength),
         index * elementByteLength
@@ -28494,14 +29266,14 @@ return true;`);
       throw new Error(`No gltf buffer view for accessor ${bufferView}`);
     }
     const externalBuffer = buffers[bufferView.buffer];
-    assert5(externalBuffer);
+    assert7(externalBuffer);
     const { arrayBuffer, byteOffset: bufferByteOffset } = externalBuffer;
-    assert5((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);
-    assert5((bufferView.byteOffset || 0) + bufferView.byteLength <= externalBuffer.byteLength);
-    assert5(
+    assert7((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);
+    assert7((bufferView.byteOffset || 0) + bufferView.byteLength <= externalBuffer.byteLength);
+    assert7(
       bufferByteOffset >= 0 && bufferByteOffset + externalBuffer.byteLength <= arrayBuffer.byteLength
     );
-    assert5((gltfAccessor.byteOffset || 0) >= 0);
+    assert7((gltfAccessor.byteOffset || 0) >= 0);
     const byteOffset = (bufferByteOffset || 0) + (gltfAccessor.byteOffset || 0) + (bufferView.byteOffset || 0);
     const { ArrayType, length: length4, componentByteSize, numberOfComponentsInElement } = getAccessorArrayTypeAndLength(gltfAccessor, bufferView);
     const elementByteSize = componentByteSize * numberOfComponentsInElement;
@@ -28510,15 +29282,15 @@ return true;`);
     const packedElementByteSize = matrixColumns > 1 ? matrixColumns * matrixColumnByteSize : elementByteSize;
     const elementStride = bufferView.byteStride ?? packedElementByteSize;
     const lastElementByteSize = matrixColumns > 1 ? (matrixColumns - 1) * matrixColumnByteSize + matrixColumns * componentByteSize : elementByteSize;
-    assert5(elementStride >= packedElementByteSize);
-    assert5(
+    assert7(elementStride >= packedElementByteSize);
+    assert7(
       (gltfAccessor.byteOffset || 0) + (gltfAccessor.count === 0 ? 0 : (gltfAccessor.count - 1) * elementStride + lastElementByteSize) <= bufferView.byteLength
     );
     if (gltfAccessor.count === 0) return new ArrayType(0);
     if (matrixColumns > 1 && matrixColumnByteSize !== matrixColumns * componentByteSize) {
       const elementStride2 = bufferView.byteStride ?? matrixColumns * matrixColumnByteSize;
       const lastElementSize = (matrixColumns - 1) * matrixColumnByteSize + matrixColumns * componentByteSize;
-      assert5(
+      assert7(
         (gltfAccessor.byteOffset || 0) + (gltfAccessor.count - 1) * elementStride2 + lastElementSize <= bufferView.byteLength
       );
       const result2 = new ArrayType(length4);
@@ -28568,7 +29340,7 @@ return true;`);
   var init_get_typed_array = __esm({
     "src/gltf/lib/gltf-utils/get-typed-array.ts"() {
       "use strict";
-      init_assert5();
+      init_assert7();
       init_loader_utils();
       init_gltf_utils();
     }
@@ -28584,23 +29356,23 @@ return true;`);
         matches4.push(fileIndex);
       }
     }
-    assert5(matches4.length <= 1, `glTF package file reference ${reference} is ambiguous.`);
+    assert7(matches4.length <= 1, `glTF package file reference ${reference} is ambiguous.`);
     return matches4[0] ?? -1;
   }
   async function resolveGLTFFile(gltf, fileReference, options, context) {
     const files = gltf.json.files || [];
     const fileIndex = typeof fileReference === "number" ? fileReference : findGLTFFileIndex(gltf, fileReference);
-    assert5(Number.isInteger(fileIndex) && fileIndex >= 0 && fileIndex < files.length);
+    assert7(Number.isInteger(fileIndex) && fileIndex >= 0 && fileIndex < files.length);
     gltf.files = gltf.files || new Array(files.length).fill(null);
     const loadedFile = gltf.files[fileIndex];
     if (loadedFile) {
       return loadedFile;
     }
     const file = files[fileIndex];
-    assert5(file.mimeType, `glTF file ${fileIndex} must define mimeType.`);
+    assert7(file.mimeType, `glTF file ${fileIndex} must define mimeType.`);
     const hasUri = file.uri !== void 0;
     const hasBufferView = file.bufferView !== void 0;
-    assert5(
+    assert7(
       hasUri !== hasBufferView,
       `glTF file ${fileIndex} must define exactly one of uri or bufferView.`
     );
@@ -28608,7 +29380,7 @@ return true;`);
     if (file.uri !== void 0) {
       const url = resolveUrl(file.uri, options, context);
       const response = await context.fetch(url);
-      assert5(response?.ok, `Failed to fetch glTF file ${file.uri}: HTTP ${response?.status}.`);
+      assert7(response?.ok, `Failed to fetch glTF file ${file.uri}: HTTP ${response?.status}.`);
       const arrayBuffer = await response.arrayBuffer();
       resolvedFile = {
         arrayBuffer,
@@ -28636,7 +29408,7 @@ return true;`);
       "use strict";
       init_get_typed_array();
       init_resolve_url();
-      init_assert5();
+      init_assert7();
     }
   });
 
@@ -28685,7 +29457,7 @@ return true;`);
       "use strict";
       init_src();
       init_loader_utils();
-      init_assert5();
+      init_assert7();
       init_gltf_utils();
       init_get_typed_array();
       GLTFScenegraph = class {
@@ -28857,7 +29629,7 @@ return true;`);
          * Add to standard GLTF top level extension object, mark as used
          */
         addExtension(extensionName, extensionData = {}) {
-          assert5(extensionData);
+          assert7(extensionData);
           this.json.extensions = this.json.extensions || {};
           this.json.extensions[extensionName] = extensionData;
           this.registerUsedExtension(extensionName);
@@ -28867,7 +29639,7 @@ return true;`);
          * Standard GLTF top level extension object, mark as used and required
          */
         addRequiredExtension(extensionName, extensionData = {}) {
-          assert5(extensionData);
+          assert7(extensionData);
           this.addExtension(extensionName, extensionData);
           this.registerRequiredExtension(extensionName);
           return extensionData;
@@ -29007,7 +29779,7 @@ return true;`);
          */
         addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
           const byteLength = buffer.byteLength;
-          assert5(Number.isFinite(byteLength));
+          assert7(Number.isFinite(byteLength));
           this.sourceBuffers = this.sourceBuffers || [];
           this.sourceBuffers.push(buffer);
           const glTFBufferView = {
@@ -29127,14 +29899,14 @@ return true;`);
           }
           for (const bufferView of this.json.bufferViews || []) {
             const bufferOffset = bufferOffsets[bufferView.buffer];
-            assert5(bufferOffset !== void 0);
+            assert7(bufferOffset !== void 0);
             bufferView.byteOffset = bufferOffset + (bufferView.byteOffset || 0);
             bufferView.buffer = 0;
             for (const name22 of ["EXT_meshopt_compression", "KHR_meshopt_compression"]) {
               const extension = bufferView.extensions?.[name22];
               if (extension) {
                 const extensionOffset = bufferOffsets[extension.buffer];
-                assert5(extensionOffset !== void 0);
+                assert7(extensionOffset !== void 0);
                 extension.byteOffset = extensionOffset + (extension.byteOffset || 0);
                 extension.buffer = 0;
               }
@@ -32540,11 +33312,11 @@ return true;`);
   });
 
   // src/draco/lib/utils/version.ts
-  var VERSION9;
+  var VERSION11;
   var init_version5 = __esm({
     "src/draco/lib/utils/version.ts"() {
       "use strict";
-      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -32584,7 +33356,7 @@ return true;`);
 
   // src/draco/lib/draco-library-loader.ts
   async function loadLibrary2(libraryUrl, moduleName = null, options = {}, libraryName = null, moduleLibraryName = null) {
-    if (isBrowser2 && options.useLocalLibraries && !options.CDN && libraryName && options.modules?.[libraryName] === void 0) {
+    if (isBrowser3 && options.useLocalLibraries && !options.CDN && libraryName && options.modules?.[libraryName] === void 0) {
       const directory = isWorker ? "./libs" : `modules/${moduleName}/dist/libs`;
       options = {
         ...options,
@@ -32735,7 +33507,7 @@ return true;`);
           "draco_decoder.mjs"
         );
       } catch (error) {
-        if (isBrowser2 || options.useLocalLibraries) {
+        if (isBrowser3 || options.useLocalLibraries) {
           throw error;
         }
         decoderLibrary2 = await loadLibrary2(
@@ -32754,7 +33526,7 @@ return true;`);
     try {
       [decoderLibrary, wasmBinary] = await loadDecoderWasmAssets(options, profile);
     } catch (error) {
-      if (isBrowser2 || options.useLocalLibraries) {
+      if (isBrowser3 || options.useLocalLibraries) {
         throw error;
       }
       [decoderLibrary, wasmBinary] = await loadDecoderWasmAssets(
@@ -32790,7 +33562,7 @@ return true;`);
     try {
       [encoderLibrary, wasmBinary] = await loadEncoderWasmAssets(options);
     } catch (error) {
-      if (isBrowser2 || options.useLocalLibraries) {
+      if (isBrowser3 || options.useLocalLibraries) {
         throw error;
       }
       [encoderLibrary, wasmBinary] = await loadEncoderWasmAssets({
@@ -33038,6 +33810,7 @@ return true;`);
   var init_draco_parser = __esm({
     "src/draco/lib/draco-parser.ts"() {
       "use strict";
+      init_loader_utils();
       init_schema_utils();
       init_get_draco_schema();
       DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP = {
@@ -33062,15 +33835,17 @@ return true;`);
       UINT16_INDEX_ITEM_SIZE = 2;
       UINT32_INDEX_ITEM_SIZE = 4;
       DracoParser = class {
-        draco;
-        decoder;
-        metadataQuerier;
         // draco - the draco decoder, either import `draco3d` or load dynamically
-        constructor(draco) {
+        constructor(draco, logger = getLoaderLog()) {
+          this.logger = logger;
           this.draco = draco;
           this.decoder = new this.draco.Decoder();
           this.metadataQuerier = new this.draco.MetadataQuerier();
         }
+        logger;
+        draco;
+        decoder;
+        metadataQuerier;
         /**
          * Destroy draco resources
          */
@@ -33332,7 +34107,7 @@ return true;`);
         _getAttributeValues(dracoGeometry, attribute) {
           const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
           if (!TypedArrayCtor) {
-            console.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`);
+            this.logger.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`)();
             return null;
           }
           const numComponents = attribute.num_components;
@@ -33526,7 +34301,7 @@ return true;`);
     reportProgress2?.({ phase: "decode", completed: 0, total: 1, unit: "tasks" });
     const { draco } = await loadDecoderModule();
     (options?.signal || context?.signal)?.throwIfAborted();
-    const dracoParser = new DracoParser(draco);
+    const dracoParser = new DracoParser(draco, getLoaderLog(options));
     try {
       const mesh = dracoParser.parseSync(arrayBuffer, options?.draco);
       reportProgress2?.({ phase: "decode", completed: 1, total: 1, unit: "tasks" });
@@ -33541,6 +34316,7 @@ return true;`);
   var init_parse_draco = __esm({
     "src/draco/lib/parse-draco.ts"() {
       "use strict";
+      init_loader_utils();
       init_schema_utils();
       init_draco_parser();
     }
@@ -33697,7 +34473,7 @@ return true;`);
         batchType: null,
         ...DracoFormat,
         // shapes: ['mesh'],
-        version: VERSION9,
+        version: VERSION11,
         worker: true,
         /** Node test workers live with the Draco implementation. */
         workerSourceNode: "draco/workers/draco-worker-node.ts",
@@ -34162,7 +34938,7 @@ return true;`);
     const { json } = gltfScenegraph;
     if (json.lights) {
       const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);
-      assert5(!extension.lights);
+      assert7(!extension.lights);
       extension.lights = json.lights;
       delete json.lights;
     }
@@ -34178,7 +34954,7 @@ return true;`);
   var init_KHR_lights_punctual = __esm({
     "src/gltf/lib/extensions/deprecated/KHR_lights_punctual.ts"() {
       "use strict";
-      init_assert5();
+      init_assert7();
       init_gltf_iterator();
       init_gltf_scenegraph();
       KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual";
@@ -36865,7 +37641,7 @@ return true;`);
     parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
     const finishNormalization = normalizeGLTFV1WithDeferredBuffers(gltf, {
       normalize: options?.gltf?.normalize,
-      log: options?.core?.log
+      log: getLoaderLog(options)
     });
     await preprocessExtensions(gltf, options, context);
     if (options?.gltf?.loadBuffers && gltf.json.buffers) {
@@ -36897,13 +37673,13 @@ return true;`);
     } else if (data instanceof ArrayBuffer) {
       const glb = {};
       byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);
-      assert5(glb.type === "glTF", `Invalid GLB magic string ${glb.type}`);
+      assert7(glb.type === "glTF", `Invalid GLB magic string ${glb.type}`);
       gltf._glb = glb;
       gltf.json = glb.json;
     } else if (data && typeof data === "object") {
       gltf.json = data;
     } else {
-      assert5(false, "GLTF: must be ArrayBuffer, string, or parsed JSON object");
+      assert7(false, "GLTF: must be ArrayBuffer, string, or parsed JSON object");
     }
     const buffers = gltf.json.buffers || [];
     const bufferDefinitions = Array.isArray(buffers) ? buffers : [];
@@ -36916,17 +37692,17 @@ return true;`);
         if (buffer.chunk === void 0) {
           continue;
         }
-        assert5(gltf._glb.version === 3, "glTF buffer.chunk requires a GLB v3 container.");
-        assert5(
+        assert7(gltf._glb.version === 3, "glTF buffer.chunk requires a GLB v3 container.");
+        assert7(
           buffer.uri === void 0,
           `glTF buffer ${bufferIndex} cannot define both uri and chunk.`
         );
         const binChunk = binChunks.find((chunk) => chunk.chunkIndex === buffer.chunk);
-        assert5(
+        assert7(
           binChunk,
           `glTF buffer ${bufferIndex} references missing GLB BIN chunk ${buffer.chunk}.`
         );
-        assert5(
+        assert7(
           buffer.byteLength <= binChunk.byteLength,
           `glTF buffer ${bufferIndex} is larger than GLB BIN chunk ${buffer.chunk}.`
         );
@@ -36950,7 +37726,7 @@ return true;`);
       }
       if (gltf._glb.version === 3) {
         for (const bufferIndex of uriLessBufferIndices) {
-          assert5(
+          assert7(
             gltf.buffers[bufferIndex],
             `glTF buffer ${bufferIndex} without a uri must define a valid GLB v3 chunk.`
           );
@@ -36959,7 +37735,7 @@ return true;`);
     }
     if (!gltf._glb) {
       const chunkBufferIndex = bufferDefinitions.findIndex((buffer) => buffer.chunk !== void 0);
-      assert5(chunkBufferIndex === -1, `glTF buffer ${chunkBufferIndex} uses chunk outside a GLB.`);
+      assert7(chunkBufferIndex === -1, `glTF buffer ${chunkBufferIndex} uses chunk outside a GLB.`);
     }
     const images = gltf.json.images || [];
     gltf.images = new Array(images.length).fill({});
@@ -36973,7 +37749,7 @@ return true;`);
     const referencedIndices = /* @__PURE__ */ new Set();
     for (const node of gltf.json.nodes || []) {
       if (node.externalAsset !== void 0) {
-        assert5(
+        assert7(
           node.externalAsset >= 0 && node.externalAsset < externalAssets.length,
           `glTF node references missing external asset ${node.externalAsset}.`
         );
@@ -36990,13 +37766,13 @@ return true;`);
     if (!externalAsset) {
       throw new Error(`Missing glTF external asset ${externalAssetIndex}.`);
     }
-    assert5(
+    assert7(
       Number.isInteger(externalAsset.file) && externalAsset.file >= 0 && externalAsset.file < (gltf.json.files?.length || 0),
       `glTF external asset ${externalAssetIndex} references missing file ${externalAsset.file}.`
     );
     const file = await resolveGLTFFile(gltf, externalAsset.file, options, context);
     const assetKey = file.url;
-    assert5(
+    assert7(
       !assetKey || !state.ancestors.has(assetKey),
       `glTF external asset cycle detected at ${assetKey}.`
     );
@@ -37052,7 +37828,7 @@ return true;`);
         }
         const reference = url.startsWith(packageUrlPrefix) ? url.slice(packageUrlPrefix.length) : url;
         const fileIndex = findGLTFFileIndex(parent, reference);
-        assert5(fileIndex >= 0, `glTF package does not contain file ${reference}.`);
+        assert7(fileIndex >= 0, `glTF package does not contain file ${reference}.`);
         const resolvedFile = await resolveGLTFFile(parent, fileIndex, options, context);
         const data = sliceArrayBuffer(
           resolvedFile.arrayBuffer,
@@ -37089,7 +37865,7 @@ return true;`);
       const buffer = buffers[i];
       if (buffer.uri) {
         const { fetch: fetch2 } = context;
-        assert5(fetch2);
+        assert7(fetch2);
         const uri = resolveUrl(buffer.uri, options, context);
         const response = await context?.fetch?.(uri);
         const arrayBuffer = await response?.arrayBuffer?.();
@@ -37145,7 +37921,7 @@ return true;`);
       const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);
       arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
     }
-    assert5(arrayBuffer, "glTF image has no data");
+    assert7(arrayBuffer, "glTF image has no data");
     const gltfOptions = getGLTFImageOptions(options, image.mimeType);
     const ddsLoader = getDDSLoader(context);
     const ddsSelected = Boolean(
@@ -37160,7 +37936,7 @@ return true;`);
         options,
         context
       );
-      assert5(levels.length > 0, "MSFT_texture_dds parser returned no texture levels");
+      assert7(levels.length > 0, "MSFT_texture_dds parser returned no texture levels");
       gltf.images = gltf.images || [];
       gltf.images[index] = {
         compressed: true,
@@ -37195,9 +37971,10 @@ return true;`);
     "src/gltf/lib/parsers/parse-gltf.ts"() {
       "use strict";
       init_loader_utils();
+      init_loader_utils();
       init_src();
       init_src();
-      init_assert5();
+      init_assert7();
       init_parse_glb();
       init_resolve_url();
       init_resolve_gltf_file();
@@ -37259,7 +38036,7 @@ return true;`);
         dataType: null,
         batchType: null,
         ...GLTFFormat,
-        version: VERSION7,
+        version: VERSION9,
         preload: preload7,
         options: {
           gltf: {
@@ -37381,7 +38158,7 @@ return true;`);
       quantization: { ...preset.quantization, ...options.quantization }
     };
   }
-  var GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP, noop, DracoBuilder;
+  var GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP, noop2, DracoBuilder;
   var init_draco_builder = __esm({
     "src/draco/lib/draco-builder.ts"() {
       "use strict";
@@ -37391,14 +38168,14 @@ return true;`);
         COLOR_0: "COLOR",
         TEXCOORD_0: "TEX_COORD"
       };
-      noop = () => {
+      noop2 = () => {
       };
       DracoBuilder = class {
         draco;
         dracoEncoder;
         dracoMeshBuilder;
         dracoMetadataBuilder;
-        log = noop;
+        log = noop2;
         // draco - the draco decoder, either import `draco3d` or load dynamically
         constructor(draco) {
           this.draco = draco;
@@ -37432,7 +38209,7 @@ return true;`);
         /** Shared implementation for ordinary encoding and report-producing encoding. */
         _encodeSync(mesh, options, trackEncodedProperties) {
           options = applyDracoEncodingPreset(options);
-          this.log = options.log || noop;
+          this.log = options.log || noop2;
           return options.pointcloud ? this._encodePointCloud(mesh, options, trackEncodedProperties) : this._encodeMesh(mesh, options, trackEncodedProperties);
         }
         // PRIVATE
@@ -38044,7 +38821,7 @@ return true;`);
         id: "draco-writer",
         name: "Draco compressed geometry writer",
         module: "scene",
-        version: VERSION9,
+        version: VERSION11,
         worker: true,
         workerNode: "draco-writer-worker-node.cjs",
         /** Node test workers live with the Draco implementation. */
@@ -38056,7 +38833,7 @@ return true;`);
       DracoWriter = {
         ...DracoFormat,
         name: "DRACO",
-        version: VERSION9,
+        version: VERSION11,
         options: {
           draco: DEFAULT_DRACO_WRITER_OPTIONS
         },
@@ -38134,7 +38911,7 @@ return true;`);
         dataType: null,
         batchType: null,
         ...GLBFormat,
-        version: VERSION7,
+        version: VERSION9,
         preload: preload8,
         options: {
           glb: {
@@ -39795,11 +40572,11 @@ Actual: ${this.attribValue}`
     if (element.name !== "materialx") {
       throw new Error("MaterialX: expected a materialx root element.");
     }
-    const version = element.attributes.version;
-    if (!version || !/^1\.\d+$/.test(version)) {
+    const version2 = element.attributes.version;
+    if (!version2 || !/^1\.\d+$/.test(version2)) {
       throw new Error("MaterialX: expected a MaterialX 1.x version.");
     }
-    return { version, root: parseElement(element, 0) };
+    return { version: version2, root: parseElement(element, 0) };
   }
   function parseElement(element, depth) {
     return {
@@ -39964,16 +40741,16 @@ Actual: ${this.attribValue}`
     const { STLLoaderWithParser: STLLoaderWithParser2 } = await Promise.resolve().then(() => (init_stl_loader(), stl_loader_exports));
     return STLLoaderWithParser2;
   }
-  var VERSION10, STLLoader;
+  var VERSION12, STLLoader;
   var init_stl_loader_types = __esm({
     "src/stl-loader-types.ts"() {
       "use strict";
-      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       STLLoader = {
         name: "STL",
         id: "stl",
         module: "scene",
-        version: VERSION10,
+        version: VERSION12,
         extensions: ["stl"],
         mimeTypes: ["model/stl"],
         binary: true,
@@ -40022,6 +40799,7 @@ Actual: ${this.attribValue}`
     concatenateArrayBuffersAsync: () => import_core4.concatenateArrayBuffersAsync,
     coreApi: () => import_core4.coreApi,
     createDataSource: () => import_core4.createDataSource,
+    createDataSourceSync: () => import_core4.createDataSourceSync,
     document: () => import_core4.document,
     encode: () => import_core4.encode,
     encodeInBatches: () => import_core4.encodeInBatches,
@@ -40085,12 +40863,12 @@ Actual: ${this.attribValue}`
   // src/obj/obj-writer.ts
   init_schema_utils();
   init_obj_format();
-  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var OBJWriter = {
     ...OBJFormat,
     dataType: null,
     batchType: null,
-    version: VERSION6,
+    version: VERSION8,
     options: {
       obj: {}
     },
@@ -40233,15 +41011,15 @@ Actual: ${this.attribValue}`
   var LE = true;
   function encodeGLBSync(glb, dataView, byteOffset = 0, options = {}) {
     const magic = MAGIC_glTF2;
-    const version = options.version ?? ("version" in glb ? glb.version : 2);
+    const version2 = options.version ?? ("version" in glb ? glb.version : 2);
     const json = glb.json ?? {};
-    if (version === 3) return encodeGLBV3(glb, dataView, byteOffset, magic, json);
-    if (version !== 2) throw new Error(`Unsupported GLB writer version ${version}.`);
+    if (version2 === 3) return encodeGLBV3(glb, dataView, byteOffset, magic, json);
+    if (version2 !== 2) throw new Error(`Unsupported GLB writer version ${version2}.`);
     const binary = "binChunks" in glb ? glb.binary ? new Uint8Array(glb.binary) : glb.binChunks?.[0] && getChunkBytes(glb.binChunks[0]) : glb.buffers?.[0] && getChunkBytes(glb.buffers[0]);
     const byteOffsetStart = byteOffset;
     if (dataView) {
       dataView.setUint32(byteOffset + 0, magic, LE);
-      dataView.setUint32(byteOffset + 4, version, LE);
+      dataView.setUint32(byteOffset + 4, version2, LE);
       dataView.setUint32(byteOffset + 8, 0, LE);
     }
     const byteOffsetFileLength = byteOffset + 8;
@@ -40536,7 +41314,7 @@ Actual: ${this.attribValue}`
     dataType: null,
     batchType: null,
     ...GLTFFormat,
-    version: VERSION7,
+    version: VERSION9,
     options: {
       gltf: {}
     },
@@ -40573,7 +41351,7 @@ Actual: ${this.attribValue}`
   init_gltf_format();
   var GLBWriter = {
     ...GLBFormat,
-    version: VERSION7,
+    version: VERSION9,
     options: {
       glb: {}
     },