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

package/dist/las-worker.js

@@ -1,28 +1,80 @@
 "use strict";
 (() => {
   var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __esm = (fn, res, err) => function __init() {
+    if (err) throw err[0];
+    try {
+      return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    } catch (e) {
+      throw err = [e], e;
+    }
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
   // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
-  var parentPort = null;
+  var worker_threads_browser_exports = {};
+  __export(worker_threads_browser_exports, {
+    NodeWorker: () => NodeWorker,
+    parentPort: () => parentPort2
+  });
+  var NodeWorker, parentPort2;
+  var init_worker_threads_browser = __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-utils/get-transfer-list.ts
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js
+  var parentPort = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort ?? null;
+
+  // ../../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) {
@@ -44,7 +96,7 @@
     return false;
   }
 
-  // ../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;
   }
@@ -52,23 +104,24 @@
   var 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;
         }
@@ -86,9 +139,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);
       }
@@ -99,9 +152,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);
       }
@@ -111,12 +164,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);
       }
@@ -130,11 +183,8 @@
     return messageData && typeof messageData.source === "string" && messageData.source.startsWith("loaders.gl") ? messageData : null;
   }
 
-  // ../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 = class {
-    _values;
-    _settlers;
-    _closed;
     constructor() {
       this._values = [];
       this._settlers = [];
@@ -200,11 +250,58 @@
     }
   };
 
-  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js
+  var 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");
+    }
+  }
+
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/create-worker.js
   var requestId = 0;
+  var activeController = null;
   var activeInputBatches = null;
   var activeOutputAcknowledgements = null;
-  async function createWorker(process, processInBatches) {
+  async function createWorker(process2, processInBatches, preload) {
     if (!await WorkerBody.inWorkerThread()) {
       return;
     }
@@ -212,27 +309,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 preload?.();
             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");
             }
@@ -241,18 +370,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;
@@ -279,11 +405,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) {
@@ -296,62 +429,584 @@
     }
   }
   function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
+    const signal = activeController?.signal;
+    signal?.throwIfAborted();
     return new Promise((resolve, reject) => {
       const id = requestId++;
-      const onMessage = (type, payload2) => {
-        if (payload2.id !== id) {
+      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;
-        }
-        switch (type) {
-          case "done":
-            WorkerBody.removeEventListener(onMessage);
-            resolve(payload2.result);
-            break;
-          case "error":
-            WorkerBody.removeEventListener(onMessage);
-            reject(payload2.error);
-            break;
-          default:
+        if (type === "done") {
+          cleanup();
+          resolve(payload.result);
+        } else if (type === "error") {
+          cleanup();
+          reject(payload.error);
         }
       };
-      WorkerBody.addEventListener(onMessage);
-      const payload = { id, input: arrayBuffer, options, context: jobContext };
-      WorkerBody.postMessage("process", payload);
+      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 pending;
+    let pending2;
     let finished = false;
     let scheduled = false;
     const flush = () => {
       scheduled = false;
-      if (pending) {
-        WorkerBody.postMessage("progress", { progress: pending });
-        pending = void 0;
+      if (pending2) {
+        WorkerBody.postMessage("progress", { progress: pending2 });
+        pending2 = void 0;
       }
     };
     return {
       /** Records progress while retaining phase transitions. */
       report(progress) {
-        if (finished) return;
-        if (pending && pending.phase !== progress.phase) flush();
-        pending = { ...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() {
+      finish(discard = false) {
+        if (discard)
+          pending2 = void 0;
         flush();
         finished = true;
       }
     };
   }
 
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/index.js
+  var import_meta = {};
+  var path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
+  var 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
+  var pending = /* @__PURE__ */ new WeakMap();
+  var loaded = /* @__PURE__ */ new WeakSet();
+  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);
+      });
+    });
+  }
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js
+  var TaskRequestError = class extends Error {
+  };
+  var 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"
+      })
+    };
+  }
+  var 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;
+      }
+    }
+  };
+  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 installed = false;
+
+  // ../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_browser(), worker_threads_browser_exports));
+      return !isMainThread;
+    }
+    return false;
+  }
+  var 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;
+  }
+
+  // ../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 };
+          }
+        }
+      } : {}
+    };
+  }
+  function createContext(context) {
+    let requestIdentifier = 0;
+    const port = context.state.port;
+    return {
+      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
+    };
+  }
+
   // ../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,
