@loaders.gl/splats 5.0.0-alpha.2 → 5.0.0-alpha.4

package/dist/index.cjs

@@ -336,7 +336,7 @@ var init_splat_loader_types = __esm({
   "dist/splat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION = true ? "5.0.0-alpha.2" : "latest";
+    VERSION = true ? "5.0.0-alpha.4" : "latest";
     SPLATLoader = {
       dataType: null,
       batchType: null,
@@ -661,7 +661,7 @@ var init_ksplat_loader_types = __esm({
   "dist/ksplat-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION2 = true ? "5.0.0-alpha.2" : "latest";
+    VERSION2 = true ? "5.0.0-alpha.4" : "latest";
     KSPLATLoader = {
       dataType: null,
       batchType: null,
@@ -677,129 +677,6 @@ var init_ksplat_loader_types = __esm({
   }
 });
 
-// ../compression/src/lib/decompression-stream.ts
-async function decompressWithNativeDecompressionStream(input, format) {
-  const outputBatches = decompressBatchesWithNativeDecompressionStream([input], format);
-  return outputBatches ? await concatenateNativeDecompressionBatches(outputBatches) : null;
-}
-function decompressBatchesWithNativeDecompressionStream(inputBatches, format) {
-  const decompressionStream = createNativeDecompressionStream(format);
-  return decompressionStream ? transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) : null;
-}
-function createNativeDecompressionStream(format) {
-  var _a, _b;
-  if (typeof globalThis.DecompressionStream === "undefined") {
-    return null;
-  }
-  if (((_b = (_a = globalThis.process) == null ? void 0 : _a.versions) == null ? void 0 : _b.node) && typeof globalThis.Buffer === "undefined") {
-    return null;
-  }
-  try {
-    const DecompressionStreamConstructor = globalThis.DecompressionStream;
-    return new DecompressionStreamConstructor(format);
-  } catch (error) {
-    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
-      return null;
-    }
-    throw error;
-  }
-}
-async function* transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) {
-  const writer = decompressionStream.writable.getWriter();
-  const reader = decompressionStream.readable.getReader();
-  const writePromise = writeBatchesToNativeDecompressionStream(inputBatches, writer);
-  writePromise.catch(() => {
-  });
-  let outputCompleted = false;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        outputCompleted = true;
-        break;
-      }
-      yield copyExactArrayBuffer(value);
-    }
-    await writePromise;
-  } finally {
-    if (!outputCompleted) {
-      await reader.cancel().catch(() => {
-      });
-      await writer.abort().catch(() => {
-      });
-      await writePromise.catch(() => {
-      });
-    }
-    reader.releaseLock();
-  }
-}
-async function concatenateNativeDecompressionBatches(outputBatches) {
-  const batches = [];
-  let byteLength = 0;
-  for await (const outputBatch of outputBatches) {
-    const bytes = new Uint8Array(outputBatch);
-    batches.push(bytes);
-    byteLength += bytes.byteLength;
-  }
-  const output = new Uint8Array(byteLength);
-  let byteOffset = 0;
-  for (const batch of batches) {
-    output.set(batch, byteOffset);
-    byteOffset += batch.byteLength;
-  }
-  return output.buffer;
-}
-function copyExactArrayBuffer(value) {
-  return new Uint8Array(value).buffer;
-}
-async function writeBatchesToNativeDecompressionStream(inputBatches, writer) {
-  try {
-    for await (const inputBatch of inputBatches) {
-      await writer.write(new Uint8Array(inputBatch));
-    }
-    await writer.close();
-  } catch (error) {
-    await writer.abort(error).catch(() => {
-    });
-    throw error;
-  }
-}
-var init_decompression_stream = __esm({
-  "../compression/src/lib/decompression-stream.ts"() {
-    "use strict";
-  }
-});
-
-// ../compression/src/native-decompression.ts
-var init_native_decompression = __esm({
-  "../compression/src/native-decompression.ts"() {
-    "use strict";
-    init_decompression_stream();
-  }
-});
-
-// ../loader-utils/src/lib/env-utils/globals.ts
-var globals, self_, window_, global_, document_, isBrowser, matches, nodeVersion;
-var init_globals = __esm({
-  "../loader-utils/src/lib/env-utils/globals.ts"() {
-    "use strict";
-    globals = {
-      self: typeof self !== "undefined" && self,
-      window: typeof window !== "undefined" && window,
-      global: typeof global !== "undefined" && global,
-      document: typeof document !== "undefined" && document
-    };
-    self_ = globals.self || globals.window || globals.global || {};
-    window_ = globals.window || globals.self || globals.global || {};
-    global_ = globals.global || globals.self || globals.window || {};
-    document_ = globals.document || {};
-    isBrowser = // @ts-ignore process does not exist on browser
-    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
-    matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-    nodeVersion = matches && parseFloat(matches[1]) || 0;
-  }
-});
-
 // ../loader-utils/src/lib/log-utils/log.ts
 function createLog() {
   const log2 = new import_log.Log({ id: "loaders.gl" });
@@ -940,6 +817,121 @@ var init_async_iteration = __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 authenticatedFetch = async (url, requestOptions = {}) => {
+    var _a, _b, _c;
+    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 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 createAbortError();
+    const refreshedTokens = /* @__PURE__ */ new Map();
+    await Promise.all(
+      refreshableCredentials.map(async ({ credential }) => {
+        const token = await refreshCredential(credential, url, response);
+        if (token) refreshedTokens.set(credential, token);
+      })
+    );
+    if (!refreshedTokens.size) return response;
+    await ((_b = response.body) == null ? void 0 : _b.cancel().catch(() => {
+    }));
+    if ((_c = requestOptions.signal) == null ? void 0 : _c.aborted) throw createAbortError();
+    const replayAuthorization = await authorizeRequest(
+      resolvedURL,
+      requestOptions,
+      options.credentials,
+      refreshedTokens,
+      authorization.credentials
+    );
+    return baseFetch(replayAuthorization.url, replayAuthorization.options);
+  };
+  Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
+    value: options.credentials
+  });
+  return authenticatedFetch;
+}
+async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
+  const url = new URL(sourceURL);
+  const headers = new Headers(requestOptions.headers);
+  const resolvedCredentials = [];
+  const previousTokens = new Map(
+    previousCredentials.map(({ credential, token }) => [credential, token])
+  );
+  for (const credential of credentials) {
+    if (!credential.origins.includes(url.origin)) continue;
+    const overrideToken = tokenOverrides.get(credential);
+    const previousToken = previousTokens.get(credential);
+    const ownsQueryParameter = credential.type === "query-parameter" && previousToken !== void 0;
+    const ownsHeader = credential.type === "header" && previousToken !== void 0;
+    if (credential.type === "query-parameter" && url.searchParams.has(credential.name) && !ownsQueryParameter || credential.type === "header" && headers.has(credential.name) && !ownsHeader) {
+      continue;
+    }
+    const token = overrideToken ?? previousToken ?? await resolveToken(credential.token, { url: sourceURL.toString(), reason: "request" });
+    if (!token) continue;
+    if (credential.type === "query-parameter") {
+      url.searchParams.set(credential.name, token);
+    } else {
+      headers.set(credential.name, `${credential.prefix || ""}${token}`);
+    }
+    resolvedCredentials.push({ credential, token });
+  }
+  return {
+    url: url.toString(),
+    options: { ...requestOptions, headers },
+    credentials: resolvedCredentials
+  };
+}
+async function refreshCredential(credential, url, response) {
+  const existingPromise = refreshPromises.get(credential);
+  if (existingPromise) return existingPromise;
+  const tokenProvider = credential.token;
+  const promise = Promise.resolve(
+    tokenProvider({
+      url,
+      reason: "refresh",
+      response: { status: response.status, headers: response.headers }
+    })
+  ).finally(() => refreshPromises.delete(credential));
+  refreshPromises.set(credential, promise);
+  return promise;
+}
+async function resolveToken(token, context) {
+  return typeof token === "function" ? token(context) : token;
+}
+function parseHTTPURL(url) {
+  try {
+    const parsedURL = new URL(url);
+    return ["http:", "https:"].includes(parsedURL.protocol) ? parsedURL : null;
+  } catch {
+    return null;
+  }
+}
+function isReplayableRequest(options) {
+  const method = (options.method || "GET").toUpperCase();
+  if (!["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method)) return false;
+  return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
+}
+function createAbortError() {
+  return new DOMException("The operation was aborted.", "AbortError");
+}
+var AUTHENTICATED_FETCH, refreshPromises;
+var init_request_credentials = __esm({
+  "../loader-utils/src/lib/request-utils/request-credentials.ts"() {
+    "use strict";
+    AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
+    refreshPromises = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // ../loader-utils/src/lib/path-utils/file-aliases.ts
 function resolvePath(filename) {
   for (const alias in fileAliases) {
@@ -962,47 +954,7 @@ var init_file_aliases = __esm({
   }
 });
 
-// ../loader-utils/src/lib/node/buffer.browser.ts
-function toArrayBuffer(buffer) {
-  return buffer;
-}
-var init_buffer_browser = __esm({
-  "../loader-utils/src/lib/node/buffer.browser.ts"() {
-    "use strict";
-  }
-});
-
 // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
-function isBuffer(value) {
-  return value && typeof value === "object" && value.isBuffer;
-}
-function toArrayBuffer2(data) {
-  if (isBuffer(data)) {
-    return toArrayBuffer(data);
-  }
-  if (data instanceof ArrayBuffer) {
-    return data;
-  }
-  if (isSharedArrayBuffer(data)) {
-    return copyToArrayBuffer2(data);
-  }
-  if (ArrayBuffer.isView(data)) {
-    const buffer = data.buffer;
-    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-      return buffer;
-    }
-    return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-  }
-  if (typeof data === "string") {
-    const text = data;
-    const uint8Array = new TextEncoder().encode(text);
-    return uint8Array.buffer;
-  }
-  if (data && typeof data === "object" && data._toArrayBuffer) {
-    return data._toArrayBuffer();
-  }
-  throw new Error("toArrayBuffer");
-}
 function ensureArrayBuffer(bufferSource) {
   if (bufferSource instanceof ArrayBuffer) {
     return bufferSource;
@@ -1026,34 +978,25 @@ var init_memory_conversion_utils = __esm({
   "../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts"() {
     "use strict";
     init_is_type();
-    init_buffer_browser();
-  }
-});
-
-// ../loader-utils/src/lib/node/promisify.ts
-function promisify1(fn) {
-  return (args) => new Promise(
-    (resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs))
-  );
-}
-var init_promisify = __esm({
-  "../loader-utils/src/lib/node/promisify.ts"() {
-    "use strict";
   }
 });
 
 // ../loader-utils/src/lib/sources/data-source.ts
 function getFetchFunction(options) {
-  var _a;
-  const fetchFunction = (_a = options == null ? void 0 : options.core) == null ? void 0 : _a.fetch;
-  if (fetchFunction && typeof fetchFunction === "function") {
-    return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
-  }
-  const fetchOptions = options == null ? void 0 : options.fetch;
-  if (fetchOptions && typeof fetchOptions !== "function") {
-    return (url, requestOptions) => fetch(url, mergeFetchOptions(fetchOptions, requestOptions));
-  }
-  return (url, requestOptions) => fetch(url, requestOptions);
+  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) || []
+  });
 }
 function mergeFetchOptions(fetchOptions, requestOptions) {
   const mergedOptions = { ...fetchOptions, ...requestOptions };
@@ -1109,6 +1052,7 @@ var init_data_source = __esm({
     init_merge_options();
     init_file_aliases();
     init_log();
+    init_request_credentials();
     UNAVAILABLE_CORE_API = {
       fetchFile: unavailableCoreApiMethod("fetchFile"),
       parse: unavailableCoreApiMethod("parse"),
@@ -1188,89 +1132,463 @@ var init_data_source = __esm({
         }
         return normalizedError;
       }
-    };
+    };
+  }
+});
+
+// ../loader-utils/src/index.ts
+var init_src = __esm({
+  "../loader-utils/src/index.ts"() {
+    "use strict";
+    init_js_module_utils();
+    init_js_module_utils();
+    init_async_iteration();
+    init_memory_conversion_utils();
+    init_data_source();
+  }
+});
+
+// ../compression/src/lib/compression.ts
+var CompressionTransform, Compressor, Decompressor, Compression;
+var init_compression = __esm({
+  "../compression/src/lib/compression.ts"() {
+    "use strict";
+    init_src();
+    CompressionTransform = class {
+      /** Preloads any dynamic libraries. May enable sync functions */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        return void 0;
+      }
+      // HELPERS
+      concatenate(asyncIterator) {
+        return concatenateArrayBuffersAsync(asyncIterator);
+      }
+      improveError(error) {
+        if (!error.message.includes(this.name)) {
+          error.message = `${this.name} ${error.message}`;
+        }
+        return error;
+      }
+    };
+    Compressor = class extends CompressionTransform {
+      constructor(options) {
+        super();
+        this.compressBatches = this.compressBatches.bind(this);
+      }
+      /** Asynchronously compresses data. */
+      async compress(input) {
+        await this.preload();
+        return this.compressSync(input);
+      }
+      /** Synchronously compresses data. */
+      compressSync(input) {
+        throw new Error(`${this.name}: sync compression not supported`);
+      }
+      /** Compresses batches. */
+      async *compressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.compress(input);
+      }
+    };
+    Decompressor = class extends CompressionTransform {
+      constructor(options) {
+        super();
+        this.decompressBatches = this.decompressBatches.bind(this);
+      }
+      /** Asynchronously decompresses data. */
+      async decompress(input, size) {
+        await this.preload();
+        return this.decompressSync(input, size);
+      }
+      /** Synchronously decompresses data. */
+      decompressSync(input, size) {
+        throw new Error(`${this.name}: sync decompression not supported`);
+      }
+      /** Decompresses batches. */
+      async *decompressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.decompress(input);
+      }
+    };
+    Compression = class extends Compressor {
+      constructor(options) {
+        super(options);
+        this.decompressBatches = this.decompressBatches.bind(this);
+      }
+      /** Asynchronously decompresses data. */
+      async decompress(input, size) {
+        await this.preload();
+        return this.decompressSync(input, size);
+      }
+      /** Synchronously decompresses data. */
+      decompressSync(input, size) {
+        throw new Error(`${this.name}: sync decompression not supported`);
+      }
+      /** Decompresses batches. */
+      async *decompressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.decompress(input);
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/compression-stream.ts
+async function compressWithNativeCompressionStream(input, format) {
+  const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
+  return outputBatches ? await concatenateBatches(outputBatches) : null;
+}
+function compressBatchesWithNativeCompressionStream(inputBatches, format) {
+  const compressionStream = createNativeCompressionStream(format);
+  return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
+}
+function createNativeCompressionStream(format) {
+  if (typeof globalThis.CompressionStream === "undefined") {
+    return null;
+  }
+  try {
+    const CompressionStreamConstructor = globalThis.CompressionStream;
+    return new CompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function* transformBatches(inputBatches, compressionStream) {
+  const writer = compressionStream.writable.getWriter();
+  const reader = compressionStream.readable.getReader();
+  const writePromise = writeBatches(inputBatches, writer);
+  writePromise.catch(() => {
+  });
+  let outputCompleted = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        outputCompleted = true;
+        break;
+      }
+      yield new Uint8Array(value).buffer;
+    }
+    await writePromise;
+  } finally {
+    if (!outputCompleted) {
+      await reader.cancel().catch(() => {
+      });
+      await writer.abort().catch(() => {
+      });
+      await writePromise.catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+}
+async function writeBatches(inputBatches, writer) {
+  try {
+    for await (const inputBatch of inputBatches) {
+      await writer.write(new Uint8Array(inputBatch));
+    }
+    await writer.close();
+  } catch (error) {
+    await writer.abort(error).catch(() => {
+    });
+    throw error;
+  }
+}
+async function concatenateBatches(batches) {
+  const output = [];
+  let byteLength = 0;
+  for await (const batch of batches) {
+    const bytes = new Uint8Array(batch);
+    output.push(bytes);
+    byteLength += bytes.byteLength;
+  }
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const batch of output) {
+    result.set(batch, offset);
+    offset += batch.byteLength;
+  }
+  return result.buffer;
+}
+var init_compression_stream = __esm({
+  "../compression/src/lib/compression-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../compression/src/lib/decompression-stream.ts
+async function decompressWithNativeDecompressionStream(input, format) {
+  const outputBatches = decompressBatchesWithNativeDecompressionStream([input], format);
+  return outputBatches ? await concatenateNativeDecompressionBatches(outputBatches) : null;
+}
+function decompressBatchesWithNativeDecompressionStream(inputBatches, format) {
+  const decompressionStream = createNativeDecompressionStream(format);
+  return decompressionStream ? transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) : null;
+}
+function isNativeDecompressionSupported(format) {
+  return Boolean(createNativeDecompressionStream(format));
+}
+function createNativeDecompressionStream(format) {
+  var _a, _b;
+  if (typeof globalThis.DecompressionStream === "undefined") {
+    return null;
+  }
+  if (((_b = (_a = globalThis.process) == null ? void 0 : _a.release) == null ? void 0 : _b.name) === "node" && typeof globalThis.Buffer === "undefined") {
+    return null;
+  }
+  try {
+    const DecompressionStreamConstructor = globalThis.DecompressionStream;
+    return new DecompressionStreamConstructor(format);
+  } catch (error) {
+    if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function* transformBatchesWithNativeDecompressionStream(inputBatches, decompressionStream) {
+  const writer = decompressionStream.writable.getWriter();
+  const reader = decompressionStream.readable.getReader();
+  const writePromise = writeBatchesToNativeDecompressionStream(inputBatches, writer);
+  writePromise.catch(() => {
+  });
+  let outputCompleted = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        outputCompleted = true;
+        break;
+      }
+      yield copyExactArrayBuffer(value);
+    }
+    await writePromise;
+  } finally {
+    if (!outputCompleted) {
+      await reader.cancel().catch(() => {
+      });
+      await writer.abort().catch(() => {
+      });
+      await writePromise.catch(() => {
+      });
+    }
+    reader.releaseLock();
+  }
+}
+async function concatenateNativeDecompressionBatches(outputBatches) {
+  const batches = [];
+  let byteLength = 0;
+  for await (const outputBatch of outputBatches) {
+    const bytes = new Uint8Array(outputBatch);
+    batches.push(bytes);
+    byteLength += bytes.byteLength;
+  }
+  const output = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (const batch of batches) {
+    output.set(batch, byteOffset);
+    byteOffset += batch.byteLength;
+  }
+  return output.buffer;
+}
+function copyExactArrayBuffer(value) {
+  return new Uint8Array(value).buffer;
+}
+async function writeBatchesToNativeDecompressionStream(inputBatches, writer) {
+  try {
+    for await (const inputBatch of inputBatches) {
+      await writer.write(new Uint8Array(inputBatch));
+    }
+    await writer.close();
+  } catch (error) {
+    await writer.abort(error).catch(() => {
+    });
+    throw error;
+  }
+}
+var init_decompression_stream = __esm({
+  "../compression/src/lib/decompression-stream.ts"() {
+    "use strict";
   }
 });
 
-// ../loader-utils/src/index.ts
-var init_src = __esm({
-  "../loader-utils/src/index.ts"() {
+// ../compression/src/lib/native-decompressor.ts
+var native_decompressor_exports = {};
+__export(native_decompressor_exports, {
+  NativeDecompressor: () => NativeDecompressor
+});
+var NativeDecompressor;
+var init_native_decompressor = __esm({
+  "../compression/src/lib/native-decompressor.ts"() {
     "use strict";
-    init_globals();
-    init_js_module_utils();
-    init_js_module_utils();
-    init_async_iteration();
-    init_memory_conversion_utils();
-    init_promisify();
-    init_data_source();
+    init_compression();
+    init_decompression_stream();
+    NativeDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Runtime stream format used for every operation. */
+      format;
+      constructor(metadata, format, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.format = format;
+      }
+      /** Decompresses one buffer with the runtime-provided stream. */
+      async decompress(input) {
+        const output = await decompressWithNativeDecompressionStream(input, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        return output;
+      }
+      /** Decompresses batches incrementally with the runtime-provided stream. */
+      async *decompressBatches(inputBatches) {
+        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        yield* output;
+      }
+    };
   }
 });
 
-// ../compression/src/lib/compression.ts
-var Compression;
-var init_compression = __esm({
-  "../compression/src/lib/compression.ts"() {
+// ../compression/src/lib/lazy-compression.ts
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
+}
+var LazyDecompressor;
+var init_lazy_compression = __esm({
+  "../compression/src/lib/lazy-compression.ts"() {
     "use strict";
-    init_src();
-    Compression = class {
-      constructor(options) {
-        this.compressBatches = this.compressBatches.bind(this);
-        this.decompressBatches = this.decompressBatches.bind(this);
+    init_compression();
+    init_decompression_stream();
+    LazyDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Constructor options retained until a concrete implementation is selected. */
+      options;
+      /** Built-in stream format to probe, or null when the format has no built-in path. */
+      nativeFormat;
+      /** Returns whether built-in selection remains eligible for the merged preload options. */
+      shouldUseNative;
+      /** Dynamically imports the balanced fallback constructor. */
+      loadFallback;
+      /** Selected concrete implementation after preload completes. */
+      implementation = null;
+      /** Shared in-flight selection used by concurrent asynchronous calls. */
+      implementationPromise = null;
+      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.options = options;
+        this.nativeFormat = nativeFormat;
+        this.shouldUseNative = shouldUseNative;
+        this.loadFallback = loadFallback;
       }
-      /** Preloads any dynamic libraries. May enable sync functions */
+      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
       async preload(modules = {}) {
-        registerJSModules(modules);
-        return;
+        if (this.implementation) return this.implementation;
+        const options = mergeModules(this.options, modules);
+        this.implementationPromise ||= this.loadImplementation(options);
+        try {
+          this.implementation = await this.implementationPromise;
+          return this.implementation;
+        } catch (error) {
+          this.implementationPromise = null;
+          throw error;
+        }
       }
-      /** Asynchronously compress data */
-      async compress(input) {
-        await this.preload();
-        return this.compressSync(input);
+      /** Loads the selected concrete decompressor. */
+      async loadImplementation(options) {
+        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
+          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
+          return new NativeDecompressor2(this, this.nativeFormat, options);
+        }
+        const Decompressor2 = await this.loadFallback();
+        const implementation = new Decompressor2({ ...options, useNative: false });
+        await implementation.preload(options.modules);
+        return implementation;
       }
-      /** Asynchronously decompress data */
+      /** Decompresses after lazily selecting the default implementation. */
       async decompress(input, size) {
-        await this.preload();
-        return this.decompressSync(input, size);
-      }
-      /** Synchronously compress data */
-      compressSync(input) {
-        throw new Error(`${this.name}: sync compression not supported`);
+        return (await this.preload()).decompress(input, size);
       }
-      /** Synchronously compress data */
+      /** Decompresses synchronously after an implementation has been preloaded. */
       decompressSync(input, size) {
-        throw new Error(`${this.name}: sync decompression not supported`);
-      }
-      /** Compress batches */
-      async *compressBatches(asyncIterator) {
-        const input = await this.concatenate(asyncIterator);
-        yield this.compress(input);
+        if (!this.implementation) {
+          throw new Error(`${this.name}: call preload() before decompressSync()`);
+        }
+        return this.implementation.decompressSync(input, size);
       }
-      /** Decompress batches */
-      async *decompressBatches(asyncIterator) {
-        const input = await this.concatenate(asyncIterator);
-        yield this.decompress(input);
+      /** Decompresses batches after lazily selecting the default implementation. */
+      async *decompressBatches(inputBatches) {
+        yield* (await this.preload()).decompressBatches(inputBatches);
       }
-      // HELPERS
-      concatenate(asyncIterator) {
-        return concatenateArrayBuffersAsync(asyncIterator);
+    };
+  }
+});
+
+// ../compression/src/zstd-decompressor-fzstd.ts
+var import_fzstd, ZstdFzstdDecompressor;
+var init_zstd_decompressor_fzstd = __esm({
+  "../compression/src/zstd-decompressor-fzstd.ts"() {
+    "use strict";
+    init_compression();
+    import_fzstd = require("fzstd");
+    ZstdFzstdDecompressor = class extends Decompressor {
+      name = "zstd";
+      extensions = ["zst"];
+      contentEncodings = ["zstd"];
+      isSupported = true;
+      constructor(options = {}) {
+        super(options);
       }
-      improveError(error) {
-        if (!error.message.includes(this.name)) {
-          error.message = `${this.name} ${error.message}`;
-        }
-        return error;
+      /** Decompresses one Zstandard frame synchronously. */
+      decompressSync(input) {
+        return (0, import_fzstd.decompress)(new Uint8Array(input)).slice().buffer;
       }
     };
   }
 });
 
+// ../compression/src/zstd-fallback.ts
+var zstd_fallback_exports = {};
+__export(zstd_fallback_exports, {
+  decompressZstd: () => decompressZstd
+});
+function decompressZstd(input) {
+  return (0, import_fzstd2.decompress)(input);
+}
+var import_fzstd2;
+var init_zstd_fallback = __esm({
+  "../compression/src/zstd-fallback.ts"() {
+    "use strict";
+    import_fzstd2 = require("fzstd");
+  }
+});
+
 // ../compression/src/lib/zstd-compression.ts
+var zstd_compression_exports = {};
+__export(zstd_compression_exports, {
+  ZstdCompression: () => ZstdCompression
+});
 var CHUNK_SIZE, zstdPromise, zstd, ZstdCompression;
 var init_zstd_compression = __esm({
   "../compression/src/lib/zstd-compression.ts"() {
     "use strict";
     init_compression();
     init_src();
+    init_compression_stream();
+    init_decompression_stream();
     CHUNK_SIZE = 1e6;
     ZstdCompression = class extends Compression {
       name = "zstd";
@@ -1303,6 +1621,15 @@ var init_zstd_compression = __esm({
         const inputArray = new Uint8Array(input);
         return simpleZstd.compress(inputArray).buffer;
       }
+      async compress(input) {
+        var _a;
+        if (this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
+          const nativeOutput = await compressWithNativeCompressionStream(input, "zstd");
+          if (nativeOutput) return nativeOutput;
+        }
+        await this.preload();
+        return this.compressSync(input);
+      }
       decompressSync(input) {
         getJSModule("zstd-codec", this.name);
         const simpleZstd = new zstd.Simple();
@@ -1310,11 +1637,16 @@ var init_zstd_compression = __esm({
         return simpleZstd.decompress(inputArray).buffer;
       }
       async decompress(input, size) {
+        var _a;
+        if (!getJSModuleOrNull("zstd-codec") && this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
+          const nativeOutput = await decompressWithNativeDecompressionStream(input, "zstd");
+          if (nativeOutput) return nativeOutput;
+        }
         await this.preload();
         const inputArray = new Uint8Array(input);
         if (!zstd) {
-          const { decompress } = await import("fzstd");
-          return ensureArrayBuffer(decompress(inputArray));
+          const { decompressZstd: decompressZstd2 } = await Promise.resolve().then(() => (init_zstd_fallback(), zstd_fallback_exports));
+          return ensureArrayBuffer(decompressZstd2(inputArray));
         }
         const simpleZstd = new zstd.Streaming();
         const chunks = [];
@@ -1330,15 +1662,105 @@ var init_zstd_compression = __esm({
   }
 });
 
-// ../compression/src/zstd-compression.ts
-var zstd_compression_exports = {};
-__export(zstd_compression_exports, {
-  ZstdCompression: () => ZstdCompression
+// ../compression/src/zstd-decompressor.ts
+var zstd_decompressor_exports = {};
+__export(zstd_decompressor_exports, {
+  ZstdDecompressor: () => ZstdDecompressor
+});
+var ZstdDecompressor;
+var init_zstd_decompressor = __esm({
+  "../compression/src/zstd-decompressor.ts"() {
+    "use strict";
+    init_zstd_decompressor_fzstd();
+    init_decompression_stream();
+    init_src();
+    ZstdDecompressor = class extends ZstdFzstdDecompressor {
+      options;
+      compatibility = null;
+      constructor(options = {}) {
+        super(options);
+        this.options = options;
+        registerJSModules(options.modules);
+      }
+      /** Preloads an injected zstd-codec implementation when supplied. */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        if (getJSModuleOrNull("zstd-codec")) {
+          const { ZstdCompression: ZstdCompression2 } = await Promise.resolve().then(() => (init_zstd_compression(), zstd_compression_exports));
+          this.compatibility ||= new ZstdCompression2(this.options);
+          await this.compatibility.preload(modules);
+        }
+      }
+      /** Decompresses with the built-in stream when available, then falls back to fzstd. */
+      async decompress(input) {
+        if (this.options.useNative !== false) {
+          const output = await decompressWithNativeDecompressionStream(input, "zstd");
+          if (output) return output;
+        }
+        if (getJSModuleOrNull("zstd-codec")) {
+          await this.preload(this.options.modules);
+        }
+        return this.decompressSync(input);
+      }
+      /** Decompresses with a preloaded zstd-codec implementation or compact fzstd. */
+      decompressSync(input) {
+        if (this.compatibility) {
+          return this.compatibility.decompressSync(input);
+        }
+        if (getJSModuleOrNull("zstd-codec")) {
+          throw new Error("zstd: call preload() before synchronous decompression with zstd-codec");
+        }
+        return super.decompressSync(input);
+      }
+      /** Decompresses batches with a built-in stream or compact fzstd fallback. */
+      async *decompressBatches(inputBatches) {
+        if (this.options.useNative !== false) {
+          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "zstd");
+          if (output) {
+            yield* output;
+            return;
+          }
+        }
+        if (getJSModuleOrNull("zstd-codec")) {
+          yield this.decompress(await this.concatenate(inputBatches));
+          return;
+        }
+        yield* super.decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
+// ../compression/src/default-codecs.ts
+var ZSTD, ZstdDecompressor2;
+var init_default_codecs = __esm({
+  "../compression/src/default-codecs.ts"() {
+    "use strict";
+    init_lazy_compression();
+    init_src();
+    ZSTD = { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] };
+    ZstdDecompressor2 = class extends LazyDecompressor {
+      constructor(options = {}) {
+        super(
+          ZSTD,
+          async () => (await Promise.resolve().then(() => (init_zstd_decompressor(), zstd_decompressor_exports))).ZstdDecompressor,
+          options,
+          "zstd",
+          (preloadOptions) => {
+            var _a;
+            return !((_a = preloadOptions.modules) == null ? void 0 : _a["zstd-codec"]) && !getJSModuleOrNull("zstd-codec");
+          }
+        );
+      }
+    };
+  }
 });
-var init_zstd_compression2 = __esm({
-  "../compression/src/zstd-compression.ts"() {
+
+// ../compression/src/index.ts
+var init_src2 = __esm({
+  "../compression/src/index.ts"() {
     "use strict";
-    init_zstd_compression();
+    init_default_codecs();
   }
 });
 
@@ -1350,30 +1772,11 @@ async function parseSPZToGaussianSplats(data, options) {
   const header = parseSPZHeader(data);
   const streamInfos = parseSPZStreamInfos(data, header, getSPZStreamByteLengths(header));
   const compressedStreams = streamInfos.map((streamInfo) => data.slice(streamInfo.compressedOffset, streamInfo.compressedOffset + streamInfo.compressedSize));
-  registerJSModules(options == null ? void 0 : options.modules);
-  const useNativeDecompressionStream = !getJSModuleOrNull("zstd-codec");
-  let compressionPromise;
-  const streams = await Promise.all(compressedStreams.map((compressedStream, streamIndex) => decompressSPZStream(compressedStream, streamInfos[streamIndex].uncompressedSize, useNativeDecompressionStream, () => {
-    compressionPromise ||= createZstdCompression(options == null ? void 0 : options.modules);
-    return compressionPromise;
-  })));
+  const decompressor = new ZstdDecompressor2({ modules: options == null ? void 0 : options.modules });
+  const streams = await Promise.all(compressedStreams.map((compressedStream, streamIndex) => decompressor.decompress(compressedStream, streamInfos[streamIndex].uncompressedSize)));
   validateSPZStreamLengths(streams, streamInfos);
   return decodeSPZStreams(header, streams, data);
 }
-async function decompressSPZStream(compressedStream, uncompressedSize, useNativeDecompressionStream, getCompression) {
-  if (useNativeDecompressionStream) {
-    const nativeOutput = await decompressWithNativeDecompressionStream(compressedStream, "zstd");
-    if (nativeOutput) {
-      return nativeOutput;
-    }
-  }
-  const compression = await getCompression();
-  return await compression.decompress(compressedStream, uncompressedSize);
-}
-async function createZstdCompression(modules) {
-  const { ZstdCompression: ZstdCompression2 } = await Promise.resolve().then(() => (init_zstd_compression2(), zstd_compression_exports));
-  return new ZstdCompression2({ modules });
-}
 function parseSPZHeader(data) {
   if (data.byteLength < SPZ_HEADER_BYTE_LENGTH) {
     throw new Error(`SPZLoader: file must contain a ${SPZ_HEADER_BYTE_LENGTH}-byte header.`);
@@ -1591,8 +1994,7 @@ var SPZ_HEADER_BYTE_LENGTH, SPZ_MAGIC, SPZ_VERSION, SPZ_EXTENSION_FLAG, SPZ_COLO
 var init_parse_spz = __esm({
   "dist/lib/parse-spz.js"() {
     "use strict";
-    init_native_decompression();
-    init_src();
+    init_src2();
     init_splats_arrow_table();
     init_splat_utils();
     SPZ_HEADER_BYTE_LENGTH = 32;
@@ -1634,7 +2036,7 @@ var init_spz_loader_types = __esm({
   "dist/spz-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION4 = true ? "5.0.0-alpha.2" : "latest";
+    VERSION4 = true ? "5.0.0-alpha.4" : "latest";
     SPZLoader = {
       dataType: null,
       batchType: null,
@@ -1808,144 +2210,94 @@ var init_parse_rad = __esm({
   }
 });
 
-// ../compression/src/lib/deflate-compression.ts
-var import_pako, import_zlib, DeflateCompression;
-var init_deflate_compression = __esm({
-  "../compression/src/lib/deflate-compression.ts"() {
+// ../compression/src/lib/fflate-stream.ts
+async function* transformFflateBatches(processor, inputBatches) {
+  const chunks = [];
+  processor.ondata = (data) => {
+    chunks.push(data.slice().buffer);
+  };
+  for await (const batch of inputBatches) {
+    processor.push(new Uint8Array(batch), false);
+    yield* chunks.splice(0);
+  }
+  processor.push(new Uint8Array(0), true);
+  yield* chunks;
+}
+var init_fflate_stream = __esm({
+  "../compression/src/lib/fflate-stream.ts"() {
+    "use strict";
+  }
+});
+
+// ../compression/src/deflate-decompressor-fflate.ts
+var import_fflate, DeflateFflateDecompressor;
+var init_deflate_decompressor_fflate = __esm({
+  "../compression/src/deflate-decompressor-fflate.ts"() {
     "use strict";
+    import_fflate = require("fflate");
     init_compression();
-    init_src();
-    import_pako = __toESM(require("pako"), 1);
-    import_zlib = __toESM(require("zlib"), 1);
-    DeflateCompression = class extends Compression {
+    init_fflate_stream();
+    DeflateFflateDecompressor = class extends Decompressor {
       name = "deflate";
       extensions = [];
       contentEncodings = ["deflate"];
       isSupported = true;
       options;
-      _chunks = [];
       constructor(options = {}) {
         super(options);
         this.options = options;
       }
-      async compress(input) {
-        var _a, _b;
-        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
-          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? await promisify1(import_zlib.default.gzip)(input) : await promisify1(import_zlib.default.deflate)(input);
-          return toArrayBuffer2(buffer);
-        }
-        return this.compressSync(input);
-      }
-      async decompress(input) {
-        var _a, _b;
-        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
-          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? await promisify1(import_zlib.default.gunzip)(input) : await promisify1(import_zlib.default.inflate)(input);
-          return toArrayBuffer2(buffer);
-        }
-        return this.decompressSync(input);
-      }
-      compressSync(input) {
-        var _a, _b, _c, _d;
-        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
-          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? import_zlib.default.gzipSync(input) : import_zlib.default.deflateSync(input);
-          return toArrayBuffer2(buffer);
-        }
-        const pakoOptions = ((_c = this.options) == null ? void 0 : _c.deflate) || {};
-        const inputArray = new Uint8Array(input);
-        const deflate = ((_d = this.options) == null ? void 0 : _d.raw) ? import_pako.default.deflateRaw : import_pako.default.deflate;
-        return toArrayBuffer2(deflate(inputArray, pakoOptions).buffer);
-      }
+      /** Decompresses one zlib-wrapped DEFLATE payload synchronously. */
       decompressSync(input) {
-        var _a, _b, _c, _d;
-        if (!isBrowser && ((_a = this.options.deflate) == null ? void 0 : _a.useZlib)) {
-          const buffer = ((_b = this.options.deflate) == null ? void 0 : _b.gzip) ? import_zlib.default.gunzipSync(input) : import_zlib.default.inflateSync(input);
-          return toArrayBuffer2(buffer);
-        }
-        const pakoOptions = ((_c = this.options) == null ? void 0 : _c.deflate) || {};
-        const inputArray = new Uint8Array(input);
-        const inflate = ((_d = this.options) == null ? void 0 : _d.raw) ? import_pako.default.inflateRaw : import_pako.default.inflate;
-        return toArrayBuffer2(inflate(inputArray, pakoOptions).buffer);
+        const bytes = new Uint8Array(input);
+        const output = this.options.raw ? (0, import_fflate.inflateSync)(bytes) : (0, import_fflate.unzlibSync)(bytes);
+        return output.slice().buffer;
       }
-      async *compressBatches(asyncIterator) {
-        var _a;
-        const pakoOptions = ((_a = this.options) == null ? void 0 : _a.deflate) || {};
-        const pakoProcessor = new import_pako.default.Deflate(pakoOptions);
-        yield* this.transformBatches(pakoProcessor, asyncIterator);
+      /** Decompresses DEFLATE batches incrementally. */
+      async *decompressBatches(inputBatches) {
+        const processor = this.options.raw ? new import_fflate.Inflate() : new import_fflate.Unzlib();
+        yield* transformFflateBatches(processor, inputBatches);
       }
-      async *decompressBatches(asyncIterator) {
-        var _a;
-        const pakoOptions = ((_a = this.options) == null ? void 0 : _a.deflate) || {};
-        const pakoProcessor = new import_pako.default.Inflate(pakoOptions);
-        yield* this.transformBatches(pakoProcessor, asyncIterator);
+    };
+  }
+});
+
+// ../compression/src/deflate-decompressor.ts
+var DeflateDecompressor2;
+var init_deflate_decompressor = __esm({
+  "../compression/src/deflate-decompressor.ts"() {
+    "use strict";
+    init_deflate_decompressor_fflate();
+    init_decompression_stream();
+    DeflateDecompressor2 = class extends DeflateFflateDecompressor {
+      constructor(options = {}) {
+        super(options);
       }
-      async *transformBatches(pakoProcessor, asyncIterator) {
-        pakoProcessor.onData = this._onData.bind(this);
-        pakoProcessor.onEnd = this._onEnd.bind(this);
-        for await (const chunk of asyncIterator) {
-          const uint8Array = new Uint8Array(chunk);
-          const ok2 = pakoProcessor.push(uint8Array, false);
-          if (!ok2) {
-            throw new Error(`${this._getError()}write`);
-          }
-          const chunks2 = this._getChunks();
-          yield* chunks2;
-        }
-        const emptyChunk = new Uint8Array(0);
-        const ok = pakoProcessor.push(emptyChunk, true);
-        if (!ok) {
+      /** Decompresses with the built-in stream when available, then falls back to fflate. */
+      async decompress(input) {
+        if (this.options.useNative !== false) {
+          const format = this.options.raw ? "deflate-raw" : "deflate";
+          const output = await decompressWithNativeDecompressionStream(input, format);
+          if (output) return output;
         }
-        const chunks = this._getChunks();
-        yield* chunks;
-      }
-      _onData(chunk) {
-        this._chunks.push(chunk);
+        return this.decompressSync(input);
       }
-      _onEnd(status) {
-        if (status !== 0) {
-          throw new Error(this._getError(status) + this._chunks.length);
+      /** Decompresses batches with a built-in or fflate stream. */
+      async *decompressBatches(inputBatches) {
+        if (this.options.useNative !== false) {
+          const format = this.options.raw ? "deflate-raw" : "deflate";
+          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, format);
+          if (output) {
+            yield* output;
+            return;
+          }
         }
-      }
-      _getChunks() {
-        const chunks = this._chunks;
-        this._chunks = [];
-        return chunks;
-      }
-      // TODO - For some reason we don't get the error message from pako in _onEnd?
-      _getError(code = 0) {
-        const MESSAGES = {
-          /* Z_NEED_DICT       2  */
-          2: "need dictionary",
-          /* Z_STREAM_END      1  */
-          1: "stream end",
-          /* Z_OK              0  */
-          0: "",
-          /* Z_ERRNO         (-1) */
-          "-1": "file error",
-          /* Z_STREAM_ERROR  (-2) */
-          "-2": "stream error",
-          /* Z_DATA_ERROR    (-3) */
-          "-3": "data error",
-          /* Z_MEM_ERROR     (-4) */
-          "-4": "insufficient memory",
-          /* Z_BUF_ERROR     (-5) */
-          "-5": "buffer error",
-          /* Z_VERSION_ERROR (-6) */
-          "-6": "incompatible version"
-        };
-        return `${this.name}: ${MESSAGES[code]}`;
+        yield* super.decompressBatches(inputBatches);
       }
     };
   }
 });
 
-// ../compression/src/index.ts
-var init_src2 = __esm({
-  "../compression/src/index.ts"() {
-    "use strict";
-    init_deflate_compression();
-  }
-});
-
 // dist/lib/parse-rad-chunk.js
 function parseRADChunk(data, options) {
   return makeGaussianSplatsArrowTable(parseRADChunkToGaussianSplats(data, options));
@@ -2408,12 +2760,12 @@ var RAD_PROPERTY_DEFLATE, RAD_PROPERTY_RAW_DEFLATE;
 var init_parse_rad_chunk = __esm({
   "dist/lib/parse-rad-chunk.js"() {
     "use strict";
-    init_src2();
+    init_deflate_decompressor();
     init_parse_rad();
     init_splats_arrow_table();
     init_splat_utils();
-    RAD_PROPERTY_DEFLATE = new DeflateCompression();
-    RAD_PROPERTY_RAW_DEFLATE = new DeflateCompression({ raw: true });
+    RAD_PROPERTY_DEFLATE = new DeflateDecompressor2({ useNative: false });
+    RAD_PROPERTY_RAW_DEFLATE = new DeflateDecompressor2({ raw: true, useNative: false });
   }
 });
 
@@ -2454,7 +2806,7 @@ var init_rad_loader_types = __esm({
   "dist/rad-loader-types.js"() {
     "use strict";
     init_splats_format();
-    VERSION5 = true ? "5.0.0-alpha.2" : "latest";
+    VERSION5 = true ? "5.0.0-alpha.4" : "latest";
     RADLoader = {
       dataType: null,
       batchType: null,
@@ -2496,7 +2848,7 @@ init_parse_rad_chunk();
 init_splats_arrow_table();
 var DEFAULT_RAD_HEADER_BYTE_LENGTHS = [64 * 1024, 256 * 1024, 1024 * 1024];
 var DEFAULT_RAD_MAX_CONCURRENT_CHUNK_REQUESTS = 4;
-var VERSION6 = true ? "5.0.0-alpha.2" : "latest";
+var VERSION6 = true ? "5.0.0-alpha.4" : "latest";
 var RADSourceLoader = {
   dataType: null,
   batchType: null,