@loaders.gl/scene 5.0.0-beta.4 → 5.0.0-beta.5

package/dist/draco-writer-worker-node.cjs

@@ -10644,7 +10644,7 @@ var NPM_TAG = "beta";
 
 // ../core/src/worker-utils/lib/env-utils/version.ts
 function getVersion() {
-  const version2 = false ? NPM_TAG : "5.0.0-beta.4";
+  const version2 = false ? NPM_TAG : "5.0.0-beta.5";
   globalThis._loadersgl_ = globalThis._loadersgl_ || {};
   globalThis._loadersgl_.version ||= version2;
   return version2;
@@ -10678,23 +10678,23 @@ var isMobile = typeof window !== "undefined" && typeof window.orientation !== "u
 var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion2 = matches && parseFloat(matches[1]) || 0;
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/npm-tag.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/npm-tag.js
 var NPM_TAG2 = "latest";
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/version.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/version.js
 function getVersion2() {
-  return false ? NPM_TAG2 : "5.0.0-beta.4";
+  return false ? NPM_TAG2 : "5.0.0-beta.5";
 }
 var VERSION2 = getVersion2();
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/assert.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/assert.js
 function assert2(condition, message) {
   if (!condition) {
     throw new Error(message || "loaders.gl assertion failed.");
   }
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/globals.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/globals.js
 var globals2 = {
   self: typeof self !== "undefined" && self,
   window: typeof window !== "undefined" && window,
@@ -10713,7 +10713,7 @@ var isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "
 var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion3 = matches2 && parseFloat(matches2[1]) || 0;
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-job.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-job.js
 var WorkerJob = class {
   constructor(jobName, workerThread) {
     this.isRunning = true;
@@ -10833,12 +10833,12 @@ function createAbortError(message) {
   return error;
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads.js
 var import_worker_threads = require("worker_threads");
 var parentPort = import_worker_threads.parentPort;
 var NodeWorker = import_worker_threads.Worker;
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js
 var workerURLCache = /* @__PURE__ */ new Map();
 function getLoadableWorkerURL(props) {
   var _a5, _b2, _c2;
@@ -10888,7 +10888,7 @@ function buildScriptSource(workerUrl) {
 }`;
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js
 function getTransferList(object2, recursive = true, transfers) {
   const transfersSet = transfers || /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
@@ -10972,7 +10972,7 @@ function getTransferListForWriter(object2) {
   return object2 === null ? {} : clone2(object2);
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-thread.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-thread.js
 var NOOP = () => {
 };
 var WorkerThread = class {
@@ -11154,7 +11154,7 @@ var WorkerThread = class {
   }
 };
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-pool.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-pool.js
 var WorkerPool = class {
   /** Snapshot; byte figures describe input buffers, not total heap memory. */
   get stats() {
@@ -11684,7 +11684,7 @@ var WorkerPool = class {
   }
 };
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-farm.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-farm.js
 var DEFAULT_PROPS = {
   maxQueuedJobs: Infinity,
   maxPendingAdmissions: 128,
@@ -11805,7 +11805,7 @@ function getLoadWorkerId(loadWorker) {
   return loadWorkerId;
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-body.js
 async function getParentPort() {
   return parentPort;
 }
@@ -11892,7 +11892,7 @@ function getWorkerMessageData(message) {
   return messageData && typeof messageData.source === "string" && messageData.source.startsWith("loaders.gl") ? messageData : null;
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/async-queue/async-queue.js
 var AsyncQueue = class {
   constructor() {
     this._values = [];
@@ -11959,7 +11959,7 @@ var AsyncQueue = class {
   }
 };
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/get-worker-url.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/get-worker-url.js
 var warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
 function getWorkerName(worker) {
   const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
@@ -11974,7 +11974,7 @@ function getCustomWorkerURL(worker, options = {}) {
     if (isBrowser3) {
       url = `modules/${worker.module}/dist/${workerFile}`;
     } else {
-      const workerSourceDirectory = worker.module === "core" && ((_b2 = worker.workerNode) == null ? void 0 : _b2.startsWith("worker-utils/")) ? "worker-utils/workers" : "workers";
+      const workerSourceDirectory = worker.module === "tasks" && ((_b2 = worker.workerNode) == null ? void 0 : _b2.startsWith("worker-utils/")) ? "worker-utils/workers" : "workers";
       const workerSourceNode = worker.workerSourceNode || `${workerSourceDirectory}/${worker.id}-worker-node.ts`;
       url = `modules/${worker.module}/src/${workerSourceNode}`;
     }
@@ -12018,7 +12018,7 @@ function warnIfUsingNpmTagFallback(worker, url) {
   console.warn(`loaders.gl: ${worker.name} loader worker version is "latest" because __VERSION__ was not injected. Fetching ${url} from CDN.`);
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js
 function getWorkerCapabilities() {
   const isolated = typeof globalThis.crossOriginIsolated === "boolean" ? globalThis.crossOriginIsolated : void 0;
   const capabilities = {
@@ -12101,7 +12101,7 @@ function prepareSharedState(options) {
   return options;
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-input-byte-length.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-input-byte-length.js
 function getInputByteLength(input) {
   const seen = /* @__PURE__ */ new Set();
   let bytes = 0;
@@ -12130,14 +12130,14 @@ function getInputByteLength(input) {
   return bytes;
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js
+// ../../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/core/dist/worker-utils/lib/worker-api/process-on-worker.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/process-on-worker.js
 async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
   var _a5;
   validateOutputOwnership(options.outputOwnership);
@@ -12434,7 +12434,7 @@ function budgetOptions(options) {
   return inputOptions;
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/create-worker.js
 var requestId = 0;
 var activeController = null;
 var activeInputBatches = null;
@@ -12643,12 +12643,12 @@ function createProgressReporter() {
   };
 }
 
-// ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+// ../../node_modules/@math.gl/tasks/dist/worker-utils/index.js
 var import_meta3 = {};
 var path3 = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
 var moduleUrl = path3 ? `file://${path3.startsWith("/") ? "" : "/"}${encodeURI(path3).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta3.url;
 
-// ../../node_modules/@math.gl/core/dist/tasks/task-preload.js
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-preload.js
 var pending = /* @__PURE__ */ new WeakMap();
 var loaded = /* @__PURE__ */ new WeakSet();
 function preloadTaskCode(task, signal) {
@@ -12688,7 +12688,154 @@ function withSignal(operation, signal) {
   });
 }
 
-// ../../node_modules/@math.gl/core/dist/tasks/task-runtime.js
+// ../../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 == null ? void 0 : 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 == null ? void 0 : signal.reason);
+        this.send({ source: "math.gl/tasks", kind: "cancel", id });
+      };
+      this.pending.set(id, {
+        resolve,
+        reject,
+        cleanup: () => signal == null ? void 0 : signal.removeEventListener("abort", abort)
+      });
+      signal == null ? void 0 : 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) {
+    var _a5, _b2, _c2, _d2, _e2, _f2, _g2, _h2;
+    if (this.failure || (message == null ? void 0 : message.source) !== "math.gl/tasks")
+      return;
+    if (message.kind === "failure") {
+      const reason = new Error(((_a5 = message.error) == null ? void 0 : _a5.message) ?? "Task channel failed");
+      this.close(reason);
+      (_c2 = (_b2 = this.options).onFailure) == null ? void 0 : _c2.call(_b2, 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(((_d2 = message.error) == null ? void 0 : _d2.message) ?? "Task request failed");
+        error.name = ((_e2 = message.error) == null ? void 0 : _e2.name) ?? "Error";
+        pending2.reject(error);
+      }
+    } else if (message.kind === "cancel") {
+      (_f2 = this.incoming.get(message.id)) == null ? void 0 : _f2.abort(new DOMException("Task request cancelled", "AbortError"));
+    } else if (message.kind === "event") {
+      try {
+        (_h2 = (_g2 = this.options).handleEvent) == null ? void 0 : _h2.call(_g2, 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) => {
+        var _a6, _b3;
+        if (!controller.signal.aborted && !this.failure) {
+          this.send({ source: "math.gl/tasks", kind: "result", id: message.id, value }, (_b3 = (_a6 = this.options).getResultTransferList) == null ? void 0 : _b3.call(_a6, 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) {
+    var _a5, _b2;
+    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 {
+    }
+    (_b2 = (_a5 = this.options).onFailure) == null ? void 0 : _b2.call(_a5, 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");
@@ -12710,6 +12857,17 @@ function taskContext(state, context = {}) {
   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) => {
+      var _a5;
+      signal.throwIfAborted();
+      (_a5 = context.emitHost) == null ? void 0 : _a5.call(context, operation, payload);
+    },
     throwIfAborted: () => {
       var _a5;
       signal.throwIfAborted();
@@ -12780,6 +12938,70 @@ async function initializeTaskWorker(task) {
     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) => {
+      var _a5;
+      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 ((_a5 = channelStream == null ? void 0 : channelStream.return) == null ? void 0 : _a5.call(channelStream));
+          } 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) {
@@ -12820,7 +13042,7 @@ function localContext(controls) {
   };
 }
 
-// ../../node_modules/@math.gl/core/dist/tasks/task-sync.js
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-sync.js
 function runTaskSync(task, input, request = {}) {
   var _a5, _b2;
   if (!isTaskCodeLoaded(task))
@@ -12905,19 +13127,158 @@ function isThenable(value) {
   return Boolean(value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function");
 }
 
-// ../../node_modules/@math.gl/core/dist/tasks/task-runner.js
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-operation-queue.js
+var TaskOperationQueue = class {
+  constructor(maxConcurrency) {
+    this.maxConcurrency = maxConcurrency;
+    this.pending = [];
+    this.active = 0;
+    this.exclusive = false;
+    this.closed = false;
+    this.idleWaiters = /* @__PURE__ */ new Set();
+    if (!Number.isSafeInteger(maxConcurrency) || maxConcurrency < 1) {
+      throw new RangeError("maxConcurrency must be a positive safe integer");
+    }
+  }
+  /** Queue an operation; aborting before it starts removes it without running it. */
+  run(mode, operation, signal) {
+    if (this.closed)
+      return Promise.reject(new Error("Task operation queue is closed"));
+    if (mode !== "parallel" && mode !== "exclusive")
+      return Promise.reject(new TypeError("Invalid operation mode"));
+    if (signal == null ? void 0 : signal.aborted)
+      return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        const index2 = this.pending.indexOf(entry);
+        if (index2 >= 0) {
+          this.pending.splice(index2, 1);
+          entry.cancel(signal == null ? void 0 : signal.reason);
+          this.pump();
+        }
+      };
+      const entry = {
+        mode,
+        cancel: (reason) => {
+          signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+          reject(reason);
+        },
+        start: () => {
+          signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+          this.active++;
+          if (mode === "exclusive")
+            this.exclusive = true;
+          void Promise.resolve().then(() => {
+            signal == null ? void 0 : signal.throwIfAborted();
+            return operation();
+          }).then(resolve, reject).finally(() => {
+            this.active--;
+            if (mode === "exclusive")
+              this.exclusive = false;
+            this.pump();
+          });
+        }
+      };
+      this.pending.push(entry);
+      signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+      if (signal == null ? void 0 : signal.aborted)
+        onAbort();
+      else
+        this.pump();
+    });
+  }
+  /** Reject queued calls with one cause while allowing active operations to settle. */
+  cancelPending(reason) {
+    this.closed = true;
+    for (const entry of this.pending.splice(0))
+      entry.cancel(reason);
+    this.pump();
+  }
+  /** Stop accepting new work; accepted operations continue to completion. */
+  close() {
+    this.closed = true;
+    return this.whenIdle();
+  }
+  /** Wait until the queue has no running or waiting operations. */
+  whenIdle() {
+    if (!this.active && !this.pending.length)
+      return Promise.resolve();
+    return new Promise((resolve) => this.idleWaiters.add(resolve));
+  }
+  pump() {
+    while (!this.exclusive && this.pending.length && this.active < this.maxConcurrency) {
+      const entry = this.pending[0];
+      if (entry.mode === "exclusive" && this.active)
+        break;
+      this.pending.shift();
+      entry.start();
+      if (entry.mode === "exclusive")
+        break;
+    }
+    if (!this.active && !this.pending.length) {
+      for (const resolve of this.idleWaiters)
+        resolve();
+      this.idleWaiters.clear();
+    }
+  }
+};
+
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-worker-channel.js
+var TaskWorkerChannel = class {
+  constructor(name, target, options) {
+    var _a5;
+    this.thread = new WorkerThread({
+      name,
+      url: (_a5 = target.url) == null ? void 0 : _a5.toString(),
+      loadWorker: target.create,
+      workerType: "module"
+    });
+    this.channel = new TaskChannel({
+      ...options,
+      send: (message, transfer) => this.thread.postMessage({ source: "loaders.gl/tasks", type: "task-channel", payload: message }, transfer)
+    });
+    this.thread.onMessage = (message) => {
+      if ((message == null ? void 0 : message.type) === "task-channel")
+        this.channel.receive(message.payload);
+    };
+    this.thread.onError = (reason) => {
+      var _a6;
+      this.channel.close(reason);
+      (_a6 = options.onFailure) == null ? void 0 : _a6.call(options, reason);
+    };
+  }
+  /** Settle pending calls and terminate the worker without replacing its state. */
+  async destroy(reason) {
+    this.channel.close(reason);
+    await this.thread.destroy();
+  }
+};
+
+// ../../node_modules/@math.gl/tasks/dist/tasks/task-runner.js
 var InitializedTask = class {
   /** @internal Use TaskRunner.initializeTask. */
-  constructor(task, release, controls) {
-    var _a5, _b2;
+  constructor(task, release, initializationControls) {
+    var _a5, _b2, _c2;
     this.task = task;
     this.release = release;
-    this.tail = Promise.resolve();
+    this.initializationControls = initializationControls;
+    this.nextProgressId = 1;
+    this.progressCallbacks = /* @__PURE__ */ new Map();
+    this.callbackFailures = /* @__PURE__ */ new Map();
     this.closed = false;
+    this.finalized = false;
     this.streams = /* @__PURE__ */ new Set();
     this.invalid = false;
     this.controller = new AbortController();
+    const controls = initializationControls;
     this.runtime = new TaskRuntime(task);
+    const concurrency2 = controls.operationConcurrency ?? 1;
+    const maximum = ((_a5 = task.concurrency) == null ? void 0 : _a5.maxConcurrency) ?? 1;
+    if (!Number.isSafeInteger(maximum) || maximum < 1 || !Number.isSafeInteger(concurrency2) || concurrency2 < 1 || concurrency2 > maximum) {
+      throw new RangeError("Task concurrency must be between 1 and the task maximum");
+    }
+    this.operationQueue = new TaskOperationQueue(concurrency2);
+    this.concurrent = concurrency2 > 1;
     const execution = controls.execution ?? "auto";
     if (!["auto", "main-thread", "worker"].includes(execution))
       throw new TypeError("Invalid execution mode");
@@ -12927,9 +13288,51 @@ var InitializedTask = class {
       const target = task.worker;
       if (Boolean(target.url) === Boolean(target.create))
         throw new Error("Supply exactly one worker URL or factory");
+      if (this.concurrent || controls.onRequest || controls.onEvent) {
+        this.workerChannel = new TaskWorkerChannel(task.id, target, {
+          handleRequest: async (operation, payload, signal) => {
+            if (operation === "task:next-input") {
+              if (!this.channelInputs)
+                throw new Error("No active task stream");
+              return this.channelInputs.next();
+            }
+            if (!controls.onRequest)
+              throw new Error("No host request handler configured");
+            const request = payload;
+            if (operation !== "task:host-request")
+              throw new Error("Unknown host request");
+            return controls.onRequest(request.operation, request.payload, signal);
+          },
+          getResultTransferList: (value, request) => request.outputOwnership === "transfer" ? getTransferList(value) : [],
+          handleEvent: (operation, payload) => {
+            var _a6, _b3;
+            const { id } = payload;
+            try {
+              if (operation === "task:progress") {
+                const event = payload;
+                (_a6 = this.progressCallbacks.get(event.id) ?? this.streamProgress) == null ? void 0 : _a6(event.progress);
+              } else if (operation === "task:host-event") {
+                const event = payload;
+                (_b3 = controls.onEvent) == null ? void 0 : _b3.call(controls, event.operation, event.payload);
+              }
+            } catch (reason) {
+              if (this.progressCallbacks.has(id) || this.streamProgressId === id) {
+                if (!this.callbackFailures.has(id))
+                  this.callbackFailures.set(id, { reason });
+              }
+            }
+          },
+          onFailure: (reason) => {
+            this.invalid = true;
+            this.operationQueue.cancelPending(reason);
+            this.controller.abort(reason);
+          }
+        });
+        return;
+      }
       this.pool = new WorkerPool({
         name: task.id,
-        url: (_a5 = target.url) == null ? void 0 : _a5.toString(),
+        url: (_b2 = target.url) == null ? void 0 : _b2.toString(),
         loadWorker: target.create,
         workerType: "module",
         maxConcurrency: 1,
@@ -12938,10 +13341,10 @@ var InitializedTask = class {
       this.descriptor = {
         id: task.id,
         name: task.id,
-        module: "core",
+        module: "tasks",
         version: "prototype",
         options: {},
-        worker: ((_b2 = target.url) == null ? void 0 : _b2.toString()) ?? true,
+        worker: ((_c2 = target.url) == null ? void 0 : _c2.toString()) ?? true,
         loadWorker: target.create,
         workerInBatches: target.capabilities.streaming
       };
@@ -12958,40 +13361,92 @@ var InitializedTask = class {
     }
   }
   runTask(input, ...args) {
-    return this.enqueue(async () => {
-      var _a5;
+    var _a5, _b2, _c2, _d2, _e2;
+    if (this.invalid)
+      return Promise.reject(new Error("Initialized task is invalid; initialize a new instance"));
+    if (this.closed)
+      return Promise.reject(new Error("Initialized task is closed"));
+    const timeout2 = (_a5 = args[0]) == null ? void 0 : _a5.timeout;
+    if (timeout2 !== void 0 && (!Number.isSafeInteger(timeout2) || timeout2 < 0 || timeout2 > 4294967295)) {
+      return Promise.reject(new RangeError("Invalid task timeout"));
+    }
+    const deadline = timeout2 === void 0 ? void 0 : AbortSignal.timeout(timeout2);
+    const signal = deadline && ((_b2 = args[0]) == null ? void 0 : _b2.signal) ? AbortSignal.any([deadline, args[0].signal]) : deadline ?? ((_c2 = args[0]) == null ? void 0 : _c2.signal);
+    const controls = { ...args[0], signal };
+    const mode = ((_e2 = (_d2 = this.task.concurrency) == null ? void 0 : _d2.getSchedulingMode) == null ? void 0 : _e2.call(_d2, input)) ?? "exclusive";
+    return this.operationQueue.run(mode, async () => {
+      var _a6;
+      signal == null ? void 0 : signal.throwIfAborted();
       this.checkCapability("atomic");
-      return this.invoke("process", input, ((_a5 = args[0]) == null ? void 0 : _a5.options) ?? {}, args[0]);
-    });
+      const invalidate = () => {
+        if (this.concurrent) {
+          this.invalid = true;
+          this.operationQueue.cancelPending(signal == null ? void 0 : signal.reason);
+          this.controller.abort(signal == null ? void 0 : signal.reason);
+        }
+      };
+      signal == null ? void 0 : signal.addEventListener("abort", invalidate, { once: true });
+      try {
+        return await this.invoke("process", input, ((_a6 = args[0]) == null ? void 0 : _a6.options) ?? {}, controls);
+      } finally {
+        signal == null ? void 0 : signal.removeEventListener("abort", invalidate);
+      }
+    }, signal);
   }
   /** Independent calls sharing this instance, always serial and in input order. */
-  async *runTasks(inputs, ...args) {
-    yield* this.serialStream(async function* (self2) {
-      var _a5;
+  runTasks(inputs, ...args) {
+    var _a5;
+    return this.serialStream(async function* (self2) {
+      var _a6;
       self2.checkCapability("atomic");
       for await (const input of asAsync(inputs, self2.controls(args[0]).signal)) {
-        yield await self2.invoke("process", input, ((_a5 = args[0]) == null ? void 0 : _a5.options) ?? {}, args[0]);
+        yield await self2.invoke("process", input, ((_a6 = args[0]) == null ? void 0 : _a6.options) ?? {}, args[0]);
       }
-    });
+    }, (_a5 = args[0]) == null ? void 0 : _a5.signal);
   }
   /** One processor invocation for the entire input iterable. */
-  async *runTaskInBatches(inputs, ...args) {
-    yield* this.serialStream(async function* (self2) {
-      var _a5, _b2;
+  runTaskInBatches(inputs, ...args) {
+    var _a5;
+    return this.serialStream(async function* (self2) {
+      var _a6, _b2, _c2, _d2;
       self2.checkCapability("streaming");
       const controls = self2.controls(args[0]);
-      const options = clonePayload(((_a5 = args[0]) == null ? void 0 : _a5.options) ?? {});
+      const options = clonePayload(((_a6 = args[0]) == null ? void 0 : _a6.options) ?? {});
       async function* prepared() {
-        var _a6, _b3;
+        var _a7, _b3;
         for await (const input of asAsync(inputs, controls.signal)) {
-          (_a6 = controls.signal) == null ? void 0 : _a6.throwIfAborted();
+          (_a7 = controls.signal) == null ? void 0 : _a7.throwIfAborted();
           assertNoTransferAlias(input, ((_b3 = args[0]) == null ? void 0 : _b3.options) ?? {}, controls.inputOwnership);
           yield clonePayload(input, controls.inputOwnership);
         }
       }
       let completed = false;
       try {
-        if (self2.pool) {
+        if (self2.workerChannel) {
+          self2.channelInputs = prepared()[Symbol.asyncIterator]();
+          self2.streamProgress = controls.onProgress;
+          try {
+            await self2.invoke("stream-open", {}, options, controls);
+            while (true) {
+              const result = await self2.invoke("stream-next", {}, {}, controls);
+              if (result.done)
+                break;
+              yield result.value;
+            }
+          } finally {
+            try {
+              if (!self2.invalid)
+                await self2.invoke("stream-close", {}, {}, controls);
+            } finally {
+              await ((_c2 = (_b2 = self2.channelInputs).return) == null ? void 0 : _c2.call(_b2));
+              self2.channelInputs = void 0;
+              self2.streamProgress = void 0;
+              if (self2.streamProgressId !== void 0)
+                self2.callbackFailures.delete(self2.streamProgressId);
+              self2.streamProgressId = void 0;
+            }
+          }
+        } else if (self2.pool) {
           await self2.invoke("stream-options", {}, options, controls);
           yield* processOnWorkerInBatches(self2.descriptor, prepared(), {
             ...self2.workerOptions(controls),
@@ -12999,13 +13454,19 @@ var InitializedTask = class {
             workerInBatches: true
           });
         } else {
-          for await (const output of self2.runtime.stream(prepared(), options, localContext(controls))) {
-            (_b2 = controls.signal) == null ? void 0 : _b2.throwIfAborted();
+          for await (const output of self2.runtime.stream(prepared(), options, self2.runtimeContext(controls))) {
+            (_d2 = controls.signal) == null ? void 0 : _d2.throwIfAborted();
             yield clonePayload(output, controls.outputOwnership ?? "transfer");
           }
         }
         completed = true;
       } catch (error) {
+        if (self2.workerChannel) {
+          self2.invalid = true;
+          self2.operationQueue.cancelPending(error);
+          self2.controller.abort(error);
+          await self2.workerChannel.destroy(error);
+        }
         if (self2.pool) {
           self2.invalid = true;
           await self2.pool.destroy(error);
@@ -13014,23 +13475,42 @@ var InitializedTask = class {
       } finally {
         if (self2.pool && !completed)
           self2.invalid = true;
+        if (self2.workerChannel && !completed && !self2.invalid) {
+          const reason = new Error("Worker stream ended before completion");
+          self2.invalid = true;
+          self2.operationQueue.cancelPending(reason);
+          self2.controller.abort(reason);
+          await self2.workerChannel.destroy(reason);
+        }
       }
-    });
+    }, (_a5 = args[0]) == null ? void 0 : _a5.signal);
+  }
+  /** Lifecycle status of this initialized task. */
+  get state() {
+    if (this.invalid)
+      return "invalid";
+    if (this.finalized)
+      return "closed";
+    return this.closed ? "closing" : "ready";
   }
   /** Drain accepted work, invoke destroy, and release execution capacity. */
   close() {
     if (!this.closing) {
       this.closed = true;
       this.closing = (async () => {
-        var _a5;
+        var _a5, _b2;
         try {
-          await this.tail;
+          await this.operationQueue.close();
           if (!this.invalid)
             await this.invoke("destroy", {}, {});
+          else if (!this.pool && !this.workerChannel)
+            await this.runtime.destroy();
         } finally {
           try {
             await ((_a5 = this.pool) == null ? void 0 : _a5.destroy());
+            await ((_b2 = this.workerChannel) == null ? void 0 : _b2.destroy());
           } finally {
+            this.finalized = true;
             this.release();
           }
         }
@@ -13040,7 +13520,12 @@ var InitializedTask = class {
   }
   /** Abort work. Local JavaScript must settle before its state can be destroyed. */
   async terminate(reason = new Error("Task terminated")) {
+    this.operationQueue.cancelPending(reason);
     this.controller.abort(reason);
+    if (this.workerChannel) {
+      this.invalid = true;
+      await this.workerChannel.destroy(reason);
+    }
     if (this.pool) {
       this.invalid = true;
       await this.pool.destroy(reason);
@@ -13050,7 +13535,7 @@ var InitializedTask = class {
   }
   checkCapability(kind) {
     var _a5;
-    if (this.pool ? !((_a5 = this.task.worker) == null ? void 0 : _a5.capabilities[kind]) : !(kind === "atomic" ? this.task.process : this.task.processInBatches)) {
+    if (this.pool || this.workerChannel ? !((_a5 = this.task.worker) == null ? void 0 : _a5.capabilities[kind]) : !(kind === "atomic" ? this.task.process : this.task.processInBatches)) {
       throw new Error(`Task has no ${kind} processor for this execution route`);
     }
   }
@@ -13074,7 +13559,7 @@ var InitializedTask = class {
     };
   }
   async invoke(operation, input, options, controls = {}) {
-    var _a5, _b2, _c2;
+    var _a5, _b2, _c2, _d2;
     if (this.invalid)
       throw new Error("Initialized task is invalid; initialize a new instance");
     const prepared = operation === "destroy" ? {} : this.controls(controls);
@@ -13082,6 +13567,38 @@ var InitializedTask = class {
     assertPayload(input);
     assertNoTransferAlias(input, options, prepared.inputOwnership);
     const copiedOptions = clonePayload(options);
+    if (this.workerChannel) {
+      const progressId = this.nextProgressId++;
+      const request = {
+        input: clonePayload(input, prepared.inputOwnership),
+        options: copiedOptions,
+        outputOwnership: prepared.outputOwnership ?? "transfer",
+        progressId
+      };
+      if (operation === "stream-open")
+        this.streamProgressId = progressId;
+      this.progressCallbacks.set(progressId, prepared.onProgress);
+      let callbackFailure;
+      try {
+        const result2 = await this.workerChannel.channel.request(operation, request, prepared.signal, getTransferList(request));
+        callbackFailure = this.callbackFailures.get(progressId) ?? (operation.startsWith("stream-") && this.streamProgressId !== void 0 ? this.callbackFailures.get(this.streamProgressId) : void 0);
+        if (callbackFailure)
+          throw callbackFailure.reason;
+        return result2;
+      } catch (reason) {
+        if (operation === "process" && !((_b2 = prepared.signal) == null ? void 0 : _b2.aborted) && (reason instanceof TaskRequestError || callbackFailure))
+          throw reason;
+        this.invalid = true;
+        this.operationQueue.cancelPending(reason);
+        this.controller.abort(reason);
+        await this.workerChannel.destroy(reason);
+        throw reason;
+      } finally {
+        this.progressCallbacks.delete(progressId);
+        if (this.streamProgressId !== progressId)
+          this.callbackFailures.delete(progressId);
+      }
+    }
     if (this.pool) {
       try {
         return await processOnWorker(this.descriptor, { operation, input: clonePayload(input, prepared.inputOwnership), options: copiedOptions }, this.workerOptions({ ...prepared, inputOwnership: "transfer" }));
@@ -13094,37 +13611,89 @@ var InitializedTask = class {
     if (operation === "destroy")
       return this.runtime.destroy();
     const copied = clonePayload(input, prepared.inputOwnership);
-    const context = localContext(prepared);
+    const context = this.runtimeContext(prepared);
     if (operation === "initialize") {
       const result2 = await this.runtime.initialize(copied, context);
-      (_b2 = prepared.signal) == null ? void 0 : _b2.throwIfAborted();
+      (_c2 = prepared.signal) == null ? void 0 : _c2.throwIfAborted();
       return result2;
     }
     const result = await this.runtime.process(copied, copiedOptions, context);
-    (_c2 = prepared.signal) == null ? void 0 : _c2.throwIfAborted();
+    (_d2 = prepared.signal) == null ? void 0 : _d2.throwIfAborted();
     return clonePayload(result, prepared.outputOwnership ?? "transfer");
   }
+  runtimeContext(prepared) {
+    return {
+      ...localContext(prepared),
+      requestHost: async (operation, payload, controls = {}) => {
+        const signal = prepared.signal ?? this.controller.signal;
+        signal.throwIfAborted();
+        const handler = this.initializationControls.onRequest;
+        if (!handler)
+          throw new Error("No host request handler configured");
+        const result = await handler(operation, clonePayload(payload, controls.inputOwnership), signal);
+        signal.throwIfAborted();
+        return structuredClone(result, {
+          transfer: controls.outputOwnership === "transfer" ? getTransferList(result) : []
+        });
+      },
+      emitHost: (operation, payload) => {
+        var _a5, _b2;
+        return (_b2 = (_a5 = this.initializationControls).onEvent) == null ? void 0 : _b2.call(_a5, operation, structuredClone(payload));
+      }
+    };
+  }
   enqueue(operation) {
     if (this.closed)
       return Promise.reject(new Error("Initialized task is closed"));
-    const result = this.tail.then(operation);
-    this.tail = result.catch(() => {
+    return this.operationQueue.run("exclusive", operation);
+  }
+  serialStream(operation, signal) {
+    const waiting = new AbortController();
+    const queueSignal = AbortSignal.any([waiting.signal, this.controller.signal, signal].filter((value) => Boolean(value)));
+    let started = false;
+    const iterator = this.acquireStream(operation, queueSignal, () => {
+      started = true;
     });
-    return result;
+    const cancelWaiting = () => {
+      if (!started)
+        waiting.abort(new Error("Stream returned before execution"));
+    };
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      next: () => iterator.next(),
+      return: async () => {
+        cancelWaiting();
+        return iterator.return(void 0);
+      },
+      throw: async (reason) => {
+        cancelWaiting();
+        return iterator.throw(reason);
+      }
+    };
   }
-  async *serialStream(operation) {
+  async *acquireStream(operation, signal, onStart) {
     if (this.closed)
       throw new Error("Initialized task is closed");
-    const before = this.tail;
+    let acquire;
+    const acquired = new Promise((resolve) => {
+      acquire = resolve;
+    });
     let release;
-    this.tail = new Promise((resolve) => {
+    const held = new Promise((resolve) => {
       release = resolve;
     });
-    await before;
-    if (this.controller.signal.aborted) {
+    const lease = this.operationQueue.run("exclusive", async () => {
+      acquire();
+      await held;
+    }, signal);
+    await Promise.race([acquired, lease]);
+    if (signal.aborted) {
       release();
-      throw this.controller.signal.reason;
+      throw signal.reason;
     }
+    onStart();
     const iterator = operation(this)[Symbol.asyncIterator]();
     let stopping;
     const stop = () => {
@@ -13449,22 +14018,6 @@ function assertNoTransferAlias(input, options, ownership) {
   }
 }
 
-// ../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() {
-  var _a5;
-  if (typeof self !== "undefined" && typeof document === "undefined" && typeof self.postMessage === "function")
-    return true;
-  if (typeof process !== "undefined" && ((_a5 = process.versions) == null ? void 0 : _a5.node)) {
-    const { isMainThread: isMainThread2 } = await Promise.resolve().then(() => (init_worker_threads(), worker_threads_exports));
-    return !isMainThread2;
-  }
-  return false;
-}
-var initializeTaskWorker2 = initializeTaskWorker;
-
 // ../core/src/worker-utils/lib/worker-api/get-worker-url.ts
 var warnedWorkerVersionFallbacks2 = /* @__PURE__ */ new Set();
 function getCustomWorkerURL2(worker, options = {}) {
@@ -13521,6 +14074,22 @@ function warnIfUsingNpmTagFallback2(worker, url) {
   );
 }
 
+// ../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() {
+  var _a5;
+  if (typeof self !== "undefined" && typeof document === "undefined" && typeof self.postMessage === "function")
+    return true;
+  if (typeof process !== "undefined" && ((_a5 = process.versions) == null ? void 0 : _a5.node)) {
+    const { isMainThread: isMainThread2 } = await Promise.resolve().then(() => (init_worker_threads(), worker_threads_exports));
+    return !isMainThread2;
+  }
+  return false;
+}
+var initializeTaskWorker2 = initializeTaskWorker;
+
 // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
 function getTransferList2(object2, recursive = true, transfers) {
   const transfersSet = transfers || /* @__PURE__ */ new Set();
@@ -28695,7 +29264,7 @@ function getLibraryCacheKey2(type, options) {
 }
 
 // src/draco/lib/utils/version.ts
-var VERSION3 = true ? "5.0.0-beta.4" : "latest";
+var VERSION3 = true ? "5.0.0-beta.5" : "latest";
 
 // src/draco/draco-format.ts
 var DracoFormat = {