@loaders.gl/parquet 4.4.5 → 5.0.0-alpha.2

package/src/parquet-js-loader-types.ts

@@ -0,0 +1,52 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Loader} from '@loaders.gl/loader-utils';
+import type {
+  ArrowTable,
+  ArrowTableBatch,
+  ObjectRowTable,
+  ObjectRowTableBatch
+} from '@loaders.gl/schema';
+
+import {ParquetFormat} from './parquet-format';
+import type {ParquetJSLoaderOptions} from './parquet-loader-options';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** Default option bag for the experimental parquetjs plain-row loader. */
+const DEFAULT_PARQUET_JS_OPTIONS = {
+  columns: undefined,
+  preserveBinary: false,
+  shape: 'object-row-table' as const
+};
+
+/** Preloads the parser-bearing TypeScript Parquet loader implementation. */
+async function preloadParquetJSLoader() {
+  const {ParquetJSLoaderWithParser} = await import('@loaders.gl/parquet/parquet-js-loader');
+  return ParquetJSLoaderWithParser;
+}
+
+/** Metadata-only Parquet loader backed by the experimental TypeScript implementation. */
+export const ParquetJSLoader = {
+  ...ParquetFormat,
+
+  dataType: null as unknown as ObjectRowTable | ArrowTable,
+  batchType: null as unknown as ObjectRowTableBatch | ArrowTableBatch,
+
+  id: 'parquet-js',
+  module: 'parquet',
+  version: VERSION,
+  worker: false,
+  options: {
+    parquet: DEFAULT_PARQUET_JS_OPTIONS
+  },
+  preload: preloadParquetJSLoader
+} as const satisfies Loader<
+  ObjectRowTable | ArrowTable,
+  ObjectRowTableBatch | ArrowTableBatch,
+  ParquetJSLoaderOptions
+>;

package/src/parquet-js-loader.ts

