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

package/src/lib/encoders/encode-table-to-parquet-js.ts

@@ -3,6 +3,12 @@
 // Copyright (c) vis.gl contributors
 
 import type {DataType, Field, ObjectRowTable, Schema, Table} from '@loaders.gl/schema';
+import {
+  getGeoMetadata,
+  type GeoArrowEdgeType,
+  type GeoArrowMetadata,
+  type GeoColumnMetadata
+} from '@loaders.gl/gis';
 import {concatUint8Arrays} from '../../parquetjs/utils/binary-utils';
 import {ParquetEncoder} from '../../parquetjs/encoder/parquet-encoder';
 import {ParquetSchema} from '../../parquetjs/schema/schema';
@@ -62,7 +68,17 @@ function convertSchemaToParquetSchema(
   const parquetFields: SchemaDefinition = {};
   const columnEncodings = options.parquet?.columnEncodings || {};
   const columnDictionaries = options.parquet?.columnDictionaries || {};
+  const bloomFilterColumns =
+    options.parquet?.bloomFilter && typeof options.parquet.bloomFilter === 'object'
+      ? options.parquet.bloomFilter
+      : {};
+  const pageIndexColumns =
+    options.parquet?.pageIndex && typeof options.parquet.pageIndex === 'object'
+      ? options.parquet.pageIndex
+      : {};
+  const columnKeyMetadata = options.parquet?.encryption?.columnKeyMetadata || {};
   const fieldNames = new Set(schema.fields.map(field => field.name));
+  const geoMetadata = getGeoMetadata(schema.metadata);
   for (const columnName of Object.keys(columnEncodings)) {
     if (!fieldNames.has(columnName)) {
       throw new Error(`ParquetJSWriter: Unknown column encoding override "${columnName}"`);
@@ -73,10 +89,32 @@ function convertSchemaToParquetSchema(
       throw new Error(`ParquetJSWriter: Unknown column dictionary override "${columnName}"`);
     }
   }
+  for (const columnName of Object.keys(bloomFilterColumns)) {
+    if (!fieldNames.has(columnName)) {
+      throw new Error(`ParquetJSWriter: Unknown Bloom-filter column "${columnName}"`);
+    }
+  }
+  for (const columnName of Object.keys(pageIndexColumns)) {
+    if (!fieldNames.has(columnName)) {
+      throw new Error(`ParquetJSWriter: Unknown page-index column "${columnName}"`);
+    }
+  }
+  for (const columnName of Object.keys(columnKeyMetadata)) {
+    if (!fieldNames.has(columnName)) {
+      throw new Error(`ParquetJSWriter: Unknown encryption column key "${columnName}"`);
+    }
+  }
 
   for (const field of schema.fields) {
     parquetFields[field.name] = {
-      ...convertFieldToParquetFieldDefinition(field, objectRowTable.data),
+      ...convertFieldToParquetFieldDefinition(
+        field,
+        objectRowTable.data,
+        geoMetadata?.version,
+        geoMetadata?.columns?.[field.name],
+        undefined,
+        options.parquet?.int96AsTimestamp
+      ),
       encoding: columnEncodings[field.name]
     };
   }
@@ -92,12 +130,116 @@ function convertSchemaToParquetSchema(
  */
 function convertFieldToParquetFieldDefinition(
   field: Field,
-  rows: Array<Record<string, unknown>>
+  rows: Array<Record<string, unknown>>,
+  geoParquetVersion?: string,
+  geoColumnMetadata?: GeoColumnMetadata,
+  fieldValues?: readonly unknown[],
+  int96AsTimestamp = false
 ): FieldDefinition {
-  const sampleValue = getFirstDefinedValue(rows, field.name);
+  const values = fieldValues || rows.map(row => row[field.name]);
+  const sampleValue = getFirstDefinedValue(values);
   const nullable = field.nullable ?? sampleValue === undefined;
   const dataType = field.type === 'null' ? getDataTypeFromValue(sampleValue) : field.type;
 
+  if (typeof dataType === 'object') {
+    switch (dataType.type) {
+      case 'struct':
+        return {
+          optional: nullable,
+          fields: Object.fromEntries(
+            dataType.children.map(child => [
+              child.name,
+              convertFieldToParquetFieldDefinition(
+                child,
+                [],
+                undefined,
+                undefined,
+                getStructChildValues(values, child.name),
+                int96AsTimestamp
+              )
+            ])
+          )
+        };
+      case 'list': {
+        const child = dataType.children[0];
+        if (!child) {
+          throw new Error(`ParquetJSWriter: List field "${field.name}" has no value child`);
+        }
+        return {
+          optional: nullable,
+          logicalType: {type: 'LIST'},
+          fields: {
+            list: {
+              repeated: true,
+              fields: {
+                element: convertFieldToParquetFieldDefinition(
+                  child,
+                  [],
+                  undefined,
+                  undefined,
+                  flattenListValues(values),
+                  int96AsTimestamp
+                )
+              }
+            }
+          }
+        };
+      }
+      case 'map': {
+        const mapEntryField = dataType.children.length === 1 ? dataType.children[0] : undefined;
+        const mapEntryChildren =
+          mapEntryField &&
+          typeof mapEntryField.type === 'object' &&
+          mapEntryField.type.type === 'struct'
+            ? mapEntryField.type.children
+            : dataType.children;
+        const [keyField, valueField] = mapEntryChildren;
+        if (!keyField || !valueField) {
+          throw new Error(
+            `ParquetJSWriter: Map field "${field.name}" needs key and value children`
+          );
+        }
+        if (keyField.nullable) {
+          throw new Error(`ParquetJSWriter: Map keys must be non-nullable ("${field.name}")`);
+        }
+        return {
+          optional: nullable,
+          logicalType: {type: 'MAP'},
+          fields: {
+            key_value: {
+              repeated: true,
+              fields: {
+                key: {
+                  ...convertFieldToParquetFieldDefinition(
+                    {...keyField, name: 'key', nullable: false},
+                    [],
+                    undefined,
+                    undefined,
+                    getMapChildValues(values, 'key'),
+                    int96AsTimestamp
+                  ),
+                  optional: false
+                },
+                value: {
+                  ...convertFieldToParquetFieldDefinition(
+                    {...valueField, name: 'value'},
+                    [],
+                    undefined,
+                    undefined,
+                    getMapChildValues(values, 'value'),
+                    int96AsTimestamp
+                  )
+                }
+              }
+            }
+          }
+        };
+      }
+      default:
+        break;
+    }
+  }
+
   switch (dataType) {
     case 'bool':
       return {type: 'BOOLEAN', optional: nullable};
@@ -141,6 +283,26 @@ function convertFieldToParquetFieldDefinition(
       return {type: 'UTF8', optional: nullable};
 
     case 'binary':
+      if (
+        geoParquetVersion?.startsWith('2.') &&
+        String(geoColumnMetadata?.encoding).toLowerCase() === 'wkb'
+      ) {
+        return getNativeGeospatialFieldDefinition(
+          nullable,
+          getNativeGeospatialCRS(geoColumnMetadata?.crs),
+          geoColumnMetadata?.edges
+        );
+      }
+      if (!geoParquetVersion) {
+        const geoArrowMetadata = getWKBGeoArrowMetadata(field);
+        if (geoArrowMetadata) {
+          return getNativeGeospatialFieldDefinition(
+            nullable,
+            getGeoArrowNativeCRS(geoArrowMetadata),
+            geoArrowMetadata.edges
+          );
+        }
+      }
       return {type: 'BYTE_ARRAY', optional: nullable};
 
     case 'date-day':
@@ -155,7 +317,10 @@ function convertFieldToParquetFieldDefinition(
       return {type: 'TIMESTAMP_MICROS', optional: nullable};
 
     case 'timestamp-nanosecond':
-      return {type: 'TIMESTAMP_NANOS', optional: nullable};
+      return {
+        type: int96AsTimestamp ? 'INT96' : 'TIMESTAMP_NANOS',
+        optional: nullable
+      };
 
     case 'time-second':
     case 'time-millisecond':
@@ -200,6 +365,70 @@ function convertFieldToParquetFieldDefinition(
   }
 }
 
+/** Serializes GeoParquet CRS metadata into the native Parquet logical-type string. */
+function getNativeGeospatialCRS(crs: object | null | undefined): string | undefined {
+  if (crs === null) return 'srid:0';
+  return crs === undefined ? undefined : JSON.stringify(crs);
+}
+
+/** Creates a native GEOMETRY or GEOGRAPHY field from normalized spatial semantics. */
+function getNativeGeospatialFieldDefinition(
+  nullable: boolean,
+  crs: string | undefined,
+  edges: 'planar' | GeoArrowEdgeType | undefined
+): FieldDefinition {
+  return edges && edges !== 'planar'
+    ? {
+        type: 'GEOGRAPHY',
+        optional: nullable,
+        logicalType: {type: 'GEOGRAPHY', crs, algorithm: edges.toUpperCase()}
+      }
+    : {
+        type: 'GEOMETRY',
+        optional: nullable,
+        logicalType: {type: 'GEOMETRY', crs}
+      };
+}
+
+/** Reads validated GeoArrow WKB extension metadata from a field. */
+function getWKBGeoArrowMetadata(field: Field): GeoArrowMetadata | undefined {
+  if (field.metadata?.['ARROW:extension:name']?.toLowerCase() !== 'geoarrow.wkb') return undefined;
+  const serializedMetadata = field.metadata['ARROW:extension:metadata'];
+  if (!serializedMetadata) return {};
+  let metadata: unknown;
+  try {
+    metadata = JSON.parse(serializedMetadata);
+  } catch (error) {
+    throw new Error(`ParquetJSWriter: Invalid GeoArrow metadata on "${field.name}"`, {
+      cause: error
+    });
+  }
+  if (!metadata || typeof metadata !== 'object') {
+    throw new Error(`ParquetJSWriter: Invalid GeoArrow metadata on "${field.name}"`);
+  }
+  const candidate = metadata as GeoArrowMetadata;
+  if (
+    candidate.crs !== undefined &&
+    typeof candidate.crs !== 'string' &&
+    (typeof candidate.crs !== 'object' || candidate.crs === null)
+  ) {
+    throw new Error(`ParquetJSWriter: Invalid GeoArrow CRS on "${field.name}"`);
+  }
+  if (
+    candidate.edges !== undefined &&
+    !['spherical', 'vincenty', 'thomas', 'andoyer', 'karney'].includes(candidate.edges)
+  ) {
+    throw new Error(`ParquetJSWriter: Invalid GeoArrow edges on "${field.name}"`);
+  }
+  return candidate;
+}
+
+/** Maps GeoArrow CRS semantics onto the native Parquet logical-type property. */
+function getGeoArrowNativeCRS(metadata: GeoArrowMetadata): string {
+  if (metadata.crs === undefined) return 'srid:0';
+  return typeof metadata.crs === 'string' ? metadata.crs : JSON.stringify(metadata.crs);
+}
+
 /** Returns the minimum fixed byte width required by one decimal precision. */
 function getDecimalByteWidth(precision: number): number {
   for (let byteWidth = 1; byteWidth <= 32; byteWidth++) {
@@ -215,9 +444,8 @@ function getDecimalByteWidth(precision: number): number {
  * @param columnName column name
  * @returns first defined value, if any
  */
-function getFirstDefinedValue(rows: Array<Record<string, unknown>>, columnName: string): unknown {
-  for (const row of rows) {
-    const value = row[columnName];
+function getFirstDefinedValue(values: readonly unknown[]): unknown {
+  for (const value of values) {
     if (value !== null && value !== undefined) {
       return value;
     }
@@ -226,6 +454,39 @@ function getFirstDefinedValue(rows: Array<Record<string, unknown>>, columnName:
   return undefined;
 }
 
+/** Extracts one named child from struct-like values for recursive schema conversion. */
+function getStructChildValues(values: readonly unknown[], childName: string): unknown[] {
+  return values.flatMap(value => {
+    if (!value || typeof value !== 'object' || ArrayBuffer.isView(value)) return [];
+    return [Reflect.get(value, childName)];
+  });
+}
+
+/** Flattens list values while retaining nested arrays as child values. */
+function flattenListValues(values: readonly unknown[]): unknown[] {
+  return values.flatMap(value => (Array.isArray(value) ? value : []));
+}
+
+/** Extracts key/value members from Map, object, tuple, or Arrow object-row map values. */
+function getMapChildValues(values: readonly unknown[], member: 'key' | 'value'): unknown[] {
+  const output: unknown[] = [];
+  for (const value of values) {
+    if (value instanceof Map) {
+      for (const [key, mapValue] of value) output.push(member === 'key' ? key : mapValue);
+    } else if (Array.isArray(value)) {
+      for (const entry of value) {
+        if (Array.isArray(entry) && entry.length >= 2) output.push(entry[member === 'key' ? 0 : 1]);
+        else if (entry && typeof entry === 'object') output.push(Reflect.get(entry, member));
+      }
+    } else if (value && typeof value === 'object') {
+      for (const [key, mapValue] of Object.entries(value)) {
+        output.push(member === 'key' ? key : mapValue);
+      }
+    }
+  }
+  return output;
+}
+
 /**
  * Infers a loaders.gl data type from a JavaScript value.
  * @param value sample value

package/src/lib/geo/geoparquet-covering.ts

@@ -0,0 +1,201 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {getGeoMetadata} from '@loaders.gl/gis';
+
+import type {
+  ParquetBoundingBox,
+  ParquetPredicate,
+  ParquetRowGroupMetadata,
+  ParquetSourceMetadata
+} from '../../parquet-source-types';
+
+/**
+ * Conservatively tests a row group using native Parquet geospatial statistics.
+ *
+ * Missing or malformed statistics retain the row group. Longitude intervals support the
+ * Parquet GEOGRAPHY antimeridian representation where `xmin` is greater than `xmax`.
+ */
+export function canGeoParquetRowGroupMatch(
+  metadata: ParquetSourceMetadata,
+  rowGroup: ParquetRowGroupMetadata,
+  bbox: ParquetBoundingBox,
+  geometryColumn?: string
+): boolean {
+  const bounds = getBoundingBoxCoordinates(bbox, true);
+  if (!bounds) return true;
+  const geoMetadata = getGeoMetadata(metadata.schema.metadata);
+  const selectedGeometryColumn = geometryColumn || geoMetadata?.primary_column;
+  if (!selectedGeometryColumn) return true;
+  const statistics = rowGroup.columns.find(
+    column => column.path.length === 1 && column.path[0] === selectedGeometryColumn
+  )?.geospatialStatistics?.bbox;
+  if (!statistics) return true;
+  if (
+    ![statistics.xmin, statistics.xmax, statistics.ymin, statistics.ymax].every(Number.isFinite)
+  ) {
+    return true;
+  }
+  return (
+    statistics.ymin <= bounds.north &&
+    statistics.ymax >= bounds.south &&
+    doLongitudeIntervalsIntersect(statistics.xmin, statistics.xmax, bounds.west, bounds.east)
+  );
+}
+
+type GeoParquetBoundingBoxCovering = {
+  /** Parquet schema path containing the per-row minimum x coordinate. */
+  xmin: readonly [string, 'xmin'];
+  /** Parquet schema path containing the per-row minimum y coordinate. */
+  ymin: readonly [string, 'ymin'];
+  /** Parquet schema path containing the per-row maximum x coordinate. */
+  xmax: readonly [string, 'xmax'];
+  /** Parquet schema path containing the per-row maximum y coordinate. */
+  ymax: readonly [string, 'ymax'];
+};
+
+/**
+ * Creates an exact per-row bounding-box predicate from GeoParquet 1.1 covering metadata.
+ *
+ * Invalid, missing, unsupported, or antimeridian-crossing coverings return `undefined` so spatial
+ * filtering remains conservative. GeoParquet 1.1 explicitly excludes antimeridian-crossing
+ * geometries from its bounding-box covering technique.
+ */
+export function createGeoParquetBoundingBoxPredicate(
+  metadata: ParquetSourceMetadata,
+  bbox: ParquetBoundingBox,
+  geometryColumn?: string
+): ParquetPredicate | undefined {
+  const bounds = getBoundingBoxCoordinates(bbox, false);
+  if (!bounds) {
+    return undefined;
+  }
+  const geoMetadata = getGeoMetadata(metadata.schema.metadata);
+  const selectedGeometryColumn = geometryColumn || geoMetadata?.primary_column;
+  const columnMetadata = selectedGeometryColumn
+    ? geoMetadata?.columns?.[selectedGeometryColumn]
+    : undefined;
+  const covering = getBoundingBoxCovering(columnMetadata?.covering);
+  if (!covering || !hasCoveringColumns(metadata, covering)) {
+    return undefined;
+  }
+
+  return {
+    op: 'and',
+    args: [
+      {op: '<=', args: [{property: covering.xmin}, bounds.east]},
+      {op: '>=', args: [{property: covering.xmax}, bounds.west]},
+      {op: '<=', args: [{property: covering.ymin}, bounds.north]},
+      {op: '>=', args: [{property: covering.ymax}, bounds.south]}
+    ]
+  };
+}
+
+/** Combines an application predicate with an optional GeoParquet covering predicate. */
+export function combineParquetPredicates(
+  predicate: ParquetPredicate | undefined,
+  spatialPredicate: ParquetPredicate | undefined
+): ParquetPredicate | undefined {
+  if (!predicate) {
+    return spatialPredicate;
+  }
+  if (!spatialPredicate) {
+    return predicate;
+  }
+  return {op: 'and', args: [predicate, spatialPredicate]};
+}
+
+/** Validates the normative GeoParquet 1.1 two-level bbox covering representation. */
+function getBoundingBoxCovering(value: unknown): GeoParquetBoundingBoxCovering | undefined {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  const bbox = (value as {bbox?: unknown}).bbox;
+  if (!bbox || typeof bbox !== 'object') {
+    return undefined;
+  }
+  const candidate = bbox as Record<string, unknown>;
+  const xmin = getCoveringPath(candidate.xmin, 'xmin');
+  const ymin = getCoveringPath(candidate.ymin, 'ymin');
+  const xmax = getCoveringPath(candidate.xmax, 'xmax');
+  const ymax = getCoveringPath(candidate.ymax, 'ymax');
+  if (!xmin || !ymin || !xmax || !ymax) {
+    return undefined;
+  }
+  const rootColumn = xmin[0];
+  if (ymin[0] !== rootColumn || xmax[0] !== rootColumn || ymax[0] !== rootColumn) {
+    return undefined;
+  }
+  return {xmin, ymin, xmax, ymax};
+}
+
+/** Validates one GeoParquet 1.1 bbox leaf path. */
+function getCoveringPath<T extends 'xmin' | 'ymin' | 'xmax' | 'ymax'>(
+  value: unknown,
+  expectedLeaf: T
+): readonly [string, T] | undefined {
+  return Array.isArray(value) &&
+    value.length === 2 &&
+    typeof value[0] === 'string' &&
+    value[0].length > 0 &&
+    value[1] === expectedLeaf
+    ? [value[0], expectedLeaf]
+    : undefined;
+}
+
+/** Ensures every covering path resolves to a physical column in the Parquet footer. */
+function hasCoveringColumns(
+  metadata: ParquetSourceMetadata,
+  covering: GeoParquetBoundingBoxCovering
+): boolean {
+  const availablePaths = new Set(
+    metadata.rowGroups.flatMap(rowGroup => rowGroup.columns.map(column => column.path.join('\0')))
+  );
+  return Object.values(covering).every(path => availablePaths.has(path.join('\0')));
+}
+
+/** Validates and normalizes the two horizontal dimensions of a query bounding box. */
+function getBoundingBoxCoordinates(
+  bbox: ParquetBoundingBox,
+  allowAntimeridian: boolean
+): {west: number; south: number; east: number; north: number} | undefined {
+  const west = bbox[0];
+  const south = bbox[1];
+  const east = bbox.length === 8 ? bbox[4] : bbox.length === 6 ? bbox[3] : bbox[2];
+  const north = bbox.length === 8 ? bbox[5] : bbox.length === 6 ? bbox[4] : bbox[3];
+  if (
+    ![west, south, east, north].every(Number.isFinite) ||
+    (!allowAntimeridian && west > east) ||
+    south > north
+  ) {
+    return undefined;
+  }
+  return {west, south, east, north};
+}
+
+/** Tests two longitude intervals, each of which may wrap across the antimeridian. */
+function doLongitudeIntervalsIntersect(
+  firstWest: number,
+  firstEast: number,
+  secondWest: number,
+  secondEast: number
+): boolean {
+  const firstIntervals =
+    firstWest <= firstEast
+      ? [[firstWest, firstEast]]
+      : [
+          [firstWest, 180],
+          [-180, firstEast]
+        ];
+  const secondIntervals =
+    secondWest <= secondEast
+      ? [[secondWest, secondEast]]
+      : [
+          [secondWest, 180],
+          [-180, secondEast]
+        ];
+  return firstIntervals.some(first =>
+    secondIntervals.some(second => first[0] <= second[1] && first[1] >= second[0])
+  );
+}

package/src/lib/geo/geospatial-metadata.ts

@@ -104,7 +104,7 @@ function getGeometryMetadataForField(
   const columnMetadata = getMetadataValue(fieldMetadata, GEOARROW_EXTENSION_METADATA_KEY);
   if (columnMetadata) {
     try {
-      const parsedMetadata = GeoArrowMetadataSchema.parse(JSON.parse(columnMetadata));
+      const parsedMetadata = parseGeoArrowMetadata(JSON.parse(columnMetadata));
       metadata = {
         ...(metadata || {}),
         ...parsedMetadata
@@ -117,6 +117,22 @@ function getGeometryMetadataForField(
   return metadata;
 }
 
+/** Validates GeoArrow metadata, treating a mislabeled string CRS as opaque metadata. */
+function parseGeoArrowMetadata(value: unknown): GeoArrowMetadata {
+  const result = GeoArrowMetadataSchema.safeParse(value);
+  if (result.success) {
+    return result.data;
+  }
+  if (value && typeof value === 'object' && typeof (value as {crs?: unknown}).crs === 'string') {
+    const {crs_type: _untrustedCRSType, ...opaqueMetadata} = value as Record<string, unknown>;
+    const opaqueResult = GeoArrowMetadataSchema.safeParse(opaqueMetadata);
+    if (opaqueResult.success) {
+      return opaqueResult.data;
+    }
+  }
+  throw result.error;
+}
+
 /**
  * Applies GeoParquet schema metadata to matching geometry fields as GeoArrow field metadata.
  *
@@ -327,14 +343,15 @@ function getGeoArrowMetadataFromGeoParquetField(
   }
 
   const extensionMetadata: Record<string, unknown> = {};
-  if (columnMetadata.crs !== undefined) {
+  if (columnMetadata.crs === undefined) {
+    extensionMetadata.crs = 'OGC:CRS84';
+    extensionMetadata.crs_type = 'authority_code';
+  } else if (columnMetadata.crs !== null) {
     extensionMetadata.crs = columnMetadata.crs;
+    extensionMetadata.crs_type = 'projjson';
   }
-  if (columnMetadata.crs_type !== undefined) {
-    extensionMetadata.crs_type = columnMetadata.crs_type;
-  }
-  if (columnMetadata.edges === 'spherical') {
-    extensionMetadata.edges = 'spherical';
+  if (columnMetadata.edges && columnMetadata.edges !== 'planar') {
+    extensionMetadata.edges = columnMetadata.edges;
   }
 
   return Object.keys(extensionMetadata).length > 0
@@ -368,19 +385,29 @@ function synthesizeGeoParquetColumnMetadata(
     geometry_types: geometryTypes
   };
 
-  if (geometryMetadata.crs !== undefined && typeof geometryMetadata.crs !== 'string') {
+  if (geometryMetadata.crs === undefined) {
+    columnMetadata.crs = null;
+  } else if (typeof geometryMetadata.crs === 'object') {
     columnMetadata.crs = geometryMetadata.crs;
+  } else if (
+    typeof geometryMetadata.crs !== 'string' ||
+    !isDefaultCRS84Identifier(geometryMetadata.crs)
+  ) {
+    return null;
   }
-  if (geometryMetadata.crs_type === 'projjson' || geometryMetadata.crs_type === 'wkt2:2019') {
-    columnMetadata.crs_type = geometryMetadata.crs_type;
-  }
-  if (geometryMetadata.edges === 'spherical') {
-    columnMetadata.edges = 'spherical';
+  if (geometryMetadata.edges) {
+    columnMetadata.edges = geometryMetadata.edges;
   }
 
   return columnMetadata;
 }
 
+/** Returns whether a compact GeoArrow CRS identifier has GeoParquet's default CRS semantics. */
+function isDefaultCRS84Identifier(crs: string): boolean {
+  const normalizedCRS = crs.toUpperCase();
+  return normalizedCRS === 'OGC:CRS84' || normalizedCRS === 'EPSG:4326';
+}
+
 function inferGeometryTypesFromGeoArrowEncoding(
   encoding?: GeoArrowEncoding
 ): GeoParquetGeometryType[] {
@@ -420,8 +447,8 @@ function pickValidOptionalGeoParquetColumnMetadata(
 
 function isValidBBox(
   bbox: GeoColumnMetadata['bbox']
-): bbox is [number, number, number, number] | [number, number, number, number, number, number] {
-  if (!Array.isArray(bbox) || (bbox.length !== 4 && bbox.length !== 6)) {
+): bbox is NonNullable<GeoColumnMetadata['bbox']> {
+  if (!Array.isArray(bbox) || ![4, 6, 8].includes(bbox.length)) {
     return false;
   }