@@ -5043,6 +5698,52 @@
     return NativeFloat16ArrayConstructor ?? Uint16Array;
   }
 
+  // ../core/src/loader-utils/lib/pace-batch-iterator.ts
+  function validateBatchDeliveryRate(rate) {
+    if (!Number.isFinite(rate) || rate < 0) {
+      throw new RangeError("core.batchMaxRowsPerSecond must be a finite nonnegative number");
+    }
+  }
+  async function* paceBatchIterator(batches, { batchMaxRowsPerSecond = 0, getRowCount, signal }) {
+    validateBatchDeliveryRate(batchMaxRowsPerSecond);
+    signal?.throwIfAborted();
+    if (batchMaxRowsPerSecond === 0) {
+      yield* batches;
+      return;
+    }
+    let deadline = 0;
+    for await (const batch of batches) {
+      signal?.throwIfAborted();
+      const rowCount = getRowCount(batch);
+      if (rowCount !== void 0 && rowCount > 0) {
+        let remaining = deadline - performance.now();
+        while (remaining > 0) {
+          await waitForBatch(Math.min(Math.ceil(remaining), 2 ** 31 - 1), signal);
+          remaining = deadline - performance.now();
+        }
+        signal?.throwIfAborted();
+        deadline = performance.now() + rowCount / batchMaxRowsPerSecond * 1e3;
+      }
+      yield batch;
+      signal?.throwIfAborted();
+    }
+  }
+  function waitForBatch(delay, signal) {
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", abort);
+        resolve();
+      }, delay);
+      function abort() {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
+        reject(signal?.reason);
+      }
+      signal?.addEventListener("abort", abort, { once: true });
+    });
+  }
+
   // ../core/src/schema-utils/lib/schema/data-type.ts
   function getDataTypeFromValue(value, defaultNumberType = "float32") {
     if (value instanceof Date) {
@@ -12456,11 +13157,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)) {
@@ -12483,12 +13184,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;
     }
@@ -14898,11 +15599,11 @@ return true;`);
     setValue(index, value) {
       return super.setValue(index, toUint8Array2(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 {
@@ -14931,11 +15632,11 @@ return true;`);
     setValue(index, value) {
       return super.setValue(index, toUint8Array2(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 {
@@ -15166,10 +15867,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 {
@@ -15198,10 +15899,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 {
@@ -15223,11 +15924,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) {
@@ -15237,10 +15938,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 {
@@ -15403,7 +16104,7 @@ return true;`);
       return super.setValue(index, encodeUtf8(value));
     }
     // @ts-ignore
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
     }
   };
   Utf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;
@@ -15425,7 +16126,7 @@ return true;`);
       return super.setValue(index, encodeUtf8(value));
     }
     // @ts-ignore
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
     }
   };
   LargeUtf8Builder.prototype._flushPending = LargeBinaryBuilder.prototype._flushPending;
@@ -19284,7 +19985,40 @@ 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"
+    );
+  }
+
+  // ../core/src/schema-utils/lib/arrow/arrow-metadata.ts
+  function snapshotArrowSchema(schema) {
+    return deserializeArrowSchema(serializeArrowSchema(schema));
+  }
+  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);
+  }
+
+  // ../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) {
@@ -19444,31 +20178,7 @@ return true;`);
 
   // ../core/src/schema-utils/lib/mesh/convert-mesh-to-table.ts
   var MESH_ARROW_ATTRIBUTE_ORDER = ["POSITION"];
-  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,
@@ -19617,6 +20327,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);
@@ -19627,8 +20338,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 = [];
@@ -19838,13 +20551,15 @@ return true;`);
   };
 
   // src/las/las-loader-shared.ts