@@ -0,0 +1,83 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderWithParser, ReadableFile} from '@loaders.gl/loader-utils';
+import {ArrayBufferFile, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';
+import type {
+  ArrowTable,
+  ArrowTableBatch,
+  ObjectRowTable,
+  ObjectRowTableBatch
+} from '@loaders.gl/schema';
+import {parseParquetFile, parseParquetFileInBatches} from './lib/parsers/parse-parquet-to-json';
+import {
+  parseParquetFileToArrowInBatchesWithJs,
+  parseParquetFileToArrowWithJs
+} from './lib/parsers/parse-parquet-to-arrow-js';
+import {normalizeParquetOptions} from './lib/utils/normalize-parquet-options';
+import {ParquetJSLoader as ParquetJSLoaderMetadata} from './parquet-js-loader-types';
+import type {ParquetJSLoaderOptions} from './parquet-loader-options';
+
+const {preload: _ParquetJSLoaderPreload, ...ParquetJSLoaderMetadataWithoutPreload} =
+  ParquetJSLoaderMetadata;
+
+/** Default option bag for the experimental parquetjs plain-row loader. */
+const DEFAULT_PARQUET_JS_OPTIONS = {
+  columns: undefined,
+  preserveBinary: false
+};
+
+/** Parser-bearing TypeScript-only Parquet loader implementation. */
+export const ParquetJSLoaderWithParser = {
+  ...ParquetJSLoaderMetadataWithoutPreload,
+  worker: false,
+  parse(arrayBuffer: ArrayBuffer, options?: ParquetJSLoaderOptions) {
+    const parquetOptions = getParquetOptions(options);
+    const file = new ArrayBufferFile(arrayBuffer);
+    return parquetOptions.parquet?.shape === 'arrow-table'
+      ? parseParquetFileToArrowWithJs(file, parquetOptions)
+      : parseParquetFile(file, parquetOptions);
+  },
+  parseFile(file: ReadableFile, options?: ParquetJSLoaderOptions) {
+    const parquetOptions = getParquetOptions(options);
+    return parquetOptions.parquet?.shape === 'arrow-table'
+      ? parseParquetFileToArrowWithJs(file, parquetOptions)
+      : parseParquetFile(file, parquetOptions);
+  },
+  parseFileInBatches(file: ReadableFile, options?: ParquetJSLoaderOptions) {
+    const parquetOptions = getParquetOptions(options);
+    return parquetOptions.parquet?.shape === 'arrow-table'
+      ? parseParquetFileToArrowInBatchesWithJs(file, parquetOptions)
+      : parseParquetFileInBatches(file, parquetOptions);
+  },
+  async *parseInBatches(
+    asyncIterator:
+      | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+      | Iterable<ArrayBufferLike | ArrayBufferView>,
+    options?: ParquetJSLoaderOptions,
+    _context?: unknown
+  ) {
+    const arrayBuffer = await concatenateArrayBuffersAsync(asyncIterator);
+    const parquetOptions = getParquetOptions(options);
+    const file = new ArrayBufferFile(arrayBuffer);
+    if (parquetOptions.parquet?.shape === 'arrow-table') {
+      yield* parseParquetFileToArrowInBatchesWithJs(file, parquetOptions);
+    } else {
+      yield* parseParquetFileInBatches(file, parquetOptions);
+    }
+  }
+} as const satisfies LoaderWithParser<
+  ObjectRowTable | ArrowTable,
+  ObjectRowTableBatch | ArrowTableBatch,
+  ParquetJSLoaderOptions
+>;
+
+/**
+ * Normalizes caller options for the TypeScript-backed Parquet loader.
+ * @param options caller-supplied loader options
+ * @returns normalized options with TypeScript defaults applied
+ */
+function getParquetOptions(options?: ParquetJSLoaderOptions): ParquetJSLoaderOptions {
+  return normalizeParquetOptions(options, DEFAULT_PARQUET_JS_OPTIONS);
+}

package/src/parquet-js-writer.ts

@@ -0,0 +1,68 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {WriterOptions, WriterWithEncoder} from '@loaders.gl/loader-utils';
+import type {ObjectRowTable, Table, TableBatch} from '@loaders.gl/schema';
+import {convertTable, deduceTableSchema} from '@loaders.gl/schema-utils';
+
+import {normalizeParquetOptions} from './lib/utils/normalize-parquet-options';
+import {encodeTableToParquetJs} from './lib/encoders/encode-table-to-parquet-js';
+import {ParquetFormat} from './parquet-format';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** Stable value encodings selectable by the TypeScript Parquet writer. */
+export type ParquetJSWriterEncoding =
+  | 'PLAIN'
+  | 'BYTE_STREAM_SPLIT'
+  | 'DELTA_BINARY_PACKED'
+  | 'DELTA_LENGTH_BYTE_ARRAY'
+  | 'DELTA_BYTE_ARRAY';
+
+/** Encoder-specific options for the experimental parquetjs writer. */
+type ParquetJSWriterEncoderOptions = {
+  /** Value encoding overrides keyed by top-level column name. */
+  columnEncodings?: Record<string, ParquetJSWriterEncoding>;
+  /** Enables dictionary pages globally when forced or size-beneficial. */
+  dictionary?: boolean | 'auto';
+  /** Dictionary policy overrides keyed by top-level column name. */
+  columnDictionaries?: Record<string, boolean | 'auto'>;
+  /** Maximum uncompressed PLAIN dictionary payload per column chunk. */
+  dictionaryPageSizeLimit?: number;
+  rowGroupSize?: number;
+  pageSize?: number;
+  useDataPageV2?: boolean;
+};
+
+/** Public options for the parquetjs-backed plain-table writer. */
+export type ParquetJSWriterOptions = WriterOptions & {
+  parquet?: {
+    [Key in keyof ParquetJSWriterEncoderOptions]?: ParquetJSWriterEncoderOptions[Key];
+  };
+};
+
+/** Default option bag for the experimental parquetjs writer. */
+const DEFAULT_PARQUET_JS_OPTIONS = {};
+
+/** Plain-row Parquet writer backed by the experimental parquetjs implementation. */
+export const ParquetJSWriter = {
+  ...ParquetFormat,
+  id: 'parquet-js',
+  module: 'parquet',
+  version: VERSION,
+  options: {
+    parquet: DEFAULT_PARQUET_JS_OPTIONS
+  },
+  async encode(table: Table, options?: ParquetJSWriterOptions) {
+    const schema = table.schema || deduceTableSchema(table);
+    const objectRowTable = convertTable({...table, schema}, 'object-row-table') as ObjectRowTable;
+    return await encodeTableToParquetJs(
+      {...table, schema},
+      objectRowTable,
+      normalizeParquetOptions(options, DEFAULT_PARQUET_JS_OPTIONS)
+    );
+  }
+} as const satisfies WriterWithEncoder<Table, TableBatch, ParquetJSWriterOptions>;

package/src/parquet-loader-base.ts

@@ -0,0 +1,34 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  ArrowTable,
+  ArrowTableBatch,
+  ObjectRowTable,
+  ObjectRowTableBatch
+} from '@loaders.gl/schema';
+
+import {ParquetFormat} from './parquet-format';
+import {PARQUET_LOADER_DEFAULT_OPTIONS} from './parquet-loader-options';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** Shared Parquet loader metadata without parser preloading or worker delivery policy. */
+export const PARQUET_LOADER_BASE = {
+  ...ParquetFormat,
+
+  dataType: null as unknown as ObjectRowTable | ArrowTable,
+  batchType: null as unknown as ObjectRowTableBatch | ArrowTableBatch,
+
+  id: 'parquet',
+  module: 'parquet',
+  version: VERSION,
+  options: {
+    parquet: {
+      ...PARQUET_LOADER_DEFAULT_OPTIONS
+    }
+  }
+} as const;

