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

package/dist/draco-writer-worker.js

@@ -50,7 +50,7 @@
 
   // ../core/src/worker-utils/lib/env-utils/version.ts
   function getVersion() {
-    const version = false ? NPM_TAG : "5.0.0-beta.4";
+    const version = false ? NPM_TAG : "5.0.0-beta.5";
     globalThis._loadersgl_ = globalThis._loadersgl_ || {};
     globalThis._loadersgl_.version ||= version;
     return version;
@@ -84,23 +84,23 @@
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = 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,
@@ -119,7 +119,7 @@
   var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion2 = 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;
@@ -236,7 +236,7 @@
     return error;
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js
   var NodeWorker = class {
     /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
     constructor(...arguments_) {
@@ -252,7 +252,7 @@
   };
   var parentPort = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort ?? null;
 
-  // ../../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) {
     assert2(props.source && !props.url || !props.source && props.url);
@@ -301,7 +301,7 @@
 }`;
   }
 
-  // ../../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(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
@@ -385,7 +385,7 @@
     return object === null ? {} : clone(object);
   }
 
-  // ../../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 {
@@ -566,7 +566,7 @@
     }
   };
 
-  // ../../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() {
@@ -1092,7 +1092,7 @@
     }
   };
 
-  // ../../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,
@@ -1213,7 +1213,7 @@
     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;
   }
@@ -1300,7 +1300,7 @@
     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 = [];
@@ -1367,7 +1367,7 @@
     }
   };
 
-  // ../../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})` : "";
@@ -1381,7 +1381,7 @@
       if (isBrowser2) {
         url = `modules/${worker.module}/dist/${workerFile}`;
       } else {
-        const workerSourceDirectory = worker.module === "core" && worker.workerNode?.startsWith("worker-utils/") ? "worker-utils/workers" : "workers";
+        const workerSourceDirectory = worker.module === "tasks" && worker.workerNode?.startsWith("worker-utils/") ? "worker-utils/workers" : "workers";
         const workerSourceNode = worker.workerSourceNode || `${workerSourceDirectory}/${worker.id}-worker-node.ts`;
         url = `modules/${worker.module}/src/${workerSourceNode}`;
       }
@@ -1425,7 +1425,7 @@
     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 = {
@@ -1508,7 +1508,7 @@
     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;
@@ -1537,14 +1537,14 @@
     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 = {}) {
     validateOutputOwnership(options.outputOwnership);
     if (options.inputOwnership !== void 0 && !["copy", "transfer", "share"].includes(options.inputOwnership))
@@ -1838,7 +1838,7 @@
     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;
@@ -2046,12 +2046,12 @@
     };
   }
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+  // ../../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/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) {
@@ -2091,7 +2091,151 @@
     });
   }
 
-  // ../../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?.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");
@@ -2113,6 +2257,16 @@
     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?.();
@@ -2177,6 +2331,69 @@
       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) {
@@ -2214,7 +2431,7 @@
     };
   }
 
-  // ../../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 = {}) {
     if (!isTaskCodeLoaded(task))
       throw new Error("Preload task on the main thread before runTaskSync");
@@ -2294,18 +2511,155 @@
     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?.aborted)