-  var VERSION = true ? "5.0.0-beta.1" : "latest";
-  var DEFAULT_LAS_SHAPE = "arrow-table";
+  var VERSION = true ? "5.0.0-beta.10" : "latest";
+  var DEFAULT_LAS_SHAPE = "arrow";
   function getLASShape(options) {
     return options?.las?.shape || DEFAULT_LAS_SHAPE;
   }
   var LAS_LOADER_METADATA = {
     ...LASFormat,
+    defaultShape: "arrow",
+    supportsNativeArrow: true,
     dataType: null,
     batchType: null,
     version: VERSION,
@@ -19883,9 +20598,46 @@ return true;`);
     return { ...mesh, attributes };
   }
 
-  // ../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts
+  // ../../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
+    ]);
+  }
+
+  // ../../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 });
+  }
+
+  // ../../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);
     }
@@ -19906,17 +20658,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));
@@ -19927,7 +20675,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,
@@ -19935,25 +20683,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;
@@ -19962,38 +20722,79 @@ return true;`);
     return ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
 
-  // ../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/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);
+  }
+
+  // ../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;
@@ -20001,50 +20802,56 @@ 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);
   }
 
   // src/las/lib/get-las-schema.ts
@@ -20075,6 +20882,11 @@ return true;`);
     if (lasHeader.isCompressed !== void 0) {
       metadata.las_isCompressed = lasHeader.isCompressed.toString();
     }
+    if (lasHeader.metadata?.wkt) metadata.las_wkt = lasHeader.metadata.wkt;
+    if (lasHeader.metadata?.wktMathTransform)
+      metadata.las_wktMathTransform = lasHeader.metadata.wktMathTransform;
+    if (lasHeader.metadata?.geotiff)
+      metadata.las_geotiff = JSON.stringify(lasHeader.metadata.geotiff);
     return metadata;
   }
 
@@ -20238,7 +21050,12 @@ return true;`);
     return attributes;
   }
   function readLASString(bytes, offset, length) {
-    return new TextDecoder().decode(bytes.subarray(offset, offset + length)).replace(/\0+$/, "").trim();
+    const decoded = new TextDecoder().decode(bytes.subarray(offset, offset + length));
+    let end = decoded.length;
+    while (end > 0 && decoded[end - 1] === "\0") {
+      end--;
+    }
+    return decoded.slice(0, end).trim();
   }
   function sanitizeExtraBytesName(name) {
     return name.trim().replace(/[^A-Za-z0-9_]+/g, "_");
@@ -20484,20 +21301,22 @@ return true;`);
   async function* parseLASInBatches(arrayBufferIterator, options = {}) {
     const batchSize = getBatchSize(options);
     const inputIterator = toAsyncIterator(arrayBufferIterator);
-    let pending = new Uint8Array(0);
+    let pending2 = new Uint8Array(0);
     let absoluteOffset = 0;
     let header = null;
     let sourcePointIndex = 0;
     let totalRead = 0;
+    let lastTable;
     while (true) {
       const next = await inputIterator.next();
       if (next.done) {
         break;
       }
       const chunk = next.value;
-      pending = concatenateUint8Arrays2(pending, toUint8Array3(chunk));
+      pending2 = concatenateUint8Arrays2(pending2, toUint8Array3(chunk));
       if (!header) {
-        header = tryParseHeader(pending, absoluteOffset);
+        header = tryParseHeader(pending2, absoluteOffset);
+        if (header && pending2.byteLength < header.pointsOffset) header = null;
         if (header) {
           header.totalToRead = header.pointsCount;
         }
@@ -20506,11 +21325,65 @@ return true;`);
         continue;
       }
       if (header.isCompressed) {
-        yield* parseLAZInBatches(pending, inputIterator, header, options);
+        const extendedOffset = header.metadata?.evlrOffset;
+        let inputOffset = pending2.byteLength;
+        const extendedChunks = [];
+        if (extendedOffset && extendedOffset < inputOffset) {
+          extendedChunks.push(pending2.subarray(extendedOffset));
+        }
+        const trackedIterator = {
+          async next() {
+            const next2 = await inputIterator.next();
+            if (!next2.done && extendedOffset) {
+              const bytes = toUint8Array3(next2.value);
+              const start = Math.max(extendedOffset - inputOffset, 0);
+              if (start < bytes.byteLength) extendedChunks.push(bytes.slice(start));
+              inputOffset += bytes.byteLength;
+            }
+            return next2;
+          }
+        };
+        if (header.pointsCount === 0) {
+          const { laszip } = await readLASZipVLRFromInput(pending2, trackedIterator, header);
+          validateTypeScriptLAZSupport(header, laszip);
+          lastTable = makeEmptyLASBatch(header, options);
+        } else {
+          for await (const table of parseLAZInBatches(pending2, trackedIterator, header, options)) {
+            lastTable = updateArrowTableMetadata(
+              table,
+              makeMetadataFromLasHeader({
+                ...header,
+                totalRead: table.loaderData.totalRead,
+                metadata: table.loaderData.metadata || header.metadata
+              })
+            );
+            yield lastTable;
+          }
+        }
+        if (extendedOffset && lastTable && header.metadata?.evlrCount && (lastTable.loaderData.metadata?.evlrs.length ?? 0) < header.metadata.evlrCount) {
+          while (!(await trackedIterator.next()).done) {
+          }
+          const suffix = extendedChunks.reduce(
+            concatenateUint8Arrays2,
+            new Uint8Array(0)
+          );
+          const update2 = makeLASMetadataUpdate(
+            lastTable,
+            header,
+            suffix,
+            extendedOffset,
+            lastTable.loaderData.totalRead
+          );
+          if (update2) {
+            yield update2;
+            return;
+          }
+        }
+        if (header.pointsCount === 0 && lastTable) yield lastTable;
         return;
       }
       for (const batch of readAvailablePointBatches(
-        pending,
+        pending2,
         absoluteOffset,
         header,
         sourcePointIndex,
@@ -20519,9 +21392,13 @@ return true;`);
       )) {
         sourcePointIndex = batch.sourcePointIndex;
         totalRead = batch.totalRead;
-        pending = batch.pending;
+        pending2 = batch.pending;
         absoluteOffset = batch.absoluteOffset;
-        yield parseLASArrowTableBatch(batch.arrayBuffer, batch.header, options);
+        lastTable = updateArrowTableMetadata(
+          parseLASArrowTableBatch(batch.arrayBuffer, batch.header, options),
+          makeMetadataFromLasHeader({ ...header, totalRead })
+        );
+        yield lastTable;
       }
     }
     if (!header) {
@@ -20530,6 +21407,50 @@ return true;`);
     if (totalRead < header.totalToRead) {
       throw new Error("LASLoader: truncated LAS point data");
     }
+    if (!lastTable) {
+      lastTable = makeEmptyLASBatch(header, options);
+      yield lastTable;
+    }
+    const update = makeLASMetadataUpdate(lastTable, header, pending2, absoluteOffset, totalRead);
+    if (update) yield update;
+  }
+  function makeEmptyLASBatch(header, options) {
+    const table = parseLASArrowTableBatch(new ArrayBuffer(0), { ...header, pointsOffset: 0 }, options);
+    return updateArrowTableMetadata(
+      { ...table, loaderData: header },
+      makeMetadataFromLasHeader(header)
+    );
+  }
+  function makeLASMetadataUpdate(lastTable, header, pending2, absoluteOffset, totalRead) {
+    const metadata = header.metadata;
+    if (metadata?.evlrOffset && metadata.evlrCount) {
+      const relativeOffset = metadata.evlrOffset - absoluteOffset;
+      const records = parseLASExtendedVariableLengthRecords(
+        new DataView(pending2.buffer, pending2.byteOffset, pending2.byteLength),
+        relativeOffset,
+        metadata.evlrCount
+      ).map((record) => ({ ...record, offset: record.offset + absoluteOffset }));
+      const finalMetadata = {
+        ...metadata,
+        evlrs: records,
+        extraBytes: [...metadata.extraBytes],
+        waveformPacketDescriptors: [...metadata.waveformPacketDescriptors]
+      };
+      for (const record of records)
+        parseTypedLASMetadataRecord(
+          { ...record, data: record.data || new Uint8Array() },
+          finalMetadata
+        );
+      resolveLASGeoTIFFKeyDirectory(finalMetadata);
+      const finalHeader = { ...header, totalRead, metadata: finalMetadata };
+      if (records.length > 0) {
+        const data = new Table([makeArrowMetadataBatch(lastTable.data.schema)]);
+        return updateArrowTableMetadata(
+          { ...lastTable, data, loaderData: finalHeader },
+          makeMetadataFromLasHeader(finalHeader)
+        );
+      }
+    }
   }
   async function* decodeLAZFileWithParsedVLRInBatches(initialPending, inputIterator, header, laszip, options) {
     if (laszip.variableChunks) {
@@ -20703,11 +21624,11 @@ return true;`);
     );
   }
   async function* parseLAZInBatches(initialPending, inputIterator, header, options) {
-    const { pending, laszip } = await readLASZipVLRFromInput(initialPending, inputIterator, header);
+    const { pending: pending2, laszip } = await readLASZipVLRFromInput(initialPending, inputIterator, header);
     validateTypeScriptLAZSupport(header, laszip);
     if (!laszip.variableChunks && header.pointsFormatId <= 5) {
       yield* parsePendingFixedLegacyLAZFileInArrowBatches(
-        pending,
+        pending2,
         inputIterator,
         header,
         laszip,
@@ -20716,11 +21637,11 @@ return true;`);
       return;
     }
     if (!laszip.variableChunks && header.pointsFormatId >= 6 && header.pointsFormatId <= 10) {
-      yield* parsePendingLAZFileInArrowBatches(pending, inputIterator, header, laszip, options);
+      yield* parsePendingLAZFileInArrowBatches(pending2, inputIterator, header, laszip, options);
       return;
     }
     for await (const batch of decodeLAZFileWithParsedVLRInBatches(
-      pending,
+      pending2,
       inputIterator,
       header,
       laszip,
@@ -20931,7 +21852,7 @@ return true;`);
     if (header.pointsFormatId <= 5 || laszip.variableChunks) {
       yield* decodeLAZFileFromCompleteBytes(new Uint8Array(arrayBuffer), header, laszip, {
         ...options,
-        batchSize
+        core: { ...options.core, batchSize }
       });
       return;
     }
@@ -20955,7 +21876,11 @@ return true;`);
   }
   function* decodeLAZFileFromCompleteBytes(bytes, header, laszip, options = {}) {
     const batchSize = getBatchSize(options);
-    const outputHeader = { ...header, totalToRead: header.pointsCount };
+    const outputHeader = {
+      ...header,
+      metadata: parseLASMetadata(bytes, header),
+      totalToRead: header.pointsCount
+    };
     const state = createRawPointBatchState(
       batchSize,
       header.pointsStructSize,
@@ -21087,7 +22012,8 @@ return true;`);
     return arrayBuffer.byteLength >= Math.max(vlrEnd, header.pointsOffset);
   }
   function parseLASMetadata(arrayBuffer, header) {
-    const dataView = new DataView(arrayBuffer);
+    const dataView = makeDataView(arrayBuffer);
+    const bytes = new Uint8Array(dataView.buffer, dataView.byteOffset, dataView.byteLength);
     const version = header.versionAsString || "1.0";
     const versionParts = version.split(".").map(Number);
     const isAtLeast14 = versionParts[0] > 1 || versionParts[0] === 1 && versionParts[1] >= 4;
@@ -21099,9 +22025,9 @@ return true;`);
       fileSourceId: dataView.getUint16(4, true),
       globalEncoding: dataView.getUint16(6, true),
       waveformDataOffset: versionParts[0] > 1 || versionParts[0] === 1 && versionParts[1] >= 3 ? dataView.getBigUint64(227, true) : void 0,
-      projectId: formatLASProjectId(new Uint8Array(arrayBuffer, 8, 16)),
-      systemIdentifier: readLASString2(new Uint8Array(arrayBuffer), 26, 32),
-      generatingSoftware: readLASString2(new Uint8Array(arrayBuffer), 58, 32),
+      projectId: formatLASProjectId(bytes.subarray(8, 24)),
+      systemIdentifier: readLASString2(bytes, 26, 32),
+      generatingSoftware: readLASString2(bytes, 58, 32),
       creationDayOfYear: dataView.getUint16(90, true),
       creationYear: dataView.getUint16(92, true),
       headerSize: header.headerSize,
@@ -21153,7 +22079,7 @@ return true;`);
     return records;
   }
   function parseLASExtendedVariableLengthRecords(dataView, evlrOffset, evlrCount) {
-    if (!evlrOffset || !evlrCount || evlrOffset >= dataView.byteLength) {
+    if (evlrOffset < 0 || !evlrCount || evlrOffset >= dataView.byteLength) {
       return [];
     }
     const bytes = new Uint8Array(dataView.buffer, dataView.byteOffset, dataView.byteLength);
@@ -21709,7 +22635,7 @@ return true;`);
     return false;
   }
   function getBatchSize(options) {
-    const batchSize = options.batchSize ?? options.core?.batchSize;
+    const batchSize = options.core?.batchSize;
     return typeof batchSize === "number" ? batchSize : DEFAULT_BATCH_SIZE;
   }
   function parseLASZipVLR(bytes, header) {
@@ -21921,10 +22847,10 @@ return true;`);
     }
   }
   async function readLASZipVLRFromInput(initialPending, inputIterator, header) {
-    let pending = initialPending;
+    let pending2 = initialPending;
     while (true) {
       try {
-        return { pending, laszip: parseLASZipVLR(pending, header) };
+        return { pending: pending2, laszip: parseLASZipVLR(pending2, header) };
       } catch (error) {
         if (!(error instanceof NeedsMoreData)) {
           throw error;
@@ -21934,7 +22860,7 @@ return true;`);
       if (next.done) {
         throw new NeedsMoreData("LASLoader: incomplete LASzip VLR");
       }