package/src/parquet-loader-options.ts

@@ -0,0 +1,51 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderOptions} from '@loaders.gl/loader-utils';
+
+/** Shared row-level options supported by both Parquet backends. */
+type ParquetCommonLoaderOptions = {
+  limit?: number;
+  offset?: number;
+  batchSize?: number;
+  columns?: string[];
+  preserveBinary?: boolean;
+};
+
+/** Additional options supported by the wasm-backed Parquet reader. */
+type ParquetWasmLoaderOptions = ParquetCommonLoaderOptions & {
+  rowGroups?: number[];
+  concurrency?: number;
+  /** Cancels an active worker parse by terminating its worker. */
+  signal?: AbortSignal;
+  /** Overrides the packaged Parquet worker asset URL. */
+  workerUrl?: string;
+  /** Overrides the package-local parquet-wasm binary URL. */
+  wasmUrl?: string;
+};
+
+/** Public options for the wasm-backed `ParquetLoader` and `GeoParquetLoader`. */
+export type ParquetLoaderOptions = LoaderOptions & {
+  parquet?: {
+    shape?: 'object-row-table' | 'arrow-table';
+  } & {
+    [Key in keyof ParquetWasmLoaderOptions]?: ParquetWasmLoaderOptions[Key];
+  };
+};
+
+/** Public options for the experimental parquetjs-backed `ParquetJSLoader`. */
+export type ParquetJSLoaderOptions = LoaderOptions & {
+  parquet?: {
+    shape?: 'object-row-table' | 'arrow-table';
+  } & {
+    [Key in keyof ParquetCommonLoaderOptions]?: ParquetCommonLoaderOptions[Key];
+  };
+};
+
+/** Shared default option bag for the wasm-backed Parquet loaders. */
+export const PARQUET_LOADER_DEFAULT_OPTIONS = {
+  columns: undefined,
+  preserveBinary: false,
+  shape: 'object-row-table'
+} as const;

package/src/parquet-loader-types.ts

