@loaders.gl/core 5.0.0-alpha.13 → 5.0.0-alpha.14

package/dist/loader-utils/index.cjs

@@ -45,6 +45,7 @@ __export(index_exports, {
   bindColumnarPredicateParameters: () => bindColumnarPredicateParameters,
   canEncodeWithWorker: () => canEncodeWithWorker,
   canParseWithWorker: () => canParseWithWorker,
+  canParseWithWorkerInBatches: () => canParseWithWorkerInBatches,
   canReuseRasterCoverage: () => canReuseRasterCoverage,
   checkJSModule: () => checkJSModule,
   compareArrayBuffers: () => compareArrayBuffers,
@@ -242,7 +243,7 @@ var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
 // dist/loader-utils/lib/log-utils/log.js
 var import_log = require("probe.gl/log");
-var VERSION = true ? "5.0.0-alpha.13" : "latest";
+var VERSION = true ? "5.0.0-alpha.14" : "latest";
 var version = VERSION[0] >= "0" && VERSION[0] <= "9" ? `v${VERSION}` : "";
 function createLog() {
   const log2 = new import_log.Log({ id: "loaders.gl" });
@@ -424,6 +425,7 @@ var WorkerJob = class {
    * @param data any data structure, ideally consisting mostly of transferrable objects
    */
   postMessage(type, payload) {
+    if (!this.isRunning) return;
     this.workerThread.postMessage({
       source: "loaders.gl",
       // Lets worker ignore unrelated messages
@@ -459,9 +461,10 @@ var WorkerJob = class {
     if (!this.isRunning) {
       return;
     }
-    const error = reason ?? createAbortError(`Worker job "${this.name}" was aborted`);
     this.workerThread.destroy();
-    this.error(error);
+    this.error(
+      arguments.length ? reason : createAbortError(`Worker job "${this.name}" was aborted`)
+    );
   }
 };
 function createAbortError(message) {
@@ -767,9 +770,13 @@ var WorkerPool = class {
    * @note Can free up significant memory
    */
   destroy(reason = new Error("Worker pool was destroyed")) {
+    this.isDestroyed = true;
     this.activeJobs.forEach((job) => job.abort(reason));
     const queuedJobs = this.jobQueue.splice(0);
-    queuedJobs.forEach((queuedJob) => queuedJob.onReject(reason));
+    queuedJobs.forEach((queuedJob) => {
+      queuedJob.removeAbortListener();
+      queuedJob.onReject(reason);
+    });
     this.idleQueue.forEach((worker) => worker.destroy());
     this.isDestroyed = true;
   }
@@ -791,12 +798,33 @@ var WorkerPool = class {
       this.onDebug = props.onDebug;
     }
   }
-  async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+  async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error), signal) {
+    if (signal == null ? void 0 : signal.aborted) {
+      throw signal.reason;
+    }
     if (this.isDestroyed) {
       return Promise.reject(new Error("Worker pool was destroyed"));
     }
     const startPromise = new Promise((onStart, onReject) => {
-      this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart, onReject });
+      const abortQueuedJob = () => {
+        const index = this.jobQueue.indexOf(queuedJob);
+        if (index >= 0) {
+          this.jobQueue.splice(index, 1);
+          queuedJob.removeAbortListener();
+          onReject(signal == null ? void 0 : signal.reason);
+        }
+      };
+      const queuedJob = {
+        name,
+        onMessage: onMessage2,
+        onError,
+        onStart,
+        onReject,
+        signal,
+        removeAbortListener: () => signal == null ? void 0 : signal.removeEventListener("abort", abortQueuedJob)
+      };
+      this.jobQueue.push(queuedJob);
+      signal == null ? void 0 : signal.addEventListener("abort", abortQueuedJob, { once: true });
       return this;
     });
     this._startQueuedJob();
@@ -808,10 +836,20 @@ var WorkerPool = class {
    * Called when job is started and whenever a worker returns to the idleQueue
    */
   async _startQueuedJob() {
+    var _a, _b, _c;
     if (!this.jobQueue.length) {
       return;
     }
-    const workerThread = this._getAvailableWorker();
+    let workerThread;
+    try {
+      workerThread = this._getAvailableWorker();
+    } catch (error) {
+      const queuedJob2 = this.jobQueue.shift();
+      queuedJob2 == null ? void 0 : queuedJob2.removeAbortListener();
+      queuedJob2 == null ? void 0 : queuedJob2.onReject(error);
+      void this._startQueuedJob();
+      return;
+    }
     if (!workerThread) {
       return;
     }
@@ -824,18 +862,30 @@ var WorkerPool = class {
         backlog: this.jobQueue.length
       });
       const job = new WorkerJob(queuedJob.name, workerThread);
+      queuedJob.removeAbortListener();
+      const abortJob = () => {
+        var _a2;
+        return job.abort((_a2 = queuedJob.signal) == null ? void 0 : _a2.reason);
+      };
+      (_a = queuedJob.signal) == null ? void 0 : _a.addEventListener("abort", abortJob, { once: true });
+      if ((_b = queuedJob.signal) == null ? void 0 : _b.aborted) abortJob();
       this.activeJobs.add(job);
       workerThread.ref();
-      workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+      workerThread.onMessage = (data) => {
+        if (job.isRunning) queuedJob.onMessage(job, data.type, data.payload);
+      };
       workerThread.onError = (error) => queuedJob.onError(job, error);
       queuedJob.onStart(job);
       try {
         await job.result;
       } catch {
       } finally {
+        (_c = queuedJob.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
         this.activeJobs.delete(job);
         this.returnWorkerToQueue(workerThread);
       }
+    } else {
+      this.returnWorkerToQueue(workerThread);
     }
   }
   /**
@@ -877,13 +927,18 @@ var WorkerPool = class {
     if (this.count < this._getMaxConcurrency()) {
       this.count++;
       const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-      return new WorkerThread({
-        name,
-        source: this.source,
-        url: this.url,
-        getUrl: this.getUrl,
-        loadWorker: this.loadWorker
-      });
+      try {
+        return new WorkerThread({
+          name,
+          source: this.source,
+          url: this.url,
+          getUrl: this.getUrl,
+          loadWorker: this.loadWorker
+        });
+      } catch (error) {
+        this.count--;
+        throw error;
+      }
     }
     return null;
   }
@@ -1160,12 +1215,8 @@ function getWorkerName(worker) {
 }
 function getCustomWorkerURL(worker, options = {}) {
   var _a, _b;
-  const workerOptions = options[worker.id] || {};
   const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
-  let url = workerOptions.workerUrl;
-  if (!url && worker.id === "compression") {
-    url = options.workerUrl;
-  }
+  let url = getConfiguredWorkerURL(worker, options);
   const workerType = options._workerType || ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._workerType);
   if (!url && workerType === "test") {
     if (isBrowser2) {
@@ -1178,6 +1229,10 @@ function getCustomWorkerURL(worker, options = {}) {
   }
   return url || null;
 }
+function getConfiguredWorkerURL(worker, options = {}) {
+  const workerOptions = options[worker.id] || {};
+  return workerOptions.workerUrl || (worker.id === "compression" ? options.workerUrl : null) || null;
+}
 function getWorkerURL(worker, options = {}) {
   const customWorkerUrl = getCustomWorkerURL(worker, options);
   const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
@@ -1222,8 +1277,15 @@ function canProcessOnWorker(worker, options) {
     (worker.worker || worker.loadWorker || (workerOptions == null ? void 0 : workerOptions.workerUrl)) && (options == null ? void 0 : options.worker)
   );
 }
+function canProcessOnWorkerInBatches(worker, options = {}) {
+  if (!canProcessOnWorker(worker, options)) return false;
+  if (options.workerInBatches !== void 0) return options.workerInBatches;
+  return Boolean(
+    worker.workerInBatches && !options.source && !getConfiguredWorkerURL(worker, options)
+  );
+}
 async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
-  var _a, _b, _c;
+  var _a;
   throwIfAborted(options.signal);
   const name = getWorkerName(worker);
   const workerFarm = WorkerFarm.getWorkerFarm(options);
@@ -1232,15 +1294,13 @@ async function processOnWorker(worker, data, options = {}, context = {}, jobCont
   const job = await workerPool.startJob(
     jobName,
     // eslint-disable-next-line
-    onMessage.bind(null, context)
+    onMessage.bind(null, context, options),
+    void 0,
+    options.signal
   );
-  const abortJob = () => job.abort(getAbortReason(options.signal));
-  (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", abortJob, { once: true });
-  if ((_b = options.signal) == null ? void 0 : _b.aborted) {
-    abortJob();
-  }
   try {
-    const { signal: _signal, ...workerOptions } = options;
+    if ((_a = options.signal) == null ? void 0 : _a.aborted) job.abort(getAbortReason(options.signal));
+    const { signal: _signal, onProgress: _onProgress, ...workerOptions } = options;
     const transferableOptions = getTransferListForWriter(workerOptions);
     const transferableContext = getTransferListForWriter(jobContext);
     if (job.isRunning) {
@@ -1252,15 +1312,15 @@ async function processOnWorker(worker, data, options = {}, context = {}, jobCont
     }
     const result = await job.result;
     return result.result;
-  } finally {
-    (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
+  } catch (error) {
+    job.abort(error);
+    throw error;
   }
 }
 function processOnWorkerInBatches(worker, input, options = {}, context = {}, jobContext = {}) {
   return processOnWorkerInBatchesIterator(worker, input, options, context, jobContext);
 }
 async function* processOnWorkerInBatchesIterator(worker, input, options, context, jobContext) {
-  var _a, _b, _c;
   throwIfAborted(options.signal);
   const name = getWorkerName(worker);
   const workerFarm = WorkerFarm.getWorkerFarm(options);
@@ -1269,8 +1329,15 @@ async function* processOnWorkerInBatchesIterator(worker, input, options, context
   const inputIterator = getAsyncIterator(input);
   let outputFinished = false;
   let inputFinished = false;
+  let inputCleanupRequested = false;
   let inputRequest = Promise.resolve();
   const batchJobFailed = new Error("Worker batch job failed");
+  const closeJobInput = () => {
+    if (!inputFinished && !inputCleanupRequested) {
+      inputCleanupRequested = true;
+      closeInputIterator(inputIterator);
+    }
+  };
   const finishOutput = () => {
     if (!outputFinished) {
       outputFinished = true;
@@ -1288,8 +1355,12 @@ async function* processOnWorkerInBatchesIterator(worker, input, options, context
     options.jobName || worker.name,
     (activeJob, type, payload) => {
       switch (type) {
+        case "progress":
+          reportProgress(activeJob, options, payload);
+          break;
         case "input-request":
           inputRequest = inputRequest.then(async () => {
+            if (!activeJob.isRunning) return;
             const nextBatch = await inputIterator.next();
             if (!activeJob.isRunning) {
               return;
@@ -1316,7 +1387,7 @@ async function* processOnWorkerInBatchesIterator(worker, input, options, context
           break;
         }
         case "process":
-          void onMessage(context, activeJob, type, payload);
+          void onMessage(context, options, activeJob, type, payload);
           break;
         default: {
           const error = new Error(`Unexpected worker batch message: ${type}`);
@@ -1325,16 +1396,19 @@ async function* processOnWorkerInBatchesIterator(worker, input, options, context
           break;
         }
       }
-    }
-  );
-  const abortJob = () => job.abort(getAbortReason(options.signal));
-  (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", abortJob, { once: true });
-  if ((_b = options.signal) == null ? void 0 : _b.aborted) {
-    abortJob();
-  }
-  void job.result.catch(failOutput);
+    },
+    void 0,
+    options.signal
+  ).catch((error) => {
+    closeJobInput();
+    throw error;
+  });
+  void job.result.catch((error) => {
+    failOutput(error);
+    closeJobInput();
+  });
   try {
-    const { signal: _signal, ...workerOptions } = options;
+    const { signal: _signal, onProgress: _onProgress, ...workerOptions } = options;
     if (job.isRunning) {
       job.postMessage("process-in-batches", {
         options: getTransferListForWriter(workerOptions),
@@ -1356,13 +1430,10 @@ async function* processOnWorkerInBatchesIterator(worker, input, options, context
     }
     await job.result;
   } finally {
-    (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
     if (job.isRunning) {
       job.abort(createAbortError2("Worker batch iterator was closed"));
     }
-    if (!inputFinished) {
-      closeInputIterator(inputIterator);
-    }
+    closeJobInput();
   }
 }
 function throwIfAborted(signal) {
@@ -1372,7 +1443,7 @@ function throwIfAborted(signal) {
   throw getAbortReason(signal);
 }
 function getAbortReason(signal) {
-  return (signal == null ? void 0 : signal.reason) ?? createAbortError2("Worker job was aborted");
+  return signal ? signal.reason : createAbortError2("Worker job was aborted");
 }
 function createAbortError2(message) {
   const error = new Error(message);
@@ -1412,8 +1483,11 @@ function getWorkerPoolTarget(worker, options, name) {
   }
   return { name, url: getWorkerURL(worker, options) };
 }
-async function onMessage(context, job, type, payload) {
+async function onMessage(context, options, job, type, payload) {
   switch (type) {
+    case "progress":
+      reportProgress(job, options, payload);
+      break;
     case "done":
       job.done(payload);
       break;
@@ -1421,13 +1495,18 @@ async function onMessage(context, job, type, payload) {
       job.error(new Error(payload.error));
       break;
     case "process":
-      const { id, input, options } = payload;
+      const { id, input, options: processOptions } = payload;
       try {
         if (!context.process) {
           job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
           return;
         }
-        const result = await context.process(input, options, void 0, payload.context || {});
+        const result = await context.process(
+          input,
+          { ...processOptions, signal: options.signal, onProgress: options.onProgress },
+          void 0,
+          payload.context || {}
+        );
         job.postMessage("done", { id, result });
       } catch (error) {
         const message = error instanceof Error ? error.message : "unknown error";
@@ -1438,6 +1517,15 @@ async function onMessage(context, job, type, payload) {
       console.warn(`process-on-worker: unknown message ${type}`);
   }
 }
+function reportProgress(job, options, payload) {
+  var _a;
+  if (!job.isRunning || !payload.progress) return;
+  try {
+    (_a = options.onProgress) == null ? void 0 : _a.call(options, payload.progress);
+  } catch (error) {
+    job.abort(error);
+  }
+}
 
 // src/worker-utils/lib/worker-api/create-worker.ts
 var requestId = 0;
@@ -1451,6 +1539,8 @@ async function createWorker(process2, processInBatches) {
     process: processOnMainThread
   };
   WorkerBody.onmessage = async (type, payload) => {
+    const reporter = type === "process" || type === "process-in-batches" ? createProgressReporter() : void 0;
+    const jobContext = { ...context, reportProgress: reporter == null ? void 0 : reporter.report };
     try {
       switch (type) {
         case "preload":
@@ -1463,9 +1553,10 @@ async function createWorker(process2, processInBatches) {
           const result = await process2(
             payload.input,
             payload.options || {},
-            context,
+            jobContext,
             payload.context || {}
           );
+          reporter == null ? void 0 : reporter.finish();
           WorkerBody.postMessage("done", { result });
           break;
         case "process-in-batches":
@@ -1480,13 +1571,14 @@ async function createWorker(process2, processInBatches) {
             const resultIterator = processInBatches(
               createDemandDrivenIterator(inputBatches),
               payload.options || {},
-              context,
+              jobContext,
               payload.context || {}
             );
             for await (const batch of resultIterator) {
               await WorkerBody.postMessage("output-batch", { result: batch });
               await outputAcknowledgements.next();
             }
+            reporter == null ? void 0 : reporter.finish();
             await WorkerBody.postMessage("done", {});
           } finally {
             activeInputBatches = null;
@@ -1514,6 +1606,7 @@ async function createWorker(process2, processInBatches) {
         default:
       }
     } catch (error) {
+      reporter == null ? void 0 : reporter.finish();
       const message = error instanceof Error ? error.message : "";
       WorkerBody.postMessage("error", { error: message });
     }
@@ -1553,6 +1646,35 @@ function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
     WorkerBody.postMessage("process", payload);
   });
 }
+function createProgressReporter() {
+  let pending;
+  let finished = false;
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    if (pending) {
+      WorkerBody.postMessage("progress", { progress: pending });
+      pending = void 0;
+    }
+  };
+  return {
+    /** Records progress while retaining phase transitions. */
+    report(progress) {
+      if (finished) return;
+      if (pending && pending.phase !== progress.phase) flush();
+      pending = { ...progress };
+      if (!scheduled) {
+        scheduled = true;
+        setTimeout(flush, 0);
+      }
+    },
+    /** Flushes final progress and suppresses reports from stale callbacks. */
+    finish() {
+      flush();
+      finished = true;
+    }
+  };
+}
 
 // dist/loader-utils/lib/worker-loader-utils/create-loader-worker.js
 async function createLoaderWorker(loader, selectLoader = () => loader) {
@@ -1565,6 +1687,7 @@ async function processLoaderWorkerData(loader, input, options = {}, workerContex
     options,
     context: {
       ...loaderContext,
+      reportProgress: workerContext == null ? void 0 : workerContext.reportProgress,
       coreApi: createWorkerCoreApi(),
       _parse: createParseOnMainThread(workerContext == null ? void 0 : workerContext.process)
     }
@@ -1575,8 +1698,10 @@ async function* processLoaderWorkerBatches(loader, inputIterator, options = {},
   if (!loader.parseInBatches) {
     throw new Error(`${loader.id} loader does not support batched parsing`);
   }
-  const resultIterator = loader.parseInBatches(inputIterator, options, {
+  const parserOptions = getWorkerLoaderOptions(loader, options);
+  const resultIterator = loader.parseInBatches(inputIterator, parserOptions, {
     ...loaderContext,
+    reportProgress: workerContext == null ? void 0 : workerContext.reportProgress,
     coreApi: createWorkerCoreApi(),
     _parse: createParseOnMainThread(workerContext == null ? void 0 : workerContext.process)
   });
@@ -1632,7 +1757,7 @@ function getSerializableLoaderContext(context) {
   if (!context) {
     return void 0;
   }
-  const { fetch: fetch2, loaders, coreApi, _parse, _parseSync, _parseInBatches, ...serializableContext } = context;
+  const { fetch: fetch2, loaders, coreApi, signal, reportProgress: reportProgress2, _parse, _parseSync, _parseInBatches, ...serializableContext } = context;
   return JSON.parse(JSON.stringify(serializableContext));
 }
 async function parseData({ loader, arrayBuffer, options, context }) {
@@ -1648,18 +1773,16 @@ async function parseData({ loader, arrayBuffer, options, context }) {
   } else {
     throw new Error(`Could not load data with ${loader.name} loader`);
   }
-  options = {
+  options = getWorkerLoaderOptions(loader, options);
+  return await parser(data, { ...options }, context, loader);
+}
+function getWorkerLoaderOptions(loader, options) {
+  var _a;
+  return {
     ...options,
-    modules: {
-      ...loader && loader.options && loader.options.modules || {},
-      ...options.modules || {}
-    },
-    core: {
-      ...options.core,
-      worker: false
-    }
+    modules: { ...(_a = loader.options) == null ? void 0 : _a.modules, ...options.modules },
+    core: { ...options.core, worker: false }
   };
-  return await parser(data, { ...options }, context, loader);
 }
 
 // dist/loader-utils/lib/worker-loader-utils/parse-with-worker.js
@@ -1683,6 +1806,13 @@ function canParseWithWorker(loader, options) {
   }
   return Boolean(canProcessOnWorker(loader, workerOptions));
 }
+function canParseWithWorkerInBatches(loader, options) {
+  const parquetOptions = options == null ? void 0 : options.parquet;
+  if (loader.id === "parquet" && typeof (parquetOptions == null ? void 0 : parquetOptions.keyRetriever) === "function") {
+    return false;
+  }
+  return Boolean(loader.workerInBatches && canParseWithWorker(loader, options) && canProcessOnWorkerInBatches(loader, getWorkerOptions(options)));
+}
 function shouldParseWithWorker(loader, data, options, context, estimateLoader = loader) {
   var _a, _b;
   if (!canParseWithWorker(loader, options)) {
@@ -1702,8 +1832,12 @@ function shouldParseWithWorker(loader, data, options, context, estimateLoader =
   }
 }
 async function parseWithWorker(loader, data, options, context, parseOnMainThread, signal) {
-  const workerSignal = signal || getWorkerAbortSignal(options);
-  const result = await processOnWorker(loader, data, { ...getWorkerOptions(options, loader), signal: workerSignal }, {
+  const workerSignal = signal || getWorkerAbortSignal(options) || (context == null ? void 0 : context.signal);
+  const result = await processOnWorker(loader, data, {
+    ...getWorkerOptions(options, loader),
+    signal: workerSignal,
+    onProgress: (options == null ? void 0 : options.onProgress) || (context == null ? void 0 : context.reportProgress)
+  }, {
     process: async (input, processOptions, _workerContext, parseContext) => {
       if (!parseOnMainThread) {
         throw new Error("Worker not set up to parse on main thread");
@@ -1716,8 +1850,12 @@ async function parseWithWorker(loader, data, options, context, parseOnMainThread
   return isLoaderWithWorkerResultDeserializer(loader) ? loader.deserializeWorkerResult(result, options, context) : result;
 }
 async function* parseWithWorkerInBatches(loader, inputIterator, options, context, parseOnMainThread, signal) {
-  const workerSignal = signal || getWorkerAbortSignal(options);
-  const outputIterator = processOnWorkerInBatches(loader, inputIterator, { ...getWorkerOptions(options), signal: workerSignal }, {
+  const workerSignal = signal || getWorkerAbortSignal(options) || (context == null ? void 0 : context.signal);
+  const outputIterator = processOnWorkerInBatches(loader, inputIterator, {
+    ...getWorkerOptions(options, loader),
+    signal: workerSignal,
+    onProgress: (options == null ? void 0 : options.onProgress) || (context == null ? void 0 : context.reportProgress)
+  }, {
     process: async (input, processOptions, _workerContext, parseContext) => {
       if (!parseOnMainThread) {
         throw new Error("Worker not set up to parse on main thread");
@@ -1733,6 +1871,8 @@ async function* parseWithWorkerInBatches(loader, inputIterator, options, context
 }
 function getWorkerAbortSignal(options) {
   var _a;
+  if (options == null ? void 0 : options.signal)
+    return options.signal;
   const parquetSignal = (_a = options == null ? void 0 : options.parquet) == null ? void 0 : _a.signal;
   if (typeof AbortSignal !== "undefined" && parquetSignal instanceof AbortSignal) {
     return parquetSignal;
@@ -1777,9 +1917,15 @@ function resolveWorkerLoaders(loader, loaderIds, loaderIsArray, context, options
 function getWorkerOptions(options = {}, loader) {
   const optionsToSerialize = {
     ...options,
+    signal: void 0,
+    onProgress: void 0,
     ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
   };
-  const serializedOptions = JSON.parse(JSON.stringify(optionsToSerialize, (_key, value) => typeof value === "bigint" ? null : value));
+  const serializedOptions = JSON.parse(JSON.stringify(optionsToSerialize, (_key, value) => {
+    if (typeof AbortSignal !== "undefined" && value instanceof AbortSignal)
+      return void 0;
+    return typeof value === "bigint" ? null : value;
+  }));
   restoreBigIntOptions(optionsToSerialize, serializedOptions);
   const workerOptions = {
     ...serializedOptions.core,
@@ -1808,7 +1954,7 @@ function getSerializableLoaderContext2(context) {
   if (!context) {
     return {};
   }
-  const { fetch: fetch2, loaders, coreApi, _parse, _parseSync, _parseInBatches, ...serializableContext } = context;
+  const { fetch: fetch2, loaders, coreApi, signal, reportProgress: reportProgress2, _parse, _parseSync, _parseInBatches, ...serializableContext } = context;
   return JSON.parse(JSON.stringify(serializableContext));
 }
 function shouldParseCSVWithWorker(options) {
@@ -2894,8 +3040,7 @@ function createAuthenticatedFetch(options) {
   const authenticatedFetch = async (url, requestOptions = {}) => {
     var _a, _b, _c, _d, _e, _f, _g;
     requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
-    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted)
-      throw createAbortError4();
+    (_a = requestOptions.signal) == null ? void 0 : _a.throwIfAborted();
     if (!credentials.length)
       return baseFetch(url, requestOptions);
     const resolvedURL = parseHTTPURL(url);
@@ -2914,8 +3059,7 @@ function createAuthenticatedFetch(options) {
     });
     if (!refreshableCredentials.length && !shouldRetrySignature)
       return response;
-    if ((_e = requestOptions.signal) == null ? void 0 : _e.aborted)
-      throw createAbortError4();
+    (_e = requestOptions.signal) == null ? void 0 : _e.throwIfAborted();
     const refreshedTokens = /* @__PURE__ */ new Map();
     await Promise.all(refreshableCredentials.map(async ({ credential }) => {
       const token = await refreshCredential(credential, url, response);
@@ -2926,8 +3070,7 @@ function createAuthenticatedFetch(options) {
       return response;
     await ((_f = response.body) == null ? void 0 : _f.cancel().catch(() => {
     }));
-    if ((_g = requestOptions.signal) == null ? void 0 : _g.aborted)
-      throw createAbortError4();
+    (_g = requestOptions.signal) == null ? void 0 : _g.throwIfAborted();
     const replayAuthorization = resolvedURL ? await authorizeRequest(resolvedURL, requestOptions, tokenCredentials, refreshedTokens, authorization.credentials) : { url, options: requestOptions };
     const replayRequest = await authenticateRequest(replayAuthorization, requestCredentials, "retry", response);
     return baseFetch(replayRequest.url, replayRequest.options);
@@ -2951,9 +3094,10 @@ function getAuthenticatedFetch(options = {}) {
   } else {
     fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
   }
+  const fetchOptions = typeof fetchOption === "object" && fetchOption ? fetchOption : void 0;
   return createAuthenticatedFetch({
     fetch: fetchFunction,
-    fetchOptions: typeof fetchOption === "object" && fetchOption ? fetchOption : void 0,
+    fetchOptions: options.signal ? { ...fetchOptions, signal: options.signal } : fetchOptions,
     credentials: ((_b = options.core) == null ? void 0 : _b.credentials) || [],
     authentications: (_c = options.core) == null ? void 0 : _c.authentications
   });
@@ -2990,8 +3134,7 @@ async function authenticateRequest(request, credentials, reason, response) {
     const origin = getRequestOrigin(request.url);
     if (!origin || !normalizeRequestOrigins(credential.origins).includes(origin))
       continue;
-    if (signal == null ? void 0 : signal.aborted)
-      throw createAbortError4();
+    signal == null ? void 0 : signal.throwIfAborted();
     const authenticatedRequest = await credential.authenticate({
       url: request.url,
       options: { ...request.options, headers: new Headers(request.options.headers) },
@@ -3007,8 +3150,7 @@ async function authenticateRequest(request, credentials, reason, response) {
     };
     appliedCredentials.push(credential);
   }
-  if (signal == null ? void 0 : signal.aborted)
-    throw createAbortError4();
+  signal == null ? void 0 : signal.throwIfAborted();
   return { ...request, credentials: appliedCredentials };
 }
 function getRequestOrigin(url) {
@@ -3110,9 +3252,6 @@ function isReplayableRequest(options) {
     return false;
   return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
 }
-function createAbortError4() {
-  return new DOMException("The operation was aborted.", "AbortError");
-}
 
 // dist/loader-utils/lib/request-utils/range-request-scheduler.js
 var import_stats2 = require("probe.gl/stats");
@@ -3209,7 +3348,7 @@ var RangeRequestScheduler = class {
       return Promise.reject(new Error("Byte range length cannot be negative"));
     }
     if ((_a = request.signal) == null ? void 0 : _a.aborted) {
-      return Promise.reject(request.signal.reason ?? createAbortError5());
+      return Promise.reject(request.signal.reason ?? createAbortError4());
     }
     if (request.length === 0) {
       return Promise.resolve(new ArrayBuffer(0));
@@ -3474,7 +3613,7 @@ var RangeRequestScheduler = class {
       }
     }
     this.transportQueue = this.transportQueue.filter((group) => group.requests.length > 0);
-    request.reject(((_a = request.signal) == null ? void 0 : _a.reason) ?? createAbortError5());
+    request.reject(((_a = request.signal) == null ? void 0 : _a.reason) ?? createAbortError4());
     this.trackEvent({
       type: "abort",
       sourceId: request.sourceId,
@@ -3705,7 +3844,7 @@ function getTimestamp() {
   var _a;
   return ((_a = globalThis.performance) == null ? void 0 : _a.now()) ?? Date.now();
 }
-function createAbortError5() {
+function createAbortError4() {
   if (typeof DOMException !== "undefined") {
     return new DOMException("Request aborted", "AbortError");
   }
@@ -3787,7 +3926,7 @@ var RangeRequestCache = class {
     (_a = this.onEvent) == null ? void 0 : _a.call(this, { type: "miss", sourceId, offset, length });
     if (this.cache.maxEntries === 0 || length > this.cache.maxBytes) {
       if (signal == null ? void 0 : signal.aborted) {
-        throw createAbortError6();
+        throw createAbortError5();
       }
       const arrayBuffer = await fetchRange(offset, length, signal || new AbortController().signal);
       validateResponseLength(arrayBuffer, length);
@@ -3898,7 +4037,7 @@ function validateResponseLength(arrayBuffer, expectedLength) {
     throw new Error(`Range request returned ${arrayBuffer.byteLength} bytes; expected ${expectedLength}`);
   }
 }
-function createAbortError6() {
+function createAbortError5() {
   const error = new Error("Request aborted");
   error.name = "AbortError";
   return error;
@@ -9797,7 +9936,7 @@ var CachedUriResolver = class {
 };
 
 // dist/loader-utils/json-loader.js
-var VERSION3 = true ? "5.0.0-alpha.13" : "latest";
+var VERSION3 = true ? "5.0.0-alpha.14" : "latest";
 var JSONLoader = {
   dataType: null,
   batchType: null,
@@ -10315,7 +10454,7 @@ var HttpFile = class _HttpFile {
   async open(signal) {
     this.assertOpen();
     if (signal == null ? void 0 : signal.aborted) {
-      const error = createAbortError7();
+      const error = createAbortError6();
       this.transport.trackFailure(error);
       throw error;
     }
@@ -10357,7 +10496,7 @@ var HttpFile = class _HttpFile {
   async read(offset = 0, length = 0, signal) {
     this.assertOpen();
     if (signal == null ? void 0 : signal.aborted) {
-      const error = createAbortError7();
+      const error = createAbortError6();
       this.transport.trackFailure(error);
       throw error;
     }
@@ -10465,7 +10604,7 @@ function validateRange2(offset, length, byteLength) {
     throw new Error("HTTP byte range extends beyond the end of the file");
   }
 }
-function createAbortError7() {
+function createAbortError6() {
   if (typeof DOMException !== "undefined") {
     return new DOMException("Request aborted", "AbortError");
   }