-      pending = concatenateUint8Arrays2(pending, toUint8Array3(next.value));
+      pending2 = concatenateUint8Arrays2(pending2, toUint8Array3(next.value));
     }
   }
   async function collectRemainingInputBytes(initialPending, inputIterator) {
@@ -22858,10 +23784,10 @@ return true;`);
       [maximum[0], maximum[1], maximum[2]]
     ];
   }
-  function* readAvailablePointBatches(pending, absoluteOffset, header, sourcePointIndex, totalRead, batchSize) {
+  function* readAvailablePointBatches(pending2, absoluteOffset, header, sourcePointIndex, totalRead, batchSize) {
     while (sourcePointIndex < header.pointsCount && totalRead < header.totalToRead) {
       const batch = readAvailableContiguousPointBatch(
-        pending,
+        pending2,
         absoluteOffset,
         header,
         sourcePointIndex,
@@ -22871,25 +23797,25 @@ return true;`);
       if (!batch) {
         return;
       }
-      pending = batch.pending;
+      pending2 = batch.pending;
       absoluteOffset = batch.absoluteOffset;
       sourcePointIndex = batch.sourcePointIndex;
       totalRead = batch.totalRead;
       yield batch;
     }
   }
-  function readAvailableContiguousPointBatch(pending, absoluteOffset, header, sourcePointIndex, totalRead, batchSize) {
+  function readAvailableContiguousPointBatch(pending2, absoluteOffset, header, sourcePointIndex, totalRead, batchSize) {
     const pointRecordLength = header.pointsStructSize;
     const pointAbsoluteOffset = header.pointsOffset + sourcePointIndex * pointRecordLength;
     const pointPendingOffset = pointAbsoluteOffset - absoluteOffset;
     if (pointPendingOffset < 0) {
       throw new Error("LASLoader: invalid streaming point offset");
     }
-    if (pointPendingOffset + pointRecordLength > pending.byteLength) {
+    if (pointPendingOffset + pointRecordLength > pending2.byteLength) {
       return null;
     }
     const availablePointCount = Math.floor(
-      (pending.byteLength - pointPendingOffset) / pointRecordLength
+      (pending2.byteLength - pointPendingOffset) / pointRecordLength
     );
     const batchPointCount = Math.min(
       batchSize,
@@ -22904,38 +23830,38 @@ return true;`);
     totalRead += batchPointCount;
     const batchHeader = {
       ...header,
-      pointsOffset: pending.byteOffset + pointPendingOffset,
+      pointsOffset: pending2.byteOffset + pointPendingOffset,
       pointsCount: batchPointCount,
       totalRead
     };
     const nextPointOffset = header.pointsOffset + sourcePointIndex * pointRecordLength;
     const discardByteCount = Math.max(
       0,
-      Math.min(pending.byteLength, nextPointOffset - absoluteOffset)
+      Math.min(pending2.byteLength, nextPointOffset - absoluteOffset)
     );
     return {
-      arrayBuffer: pending.buffer,
+      arrayBuffer: pending2.buffer,
       header: batchHeader,
-      pending: pending.subarray(discardByteCount),
+      pending: pending2.subarray(discardByteCount),
       absoluteOffset: absoluteOffset + discardByteCount,
       sourcePointIndex,
       totalRead
     };
   }
-  function tryParseHeader(pending, absoluteOffset) {
-    if (absoluteOffset !== 0 || pending.byteLength < 227) {
+  function tryParseHeader(pending2, absoluteOffset) {
+    if (absoluteOffset !== 0 || pending2.byteLength < 227) {
       return null;
     }
-    const dataView = new DataView(pending.buffer, pending.byteOffset, pending.byteLength);
+    const dataView = new DataView(pending2.buffer, pending2.byteOffset, pending2.byteLength);
     if (dataView.getUint32(0, true) !== LASF_SIGNATURE) {
       throw new Error("LASLoader: invalid LAS header");
     }
     const headerLength = dataView.getUint32(96, true);
-    if (pending.byteLength < Math.max(headerLength, 255)) {
+    if (pending2.byteLength < Math.max(headerLength, 255)) {
       return null;
     }
     const header = parseLASHeader(
-      pending.buffer.slice(pending.byteOffset, pending.byteOffset + pending.byteLength)
+      pending2.buffer.slice(pending2.byteOffset, pending2.byteOffset + pending2.byteLength)
     );
     return header;
   }
@@ -22990,8 +23916,10 @@ return true;`);
   }
 
   // src/las/las-loader.ts
-  var LASLoaderWithParser = {
+  var LASColumnLoader = {
     ...LAS_LOADER_METADATA,
+    dataType: null,
+    batchType: null,
     worker: true,
     workerInBatches: true,
     serializeWorkerResult: serializeArrowWorkerTable,
@@ -23010,15 +23938,14 @@ return true;`);
   }
   function convertLASMesh(table, options) {
     const formattedTable = options?.las?.colorFormat === void 0 || options.las.colorFormat === "uint8norm" ? table : {
-      ...convertMeshToTable(
-        formatLASMeshColors(convertTableToMesh(table), options.las.colorFormat),
-        "arrow-table"
+      ...convertMeshToArrowTableWrapper(
+        formatLASMeshColors(convertTableToMesh(table), options.las.colorFormat)
       ),
       loader: table.loader,
       loaderData: table.loaderData,
       progress: table.progress
     };
-    if (getLASShape(options) === "arrow-table") {
+    if (getLASShape(options) === "arrow") {
       return formattedTable;
     }
     return {
@@ -23029,29 +23956,68 @@ return true;`);
     };
   }
   async function* convertLASMeshBatches(tableBatches, options) {
-    for await (const table of tableBatches) {
+    for await (const table of paceBatchIterator(tableBatches, {
+      batchMaxRowsPerSecond: options?.core?.batchMaxRowsPerSecond,
+      getRowCount: (batch) => batch.data.numRows,
+      signal: options?.signal
+    })) {
       yield convertLASMesh(table, options);
     }
   }
   function deserializeLASWorkerTable(result, options) {
     return convertLASMesh(deserializeArrowWorkerTable(result), options);
   }
+  var LASLoaderWithParser = {
+    ...LASColumnLoader,
+    dataType: LAS_LOADER_METADATA.dataType,
+    batchType: LAS_LOADER_METADATA.batchType,
+    parse: async (input, options) => toPublicLASResult(await LASColumnLoader.parse(input, options)),
+    parseSync: (input, options) => toPublicLASResult(LASColumnLoader.parseSync(input, options)),
+    async *parseInBatches(input, options) {
+      for await (const result of LASColumnLoader.parseInBatches(input, options)) {
+        if ("shape" in result) yield* getLASRecordBatches(result);
+        else yield result;
+      }
+    },
+    deserializeWorkerResult: (result, options) => toPublicLASResult(deserializeLASWorkerTable(result, options)),
+    deserializeWorkerBatch(result, options) {
+      const decoded = deserializeLASWorkerTable(result, options);
+      return "shape" in decoded ? getLASRecordBatches(decoded)[0] : decoded;
+    }
+  };
+  function toPublicLASResult(result) {
+    if (!("shape" in result)) return result;
+    const header = JSON.stringify(
+      result.loaderData,
+      (_key, value) => typeof value === "bigint" ? value.toString() : ArrayBuffer.isView(value) ? Array.from(value) : value
+    );
+    if (header) {
+      result.data.schema.metadata.set("loaders.gl.las.header", header);
+      for (const batch of result.data.batches)
+        batch.schema.metadata.set("loaders.gl.las.header", header);
+    }
+    return result.data;
+  }
+  function getLASRecordBatches(result) {
+    const table = toPublicLASResult(result);
+    return table.batches.length ? table.batches : [makeArrowMetadataBatch(table.schema)];
+  }
 
   // src/las/workers/las-worker.ts
   createLoaderWorker({
-    ...LASLoaderWithParser,
+    ...LASColumnLoader,
     /** Decodes worker output as transferable columns; caller formatting follows hydration. */
     parse(input, options) {
-      return LASLoaderWithParser.parse(input, {
+      return LASColumnLoader.parse(input, {
         ...options,
-        las: { ...options?.las, shape: "arrow-table", colorFormat: "uint8norm" }
+        las: { ...options?.las, shape: "arrow", colorFormat: "uint8norm" }
       });
     },
     /** Keeps the primary TypeScript decoder alive for the full input stream. */
     parseInBatches(input, options) {
-      return LASLoaderWithParser.parseInBatches(input, {
+      return LASColumnLoader.parseInBatches(input, {
         ...options,
-        las: { ...options?.las, shape: "arrow-table", colorFormat: "uint8norm" }
+        las: { ...options?.las, shape: "arrow", colorFormat: "uint8norm" }
       });
     }
   });