@@ -0,0 +1,35 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Loader} from '@loaders.gl/loader-utils';
+import type {
+  ObjectRowTable,
+  ObjectRowTableBatch,
+  ArrowTable,
+  ArrowTableBatch
+} from '@loaders.gl/schema';
+
+import {PARQUET_LOADER_BASE} from './parquet-loader-base';
+import type {ParquetLoaderOptions as SharedParquetLoaderOptions} from './parquet-loader-options';
+import {PARQUET_WORKER_URL} from './parquet-worker-url';
+
+/** Options for the Parquet loader. */
+export type ParquetLoaderOptions = SharedParquetLoaderOptions;
+
+/** Preloads the parser-bearing WASM Parquet loader implementation. */
+async function preloadParquetLoader() {
+  const {ParquetLoaderWithParser} = await import('@loaders.gl/parquet/parquet-loader');
+  return ParquetLoaderWithParser;
+}
+
+/** Metadata-only Parquet table loader supporting object-row and Arrow table output. */
+export const ParquetLoader = {
+  ...PARQUET_LOADER_BASE,
+  worker: PARQUET_WORKER_URL,
+  preload: preloadParquetLoader
+} as const satisfies Loader<
+  ObjectRowTable | ArrowTable,
+  ObjectRowTableBatch | ArrowTableBatch,
+  ParquetLoaderOptions
+>;

package/src/parquet-loader.ts