+        return Promise.reject(signal.reason);
+      return new Promise((resolve, reject) => {
+        const onAbort = () => {
+          const index = this.pending.indexOf(entry);
+          if (index >= 0) {
+            this.pending.splice(index, 1);
+            entry.cancel(signal?.reason);
+            this.pump();
+          }
+        };
+        const entry = {
+          mode,
+          cancel: (reason) => {
+            signal?.removeEventListener("abort", onAbort);
+            reject(reason);
+          },
+          start: () => {
+            signal?.removeEventListener("abort", onAbort);
+            this.active++;
+            if (mode === "exclusive")
+              this.exclusive = true;
+            void Promise.resolve().then(() => {
+              signal?.throwIfAborted();
+              return operation();
+            }).then(resolve, reject).finally(() => {
+              this.active--;
+              if (mode === "exclusive")
+                this.exclusive = false;
+              this.pump();
+            });
+          }
+        };
+        this.pending.push(entry);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (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) {
+      this.thread = new WorkerThread({
+        name,
+        url: target.url?.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?.type === "task-channel")
+          this.channel.receive(message.payload);
+      };
+      this.thread.onError = (reason) => {
+        this.channel.close(reason);
+        options.onFailure?.(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) {
+    constructor(task, release, initializationControls) {
       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 concurrency = controls.operationConcurrency ?? 1;
+      const maximum = task.concurrency?.maxConcurrency ?? 1;
+      if (!Number.isSafeInteger(maximum) || maximum < 1 || !Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > maximum) {
+        throw new RangeError("Task concurrency must be between 1 and the task maximum");
+      }
+      this.operationQueue = new TaskOperationQueue(concurrency);
+      this.concurrent = concurrency > 1;
       const execution = controls.execution ?? "auto";
       if (!["auto", "main-thread", "worker"].includes(execution))
         throw new TypeError("Invalid execution mode");
@@ -2315,6 +2669,47 @@
         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) => {
+              const { id } = payload;
+              try {
+                if (operation === "task:progress") {
+                  const event = payload;
+                  (this.progressCallbacks.get(event.id) ?? this.streamProgress)?.(event.progress);
+                } else if (operation === "task:host-event") {
+                  const event = payload;
+                  controls.onEvent?.(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: target.url?.toString(),
@@ -2326,7 +2721,7 @@
         this.descriptor = {
           id: task.id,
           name: task.id,
-          module: "core",
+          module: "tasks",
           version: "prototype",
           options: {},
           worker: target.url?.toString() ?? true,
@@ -2346,23 +2741,48 @@
       }
     }
     runTask(input, ...args) {
-      return this.enqueue(async () => {
+      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 timeout = args[0]?.timeout;
+      if (timeout !== void 0 && (!Number.isSafeInteger(timeout) || timeout < 0 || timeout > 4294967295)) {
+        return Promise.reject(new RangeError("Invalid task timeout"));
+      }
+      const deadline = timeout === void 0 ? void 0 : AbortSignal.timeout(timeout);
+      const signal = deadline && args[0]?.signal ? AbortSignal.any([deadline, args[0].signal]) : deadline ?? args[0]?.signal;
+      const controls = { ...args[0], signal };
+      const mode = this.task.concurrency?.getSchedulingMode?.(input) ?? "exclusive";
+      return this.operationQueue.run(mode, async () => {
+        signal?.throwIfAborted();
         this.checkCapability("atomic");
-        return this.invoke("process", input, args[0]?.options ?? {}, args[0]);
-      });
+        const invalidate = () => {
+          if (this.concurrent) {
+            this.invalid = true;
+            this.operationQueue.cancelPending(signal?.reason);
+            this.controller.abort(signal?.reason);
+          }
+        };
+        signal?.addEventListener("abort", invalidate, { once: true });
+        try {
+          return await this.invoke("process", input, args[0]?.options ?? {}, controls);
+        } finally {
+          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) {
+    runTasks(inputs, ...args) {
+      return this.serialStream(async function* (self2) {
         self2.checkCapability("atomic");
         for await (const input of asAsync(inputs, self2.controls(args[0]).signal)) {
           yield await self2.invoke("process", input, args[0]?.options ?? {}, args[0]);
         }
-      });
+      }, args[0]?.signal);
     }
     /** One processor invocation for the entire input iterable. */
-    async *runTaskInBatches(inputs, ...args) {
-      yield* this.serialStream(async function* (self2) {
+    runTaskInBatches(inputs, ...args) {
+      return this.serialStream(async function* (self2) {
         self2.checkCapability("streaming");
         const controls = self2.controls(args[0]);
         const options = clonePayload(args[0]?.options ?? {});
@@ -2375,7 +2795,31 @@
         }
         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 self2.channelInputs.return?.();
+                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),
@@ -2383,13 +2827,19 @@
               workerInBatches: true
             });
           } else {
-            for await (const output of self2.runtime.stream(prepared(), options, localContext(controls))) {
+            for await (const output of self2.runtime.stream(prepared(), options, self2.runtimeContext(controls))) {
               controls.signal?.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);
@@ -2398,8 +2848,23 @@
         } 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);
+          }
         }
-      });
+      }, args[0]?.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() {
@@ -2407,13 +2872,17 @@
         this.closed = true;
         this.closing = (async () => {
           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 this.pool?.destroy();
+              await this.workerChannel?.destroy();
             } finally {
+              this.finalized = true;
               this.release();
             }
           }
@@ -2423,7 +2892,12 @@
     }
     /** 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);
@@ -2432,7 +2906,7 @@
       await this.close();
     }
     checkCapability(kind) {
-      if (this.pool ? !this.task.worker?.capabilities[kind] : !(kind === "atomic" ? this.task.process : this.task.processInBatches)) {
+      if (this.pool || this.workerChannel ? !this.task.worker?.capabilities[kind] : !(kind === "atomic" ? this.task.process : this.task.processInBatches)) {
         throw new Error(`Task has no ${kind} processor for this execution route`);
       }
     }
@@ -2463,6 +2937,38 @@
       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" && !prepared.signal?.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" }));
@@ -2475,7 +2981,7 @@
       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);
         prepared.signal?.throwIfAborted();
@@ -2485,27 +2991,76 @@
       prepared.signal?.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) => this.initializationControls.onEvent?.(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 = () => {
@@ -2821,21 +3376,6 @@
     }
   }
 
-  // ../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-api/get-worker-url.ts
   var warnedWorkerVersionFallbacks2 = /* @__PURE__ */ new Set();
   function getCustomWorkerURL2(worker, options = {}) {
@@ -2891,6 +3431,21 @@
     );
   }
 
+  // ../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();
@@ -18476,7 +19031,7 @@ return true;`);
   }
 
   // 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 = {