@loaders.gl/pointclouds 5.0.0-beta.1 → 5.0.0-beta.10

package/dist/ply-worker.js

@@ -15,29 +15,772 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
+  // ../../node_modules/probe.gl/dist/env/lib/globals.js
+  var window_, document_, process_, console_, navigator_;
+  var init_globals = __esm({
+    "../../node_modules/probe.gl/dist/env/lib/globals.js"() {
+      window_ = globalThis;
+      document_ = 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 isBrowser() {
+    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_globals();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/env/utils/assert.js
+  var init_assert = __esm({
+    "../../node_modules/probe.gl/dist/env/utils/assert.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/env/index.js
+  var VERSION;
+  var init_env = __esm({
+    "../../node_modules/probe.gl/dist/env/index.js"() {
+      init_globals();
+      init_is_browser();
+      init_get_browser();
+      init_is_electron();
+      init_assert();
+      VERSION = true ? "5.0.0" : "untranspiled source";
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/utils/assert.js
+  function assert2(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+  var init_assert2 = __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;
+    }
+    assert2(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;
+    assert2(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_assert2();
+    }
+  });
+
+  // ../../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, length = 8) {
+    const padLength = Math.max(length - 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 (!isBrowser && 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((name) => key === name)) {
+          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 (isBrowser() && window_.performance) {
+            timestamp = window_?.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_?.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_assert2();
+      init_probe();
+      init_log_utils();
+      init_log_utils();
+      originalConsole = {
+        debug: isBrowser() ? 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 = VERSION;
+          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;
+          assert2(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 = VERSION;
+    }
+  });
+
+  // ../../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() {
+  }
+  var VERSION2, version, log2, NullLog, nullLog;
+  var init_log2 = __esm({
+    "../core/src/loader-utils/lib/log-utils/log.ts"() {
+      "use strict";
+      init_log();
+      VERSION2 = true ? "5.0.0-beta.10" : "latest";
+      version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
+      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();
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js
   var parentPort;
   var init_worker_threads_browser = __esm({
-    "../core/src/worker-utils/lib/node/worker_threads-browser.ts"() {
-      "use strict";
-      parentPort = null;
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js"() {
+      parentPort = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort ?? null;
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js
   function getTransferList(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
-    if (!object) {
-    } else if (isTransferable(object)) {
-      transfersSet.add(object);
-    } else if (isTransferable(object.buffer)) {
-      transfersSet.add(object.buffer);
-    } else if (ArrayBuffer.isView(object)) {
-    } else if (recursive && typeof object === "object") {
-      for (const key in object) {
-        getTransferList(object[key], recursive, transfersSet);
+    const seen = /* @__PURE__ */ new Set();
+    function visit(value) {
+      if (!value || typeof value !== "object" || seen.has(value))
+        return;
+      seen.add(value);
+      if (isTransferable(value))
+        transfersSet.add(value);
+      else if (ArrayBuffer.isView(value)) {
+        if (isTransferable(value.buffer))
+          transfersSet.add(value.buffer);
+      } else if (recursive && typeof MessageChannel !== "undefined" && value instanceof MessageChannel) {
+        visit(value.port1);
+        visit(value.port2);
+      } else if (recursive && value instanceof Map) {
+        for (const [key, item] of value) {
+          visit(key);
+          visit(item);
+        }
+      } else if (recursive && value instanceof Set) {
+        for (const item of value)
+          visit(item);
+      } else if (recursive) {
+        for (const key of Object.keys(value))
+          visit(value[key]);
       }
     }
+    visit(object);
     return transfers === void 0 ? Array.from(transfersSet) : [];
   }
   function isTransferable(object) {
@@ -59,12 +802,11 @@
     return false;
   }
   var init_get_transfer_list = __esm({
-    "../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js"() {
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-farm/worker-body.ts
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-body.js
   async function getParentPort() {
     return parentPort;
   }
@@ -77,31 +819,31 @@
   }
   var onMessageWrapperMap, WorkerBody;
   var init_worker_body = __esm({
-    "../core/src/worker-utils/lib/worker-farm/worker-body.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-body.js"() {
       init_get_transfer_list();
       init_worker_threads_browser();
       onMessageWrapperMap = /* @__PURE__ */ new Map();
       WorkerBody = class {
         /** Check that we are actually in a worker thread */
         static async inWorkerThread() {
-          return typeof self !== "undefined" || Boolean(await getParentPort());
+          const workerGlobalScope = globalThis.WorkerGlobalScope;
+          return typeof workerGlobalScope === "function" && globalThis instanceof workerGlobalScope || Boolean(await getParentPort());
         }
         /*
          * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
          */
         static set onmessage(onMessage) {
           async function handleMessage(message) {
-            const parentPort2 = await getParentPort();
-            const { type, payload } = parentPort2 ? message : message.data;
+            const parentPort3 = await getParentPort();
+            const { type, payload } = parentPort3 ? message : message.data;
             onMessage(type, payload);
           }
-          getParentPort().then((parentPort2) => {
-            if (parentPort2) {
-              parentPort2.on("message", (message) => {
+          getParentPort().then((parentPort3) => {
+            if (parentPort3) {
+              parentPort3.on("message", (message) => {
                 handleMessage(message);
               });
-              parentPort2.on("exit", () => console.debug("Node worker closing"));
+              parentPort3.on("exit", () => console.debug("Node worker closing"));
             } else {
               globalThis.onmessage = handleMessage;
             }
@@ -119,9 +861,9 @@
             };
             onMessageWrapperMap.set(onMessage, onMessageWrapper);
           }
-          const parentPort2 = await getParentPort();
-          if (parentPort2) {
-            parentPort2.on("message", onMessageWrapper);
+          const parentPort3 = await getParentPort();
+          if (parentPort3) {
+            parentPort3.on("message", onMessageWrapper);
           } else {
             globalThis.addEventListener("message", onMessageWrapper);
           }
@@ -132,9 +874,9 @@
           if (!onMessageWrapper) {
             return;
           }
-          const parentPort2 = await getParentPort();
-          if (parentPort2) {
-            parentPort2.off("message", onMessageWrapper);
+          const parentPort3 = await getParentPort();
+          if (parentPort3) {
+            parentPort3.off("message", onMessageWrapper);
           } else {
             globalThis.removeEventListener("message", onMessageWrapper);
           }
@@ -144,12 +886,12 @@
          * @param type
          * @param payload
          */
-        static async postMessage(type, payload) {
+        static async postMessage(type, payload, copy = false) {
           const data = { source: "loaders.gl", type, payload };
-          const transferList = getTransferList(payload);
-          const parentPort2 = await getParentPort();
-          if (parentPort2) {
-            parentPort2.postMessage(data, transferList);
+          const transferList = copy ? [] : getTransferList(payload);
+          const parentPort3 = await getParentPort();
+          if (parentPort3) {
+            parentPort3.postMessage(data, transferList);
           } else {
             globalThis.postMessage(data, transferList);
           }
@@ -158,15 +900,11 @@
     }
   });
 
-  // ../core/src/worker-utils/lib/async-queue/async-queue.ts
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/async-queue/async-queue.js
   var AsyncQueue;
   var init_async_queue = __esm({
-    "../core/src/worker-utils/lib/async-queue/async-queue.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/async-queue/async-queue.js"() {
       AsyncQueue = class {
-        _values;
-        _settlers;
-        _closed;
         constructor() {
           this._values = [];
           this._settlers = [];
@@ -234,8 +972,63 @@
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
-  async function createWorker(process, processInBatches) {
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js
+  var SharedWorkerState;
+  var init_shared_state = __esm({
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js"() {
+      SharedWorkerState = class {
+        constructor(buffer) {
+          if (typeof SharedArrayBuffer === "undefined" || !(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== 16)
+            throw new Error("Expected a 16-byte shared worker control buffer");
+          this.buffer = buffer;
+          this.values = new Int32Array(buffer);
+        }
+        get snapshot() {
+          return {
+            cancelled: Atomics.load(this.values, 0) !== 0,
+            completed: Atomics.load(this.values, 1),
+            total: Atomics.load(this.values, 2),
+            revision: Atomics.load(this.values, 3)
+          };
+        }
+        cancel() {
+          Atomics.store(this.values, 0, 1);
+          Atomics.add(this.values, 3, 1);
+          Atomics.notify(this.values, 0);
+        }
+        throwIfCancelled() {
+          if (Atomics.load(this.values, 0) !== 0) {
+            const error = new Error("Shared worker task was cancelled");
+            error.name = "AbortError";
+            throw error;
+          }
+        }
+        /** Integer counters for application-defined work; messages still carry phase names and units. */
+        setProgress(completed, total = -1) {
+          if (!Number.isInteger(completed) || completed < 0 || completed > 2147483647 || !Number.isInteger(total) || total < -1 || total > 2147483647) {
+            throw new RangeError("Shared progress requires nonnegative int32 counts (or total -1)");
+          }
+          Atomics.store(this.values, 1, completed);
+          Atomics.store(this.values, 2, total);
+          Atomics.add(this.values, 3, 1);
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/validate-output-ownership.js
+  function validateOutputOwnership(ownership) {
+    if (ownership !== void 0 && ownership !== "copy" && ownership !== "transfer") {
+      throw new Error("Invalid worker output ownership");
+    }
+  }
+  var init_validate_output_ownership = __esm({
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/validate-output-ownership.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/create-worker.js
+  async function createWorker(process2, processInBatches, preload2) {
     if (!await WorkerBody.inWorkerThread()) {
       return;
     }
@@ -243,27 +1036,59 @@
       process: processOnMainThread
     };
     WorkerBody.onmessage = async (type, payload) => {
+      if (type === "cancel") {
+        activeController?.abort();
+        activeInputBatches?.close();
+        activeOutputAcknowledgements?.close();
+        return;
+      }
+      const controller = type === "process" || type === "process-in-batches" ? new AbortController() : void 0;
+      if (controller)
+        activeController = controller;
+      const startedAt = performance.now();
       const reporter = type === "process" || type === "process-in-batches" ? createProgressReporter() : void 0;
-      const jobContext = { ...context, reportProgress: reporter?.report };
+      let sharedState;
+      const throwIfAborted = () => {
+        controller?.signal.throwIfAborted();
+        sharedState?.throwIfCancelled();
+      };
+      const jobContext = {
+        ...context,
+        signal: controller?.signal,
+        sharedState,
+        throwIfAborted,
+        reportProgress: (progress) => {
+          if (!controller?.signal.aborted && !sharedState?.snapshot.cancelled)
+            reporter?.report(progress);
+        }
+      };
       try {
+        if (controller && payload.options?.["sharedState"]) {
+          sharedState = new SharedWorkerState(payload.options["sharedState"]);
+          jobContext.sharedState = sharedState;
+        }
         switch (type) {
           case "preload":
+            await preload2?.();
             WorkerBody.postMessage("done", {});
             break;
           case "process":
-            if (!process) {
+            throwIfAborted();
+            validateOutputOwnership(payload.options?.["outputOwnership"]);
+            if (!process2) {
               throw new Error("Worker does not support atomic processing");
             }
-            const result = await process(
-              payload.input,
-              payload.options || {},
-              jobContext,
-              payload.context || {}
-            );
+            const result = await process2(payload.input, payload.options || {}, jobContext, payload.context || {});
+            throwIfAborted();
             reporter?.finish();
-            WorkerBody.postMessage("done", { result });
+            await WorkerBody.postMessage("done", {
+              result,
+              executionMs: performance.now() - startedAt
+            }, payload.options?.["outputOwnership"] === "copy");
             break;
           case "process-in-batches":
+            throwIfAborted();
+            validateOutputOwnership(payload.options?.["outputOwnership"]);
             if (!processInBatches) {
               throw new Error("Worker does not support batched processing");
             }
@@ -272,18 +1097,15 @@
             activeInputBatches = inputBatches;
             activeOutputAcknowledgements = outputAcknowledgements;
             try {
-              const resultIterator = processInBatches(
-                createDemandDrivenIterator(inputBatches),
-                payload.options || {},
-                jobContext,
-                payload.context || {}
-              );
+              const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, jobContext, payload.context || {});
               for await (const batch of resultIterator) {
-                await WorkerBody.postMessage("output-batch", { result: batch });
+                throwIfAborted();
+                await WorkerBody.postMessage("output-batch", { result: batch }, payload.options?.["outputOwnership"] === "copy");
                 await outputAcknowledgements.next();
               }
+              throwIfAborted();
               reporter?.finish();
-              await WorkerBody.postMessage("done", {});
+              await WorkerBody.postMessage("done", { executionMs: performance.now() - startedAt });
             } finally {
               activeInputBatches = null;
               activeOutputAcknowledgements = null;
@@ -310,11 +1132,18 @@
           default:
         }
       } catch (error) {
-        reporter?.finish();
+        reporter?.finish(controller?.signal.aborted || sharedState?.snapshot.cancelled);
         const message = error instanceof Error ? error.message : "";
-        WorkerBody.postMessage("error", { error: message });
+        await WorkerBody.postMessage("error", {
+          error: message,
+          errorName: error instanceof Error ? error.name : "Error"
+        });
+      } finally {
+        if (controller && activeController === controller)
+          activeController = null;
       }
     };
+    await WorkerBody.postMessage("ready", {});
   }
   async function* createDemandDrivenIterator(inputBatches) {
     while (true) {
@@ -326,82 +1155,692 @@
       yield nextBatch.value;
     }
   }
-  function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
-    return new Promise((resolve, reject) => {
-      const id = requestId++;
-      const onMessage = (type, payload2) => {
-        if (payload2.id !== id) {
-          return;
-        }
-        switch (type) {
-          case "done":
-            WorkerBody.removeEventListener(onMessage);
-            resolve(payload2.result);
-            break;
-          case "error":
-            WorkerBody.removeEventListener(onMessage);
-            reject(payload2.error);
-            break;
-          default:
+  function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
+    const signal = activeController?.signal;
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+      const id = requestId++;
+      const cleanup = () => {
+        signal?.removeEventListener("abort", abort);
+        void WorkerBody.removeEventListener(onMessage);
+      };
+      const abort = () => {
+        cleanup();
+        reject(signal?.reason);
+      };
+      const onMessage = (type, payload) => {
+        if (payload.id !== id)
+          return;
+        if (type === "done") {
+          cleanup();
+          resolve(payload.result);
+        } else if (type === "error") {
+          cleanup();
+          reject(payload.error);
+        }
+      };
+      void WorkerBody.addEventListener(onMessage).then(async () => {
+        if (signal?.aborted) {
+          abort();
+          return;
+        }
+        signal?.addEventListener("abort", abort, { once: true });
+        await WorkerBody.postMessage("process", {
+          id,
+          input: arrayBuffer,
+          options,
+          context: jobContext
+        });
+      }).catch((error) => {
+        cleanup();
+        reject(error);
+      });
+    });
+  }
+  function createProgressReporter() {
+    let pending2;
+    let finished = false;
+    let scheduled = false;
+    const flush = () => {
+      scheduled = false;
+      if (pending2) {
+        WorkerBody.postMessage("progress", { progress: pending2 });
+        pending2 = void 0;
+      }
+    };
+    return {
+      /** Records progress while retaining phase transitions. */
+      report(progress) {
+        if (finished)
+          return;
+        if (pending2 && pending2.phase !== progress.phase)
+          flush();
+        pending2 = { ...progress };
+        if (!scheduled) {
+          scheduled = true;
+          setTimeout(flush, 0);
+        }
+      },
+      /** Flushes final progress and suppresses reports from stale callbacks. */
+      finish(discard = false) {
+        if (discard)
+          pending2 = void 0;
+        flush();
+        finished = true;
+      }
+    };
+  }
+  var requestId, activeController, activeInputBatches, activeOutputAcknowledgements;
+  var init_create_worker = __esm({
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/create-worker.js"() {
+      init_shared_state();
+      init_async_queue();
+      init_worker_body();
+      init_validate_output_ownership();
+      requestId = 0;
+      activeController = null;
+      activeInputBatches = null;
+      activeOutputAcknowledgements = null;
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/index.js
+  var import_meta, path, moduleUrl;
+  var init_worker_utils = __esm({
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/index.js"() {
+      init_worker_body();
+      init_create_worker();
+      init_get_transfer_list();
+      import_meta = {};
+      path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
+      moduleUrl = path ? `file://${path.startsWith("/") ? "" : "/"}${encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta.url;
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-preload.js
+  function preloadTaskCode(task, signal) {
+    if (!task.preload)
+      return Promise.resolve();
+    let promise = pending.get(task);
+    if (!promise) {
+      promise = Promise.resolve().then(() => task.preload()).then(() => {
+        loaded.add(task);
+      });
+      pending.set(task, promise);
+      void promise.catch(() => pending.delete(task));
+    }
+    return withSignal(promise, signal);
+  }
+  function withSignal(operation, signal) {
+    if (!signal)
+      return operation;
+    return new Promise((resolve, reject) => {
+      const abort = () => {
+        signal.removeEventListener("abort", abort);
+        reject(signal.reason);
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted)
+        abort();
+      operation.then((value) => {
+        signal.removeEventListener("abort", abort);
+        resolve(value);
+      }, (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      });
+    });
+  }
+  var pending, loaded;
+  var init_task_preload = __esm({
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-preload.js"() {
+      pending = /* @__PURE__ */ new WeakMap();
+      loaded = /* @__PURE__ */ new WeakSet();
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js
+  var TaskRequestError, TaskChannel;
+  var init_task_channel = __esm({
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js"() {
+      TaskRequestError = class extends Error {
+      };
+      TaskChannel = class {
+        constructor(options) {
+          this.options = options;
+          this.nextId = 1;
+          this.pending = /* @__PURE__ */ new Map();
+          this.incoming = /* @__PURE__ */ new Map();
+        }
+        /** Send a request without serializing other in-flight requests. */
+        request(operation, value, signal, transfer = []) {
+          if (this.failure)
+            return Promise.reject(this.failure.reason);
+          if (signal?.aborted)
+            return Promise.reject(signal.reason);
+          const id = this.nextId++;
+          return new Promise((resolve, reject) => {
+            const abort = () => {
+              const pending2 = this.pending.get(id);
+              if (!pending2)
+                return;
+              this.pending.delete(id);
+              pending2.cleanup();
+              reject(signal?.reason);
+              this.send({ source: "math.gl/tasks", kind: "cancel", id });
+            };
+            this.pending.set(id, {
+              resolve,
+              reject,
+              cleanup: () => signal?.removeEventListener("abort", abort)
+            });
+            signal?.addEventListener("abort", abort, { once: true });
+            this.send({ source: "math.gl/tasks", kind: "request", id, operation, value }, transfer);
+          });
+        }
+        /** Send a one-way notification. */
+        emit(operation, value, transfer = []) {
+          if (this.failure)
+            throw this.failure.reason;
+          this.send({ source: "math.gl/tasks", kind: "event", id: 0, operation, value }, transfer);
+        }
+        /** Dispatch a transport message; unrelated protocols are ignored. */
+        receive(message) {
+          if (this.failure || message?.source !== "math.gl/tasks")
+            return;
+          if (message.kind === "failure") {
+            const reason = new Error(message.error?.message ?? "Task channel failed");
+            this.close(reason);
+            this.options.onFailure?.(reason);
+          } else if (message.kind === "result" || message.kind === "error") {
+            const pending2 = this.pending.get(message.id);
+            if (!pending2)
+              return;
+            this.pending.delete(message.id);
+            pending2.cleanup();
+            if (message.kind === "result")
+              pending2.resolve(message.value);
+            else {
+              const error = new TaskRequestError(message.error?.message ?? "Task request failed");
+              error.name = message.error?.name ?? "Error";
+              pending2.reject(error);
+            }
+          } else if (message.kind === "cancel") {
+            this.incoming.get(message.id)?.abort(new DOMException("Task request cancelled", "AbortError"));
+          } else if (message.kind === "event") {
+            try {
+              this.options.handleEvent?.(message.operation, message.value);
+            } catch (error) {
+              this.fail(error);
+            }
+          } else if (message.kind === "request") {
+            if (this.incoming.has(message.id)) {
+              this.fail(new Error("Duplicate task request identifier"));
+              return;
+            }
+            const controller = new AbortController();
+            this.incoming.set(message.id, controller);
+            void Promise.resolve().then(() => {
+              controller.signal.throwIfAborted();
+              return this.options.handleRequest(message.operation, message.value, controller.signal);
+            }).then((value) => {
+              if (!controller.signal.aborted && !this.failure) {
+                this.send({ source: "math.gl/tasks", kind: "result", id: message.id, value }, this.options.getResultTransferList?.(value, message.value));
+              }
+            }).catch((reason) => {
+              if (!controller.signal.aborted && !this.failure) {
+                this.send({
+                  source: "math.gl/tasks",
+                  kind: "error",
+                  id: message.id,
+                  error: {
+                    name: reason instanceof Error ? reason.name : "Error",
+                    message: reason instanceof Error ? reason.message : String(reason)
+                  }
+                });
+              }
+            }).finally(() => this.incoming.delete(message.id));
+          }
+        }
+        /** Reject all outstanding calls with a common cause and abort incoming callbacks. */
+        close(reason = new Error("Task channel closed")) {
+          if (this.failure)
+            return;
+          this.failure = { reason };
+          for (const pending2 of this.pending.values()) {
+            pending2.cleanup();
+            pending2.reject(reason);
+          }
+          this.pending.clear();
+          for (const controller of this.incoming.values())
+            controller.abort(reason);
+          this.incoming.clear();
+        }
+        send(message, transfer = []) {
+          if (this.failure)
+            return;
+          try {
+            this.options.send(message, transfer);
+          } catch (error) {
+            this.fail(error);
+          }
+        }
+        /** Invalidate the channel and notify the peer when the transport still works. */
+        fail(reason) {
+          if (this.failure)
+            return;
+          this.close(reason);
+          try {
+            this.options.send({
+              source: "math.gl/tasks",
+              kind: "failure",
+              id: 0,
+              error: {
+                name: reason instanceof Error ? reason.name : "Error",
+                message: reason instanceof Error ? reason.message : String(reason)
+              }
+            }, []);
+          } catch {
+          }
+          this.options.onFailure?.(reason);
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-runtime.js
+  function assertPayload(value) {
+    if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) {
+      throw new TypeError("Task payloads must be plain objects with named fields");
+    }
+  }
+  function clonePayload(value, ownership = "copy") {
+    assertPayload(value);
+    if (!["copy", "transfer", "share"].includes(ownership))
+      throw new TypeError("Invalid input ownership");
+    const transfer = getTransferList(value);
+    if (ownership === "share" && transfer.length)
+      throw new TypeError("Share requires shared storage");
+    return structuredClone(value, {
+      transfer: ownership === "transfer" ? transfer : []
+    });
+  }
+  function taskContext(state, context = {}) {
+    const signal = context.signal ?? new AbortController().signal;
+    return {
+      state,
+      signal,
+      requestHost: async (operation, payload, controls) => {
+        signal.throwIfAborted();
+        if (!context.requestHost)
+          throw new Error("No host request handler configured");
+        return context.requestHost(operation, payload, controls);
+      },
+      emitHost: (operation, payload) => {
+        signal.throwIfAborted();
+        context.emitHost?.(operation, payload);
+      },
+      throwIfAborted: () => {
+        signal.throwIfAborted();
+        context.throwIfAborted?.();
+      },
+      reportProgress: (progress) => context.reportProgress?.({
+        ...progress,
+        phase: progress.phase ?? "process",
+        unit: progress.unit ?? "items"
+      })
+    };
+  }
+  async function initializeTaskWorker(task) {
+    if (!await WorkerBody.inWorkerThread())
+      throw new Error("initializeTaskWorker must run inside a worker");
+    if (installed)
+      throw new Error("A task is already installed in this worker");
+    installed = true;
+    const runtime = new TaskRuntime(task);
+    let channelStream;
+    const channel = new TaskChannel({
+      getResultTransferList: (value, request) => request.outputOwnership === "transfer" ? getTransferList(value) : [],
+      send: (message, transfer) => {
+        const snapshot = structuredClone(message, { transfer });
+        void WorkerBody.postMessage("task-channel", snapshot).catch((reason) => channel.fail(reason));
+      },
+      handleRequest: async (operation, value, signal) => {
+        const request = value;
+        const context = {
+          signal,
+          reportProgress: (progress) => channel.emit("task:progress", { id: request.progressId, progress }),
+          requestHost: (operation2, payload, controls = {}) => {
+            const request2 = {
+              operation: operation2,
+              payload: clonePayload(payload, controls.inputOwnership),
+              outputOwnership: controls.outputOwnership ?? "copy"
+            };
+            return channel.request("task:host-request", request2, signal, getTransferList(request2));
+          },
+          emitHost: (operation2, payload) => channel.emit("task:host-event", { operation: operation2, payload, id: request.progressId })
+        };
+        switch (operation) {
+          case "initialize":
+            return runtime.initialize(request.input, context);
+          case "process":
+            return runtime.process(request.input, request.options, context);
+          case "stream-open": {
+            if (channelStream)
+              throw new Error("A task stream is already open");
+            async function* inputs() {
+              while (true) {
+                const result = await channel.request("task:next-input", { outputOwnership: "transfer" }, signal);
+                if (result.done)
+                  return;
+                yield result.value;
+              }
+            }
+            channelStream = runtime.stream(inputs(), request.options, context)[Symbol.asyncIterator]();
+            return {};
+          }
+          case "stream-next":
+            if (!channelStream)
+              throw new Error("No active task stream");
+            return channelStream.next();
+          case "stream-close":
+            try {
+              await channelStream?.return?.();
+            } finally {
+              channelStream = void 0;
+            }
+            return {};
+          case "destroy":
+            return runtime.destroy();
+          default:
+            throw new Error("Unknown task channel operation");
+        }
+      }
+    });
+    await WorkerBody.addEventListener((type, payload) => {
+      if (type === "task-channel")
+        channel.receive(payload);
+    });
+    let streamOptions = {};
+    return createWorker(async (request, _options, context) => {
+      switch (request.operation) {
+        case "initialize":
+          return runtime.initialize(request.input, context);
+        case "destroy":
+          return runtime.destroy();
+        case "stream-options":
+          streamOptions = request.options;
+          return {};
+        case "process":
+          return runtime.process(request.input, request.options, context);
+        default:
+          throw new Error("Unknown task operation");
+      }
+    }, async function* (inputs, _options, context) {
+      async function* batches() {
+        for await (const input of inputs) {
+          assertPayload(input);
+          yield input;
+        }
+      }
+      try {
+        yield* runtime.stream(batches(), streamOptions, context);
+      } finally {
+        streamOptions = {};
+      }
+    }, () => preloadTaskCode(task));
+  }
+  var TaskRuntime, installed;
+  var init_task_runtime = __esm({
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-runtime.js"() {
+      init_worker_utils();
+      init_task_preload();
+      init_task_channel();
+      TaskRuntime = class {
+        constructor(task) {
+          this.task = task;
+          this.initialized = false;
+        }
+        async initialize(input, context = {}) {
+          if (this.initialized)
+            throw new Error("Task is already initialized");
+          assertPayload(input);
+          await preloadTaskCode(this.task, context.signal);
+          context.signal?.throwIfAborted();
+          this.state = await this.task.initialize?.(input, taskContext(void 0, context));
+          this.initialized = true;
+          return {};
+        }
+        async destroy() {
+          if (this.initialized) {
+            this.initialized = false;
+            const state = this.state;
+            this.state = void 0;
+            if (this.task.initialize)
+              await this.task.destroy?.(state);
+          }
+          return {};
+        }
+        async process(input, options, context = {}) {
+          if (!this.initialized)
+            throw new Error("Task is not initialized");
+          if (!this.task.process)
+            throw new Error("Task has no atomic processor");
+          assertPayload(input);
+          const result = await this.task.process(input, options, taskContext(this.state, context));
+          assertPayload(result);
+          return result;
+        }
+        async *stream(inputs, options, context = {}) {
+          if (!this.initialized)
+            throw new Error("Task is not initialized");
+          if (!this.task.processInBatches)
+            throw new Error("Task has no streaming processor");
+          for await (const output of this.task.processInBatches(inputs, options, taskContext(this.state, context))) {
+            assertPayload(output);
+            yield output;
+          }
+        }
+      };
+      installed = false;
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/index.js
+  var init_tasks = __esm({
+    "../../node_modules/@math.gl/tasks/dist/tasks/index.js"() {
+      init_task_runtime();
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/index.js
+  var init_dist = __esm({
+    "../../node_modules/@math.gl/tasks/dist/index.js"() {
+      init_tasks();
+    }
+  });
+
+  // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
+  var worker_threads_browser_exports = {};
+  __export(worker_threads_browser_exports, {
+    NodeWorker: () => NodeWorker,
+    parentPort: () => parentPort2
+  });
+  var NodeWorker, parentPort2;
+  var init_worker_threads_browser2 = __esm({
+    "../core/src/worker-utils/lib/node/worker_threads-browser.ts"() {
+      "use strict";
+      NodeWorker = class {
+        /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
+        constructor(...arguments_) {
+          const runtimeProcess = globalThis.process;
+          const WorkerConstructor = runtimeProcess?.getBuiltinModule?.("node:worker_threads").Worker;
+          if (WorkerConstructor) {
+            return new WorkerConstructor(...arguments_);
+          }
+        }
+        /** No-op browser fallback matching the native Worker API. */
+        terminate() {
+        }
+      };
+      parentPort2 = null;
+    }
+  });
+
+  // ../core/src/worker-utils/lib/worker-api/task-runtime.ts
+  function normalizeTaskProgress(progress) {
+    return { ...progress, phase: progress.phase ?? "process", unit: progress.unit ?? "items" };
+  }
+  async function isWorkerThread() {
+    if (typeof self !== "undefined" && typeof document === "undefined" && typeof self.postMessage === "function")
+      return true;
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const { isMainThread } = await Promise.resolve().then(() => (init_worker_threads_browser2(), worker_threads_browser_exports));
+      return !isMainThread;
+    }
+    return false;
+  }
+  var initializeTaskWorker2;
+  var init_task_runtime2 = __esm({
+    "../core/src/worker-utils/lib/worker-api/task-runtime.ts"() {
+      "use strict";
+      init_dist();
+      initializeTaskWorker2 = initializeTaskWorker;
+    }
+  });
+
+  // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+  function getTransferList2(object, recursive = true, transfers) {
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable2(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable2(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList2(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable2(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+  var init_get_transfer_list2 = __esm({
+    "../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts"() {
+      "use strict";
+    }
+  });
+
+  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
+  async function createWorker2(process2, processInBatches) {
+    if (!await isWorkerThread()) return;
+    await initializeTaskWorker2(createWorkerTask(process2, processInBatches));
+  }
+  function createWorkerTask(process2, processInBatches) {
+    return {
+      id: "loaders.gl",
+      initialize: (state) => state,
+      destroy: (state) => state.port?.close(),
+      process: async ({ value }, options, context) => {
+        if (!process2) throw new Error("Worker does not support atomic processing");
+        return { value: await process2(value, options, createContext(context), context.state.context) };
+      },
+      ...processInBatches ? {
+        processInBatches: async function* (inputs, options, context) {
+          async function* values() {
+            for await (const input of inputs) yield input.value;
+          }
+          for await (const value of processInBatches(
+            values(),
+            options,
+            createContext(context),
+            context.state.context
+          )) {
+            yield { value };
+          }
         }
-      };
-      WorkerBody.addEventListener(onMessage);
-      const payload = { id, input: arrayBuffer, options, context: jobContext };
-      WorkerBody.postMessage("process", payload);
-    });
-  }
-  function createProgressReporter() {
-    let pending;
-    let finished = false;
-    let scheduled = false;
-    const flush = () => {
-      scheduled = false;
-      if (pending) {
-        WorkerBody.postMessage("progress", { progress: pending });
-        pending = void 0;
-      }
+      } : {}
     };
+  }
+  function createContext(context) {
+    let requestIdentifier = 0;
+    const port = context.state.port;
     return {
-      /** Records progress while retaining phase transitions. */
-      report(progress) {
-        if (finished) return;
-        if (pending && pending.phase !== progress.phase) flush();
-        pending = { ...progress };
-        if (!scheduled) {
-          scheduled = true;
-          setTimeout(flush, 0);
-        }
-      },
-      /** Flushes final progress and suppresses reports from stale callbacks. */
-      finish() {
-        flush();
-        finished = true;
-      }
+      signal: context.signal,
+      throwIfAborted: () => context.throwIfAborted(),
+      reportProgress: (progress) => context.reportProgress(normalizeTaskProgress(progress)),
+      process: port ? (input, options = {}, jobContext = {}) => {
+        context.throwIfAborted();
+        const identifier = ++requestIdentifier;
+        return new Promise((resolve, reject) => {
+          const onMessage = (event) => {
+            if (event.data.identifier !== identifier) return;
+            cleanup();
+            if (event.data.error) {
+              const error = new Error(event.data.error.message);
+              error.name = event.data.error.name;
+              reject(error);
+            } else resolve(event.data.value);
+          };
+          const onAbort = () => {
+            cleanup();
+            reject(context.signal.reason);
+          };
+          const cleanup = () => {
+            port.removeEventListener("message", onMessage);
+            context.signal.removeEventListener("abort", onAbort);
+          };
+          port.addEventListener("message", onMessage);
+          context.signal.addEventListener("abort", onAbort, { once: true });
+          port.start();
+          try {
+            const request = { identifier, input, options, context: jobContext };
+            port.postMessage(request, getTransferList2(request));
+          } catch (error) {
+            cleanup();
+            reject(error);
+          }
+        });
+      } : void 0
     };
   }
-  var requestId, activeInputBatches, activeOutputAcknowledgements;
-  var init_create_worker = __esm({
+  var init_create_worker2 = __esm({
     "../core/src/worker-utils/lib/worker-api/create-worker.ts"() {
       "use strict";
-      init_async_queue();
-      init_worker_body();
-      requestId = 0;
-      activeInputBatches = null;
-      activeOutputAcknowledgements = null;
+      init_task_runtime2();
+      init_get_transfer_list2();
     }
   });
 
   // ../core/src/worker-utils/index.ts
-  var init_worker_utils = __esm({
+  var init_worker_utils2 = __esm({
     "../core/src/worker-utils/index.ts"() {
       "use strict";
-      init_create_worker();
+      init_create_worker2();
     }
   });
 
   // ../core/src/loader-utils/lib/worker-loader-utils/create-loader-worker.ts
   async function createLoaderWorker(loader, selectLoader = () => loader) {
-    await createWorker(
+    await createWorker2(
       (input, options, workerContext, loaderContext) => processLoaderWorkerData(
         selectLoader(options || {}),
         input,
@@ -539,7 +1978,7 @@
   var init_create_loader_worker = __esm({
     "../core/src/loader-utils/lib/worker-loader-utils/create-loader-worker.ts"() {
       "use strict";
-      init_worker_utils();
+      init_worker_utils2();
     }
   });
 
@@ -771,7 +2210,7 @@
   });
 
   // ../../node_modules/@math.gl/core/dist/index.js
-  var init_dist = __esm({
+  var init_dist2 = __esm({
     "../../node_modules/@math.gl/core/dist/index.js"() {
       init_math_utils();
       init_types2();
@@ -788,6 +2227,7 @@
   var init_loader_utils = __esm({
     "../core/src/loader-utils/index.ts"() {
       "use strict";
+      init_log2();
       init_create_loader_worker();
       init_text_iterators();
       init_async_iteration();
@@ -8511,11 +9951,11 @@ return true;`);
           this._offsets = new OffsetsBufferBuilder(opts.type);
         }
         setValue(index, value) {
-          const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-          const current = pending.get(index);
+          const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+          const current = pending2.get(index);
           current && (this._pendingLength -= current.length);
           this._pendingLength += value instanceof MapRow ? value[kKeys].length : value.length;
-          pending.set(index, value);
+          pending2.set(index, value);
         }
         setValid(index, isValid) {
           if (!super.setValid(index, isValid)) {
@@ -8538,12 +9978,12 @@ return true;`);
           return super.finish();
         }
         _flush() {
-          const pending = this._pending;
+          const pending2 = this._pending;
           const pendingLength = this._pendingLength;
           this._pendingLength = 0;
           this._pending = void 0;
-          if (pending && pending.size > 0) {
-            this._flushPending(pending, pendingLength);
+          if (pending2 && pending2.size > 0) {
+            this._flushPending(pending2, pendingLength);
           }
           return this;
         }
@@ -8663,8 +10103,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);
@@ -8910,9 +10350,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);
         }
@@ -9040,8 +10480,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);
@@ -9075,9 +10515,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);
@@ -9449,16 +10889,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());
@@ -9475,11 +10915,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);
@@ -9804,10 +11244,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 metadata = decodeMessageCustomMetadata(_message);
-          const message = new _Message(bodyLength, version, headerType, void 0, metadata);
+          const message = new _Message(bodyLength, version2, headerType, void 0, metadata);
           message._createHeader = decodeMessageHeader(_message, headerType);
           return message;
         }
@@ -9884,8 +11324,8 @@ return true;`);
         isDictionaryBatch() {
           return this.headerType === MessageHeader.DictionaryBatch;
         }
-        constructor(bodyLength, version, headerType, header, metadata) {
-          this._version = version;
+        constructor(bodyLength, version2, headerType, header, metadata) {
+          this._version = version2;
           this._headerType = headerType;
           this.body = new Uint8Array(0);
           this._compression = header === null || header === void 0 ? void 0 : header.compression;
@@ -11129,11 +12569,11 @@ return true;`);
         setValue(index, value) {
           return super.setValue(index, toUint8Array(value));
         }
-        _flushPending(pending, pendingLength) {
+        _flushPending(pending2, pendingLength) {
           const offsets = this._offsets;
           const data = this._values.reserve(pendingLength).buffer;
           let offset = 0;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (value === void 0) {
               offsets.set(index, 0);
             } else {
@@ -11170,11 +12610,11 @@ return true;`);
         setValue(index, value) {
           return super.setValue(index, toUint8Array(value));
         }
-        _flushPending(pending, pendingLength) {
+        _flushPending(pending2, pendingLength) {
           const offsets = this._offsets;
           const data = this._values.reserve(pendingLength).buffer;
           let offset = 0;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (value === void 0) {
               offsets.set(index, BigInt(0));
             } else {
@@ -11485,10 +12925,10 @@ return true;`);
           this.type = new List2(new Field2(name, child.type, true));
           return this.numChildren - 1;
         }
-        _flushPending(pending) {
+        _flushPending(pending2) {
           const offsets = this._offsets;
           const [child] = this.children;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (typeof value === "undefined") {
               offsets.set(index, 0);
             } else {
@@ -11527,10 +12967,10 @@ return true;`);
           this.type = new LargeList2(new Field2(name, child.type, true));
           return this.numChildren - 1;
         }
-        _flushPending(pending) {
+        _flushPending(pending2) {
           const offsets = this._offsets;
           const [child] = this.children;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (typeof value === "undefined") {
               offsets.set(index, BigInt(0));
             } else {
@@ -11560,11 +13000,11 @@ return true;`);
         }
         setValue(index, value) {
           const row = value instanceof Map ? value : new Map(Object.entries(value));
-          const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-          const current = pending.get(index);
+          const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+          const current = pending2.get(index);
           current && (this._pendingLength -= current.size);
           this._pendingLength += row.size;
-          pending.set(index, row);
+          pending2.set(index, row);
         }
         addChild(child, name = `${this.numChildren}`) {
           if (this.numChildren > 0) {
@@ -11574,10 +13014,10 @@ return true;`);
           this.type = new Map_(new Field2(name, child.type, true), this.type.keysSorted);
           return this.numChildren - 1;
         }
-        _flushPending(pending) {
+        _flushPending(pending2) {
           const offsets = this._offsets;
           const [child] = this.children;
-          for (const [index, value] of pending) {
+          for (const [index, value] of pending2) {
             if (value === void 0) {
               offsets.set(index, 0);
             } else {
@@ -11786,7 +13226,7 @@ return true;`);
           return super.setValue(index, encodeUtf8(value));
         }
         // @ts-ignore
-        _flushPending(pending, pendingLength) {
+        _flushPending(pending2, pendingLength) {
         }
       };
       Utf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;
@@ -11817,7 +13257,7 @@ return true;`);
           return super.setValue(index, encodeUtf8(value));
         }
         // @ts-ignore
-        _flushPending(pending, pendingLength) {
+        _flushPending(pending2, pendingLength) {
         }
       };
       LargeUtf8Builder.prototype._flushPending = LargeBinaryBuilder.prototype._flushPending;
@@ -16196,7 +17636,113 @@ return true;`);
     }
   });
 
-  // ../core/src/schema-utils/lib/mesh/mesh-utils.ts
+  // ../core/src/lib/loader-utils/native-arrow.ts
+  function isNativeArrowTable(value) {
+    return Boolean(
+      value && typeof value === "object" && "schema" in value && "batches" in value && Array.isArray(value.batches) && "numRows" in value && typeof value.numRows === "number" && "getChildAt" in value && typeof value.getChildAt === "function"
+    );
+  }
+  var init_native_arrow = __esm({
+    "../core/src/lib/loader-utils/native-arrow.ts"() {
+      "use strict";
+    }
+  });
+
+  // ../core/src/schema-utils/lib/arrow/arrow-metadata.ts
+  function snapshotArrowSchema(schema) {
+    return deserializeArrowSchema(serializeArrowSchema(schema));
+  }
+  function mergeArrowSchemas(previous, next) {
+    if (!previous) return snapshotArrowSchema(next);
+    new Table(previous, [new RecordBatch3(next, void 0)]);
+    const earlier = serializeArrowSchema(previous);
+    const later = serializeArrowSchema(next);
+    return deserializeArrowSchema({
+      ...later,
+      fields: later.fields.map((field, index) => mergeFieldMetadata(earlier.fields[index], field)),
+      metadata: { ...earlier.metadata, ...later.metadata }
+    });
+  }
+  function mergeFieldMetadata(previous, next) {
+    return {
+      ...next,
+      type: mergeTypeMetadata(previous.type, next.type),
+      metadata: { ...previous.metadata, ...next.metadata }
+    };
+  }
+  function mergeTypeMetadata(previous, next) {
+    if (typeof previous !== "object" || typeof next !== "object") return next;
+    if ("children" in previous && "children" in next) {
+      const previousChildren = previous.children;
+      return {
+        ...next,
+        children: next.children.map(
+          (field, index) => mergeFieldMetadata(previousChildren[index], field)
+        )
+      };
+    }
+    if (previous.type === "dictionary" && next.type === "dictionary") {
+      return { ...next, dictionary: mergeTypeMetadata(previous.dictionary, next.dictionary) };
+    }
+    return next;
+  }
+  function updateArrowTableSchema(table, schema) {
+    const snapshot = snapshotArrowSchema(schema);
+    const batches = table.batches.map(
+      (batch) => new RecordBatch3(snapshotArrowSchema(snapshot), batch.data, new Map(batch.metadata))
+    );
+    return new Table(
+      snapshot,
+      batches.length ? batches : [new RecordBatch3(snapshotArrowSchema(snapshot), void 0)]
+    );
+  }
+  function updateArrowTableMetadata(table, metadata) {
+    const schema = new Schema2(
+      table.data.schema.fields,
+      new Map([...table.data.schema.metadata, ...Object.entries(metadata)])
+    );
+    const data = updateArrowTableSchema(table.data, schema);
+    return { ...table, data, schema: serializeArrowSchema(data.schema) };
+  }
+  function makeArrowMetadataBatch(schema) {
+    return new RecordBatch3(snapshotArrowSchema(schema), void 0);
+  }
+  async function* refineArrowTableBatches(batches) {
+    let schema;
+    let bounds;
+    for await (const batch of batches) {
+      const table = batch;
+      if (table?.shape !== "arrow-table") {
+        yield batch;
+        continue;
+      }
+      const localBounds = table.data.schema.metadata.get("boundingBox");
+      const nextSchema = snapshotArrowSchema(table.data.schema);
+      if (localBounds) {
+        const nextBounds = JSON.parse(localBounds);
+        bounds = bounds ? [
+          nextBounds[0].map((value, index) => Math.min(bounds[0][index], value)),
+          nextBounds[1].map((value, index) => Math.max(bounds[1][index], value))
+        ] : nextBounds;
+        nextSchema.metadata.set("boundingBox", JSON.stringify(bounds));
+      }
+      schema = mergeArrowSchemas(schema, nextSchema);
+      const data = updateArrowTableSchema(table.data, schema);
+      if (localBounds) {
+        for (const recordBatch of data.batches) recordBatch.metadata.set("boundingBox", localBounds);
+      }
+      yield { ...table, data, schema: serializeArrowSchema(data.schema) };
+    }
+  }
+  var init_arrow_metadata = __esm({
+    "../core/src/schema-utils/lib/arrow/arrow-metadata.ts"() {
+      "use strict";
+      init_Arrow_dom();
+      init_convert_arrow_schema();
+    }
+  });
+
+  // ../core/src/schema-utils/lib/mesh/get-mesh-bounding-box.ts
   function getMeshBoundingBox(attributes) {
     const positionAttribute = attributes?.POSITION;
     if (!positionAttribute || !("value" in positionAttribute) || !positionAttribute.value.length) {
@@ -16226,9 +17772,17 @@ return true;`);
       [maxX, maxY, maxZ]
     ];
   }
+  var init_get_mesh_bounding_box = __esm({
+    "../core/src/schema-utils/lib/mesh/get-mesh-bounding-box.ts"() {
+      "use strict";
+    }
+  });
+
+  // ../core/src/schema-utils/lib/mesh/mesh-utils.ts
   var init_mesh_utils = __esm({
     "../core/src/schema-utils/lib/mesh/mesh-utils.ts"() {
       "use strict";
+      init_get_mesh_bounding_box();
     }
   });
 
@@ -16307,7 +17861,7 @@ return true;`);
   var init_float162 = __esm({
     "../core/src/schema/float16.ts"() {
       "use strict";
-      init_dist();
+      init_dist2();
     }
   });
 
@@ -16391,31 +17945,7 @@ return true;`);
   });
 
   // ../core/src/schema-utils/lib/mesh/convert-mesh-to-table.ts
-  function convertMeshToTable(mesh, shape) {
-    switch (shape) {
-      case "columnar-table":
-        return convertMeshToColumnarTable(mesh);
-      case "arrow-table":
-        return convertMeshToArrowTable(mesh);
-      default:
-        throw new Error(shape);
-    }
-  }
-  function convertMeshToColumnarTable(mesh) {
-    const columns = {};
-    const hasIndices = hasMeshIndices(mesh);
-    for (const [columnName, attribute] of Object.entries(mesh.attributes)) {
-      columns[columnName] = attribute.value;
-    }
-    return {
-      shape: "columnar-table",
-      schema: mesh.schema,
-      data: columns,
-      topology: mesh.topology,
-      indices: hasIndices ? mesh.indices : void 0
-    };
-  }
-  function convertMeshToArrowTable(mesh, batchSize) {
+  function convertMeshToArrowTableWrapper(mesh, batchSize) {
     return makeMeshArrowTable(mesh.attributes, {
       schema: mesh.schema,
       topology: mesh.topology,
@@ -16576,6 +18106,7 @@ return true;`);
 
   // ../core/src/schema-utils/lib/mesh/convert-table-to-mesh.ts
   function convertTableToMesh(table) {
+    if (isNativeArrowTable(table)) return convertArrowTableToMesh(table);
     switch (table.shape) {
       // case 'columnar-table':
       //   return convertColumnarTableToMesh(table);
@@ -16586,8 +18117,10 @@ return true;`);
     }
   }
   function convertArrowTableToMesh(table) {
-    const arrowTable = table.data;
+    const arrowTable = isNativeArrowTable(table) ? table : table.data;
     const schema = serializeArrowSchema(arrowTable.schema);
+    const localBounds = arrowTable.batches.length === 1 ? arrowTable.batches[0].metadata.get("boundingBox") : void 0;
+    if (localBounds) schema.metadata = { ...schema.metadata, boundingBox: localBounds };
     const fields = schema.fields;
     const attributes = {};
     const columns = [];
@@ -16742,6 +18275,7 @@ return true;`);
       init_Arrow_dom();
       init_arrow_fixed_size_list_utils();
       init_convert_arrow_schema();
+      init_native_arrow();
       init_mesh_utils();
     }
   });
@@ -16800,16 +18334,78 @@ return true;`);
   var init_schema_utils = __esm({
     "../core/src/schema-utils/index.ts"() {
       "use strict";
+      init_convert_arrow_schema();
       init_mesh_utils();
       init_convert_mesh_to_table();
       init_convert_table_to_mesh();
       init_deduce_mesh_schema();
+      init_arrow_metadata();
+      init_arrow_metadata();
+    }
+  });
+
+  // ../../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/@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 ?? [];
+  }
+  function createArrowData(type, offset, length, nullCount, buffers, children, dictionary, variadicBuffers) {
+    return Reflect.construct(Data, [
+      type,
+      offset,
+      length,
+      nullCount,
+      buffers,
+      children,
+      dictionary,
+      variadicBuffers
+    ]);
+  }
+  var init_arrow_data = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/arrow-data.js"() {
+      init_Arrow_dom();
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/arrow/arrow-record-batch.js
+  function getRecordBatchMetadata(batch) {
+    return batch.metadata;
+  }
+  function createRecordBatchWithMetadata(schema, data, metadata) {
+    if ("metadata" in RecordBatch3.prototype) {
+      const MetadataRecordBatch = RecordBatch3;
+      return Object.assign(new MetadataRecordBatch(schema, data, metadata), { data });
+    }
+    const batch = Object.assign(new RecordBatch3(schema, data), { data });
+    return metadata === void 0 ? batch : Object.assign(batch, { metadata });
+  }
+  var init_arrow_record_batch = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/arrow-record-batch.js"() {
+      init_Arrow_dom();
     }
   });
 
-  // ../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts
+  // ../../node_modules/@math.gl/arrow/dist/arrow/split-arrow-buffers.js
   function splitArrowBuffers(input, options = {}) {
-    const context = { ...options, copies: /* @__PURE__ */ new WeakMap() };
+    const retainedBuffers = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    for (const retained of options.retain ?? []) {
+      const chunks = isArrowTable2(retained) ? retained.batches.map((batch) => batch.data) : isArrowVector2(retained) ? retained.data : [isArrowRecordBatch2(retained) ? retained.data : retained];
+      for (const data of chunks)
+        collectArrowBuffers(data, retainedBuffers, visited);
+    }
+    const context = { ...options, copies: /* @__PURE__ */ new WeakMap(), retainedBuffers };
     if (isArrowTable2(input)) {
       return splitArrowTableBuffersInternal(input, context);
     }
@@ -16830,17 +18426,13 @@ return true;`);
   function isArrowVector2(input) {
     return "data" in input && Array.isArray(input.data);
   }
-  function splitArrowTableBuffersInternal(table, options) {
-    const recordBatches = table.batches.map(
-      (recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options)
-    );
-    return new Table(table.schema, recordBatches);
+  function splitArrowTableBuffersInternal(arrowTable, options) {
+    const recordBatches = arrowTable.batches.map((recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options));
+    return new Table(arrowTable.schema, recordBatches);
   }
   function splitArrowRecordBatchBuffers(recordBatch, options) {
-    return new RecordBatch3(
-      recordBatch.schema,
-      splitArrowDataBuffers(recordBatch.data, options)
-    );
+    const data = splitArrowDataBuffers(recordBatch.data, options);
+    return createRecordBatchWithMetadata(recordBatch.schema, data, getRecordBatchMetadata(recordBatch));
   }
   function splitArrowDataBuffers(data, options) {
     const children = data.children.map((childData) => splitArrowDataBuffers(childData, options));
@@ -16851,7 +18443,7 @@ return true;`);
       [BufferType.VALIDITY]: splitArrowBuffer(data.buffers[BufferType.VALIDITY], options),
       [BufferType.TYPE]: splitArrowBuffer(data.buffers[BufferType.TYPE], options)
     };
-    return new Data(
+    return createArrowData(
       data.type,
       data.offset,
       data.length,
@@ -16859,25 +18451,37 @@ return true;`);
       data._nullCount,
       buffers,
       children,
-      dictionary
+      dictionary,
+      getArrowVariadicBuffers(data).map((buffer) => splitArrowBuffer(buffer, options))
     );
   }
   function splitArrowVectorBuffers(vector, options) {
     return new Vector(vector.data.map((data) => splitArrowDataBuffers(data, options)));
   }
+  function collectArrowBuffers(data, buffers, visited) {
+    if (visited.has(data))
+      return;
+    visited.add(data);
+    for (const view of [...Object.values(data.buffers), ...getArrowVariadicBuffers(data)]) {
+      if (isArrowTypedArray(view))
+        buffers.add(view.buffer);
+    }
+    for (const child of data.children)
+      collectArrowBuffers(child, buffers, visited);
+    for (const chunk of data.dictionary?.data ?? [])
+      collectArrowBuffers(chunk, buffers, visited);
+  }
   function splitArrowBuffer(array, options) {
     if (!isArrowTypedArray(array)) {
       return array;
     }
-    if (options.copy === "none") {
-      return array;
-    }
-    if (options.copy !== "all" && array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {
+    const sliced = array.byteOffset !== 0 || array.byteLength !== array.buffer.byteLength;
+    if (!options.retainedBuffers.has(array.buffer) && options.copy !== "all" && (options.copy === "none" || !sliced)) {
       return array;
     }
     let copy = options.copies.get(array);
     if (!copy) {
-      copy = array.slice();
+      copy = array instanceof Uint8Array ? new Uint8Array(array) : array.slice();
       options.copies.set(array, copy);
     }
     return copy;
@@ -16886,44 +18490,163 @@ return true;`);
     return ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
   var init_split_arrow_buffers = __esm({
-    "../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/arrow/dist/arrow/split-arrow-buffers.js"() {
       init_Arrow_dom();
+      init_arrow_record_batch();
+      init_arrow_data();
+    }
+  });
+
+  // ../../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();
     }
   });
 
-  // ../core/src/schema-utils/lib/arrow/arrow-table-transport.ts
-  function dehydrateArrowTable(table, options) {
-    const splitTable = splitArrowBuffers(table, options);
+  // ../../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();
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/arrow/arrow-table-transport.js
+  function dehydrateArrowTable(arrowTable, options) {
+    const splitTable = splitArrowBuffers(arrowTable, options);
     return {
-      shape: "arrow-table",
       transport: "arrow-js",
-      schema: serializeArrowSchema(splitTable.schema),
-      batches: splitTable.batches.map((recordBatch) => dehydrateArrowRecordBatch(recordBatch))
+      version: 1,
+      schema: tableToIPC(new Table(splitTable.schema, [])),
+      metadataVersion: splitTable.schema.metadataVersion,
+      batches: splitTable.batches.map((batch) => {
+        const metadata = getRecordBatchMetadata(batch);
+        return {
+          ...dehydrateArrowData(batch.data),
+          ...metadata !== void 0 ? { metadata: [...metadata] } : {}
+        };
+      })
     };
   }
   function hydrateArrowTable(table) {
-    const schema = deserializeArrowSchema(table.schema);
-    const recordBatches = table.batches.map(
-      (recordBatch) => new RecordBatch3(schema, hydrateArrowData(recordBatch.data))
-    );
-    return new Table(schema, recordBatches);
+    if (table.transport !== "arrow-js" || table.version !== 1) {
+      throw new Error("Unsupported Arrow column-buffer transport protocol.");
+    }
+    const decodedSchema = tableFromIPC(table.schema).schema;
+    const schema = new Schema2(decodedSchema.fields, decodedSchema.metadata, decodedSchema.dictionaries, table.metadataVersion);
+    const type = new Struct(schema.fields);
+    const batches = table.batches.map((payload) => {
+      const data = hydrateArrowData(payload, type);
+      return createRecordBatchWithMetadata(schema, data, payload.metadata && new Map(payload.metadata));
+    });
+    return new Table(schema, batches);
+  }
+  function dehydrateArrowData(data) {
+    return {
+      offset: data.offset,
+      length: data.length,
+      nullCount: data.nullCount,
+      buffers: {
+        [BufferType.OFFSET]: data.buffers[BufferType.OFFSET],
+        [BufferType.DATA]: data.buffers[BufferType.DATA],
+        [BufferType.VALIDITY]: data.buffers[BufferType.VALIDITY],
+        [BufferType.TYPE]: data.buffers[BufferType.TYPE]
+      },
+      children: data.children.map((child) => dehydrateArrowData(child)),
+      variadicBuffers: getArrowVariadicBuffers(data),
+      dictionary: data.dictionary?.data.map((chunk) => dehydrateArrowData(chunk))
+    };
+  }
+  function hydrateArrowData(data, type) {
+    const children = data.children.map((child, index) => hydrateArrowData(child, type.children[index].type));
+    const dictionary = data.dictionary && DataType.isDictionary(type) ? new Vector(data.dictionary.map((chunk) => hydrateArrowData(chunk, type.dictionary))) : void 0;
+    return createArrowData(type, data.offset, data.length, data.nullCount, data.buffers, children, dictionary, data.variadicBuffers);
   }
+  var init_arrow_table_transport = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/arrow-table-transport.js"() {
+      init_Arrow_dom();
+      init_arrow_record_batch();
+      init_arrow_data();
+      init_split_arrow_buffers();
+    }
+  });
+
+  // ../../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();
+      init_take_arrow_rows();
+      init_arrow_record_batch();
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/index.js
+  var init_dist3 = __esm({
+    "../../node_modules/@math.gl/arrow/dist/index.js"() {
+      init_arrow();
+    }
+  });
+
+  // ../core/src/arrow-worker-transport.ts
   function serializeArrowWorkerTable(result) {
     if (!isArrowTableWrapper(result)) {
       throw new Error("Workers require Arrow table output");
     }
-    const { data, ...metadata } = result;
+    const { data, shape: _shape, ...metadata } = result;
     return {
-      ...structuredClone(metadata),
-      data: dehydrateArrowTable(data, { copy: "all" })
+      transport: "arrow-column-envelope",
+      metadata: structuredClone(metadata),
+      ...serializeWorkerColumns(data, { copy: "all" })
     };
   }
   function deserializeArrowWorkerTable(result) {
-    if (!isDehydratedArrowTableWrapper(result)) {
-      throw new Error("Workers require Arrow column transport");
+    if (isArrowWorkerEnvelope(result)) {
+      return { ...result.metadata, shape: "arrow-table", data: hydrateWorkerTable(result) };
+    }
+    if (isLegacyArrowWorkerEnvelope(result)) {
+      const { arrowBatchMetadata: _snapshots, data: _columns, ...metadata } = result;
+      return { ...metadata, data: hydrateWorkerTable(result) };
     }
-    return { ...result, data: hydrateArrowTable(result.data) };
+    throw new Error("Workers require Arrow column transport");
   }
   function isArrowTableWrapper(value) {
     const table = value;
@@ -16931,66 +18654,62 @@ return true;`);
       table && table.shape === "arrow-table" && table.data && typeof table.data === "object" && "batches" in table.data
     );
   }
-  function isDehydratedArrowTableWrapper(value) {
-    const table = value;
-    return Boolean(
-      table && table.shape === "arrow-table" && table.data && table.data.transport === "arrow-js" && Array.isArray(table.data.batches)
-    );
+  function hasArrowWorkerColumns(value) {
+    const columns = value;
+    return columns?.data?.transport === "arrow-js" && Array.isArray(columns.data.batches);
   }
-  function dehydrateArrowRecordBatch(recordBatch) {
-    return { data: dehydrateArrowData(recordBatch.data) };
+  function isArrowWorkerEnvelope(value) {
+    return value?.transport === "arrow-column-envelope" && hasArrowWorkerColumns(value);
   }
-  function dehydrateArrowData(data) {
+  function isLegacyArrowWorkerEnvelope(value) {
+    return value?.shape === "arrow-table" && hasArrowWorkerColumns(value);
+  }
+  function serializeWorkerColumns(table, options) {
     return {
-      type: serializeArrowType(data.type),
-      offset: data.offset,
-      length: data.length,
-      // @ts-expect-error _nullCount is protected. Preserve the Arrow lazy null-count state.
-      nullCount: data._nullCount,
-      buffers: {
-        [BufferType.OFFSET]: data.buffers[BufferType.OFFSET],
-        [BufferType.DATA]: data.buffers[BufferType.DATA],
-        [BufferType.VALIDITY]: data.buffers[BufferType.VALIDITY],
-        [BufferType.TYPE]: data.buffers[BufferType.TYPE]
-      },
-      children: data.children.map((childData) => dehydrateArrowData(childData)),
-      dictionary: data.dictionary ? dehydrateArrowVector(data.dictionary) : void 0
+      arrowBatchMetadata: snapshotBatchMetadata(table),
+      data: dehydrateWorkerTable(table, options)
     };
   }
-  function dehydrateArrowVector(vector) {
-    return { data: vector.data.map((data) => dehydrateArrowData(data)) };
+  function dehydrateWorkerTable(table, options) {
+    const payload = dehydrateArrowTable(table, options);
+    if (table.numCols === 0) {
+      for (const [index, batch] of table.batches.entries()) {
+        payload.batches[index].length = batch.numRows;
+      }
+    }
+    return payload;
   }
-  function hydrateArrowData(data) {
-    const children = data.children.map((childData) => hydrateArrowData(childData));
-    const dictionary = data.dictionary ? hydrateArrowVector(data.dictionary) : void 0;
-    return new Data(
-      deserializeArrowType(data.type),
-      data.offset,
-      data.length,
-      data.nullCount,
-      data.buffers,
-      children,
-      dictionary
-    );
+  function snapshotBatchMetadata(table) {
+    return table.batches.map((batch) => ({
+      schema: tableToIPC(new Table(batch.schema, [])),
+      metadata: Array.from(batch.metadata)
+    }));
   }
-  function hydrateArrowVector(vector) {
-    return new Vector(vector.data.map((data) => hydrateArrowData(data)));
+  function hydrateWorkerTable(result) {
+    const { arrowBatchMetadata, data } = result;
+    const table = hydrateArrowTable(data);
+    const batches = table.batches.map((batch, index) => {
+      const snapshot = arrowBatchMetadata?.[index];
+      const restored = snapshot ? new RecordBatch3(
+        tableFromIPC(snapshot.schema).schema,
+        batch.data,
+        new Map(snapshot.metadata)
+      ) : batch;
+      const rowCount = data.batches[index].length;
+      if (restored.numCols === 0 && restored.numRows !== rowCount) {
+        Object.defineProperty(restored, "data", {
+          value: new Data(new Struct([]), 0, rowCount, 0, void 0, [])
+        });
+      }
+      return restored;
+    });
+    return new Table(table.schema, batches);
   }
-  var init_arrow_table_transport = __esm({
-    "../core/src/schema-utils/lib/arrow/arrow-table-transport.ts"() {
+  var init_arrow_worker_transport = __esm({
+    "../core/src/arrow-worker-transport.ts"() {
       "use strict";
       init_Arrow_dom();
-      init_convert_arrow_schema();
-      init_split_arrow_buffers();
-    }
-  });
-
-  // ../core/src/schema-utils/arrow-transport.ts
-  var init_arrow_transport = __esm({
-    "../core/src/schema-utils/arrow-transport.ts"() {
-      "use strict";
-      init_arrow_table_transport();
-      init_split_arrow_buffers();
+      init_dist3();
     }
   });
 
@@ -17541,6 +19260,8 @@ return true;`);
     const schema = getPLYSchema(header, meshAttributes);
     schema.metadata.topology = "point-list";
     schema.metadata.mode = "0";
+    const boundingBox = getMeshBoundingBox(meshAttributes);
+    if (boundingBox) schema.metadata.boundingBox = JSON.stringify(boundingBox);
     const columns = {};
     const fields = [];
     for (const field of schema.fields) {
@@ -17877,6 +19598,7 @@ return true;`);
     "src/ply/lib/parse-ply.ts"() {
       "use strict";
       init_Arrow_dom();
+      init_schema_utils();
       init_normalize_ply();
       init_get_ply_schema();
       PLY_END_HEADER = "end_header";
@@ -18169,7 +19891,7 @@ return true;`);
     const arrowSchema = new Schema2(fields, metadata);
     return {
       shape: "arrow-table",
-      schema: mesh.schema,
+      schema: serializeArrowSchema(arrowSchema),
       data: new Table(arrowSchema, columns),
       topology: mesh.topology,
       indices: mesh.indices?.value.length ? mesh.indices : void 0
@@ -18401,7 +20123,7 @@ return true;`);
 
   // src/ply/lib/parse-ply-in-batches.ts
   async function* parsePLYInBatches(iterator, options) {
-    if (options?.shape === "arrow-table") {
+    if (options?.shape === "arrow") {
       yield* parseBinaryPLYToArrowInBatches(iterator, options);
       return;
     }
@@ -18438,7 +20160,10 @@ return true;`);
       );
     }
     for await (const table of tables) {
-      yield { ...table, loaderData: header };
+      yield {
+        ...updateArrowTableMetadata(table, makeMetadataFromPlyHeader(header)),
+        loaderData: header
+      };
     }
   }
   async function* parseBinaryFixedWidthVertexPLYToArrowInBatches(byteIterator, header, initialBodyBytes, options) {
@@ -18843,7 +20568,7 @@ return true;`);
           currentElement?.properties.push(property);
           break;
         default:
-          console.log("unhandled", lineType, lineValues);
+          log2.log(0, "unhandled", lineType, lineValues)();
       }
       return false;
     });
@@ -18966,6 +20691,9 @@ return true;`);
     "src/ply/lib/parse-ply-in-batches.ts"() {
       "use strict";
       init_loader_utils();
+      init_loader_utils();
+      init_schema_utils();
+      init_get_ply_schema();
       init_normalize_ply();
       init_parse_ply();
       init_parse_ply_arrow();
@@ -19000,25 +20728,27 @@ return true;`);
     const { PLYLoaderWithParser: PLYLoaderWithParser2 } = await Promise.resolve().then(() => (init_ply_loader(), ply_loader_exports));
     return PLYLoaderWithParser2;
   }
-  var VERSION, PLYLoader;
+  var VERSION3, PLYLoader;
   var init_ply_loader_types = __esm({
     "src/ply/ply-loader-types.ts"() {
       "use strict";
       init_ply_format();
-      init_arrow_transport();
-      VERSION = true ? "5.0.0-beta.1" : "latest";
+      init_arrow_worker_transport();
+      VERSION3 = true ? "5.0.0-beta.10" : "latest";
       PLYLoader = {
+        defaultShape: "arrow",
+        supportsNativeArrow: true,
         dataType: null,
         batchType: null,
         ...PLYFormat,
         // shapes: ['mesh', 'gltf', 'columnar-table'],
-        version: VERSION,
+        version: VERSION3,
         worker: true,
         /** Enables the stateful input/output batch protocol on the built-in worker. */
         workerInBatches: true,
         serializeWorkerResult: serializeArrowWorkerTable,
         options: {
-          ply: { shape: "arrow-table", colorFormat: "uint8norm" }
+          ply: { shape: "arrow", colorFormat: "uint8norm" }
         },
         preload
       };
@@ -19028,10 +20758,11 @@ return true;`);
   // src/ply/ply-loader.ts
   var ply_loader_exports = {};
   __export(ply_loader_exports, {
+    PLYColumnLoader: () => PLYColumnLoader,
     PLYLoaderWithParser: () => PLYLoaderWithParser
   });
   function convertPLYMesh(mesh, options) {
-    const table = convertMeshToTable(mesh, "arrow-table");
+    const table = convertMeshToArrowTableWrapper(mesh);
     return convertPLYTable(table, options, mesh.loaderData);
   }
   function parsePLYData(data, options) {
@@ -19051,7 +20782,7 @@ return true;`);
   }
   function convertPLYTable(table, options, header) {
     const loaderData = header || table.loaderData || { comments: [], elements: [] };
-    const result = options?.ply?.shape === "arrow-table" ? { ...table, loader: "ply", loaderData } : {
+    const result = options?.ply?.shape === "arrow" ? { ...table, loader: "ply", loaderData } : {
       ...convertTableToMesh(table),
       loader: "ply",
       loaderData
@@ -19065,8 +20796,8 @@ return true;`);
       isMeshArrowTable(resultData) ? convertTableToMesh(resultData) : resultData,
       colorFormat
     );
-    return options?.ply?.shape === "arrow-table" ? {
-      ...convertMeshToTable(formattedMesh, "arrow-table"),
+    return options?.ply?.shape === "arrow" ? {
+      ...convertMeshToArrowTableWrapper(formattedMesh),
       loader: "ply",
       loaderData
     } : formattedMesh;
@@ -19105,39 +20836,95 @@ return true;`);
   function deserializePLYWorkerBatch(result, options) {
     return deserializePLYWorkerResult(result, options);
   }
-  var _PLYLoaderPreload, PLYLoaderMetadataWithoutPreload, PLYLoaderWithParser;
+  async function* parsePLYWithMetadataInBatches(arrayBuffer, options) {
+    const plyOptions = {
+      ...options?.ply,
+      batchSize: options?.core?.batchSize
+    };
+    for await (const meshOrTable of parsePLYInBatches(arrayBuffer, plyOptions)) {
+      const convertedData = isMeshArrowTable(meshOrTable) ? convertPLYTable(meshOrTable, options) : convertPLYMesh(meshOrTable, options);
+      yield isMeshArrowTable(convertedData) ? makeTableScanBatch(convertedData) : convertedData;
+    }
+  }
+  function unwrapPLYTable(result) {
+    if ("shape" in result && result.shape === "arrow-table") {
+      result.data.schema.metadata.set(
+        "loaders.gl.ply.header",
+        JSON.stringify(result.loaderData)
+      );
+      return result.data;
+    }
+    return result;
+  }
+  function isColumnBatch(batch) {
+    return "shape" in batch && batch.shape === "arrow-table";
+  }
+  var _PLYLoaderPreload, PLYLoaderMetadataWithoutPreload, PLYColumnLoader, PLYLoaderWithParser;
   var init_ply_loader = __esm({
     "src/ply/ply-loader.ts"() {
       "use strict";
+      init_schema_utils();
       init_loader_utils();
       init_schema3();
-      init_arrow_transport();
+      init_arrow_worker_transport();
       init_schema_utils();
       init_parse_ply();
       init_parse_ply_arrow();
       init_parse_ply_in_batches();
       init_ply_loader_types();
       ({ preload: _PLYLoaderPreload, ...PLYLoaderMetadataWithoutPreload } = PLYLoader);
-      PLYLoaderWithParser = {
+      PLYColumnLoader = {
         ...PLYLoaderMetadataWithoutPreload,
+        dataType: null,
+        batchType: null,
         parse: async (arrayBuffer, options) => parsePLYData(arrayBuffer, options),
         parseTextSync: (arrayBuffer, options) => parsePLYData(arrayBuffer, options),
         parseSync: (arrayBuffer, options) => parsePLYData(arrayBuffer, options),
-        parseInBatches: async function* (arrayBuffer, options) {
-          const plyOptions = {
-            ...options?.ply,
-            batchSize: options?.batchSize ?? options?.core?.batchSize
-          };
-          for await (const meshOrTable of parsePLYInBatches(arrayBuffer, plyOptions)) {
-            const convertedData = isMeshArrowTable(meshOrTable) ? convertPLYTable(meshOrTable, options) : convertPLYMesh(meshOrTable, options);
-            yield isMeshArrowTable(convertedData) ? makeTableScanBatch(convertedData) : convertedData;
-          }
-        },
+        parseInBatches: (input, options) => refineArrowTableBatches(parsePLYWithMetadataInBatches(input, options)),
         serializeWorkerResult: serializeArrowWorkerTable,
         deserializeWorkerResult: deserializePLYWorkerResult,
         serializeWorkerBatch: serializeArrowWorkerTable,
         deserializeWorkerBatch: deserializePLYWorkerBatch
       };
+      PLYLoaderWithParser = {
+        ...PLYColumnLoader,
+        dataType: PLYLoader.dataType,
+        batchType: PLYLoader.batchType,
+        parse: async (input, options) => unwrapPLYTable(await PLYColumnLoader.parse(input, options)),
+        parseTextSync: (input, options) => unwrapPLYTable(PLYColumnLoader.parseTextSync(input, options)),
+        parseSync: (input, options) => unwrapPLYTable(PLYColumnLoader.parseSync(input, options)),
+        async *parseInBatches(input, options) {
+          for await (const batch of PLYColumnLoader.parseInBatches(input, options)) {
+            if (isColumnBatch(batch)) {
+              batch.data.schema.metadata.set(
+                "loaders.gl.ply.header",
+                JSON.stringify(batch.loaderData)
+              );
+              for (const recordBatch of batch.data.batches) {
+                recordBatch.schema.metadata.set(
+                  "loaders.gl.ply.header",
+                  batch.data.schema.metadata.get("loaders.gl.ply.header")
+                );
+              }
+              if (batch.data.batches.length) yield* batch.data.batches;
+              else yield makeArrowMetadataBatch(batch.data.schema);
+            } else yield batch;
+          }
+        },
+        deserializeWorkerResult: (result, options) => unwrapPLYTable(PLYColumnLoader.deserializeWorkerResult(result, options)),
+        deserializeWorkerBatch(result, options) {
+          const batch = PLYColumnLoader.deserializeWorkerBatch(result, options);
+          if (isColumnBatch(batch)) {
+            const recordBatch = batch.data.batches[0] ?? makeArrowMetadataBatch(batch.data.schema);
+            recordBatch.schema.metadata.set(
+              "loaders.gl.ply.header",
+              JSON.stringify(batch.loaderData)
+            );
+            return recordBatch;
+          }
+          return batch;
+        }
+      };
     }
   });
 
@@ -19146,25 +20933,25 @@ return true;`);
   init_schema_utils();
   init_ply_loader();
   createLoaderWorker({
-    ...PLYLoaderWithParser,
+    ...PLYColumnLoader,
     /** Always returns columnar data; legacy mesh conversion runs on the caller. */
     parse(input, options) {
-      return PLYLoaderWithParser.parse(input, {
+      return PLYColumnLoader.parse(input, {
         ...options,
-        ply: { ...options?.ply, shape: "arrow-table" }
+        ply: { ...options?.ply, shape: "arrow" }
       });
     },
     /** Preserves full-mesh parsing while streaming point-cloud vertices as Arrow batches. */
     async *parseInBatches(input, options) {
       const parseMesh = options?.ply?.shape === "mesh" && !options?.ply?.pointCloud;
-      const parserOptions = parseMesh ? options : { ...options, ply: { ...options?.ply, shape: "arrow-table" } };
-      for await (const batch of PLYLoaderWithParser.parseInBatches(input, parserOptions)) {
+      const parserOptions = parseMesh ? options : { ...options, ply: { ...options?.ply, shape: "arrow" } };
+      for await (const batch of PLYColumnLoader.parseInBatches(input, parserOptions)) {
         if ("shape" in batch && batch.shape === "arrow-table") {
           yield batch;
         } else {
           const mesh = batch;
           yield makeTableScanBatch({
-            ...convertMeshToTable(mesh, "arrow-table"),
+            ...convertMeshToArrowTableWrapper(mesh),
             loader: mesh.loader,
             loaderData: mesh.loaderData
           });