@@ -0,0 +1,115 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import {BlobFile, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';
+import type {
+  ObjectRowTable,
+  ObjectRowTableBatch,
+  ArrowTable,
+  ArrowTableBatch
+} from '@loaders.gl/schema';
+import type {ReadableFile} from '@loaders.gl/loader-utils';
+
+import {
+  convertArrowBatchToObjectRows,
+  convertArrowTableToObjectRows
+} from './lib/parsers/convert-parquet-tables';
+import {
+  parseParquetFileToArrow,
+  parseParquetFileToArrowInBatches
+} from './lib/parsers/parse-parquet-to-arrow';
+import {normalizeParquetOptions} from './lib/utils/normalize-parquet-options';
+import {
+  deserializeParquetWorkerResult,
+  serializeParquetWorkerResult
+} from './lib/parquet-worker-transport';
+import {ParquetLoader as ParquetLoaderMetadata} from './parquet-loader-types';
+import type {ParquetLoaderOptions} from './parquet-loader-options';
+
+export type {ParquetLoaderOptions} from './parquet-loader-options';
+
+const {preload: _ParquetLoaderPreload, ...ParquetLoaderMetadataWithoutPreload} =
+  ParquetLoaderMetadata;
+
+/** WASM-backed Parquet table loader supporting object-row and Arrow table output. */
+export const ParquetLoaderWithParser = {
+  ...ParquetLoaderMetadataWithoutPreload,
+  parse(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions) {
+    return parseParquetTable(new BlobFile(arrayBuffer), options);
+  },
+  parseFile(file, options?: ParquetLoaderOptions) {
+    return parseParquetTable(file, options);
+  },
+  parseFileInBatches(file, options?: ParquetLoaderOptions) {
+    return parseParquetTableInBatches(file, options);
+  },
+  async *parseInBatches(
+    asyncIterator:
+      | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+      | Iterable<ArrayBufferLike | ArrayBufferView>,
+    options?: ParquetLoaderOptions,
+    _context?: unknown
+  ) {
+    const arrayBuffer = await concatenateArrayBuffersAsync(asyncIterator);
+    yield* parseParquetTableInBatches(new BlobFile(arrayBuffer), options);
+  },
+  serializeWorkerResult: serializeParquetWorkerResult,
+  deserializeWorkerResult: deserializeParquetWorkerResult
+} as const satisfies LoaderWithParser<
+  ObjectRowTable | ArrowTable,
+  ObjectRowTableBatch | ArrowTableBatch,
+  ParquetLoaderOptions
+>;
+
+/**
+ * Parses a Parquet file using the canonical WASM-backed table loader.
+ * @param file readable file abstraction
+ * @param options optional loader options
+ * @returns object-row or Arrow table output depending on `parquet.shape`
+ */
+async function parseParquetTable(
+  file: BlobFile | ReadableFile,
+  options?: ParquetLoaderOptions
+): Promise<ObjectRowTable | ArrowTable> {
+  const parquetOptions = getParquetOptions(options);
+
+  if (parquetOptions.parquet?.shape === 'arrow-table') {
+    return await parseParquetFileToArrow(file, parquetOptions.parquet);
+  }
+
+  const arrowTable = await parseParquetFileToArrow(file, parquetOptions.parquet);
+  return convertArrowTableToObjectRows(arrowTable);
+}
+
+/**
+ * Parses a Parquet file into streamed table batches using the canonical WASM-backed loader.
+ * @param file readable file abstraction
+ * @param options optional loader options
+ * @returns async iterable of object-row or Arrow batches
+ */
+async function* parseParquetTableInBatches(
+  file: BlobFile | ReadableFile,
+  options?: ParquetLoaderOptions
+): AsyncIterable<ObjectRowTableBatch | ArrowTableBatch> {
+  const parquetOptions = getParquetOptions(options);
+
+  if (parquetOptions.parquet?.shape === 'arrow-table') {
+    yield* parseParquetFileToArrowInBatches(file, parquetOptions.parquet);
+    return;
+  }
+
+  for await (const batch of parseParquetFileToArrowInBatches(file, parquetOptions.parquet)) {
+    yield convertArrowBatchToObjectRows(batch);
+  }
+}
+
+/**
+ * Normalizes caller options for the canonical WASM-backed Parquet loaders.
+ * @param options caller-supplied loader options
+ * @returns normalized loader options
+ */
+export function getParquetOptions(options?: ParquetLoaderOptions): ParquetLoaderOptions {
+  return normalizeParquetOptions(options, ParquetLoaderWithParser.options.parquet);
+}

package/src/parquet-source-capabilities.ts

@@ -0,0 +1,56 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Feature support advertised by a {@link ParquetSource}. */
+export type ParquetSourceCapabilities = Readonly<{
+  /** Schema and footer metadata are cached for the lifetime of the source. */
+  supportsCachedMetadata: boolean;
+  /** Reads can select explicit Parquet row groups. */
+  supportsRowGroupSelection: boolean;
+  /** Reads can project explicit Parquet column paths. */
+  supportsColumnProjection: boolean;
+  /** Every emitted batch identifies its source row group and row offsets. */
+  supportsBatchProvenance: boolean;
+  /** Read cancellation is propagated cooperatively through the active stream. */
+  supportsCooperativeReadCancellation: boolean;
+  /** The package includes a local parquet-wasm binary for self-hosted delivery. */
+  supportsLocalWasmAsset: boolean;
+  /** Column min/max/null statistics are exposed in public metadata. */
+  supportsColumnStatistics: boolean;
+  /** Serializable predicates can prune impossible row groups using column statistics. */
+  supportsPredicatePushdown: boolean;
+  /** Column and offset indexes can avoid irrelevant data-page range reads for flat columns. */
+  supportsPageIndexPruning: boolean;
+  /** Surviving decoded rows are filtered exactly on the caller thread or worker. */
+  supportsExactPredicateFiltering: boolean;
+  /** Callers can supply the random-access transport used by the source. */
+  supportsCustomRangeTransport: boolean;
+  /** Range requests validate that the source object version remains unchanged. */
+  supportsObjectVersionValidation: boolean;
+  /** Requested bytes, downloaded bytes, request counts, and network time are reported. */
+  supportsNetworkTelemetry: boolean;
+  /** Decoder time is reported separately from network and Arrow conversion time. */
+  supportsDecodeTelemetry: boolean;
+  /** Parquet decoding can run in a worker and transfer Arrow output. */
+  supportsWorkerDecoding: boolean;
+}>;
+
+/** Capabilities of the current range-backed TypeScript {@link ParquetSource}. */
+export const PARQUET_SOURCE_CAPABILITIES: ParquetSourceCapabilities = Object.freeze({
+  supportsCachedMetadata: true,
+  supportsRowGroupSelection: true,
+  supportsColumnProjection: true,
+  supportsBatchProvenance: true,
+  supportsCooperativeReadCancellation: true,
+  supportsLocalWasmAsset: true,
+  supportsColumnStatistics: true,
+  supportsPredicatePushdown: true,
+  supportsPageIndexPruning: true,
+  supportsExactPredicateFiltering: true,
+  supportsCustomRangeTransport: true,
+  supportsObjectVersionValidation: true,
+  supportsNetworkTelemetry: true,
+  supportsDecodeTelemetry: true,
+  supportsWorkerDecoding: true
+});

package/src/parquet-source-loader-types.ts

@@ -0,0 +1,87 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {CoreAPI, SourceLoader} from '@loaders.gl/loader-utils';
+
+import {ParquetFormat} from './parquet-format';
+import type {ParquetSource} from './parquet-source-loader';
+import type {ParquetSourceLoaderOptions} from './parquet-source-types';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** Loads the runtime Parquet source implementation from its explicit package subpath. */
+async function preloadParquetSourceLoader(): Promise<SourceLoader<ParquetSource>> {
+  const {ParquetSourceLoaderWithParser} = await import('@loaders.gl/parquet/parquet-source-loader');
+  return ParquetSourceLoaderWithParser;
+}
+
+/**
+ * Lightweight Parquet source metadata.
+ *
+ * Use with the async `load()` API, which preloads the implementation, or import the runtime source
+ * loader from `@loaders.gl/parquet/parquet-source-loader` for synchronous `createDataSource()`.
+ */
+export const ParquetSourceLoader = {
+  ...ParquetFormat,
+  dataType: null as unknown as ParquetSource,
+  batchType: null as never,
+  name: 'ParquetSourceLoader',
+  id: 'parquet-source',
+  module: 'parquet',
+  version: VERSION,
+  type: 'parquet',
+  fromUrl: true,
+  fromBlob: true,
+  options: {
+    parquet: {
+      rowGroups: undefined,
+      columns: undefined,
+      batchSize: undefined,
+      concurrency: undefined,
+      rowGroupFilter: undefined,
+      headers: undefined,
+      preserveBinary: false,
+      onTelemetry: undefined,
+      workerUrl: undefined,
+      wasmUrl: undefined
+    },
+    rangeRequests: {
+      batchDelayMs: 0,
+      maxGapBytes: 0,
+      rangeExpansionBytes: 0
+    }
+  },
+  defaultOptions: {
+    parquet: {
+      rowGroups: undefined!,
+      columns: undefined!,
+      batchSize: undefined!,
+      concurrency: undefined!,
+      rowGroupFilter: undefined!,
+      headers: undefined!,
+      preserveBinary: false,
+      onTelemetry: undefined!,
+      workerUrl: undefined!,
+      wasmUrl: undefined!
+    },
+    rangeRequests: {
+      batchDelayMs: 0,
+      maxGapBytes: 0,
+      rangeExpansionBytes: 0
+    }
+  },
+  testURL: (url: string): boolean => /\.parquet(?:$|[?#])/i.test(url),
+  preload: preloadParquetSourceLoader,
+  createDataSource(
+    _data: string | Blob,
+    _options: ParquetSourceLoaderOptions,
+    _coreApi?: CoreAPI
+  ): ParquetSource {
+    throw new Error(
+      'ParquetSourceLoader requires async load() or an explicit @loaders.gl/parquet/parquet-source-loader import'
+    );
+  }
+} as const satisfies SourceLoader<ParquetSource>;