@loaders.gl/scan 5.0.0-alpha.6 → 5.0.0-alpha.8

package/dist/delta.cjs

@@ -593,6 +593,7 @@ var init_worker_pool = __esm({
       props = {};
       jobQueue = [];
       idleQueue = [];
+      activeJobs = /* @__PURE__ */ new Set();
       count = 0;
       isDestroyed = false;
       /** Checks if workers are supported on this platform */
@@ -611,10 +612,14 @@ var init_worker_pool = __esm({
         this.setProps(props);
       }
       /**
-       * Terminates all workers in the pool
+       * Terminates all workers in the pool and aborts active jobs.
+       * @param reason Optional error delivered to active jobs.
        * @note Can free up significant memory
        */
-      destroy() {
+      destroy(reason = new Error("Worker pool was destroyed")) {
+        this.activeJobs.forEach((job) => job.abort(reason));
+        const queuedJobs = this.jobQueue.splice(0);
+        queuedJobs.forEach((queuedJob) => queuedJob.onReject(reason));
         this.idleQueue.forEach((worker) => worker.destroy());
         this.isDestroyed = true;
       }
@@ -637,8 +642,11 @@ var init_worker_pool = __esm({
         }
       }
       async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
-        const startPromise = new Promise((onStart) => {
-          this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+        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 });
           return this;
         });
         this._startQueuedJob();
@@ -666,6 +674,7 @@ var init_worker_pool = __esm({
             backlog: this.jobQueue.length
           });
           const job = new WorkerJob(queuedJob.name, workerThread);
+          this.activeJobs.add(job);
           workerThread.ref();
           workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
           workerThread.onError = (error) => queuedJob.onError(job, error);
@@ -674,6 +683,7 @@ var init_worker_pool = __esm({
             await job.result;
           } catch {
           } finally {
+            this.activeJobs.delete(job);
             this.returnWorkerToQueue(workerThread);
           }
         }
@@ -787,12 +797,13 @@ var init_worker_farm = __esm({
         this.workerPools = /* @__PURE__ */ new Map();
       }
       /**
-       * Terminate all workers in the farm
+       * Terminate all workers in the farm and abort active jobs.
+       * @param reason Optional error delivered to active jobs.
        * @note Can free up significant memory
        */
-      destroy() {
+      destroy(reason) {
         for (const workerPool of this.workerPools.values()) {
-          workerPool.destroy();
+          workerPool.destroy(reason);
         }
         this.workerPools = /* @__PURE__ */ new Map();
       }
@@ -1036,13 +1047,17 @@ var init_src = __esm({
 
 // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
 function canParseWithWorker(loader, options) {
-  var _a, _b;
+  var _a, _b, _c;
+  if ((_b = (_a = options == null ? void 0 : options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.some(
+    (credential) => credential.type === "request" || "token" in credential && typeof credential.token === "function"
+  ))
+    return false;
   const workerOptions = getWorkerOptions(options);
   const nodeWorkers = workerOptions._nodeWorkers;
   if (!isBrowser2 && !nodeWorkers) {
     return false;
   }
-  if (loader.id === "excel" && ((_a = options == null ? void 0 : options.excel) == null ? void 0 : _a.shape) === "arrow-table" || loader.id === "ply" && ((_b = options == null ? void 0 : options.ply) == null ? void 0 : _b.shape) === "arrow-table") {
+  if (loader.id === "las" && (((_c = options == null ? void 0 : options.las) == null ? void 0 : _c.shape) ?? "arrow-table") === "arrow-table") {
     return false;
   }
   if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
@@ -1089,7 +1104,12 @@ function callParseOnMainThread(parseOnMainThread, input, options, context) {
   return parseOnMainThread(input, void 0, options, context);
 }
 function getWorkerOptions(options = {}, loader) {
-  const serializedOptions = JSON.parse(JSON.stringify(options));
+  const serializedOptions = JSON.parse(
+    JSON.stringify({
+      ...options,
+      ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
+    })
+  );
   const workerOptions = {
     ...serializedOptions.core,
     ...serializedOptions
@@ -1178,6 +1198,48 @@ var init_async_iteration = __esm({
   }
 });
 
+// ../loader-utils/src/lib/request-utils/authentication.ts
+function resolveCredentials(credentials, authentications = []) {
+  if (credentials.every(isAuthentication)) return credentials;
+  return credentials.map((credential, index) => {
+    if (isAuthentication(credential)) return credential;
+    const AuthenticationClass = authentications.find(
+      (authentication2) => authentication2.type === (credential == null ? void 0 : credential.type)
+    );
+    if (!AuthenticationClass) {
+      throw new Error(`No authentication class registered for credential at index ${index}.`);
+    }
+    let authentication;
+    try {
+      authentication = new AuthenticationClass(credential);
+    } catch {
+      throw new Error(`Invalid authentication configuration at index ${index}.`);
+    }
+    if (!isAuthentication(authentication)) {
+      throw new Error(`Authentication class returned an invalid credential at index ${index}.`);
+    }
+    return authentication;
+  });
+}
+function resolveAuthenticationOptions(options) {
+  var _a, _b;
+  if (!((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length)) return options;
+  const credentials = resolveCredentials(options.core.credentials, options.core.authentications);
+  if (credentials === options.core.credentials) return options;
+  return { ...options, core: { ...options.core, credentials } };
+}
+function isAuthentication(credential) {
+  if (!credential || typeof credential !== "object") return false;
+  if (typeof credential.id !== "string" || !Array.isArray(credential.origins)) return false;
+  if (credential.type === "request") return typeof credential.authenticate === "function";
+  return (credential.type === "header" || credential.type === "query-parameter") && typeof credential.name === "string" && (typeof credential.token === "string" || typeof credential.token === "function") && Array.isArray(credential.refreshStatusCodes);
+}
+var init_authentication = __esm({
+  "../loader-utils/src/lib/request-utils/authentication.ts"() {
+    "use strict";
+  }
+});
+
 // ../loader-utils/src/lib/request-utils/request-cache.ts
 function createAbortError3() {
   const error = new Error("Request aborted");
@@ -1412,21 +1474,54 @@ var init_request_cache = __esm({
 
 // ../loader-utils/src/lib/request-utils/request-credentials.ts
 function createAuthenticatedFetch(options) {
-  const baseFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
-  if (!options.credentials.length) return baseFetch;
-  const existingMetadata = baseFetch[AUTHENTICATED_FETCH];
-  if (existingMetadata === options.credentials) return baseFetch;
+  const suppliedFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+  const existingMetadata = suppliedFetch[AUTHENTICATED_FETCH];
+  const credentialResolutions = new Map(existingMetadata == null ? void 0 : existingMetadata.credentialResolutions);
+  const resolvedCredentials = resolveCredentials(
+    options.credentials.map((credential) => credentialResolutions.get(credential) || credential),
+    options.authentications
+  );
+  options.credentials.forEach((credential, index) => {
+    credentialResolutions.set(credential, resolvedCredentials[index]);
+  });
+  if (!options.fetchOptions && (!resolvedCredentials.length || (existingMetadata == null ? void 0 : existingMetadata.credentials.length) === resolvedCredentials.length && resolvedCredentials.every(
+    (credential, index) => credential === existingMetadata.credentials[index]
+  )))
+    return suppliedFetch;
+  const baseFetch = (existingMetadata == null ? void 0 : existingMetadata.fetch) || suppliedFetch;
+  const credentials = existingMetadata ? [.../* @__PURE__ */ new Set([...resolvedCredentials, ...existingMetadata.credentials])] : resolvedCredentials;
+  const fetchOptions = mergeFetchOptions(
+    (existingMetadata == null ? void 0 : existingMetadata.fetchOptions) || {},
+    options.fetchOptions
+  );
+  const tokenCredentials = credentials.filter(
+    (credential) => credential.type !== "request"
+  );
+  const requestCredentials = credentials.filter(
+    (credential) => credential.type === "request"
+  );
+  for (const credential of requestCredentials) normalizeRequestOrigins(credential.origins);
   const authenticatedFetch = async (url, requestOptions = {}) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
+    requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
+    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError4();
+    if (!credentials.length) return baseFetch(url, requestOptions);
     const resolvedURL = parseHTTPURL(url);
-    if (!resolvedURL) return baseFetch(url, requestOptions);
-    const authorization = await authorizeRequest(resolvedURL, requestOptions, options.credentials);
-    const response = await baseFetch(authorization.url, authorization.options);
+    const authorization = resolvedURL ? await authorizeRequest(resolvedURL, requestOptions, tokenCredentials) : { url, options: requestOptions, credentials: [] };
+    const signedRequest = await authenticateRequest(authorization, requestCredentials, "request");
+    const response = await baseFetch(signedRequest.url, signedRequest.options);
     const refreshableCredentials = authorization.credentials.filter(
       ({ credential }) => typeof credential.token === "function" && credential.refreshStatusCodes.includes(response.status)
     );
-    if (!refreshableCredentials.length || !isReplayableRequest(requestOptions)) return response;
-    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError4();
+    const shouldRetrySignature = signedRequest.credentials.some(
+      (credential) => {
+        var _a2;
+        return (_a2 = credential.refreshStatusCodes) == null ? void 0 : _a2.includes(response.status);
+      }
+    );
+    if (!refreshableCredentials.length && !shouldRetrySignature || !isReplayableRequest(requestOptions) || !isReplayableRequest(signedRequest.options))
+      return response;
+    if ((_b = requestOptions.signal) == null ? void 0 : _b.aborted) throw createAbortError4();
     const refreshedTokens = /* @__PURE__ */ new Map();
     await Promise.all(
       refreshableCredentials.map(async ({ credential }) => {
@@ -1434,24 +1529,111 @@ function createAuthenticatedFetch(options) {
         if (token) refreshedTokens.set(credential, token);
       })
     );
-    if (!refreshedTokens.size) return response;
-    await ((_b = response.body) == null ? void 0 : _b.cancel().catch(() => {
+    if (!refreshedTokens.size && !shouldRetrySignature) return response;
+    await ((_c = response.body) == null ? void 0 : _c.cancel().catch(() => {
     }));
-    if ((_c = requestOptions.signal) == null ? void 0 : _c.aborted) throw createAbortError4();
-    const replayAuthorization = await authorizeRequest(
+    if ((_d = requestOptions.signal) == null ? void 0 : _d.aborted) throw createAbortError4();
+    const replayAuthorization = resolvedURL ? await authorizeRequest(
       resolvedURL,
       requestOptions,
-      options.credentials,
+      tokenCredentials,
       refreshedTokens,
       authorization.credentials
+    ) : { url, options: requestOptions };
+    const replayRequest = await authenticateRequest(
+      replayAuthorization,
+      requestCredentials,
+      "retry",
+      response
     );
-    return baseFetch(replayAuthorization.url, replayAuthorization.options);
+    return baseFetch(replayRequest.url, replayRequest.options);
   };
   Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
-    value: options.credentials
+    value: {
+      fetch: baseFetch,
+      credentials,
+      credentialResolutions,
+      fetchOptions
+    }
   });
   return authenticatedFetch;
 }
+function getAuthenticatedFetch(options = {}) {
+  var _a, _b, _c;
+  const fetchOption = options.fetch ?? ((_a = options.core) == null ? void 0 : _a.fetch);
+  let fetchFunction;
+  if (typeof fetchOption === "function") {
+    fetchFunction = fetchOption;
+  } else {
+    fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
+  }
+  return createAuthenticatedFetch({
+    fetch: fetchFunction,
+    fetchOptions: typeof fetchOption === "object" && fetchOption ? fetchOption : void 0,
+    credentials: ((_b = options.core) == null ? void 0 : _b.credentials) || [],
+    authentications: (_c = options.core) == null ? void 0 : _c.authentications
+  });
+}
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const mergedOptions = { ...defaultOptions, ...requestOptions };
+  if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
+    const headers = new Headers(defaultOptions.headers);
+    new Headers(requestOptions == null ? void 0 : requestOptions.headers).forEach((value, key) => headers.set(key, value));
+    mergedOptions.headers = headers;
+  }
+  return mergedOptions;
+}
+async function authenticateRequest(request, credentials, reason, response) {
+  const appliedCredentials = [];
+  const signal = request.options.signal;
+  for (const credential of credentials) {
+    const origin = getRequestOrigin(request.url);
+    if (!origin || !normalizeRequestOrigins(credential.origins).includes(origin)) continue;
+    if (signal == null ? void 0 : signal.aborted) throw createAbortError4();
+    const authenticatedRequest = await credential.authenticate({
+      url: request.url,
+      options: { ...request.options, headers: new Headers(request.options.headers) },
+      reason,
+      response: response ? { status: response.status, headers: new Headers(response.headers) } : void 0
+    });
+    if (!authenticatedRequest || typeof authenticatedRequest.url !== "string" || !authenticatedRequest.options || typeof authenticatedRequest.options !== "object") {
+      throw new Error("Authentication callback returned an invalid request.");
+    }
+    request = {
+      url: authenticatedRequest.url,
+      options: { ...authenticatedRequest.options, ...signal ? { signal } : {} }
+    };
+    appliedCredentials.push(credential);
+  }
+  if (signal == null ? void 0 : signal.aborted) throw createAbortError4();
+  return { ...request, credentials: appliedCredentials };
+}
+function getRequestOrigin(url) {
+  try {
+    const parsedURL = new URL(url);
+    if (!parsedURL.host || parsedURL.username || parsedURL.password) return null;
+    return parsedURL.origin !== "null" ? parsedURL.origin : `${parsedURL.protocol}//${parsedURL.host}`;
+  } catch {
+    return null;
+  }
+}
+function normalizeRequestOrigins(origins) {
+  if (!origins.length)
+    throw new Error("Request authentication requires at least one exact origin.");
+  return origins.map((origin) => {
+    const resolvedOrigin = getRequestOrigin(origin);
+    let url;
+    try {
+      url = new URL(origin);
+    } catch {
+      throw new Error("Invalid request authentication origin.");
+    }
+    if (!resolvedOrigin || url.pathname && url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("Invalid request authentication origin.");
+    }
+    return resolvedOrigin;
+  });
+}
 async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
   const url = new URL(sourceURL);
   const headers = new Headers(requestOptions.headers);
@@ -1520,6 +1702,7 @@ var AUTHENTICATED_FETCH, refreshPromises;
 var init_request_credentials = __esm({
   "../loader-utils/src/lib/request-utils/request-credentials.ts"() {
     "use strict";
+    init_authentication();
     AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
     refreshPromises = /* @__PURE__ */ new WeakMap();
   }
@@ -1765,6 +1948,7 @@ var init_range_request_scheduler = __esm({
       /** Optional event callback for range batching diagnostics. */
       onEvent;
       pendingRequests = [];
+      /** Pending batch window, independent of in-flight transport requests. */
       flushTimer = null;
       /** Creates a scheduler for one group of byte-range-addressable resources. */
       constructor(props = {}) {
@@ -1841,7 +2025,7 @@ var init_range_request_scheduler = __esm({
       }
       /** Immediately starts loading the currently queued requests. */
       flush() {
-        if (this.flushTimer) {
+        if (this.flushTimer !== null) {
           clearTimeout(this.flushTimer);
           this.flushTimer = null;
         }
@@ -1863,9 +2047,9 @@ var init_range_request_scheduler = __esm({
           this.fetchMergedRequest(mergedRequest);
         }
       }
-      /** Schedules the next pending-request flush. */
+      /** Starts a fixed batch window only when no flush is already scheduled. */
       scheduleFlush() {
-        if (this.flushTimer) {
+        if (this.flushTimer !== null) {
           return;
         }
         this.flushTimer = setTimeout(() => this.flush(), this.props.batchDelayMs);
@@ -2385,39 +2569,25 @@ var init_blob_file = __esm({
 
 // ../loader-utils/src/lib/sources/data-source.ts
 function getFetchFunction(options) {
-  var _a, _b;
-  const fetchOption = (options == null ? void 0 : options.fetch) ?? ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.fetch);
-  let fetchFunction;
-  if (typeof fetchOption === "function") {
-    fetchFunction = (url, fetchOptions) => fetchOption(url, fetchOptions);
-  } else if (fetchOption) {
-    fetchFunction = (url, requestOptions) => fetch(url, mergeFetchOptions(fetchOption, requestOptions));
-  } else {
-    fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
-  }
-  return createAuthenticatedFetch({
-    fetch: fetchFunction,
-    credentials: ((_b = options == null ? void 0 : options.core) == null ? void 0 : _b.credentials) || []
-  });
+  return getAuthenticatedFetch(options);
 }
-function mergeFetchOptions(fetchOptions, requestOptions) {
-  const mergedOptions = { ...fetchOptions, ...requestOptions };
-  if (fetchOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
-    mergedOptions.headers = mergeHeaders(fetchOptions.headers, requestOptions == null ? void 0 : requestOptions.headers);
-  }
-  return mergedOptions;
-}
-function mergeHeaders(defaultHeaders, requestHeaders) {
-  const headers = new Headers(defaultHeaders);
-  if (requestHeaders) {
-    new Headers(requestHeaders).forEach((value, key) => headers.set(key, value));
+function getSourceLoaderOptions(options) {
+  var _a;
+  if (options.loadOptions !== void 0 || ((_a = options.core) == null ? void 0 : _a.loadOptions) !== void 0) {
+    throw new Error(
+      "Source loadOptions and core.loadOptions were removed. Use core and root loader namespaces directly."
+    );
   }
-  return headers;
-}
-function normalizeDirectLoaderOptions(options) {
   const loadOptions = { ...options };
   if (options == null ? void 0 : options.core) {
     loadOptions.core = { ...options.core };
+    const parserCore = loadOptions.core;
+    for (const key of ["type", "attributions", "loaders", "onError", "loadOptions"]) {
+      delete parserCore[key];
+    }
+    if (Object.keys(parserCore).length === 0) {
+      delete loadOptions.core;
+    }
   }
   const topLevelBaseUri = typeof loadOptions.baseUri === "string" ? loadOptions.baseUri : void 0;
   const topLevelBaseUrl = typeof loadOptions.baseUrl === "string" ? loadOptions.baseUrl : void 0;
@@ -2455,6 +2625,7 @@ var init_data_source = __esm({
     init_file_aliases();
     init_log();
     init_request_credentials();
+    init_authentication();
     UNAVAILABLE_CORE_API = {
       fetchFile: unavailableCoreApiMethod("fetchFile"),
       parse: unavailableCoreApiMethod("parse"),
@@ -2469,7 +2640,6 @@ var init_data_source = __esm({
         core: {
           type: "auto",
           attributions: [],
-          loadOptions: {},
           loaders: [],
           onError: void 0
         }
@@ -2478,9 +2648,9 @@ var init_data_source = __esm({
       options;
       data;
       url;
-      /** The actual load options, if calling a loaders.gl loader */
+      /** Shared parser options derived from the source options, excluding source-only core controls. */
       loadOptions;
-      /** A resolved fetch function extracted from loadOptions prop */
+      /** A resolved fetch function extracted from the shared core options. */
       fetch;
       /** Shared source-level runtime hooks, when supplied by the source factory. */
       coreApi;
@@ -2488,15 +2658,13 @@ var init_data_source = __esm({
       hasCoreApi;
       _needsRefresh = true;
       constructor(data, options, defaultOptions, coreApi) {
-        var _a;
-        if (defaultOptions) {
-          this.options = mergeOptions({ ...defaultOptions, core: _DataSource.defaultOptions }, options);
-        } else {
-          this.options = { ...options };
-        }
+        this.options = mergeOptions(
+          mergeOptions(_DataSource.defaultOptions, defaultOptions || {}),
+          options
+        );
         this.data = data;
         this.url = typeof data === "string" ? resolvePath(data) : "";
-        const loadOptions = normalizeDirectLoaderOptions((_a = this.options.core) == null ? void 0 : _a.loadOptions);
+        const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(this.options));
         this.loadOptions = loadOptions;
         const fetch2 = getFetchFunction(loadOptions);
         this.coreApi = coreApi || UNAVAILABLE_CORE_API;
@@ -2504,7 +2672,11 @@ var init_data_source = __esm({
         this.fetch = fetch2;
       }
       setProps(options) {
-        this.options = Object.assign(this.options, options);
+        const mergedOptions = mergeOptions(this.options, options);
+        const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(mergedOptions));
+        this.options = mergedOptions;
+        this.loadOptions = loadOptions;
+        this.fetch = getFetchFunction(loadOptions);
         this.setNeedsRefresh();
       }
       /** Mark this data source as needing a refresh (redraw) */
@@ -2986,6 +3158,9 @@ function getDataTypeFromArray(array) {
   return { type: "null", nullable: true };
 }
 function getDataTypeFromTypedArray(array) {
+  if (typeof Float16Array !== "undefined" && array instanceof Float16Array) {
+    return "float16";
+  }
   switch (array.constructor) {
     case Int8Array:
       return "int8";
@@ -3000,6 +3175,10 @@ function getDataTypeFromTypedArray(array) {
       return "int32";
     case Uint32Array:
       return "uint32";
+    case BigInt64Array:
+      return "int64";
+    case BigUint64Array:
+      return "uint64";
     case Float32Array:
       return "float32";
     case Float64Array:
@@ -3027,15 +3206,19 @@ function getArrayTypeFromDataType(type, nullable) {
         return Float32Array;
       case "float64":
         return Float64Array;
+      case "float16":
+        return (0, import_types.getFloat16ArrayConstructor)();
       default:
         break;
     }
   }
   return Array;
 }
+var import_types;
 var init_data_type = __esm({
   "../schema-utils/src/lib/schema/data-type.ts"() {
     "use strict";
+    import_types = require("@math.gl/types");
   }
 });
 
@@ -3084,6 +3267,13 @@ function serializeArrowType(arrowType) {
   if (isArrowViewType(arrowType, "Utf8View")) {
     return "utf8-view";
   }
+  if (isOptionalArrowType(arrowType, "LargeList")) {
+    const largeListType = arrowType;
+    return {
+      type: "large-list",
+      children: [serializeArrowField(largeListType.valueField)]
+    };
+  }
   switch (arrowType.constructor) {
     case arrow.Null:
       return "null";
@@ -3222,12 +3412,6 @@ function serializeArrowType(arrowType) {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case arrow.LargeList:
-      const largeListType = arrowType;
-      return {
-        type: "large-list",
-        children: [serializeArrowField(largeListType.valueField)]
-      };
     case arrow.FixedSizeList:
       const fixedSizeList = arrowType;
       return {
@@ -3280,7 +3464,13 @@ function deserializeArrowType(dataType, options) {
       }
       case "large-list": {
         const field = deserializeArrowField(dataType.children[0], options);
-        return new arrow.LargeList(field);
+        const LargeList = getOptionalArrowConstructor("LargeList");
+        if (!LargeList) {
+          throw new Error(
+            "LargeList requires an Apache Arrow runtime that exports the LargeList constructor"
+          );
+        }
+        return new LargeList(field);
       }
       case "fixed-size-list": {
         const child = deserializeArrowField(dataType.children[0], options);
@@ -3376,11 +3566,11 @@ function deserializeArrowType(dataType, options) {
       throw new Error("array type not supported");
   }
 }
-function getArrowViewConstructors() {
-  return arrow;
+function getOptionalArrowConstructor(typeName) {
+  return arrow[typeName];
 }
 function isArrowViewType(arrowType, viewTypeName) {
-  const constructor = getArrowViewConstructors()[viewTypeName];
+  const constructor = getOptionalArrowConstructor(viewTypeName);
   if (constructor && arrowType instanceof constructor) {
     return true;
   }
@@ -3388,12 +3578,16 @@ function isArrowViewType(arrowType, viewTypeName) {
   const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
   return Boolean(guard == null ? void 0 : guard(arrowType));
 }
+function isOptionalArrowType(arrowType, typeName) {
+  const constructor = getOptionalArrowConstructor(typeName);
+  return Boolean(constructor && arrowType instanceof constructor);
+}
 function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
   const viewTypeMode = (options == null ? void 0 : options.viewTypes) || "never";
   if (viewTypeMode === "never") {
     return fallbackType;
   }
-  const constructor = getArrowViewConstructors()[viewTypeName];
+  const constructor = getOptionalArrowConstructor(viewTypeName);
   if (constructor) {
     return new constructor();
   }
@@ -3405,7 +3599,7 @@ function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
   return fallbackType;
 }
 function makeRequiredArrowViewType(viewTypeName) {
-  const constructor = getArrowViewConstructors()[viewTypeName];
+  const constructor = getOptionalArrowConstructor(viewTypeName);
   if (!constructor) {
     throw new Error(
       `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
@@ -13295,7 +13489,7 @@ var init_parquet_loader_options = __esm({
     PARQUET_LOADER_DEFAULT_OPTIONS = {
       columns: void 0,
       preserveBinary: false,
-      shape: "object-row-table"
+      shape: "arrow-table"
     };
   }
 });
@@ -13324,6 +13518,15 @@ var init_parquet_loader_base = __esm({
   }
 });
 
+// ../parquet/src/parquet-source-worker-factory.ts
+var PARQUET_SOURCE_WORKER_LOAD_WORKER;
+var init_parquet_source_worker_factory = __esm({
+  "../parquet/src/parquet-source-worker-factory.ts"() {
+    "use strict";
+    PARQUET_SOURCE_WORKER_LOAD_WORKER = void 0;
+  }
+});
+
 // ../parquet/src/parquet-source-worker-url.ts
 function resolveParquetSourceWorkerUrl() {
   if (!import_meta.url) {
@@ -13364,12 +13567,14 @@ var init_parquet_source_worker_client = __esm({
     "use strict";
     init_src2();
     init_parquet_loader_base();
+    init_parquet_source_worker_factory();
     init_parquet_source_worker_url();
     PARQUET_SOURCE_WORKER = {
       ...PARQUET_LOADER_BASE,
       id: "parquet-source",
       name: "ParquetSource",
-      worker: PARQUET_SOURCE_WORKER_URL
+      worker: PARQUET_SOURCE_WORKER_URL,
+      loadWorker: PARQUET_SOURCE_WORKER_LOAD_WORKER
     };
   }
 });
@@ -17841,6 +18046,18 @@ function readUnsignedVarIntNumber(cursor) {
   }
   throw new Error("invalid RLE run header");
 }
+function encodeUnsignedVarIntNumber(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("RLE run header must be a non-negative safe integer");
+  }
+  const bytes = [];
+  while (value >= 128) {
+    bytes.push(value % 128 | 128);
+    value = Math.floor(value / 128);
+  }
+  bytes.push(value);
+  return Uint8Array.from(bytes);
+}
 function assertReadable(cursor, byteLength) {
   const size = cursor.size ?? cursor.buffer.length;
   if (byteLength < 0 || cursor.offset + byteLength > size) {
@@ -17862,10 +18079,7 @@ function encodeRunBitpacked(values, opts) {
       buf[Math.floor(b / 8)] |= 1 << b % 8;
     }
   }
-  return concatUint8Arrays([
-    Uint8Array.from(import_varint.default.encode(paddedValues.length / 8 << 1 | 1)),
-    buf
-  ]);
+  return concatUint8Arrays([encodeUnsignedVarIntNumber(paddedValues.length / 8 << 1 | 1), buf]);
 }
 function encodeRunRepeated(value, count, opts) {
   const bitWidth = opts.bitWidth;
@@ -17874,15 +18088,13 @@ function encodeRunRepeated(value, count, opts) {
     buf[i] = value & 255;
     value = Math.floor(value / 256);
   }
-  return concatUint8Arrays([Uint8Array.from(import_varint.default.encode(count << 1)), buf]);
+  return concatUint8Arrays([encodeUnsignedVarIntNumber(count << 1), buf]);
 }
-var import_varint;
 var init_rle = __esm({
   "../parquet/src/parquetjs/codecs/rle.ts"() {
     "use strict";
     init_declare();
     init_binary_utils();
-    import_varint = __toESM(require("varint"), 1);
   }
 });