@math.gl/geoarrow 5.0.0-alpha.2 → 5.0.0-alpha.3

package/dist/index.cjs

@@ -31,6 +31,7 @@ __export(index_exports, {
   getGeoArrowDimensionSize: () => getGeoArrowDimensionSize,
   getGeoArrowEncodingForGeometry: () => getGeoArrowEncodingForGeometry,
   getGeoArrowGeometryType: () => getGeoArrowGeometryType,
+  getGeoArrowRowBounds: () => getGeoArrowRowBounds,
   getGeoArrowRowCount: () => getGeoArrowRowCount,
   getGeoArrowTransferList: () => getGeoArrowTransferList,
   getGeoArrowVertexCount: () => getGeoArrowVertexCount,
@@ -285,7 +286,7 @@ function visitUnionRowCoordinates(union, rowIndex, sourceRowIndex, visitor) {
   const child = union.children.find((candidate) => candidate.typeId === typeId);
   if (!child)
     return;
-  const encoding = getEncodingFromChildName(child.name);
+  const encoding = child.encoding || getEncodingFromChildName(child.name);
   if (encoding === "geoarrow.geometrycollection" && child.data.kind === "list") {
     const [first, last] = getListRange(child.data, valueOffset);
     if (child.data.child.kind === "dense-union") {
@@ -363,7 +364,7 @@ function materializeUnionRow(union, rowIndex) {
   const child = union.children.find((candidate) => candidate.typeId === typeId);
   if (!child || valueOffset < 0 || valueOffset >= child.data.length)
     return null;
-  return materializeGeometryRow(child.data, valueOffset, getEncodingFromChildName(child.name));
+  return materializeGeometryRow(child.data, valueOffset, child.encoding || getEncodingFromChildName(child.name));
 }
 function getEncodingFromChildName(name) {
   const normalized = name.replace(/[^a-z]/gi, "").toLowerCase();
@@ -509,7 +510,18 @@ function validateArray(array, path, issues) {
       break;
     }
     case "serialized": {
-      validateOffsets(array.offsets, array.offset || 0, array.length, array.values.length, array.offsetBase, path, issues);
+      if (array.views) {
+        const requiredWords = ((array.offset || 0) + array.length) * 4;
+        if (requiredWords > array.views.length) {
+          issues.push({
+            code: "invalid-length",
+            path,
+            message: "Serialized view records are too short."
+          });
+        }
+      } else {
+        validateOffsets(array.offsets, array.offset || 0, array.length, array.values.length, array.offsetBase, path, issues);
+      }
       break;
     }
   }
@@ -627,12 +639,17 @@ function validateUnionLayouts(union, column, path, issues) {
   for (const child of union.children) {
     let encoding;
     try {
-      encoding = getEncodingFromChildName(child.name);
+      encoding = child.encoding || getEncodingFromChildName(child.name);
     } catch (error) {
       addInvalidLayout(`${path}.${child.name}`, error.message, issues);
       continue;
     }
-    validateGeometryLayout(child.data, encoding, column, `${path}.${child.name}`, issues);
+    const childColumn = child.dimension || child.coordinateLayout ? {
+      ...column,
+      dimension: child.dimension || column.dimension,
+      coordinateLayout: child.coordinateLayout || column.coordinateLayout
+    } : column;
+    validateGeometryLayout(child.data, encoding, childColumn, `${path}.${child.name}`, issues);
   }
 }
 function validateCoordinateLayout(array, column, path, issues) {
@@ -704,6 +721,10 @@ function collectArrayBuffers(array, buffers) {
     case "serialized":
       addBuffer(array.offsets.buffer, buffers);
       addBuffer(array.values.buffer, buffers);
+      if (array.views)
+        addBuffer(array.views.buffer, buffers);
+      for (const data of array.dataBuffers || [])
+        addBuffer(data.buffer, buffers);
       break;
   }
 }
@@ -724,6 +745,7 @@ var GeoArrowBuilder = class _GeoArrowBuilder {
     this.coordinateCount = 0;
     this.partCount = 0;
     this.ringCount = 0;
+    this.eventStack = [];
     this.mode = options.mode;
     this.encoding = options.encoding;
     this.dimension = options.dimension || "xy";
@@ -755,7 +777,7 @@ var GeoArrowBuilder = class _GeoArrowBuilder {
     const depth = getBuilderDepth(this.encoding);
     const coordinates = geometry.coordinates;
     if (depth === 0) {
-      this.writeCoordinate(coordinates);
+      this.writeCoordinateValues(coordinates);
     } else if (depth === 1) {
       this.writeCoordinateList(coordinates);
       this.writeOffset((_a = this.target) == null ? void 0 : _a.geometryOffsets, rowIndex + 1, this.coordinateCount);
@@ -865,16 +887,16 @@ var GeoArrowBuilder = class _GeoArrowBuilder {
     var _a;
     const depth = getBuilderDepth(this.encoding);
     if (depth === 0) {
-      this.writeCoordinate(new Array(getGeoArrowDimensionSize(this.dimension)).fill(0));
+      this.writeCoordinateValues(new Array(getGeoArrowDimensionSize(this.dimension)).fill(0));
     } else {
       this.writeOffset((_a = this.target) == null ? void 0 : _a.geometryOffsets, rowIndex + 1, depth === 1 ? this.coordinateCount : this.partCount);
     }
   }
   writeCoordinateList(coordinates) {
     for (const coordinate of coordinates)
-      this.writeCoordinate(coordinate);
+      this.writeCoordinateValues(coordinate);
   }
-  writeCoordinate(coordinate) {
+  writeCoordinateValues(coordinate) {
     const size = getGeoArrowDimensionSize(this.dimension);
     if (coordinate.length !== size) {
       throw new Error(`Expected ${size} coordinate values for ${this.dimension}`);
@@ -883,6 +905,96 @@ var GeoArrowBuilder = class _GeoArrowBuilder {
       writeCoordinate(this.target.coordinates, this.coordinateCount, coordinate, this.dimension);
     this.coordinateCount++;
   }
+  /** Begins an event-driven geometry. Events are accepted by both measure and write builders. */
+  beginGeometry(type, dimension = this.dimension, _count) {
+    this.eventStack.push({ type, dimension, rings: [], polygons: [], children: [] });
+    return this;
+  }
+  /** Begins a polygon part inside an event-built MultiPolygon. */
+  beginPolygon() {
+    const state = this.eventStack[this.eventStack.length - 1];
+    if (!state || state.type !== "MultiPolygon") {
+      throw new Error("beginPolygon must follow beginGeometry('MultiPolygon')");
+    }
+    state.currentPolygon = [];
+    state.polygons.push(state.currentPolygon);
+    state.currentRing = void 0;
+    return this;
+  }
+  /** Begins a ring/part in the current event geometry. */
+  beginRing(_count) {
+    const state = this.eventStack[this.eventStack.length - 1];
+    if (!state)
+      throw new Error("beginRing must follow beginGeometry");
+    state.currentRing = [];
+    if (state.type === "MultiPolygon") {
+      if (!state.currentPolygon)
+        this.beginPolygon();
+      state.currentPolygon.push(state.currentRing);
+    } else {
+      state.rings.push(state.currentRing);
+    }
+    return this;
+  }
+  /** Writes one coordinate into the current event ring or point. */
+  writeCoordinate(x, y, z, m) {
+    const state = this.eventStack[this.eventStack.length - 1];
+    if (!state)
+      throw new Error("writeCoordinate must follow beginGeometry");
+    const coordinate = Array.isArray(x) ? [...x] : [x, y, ...z === void 0 ? [] : [z], ...m === void 0 ? [] : [m]];
+    const size = getGeoArrowDimensionSize(state.dimension);
+    if (coordinate.length !== size)
+      throw new Error(`Expected ${size} coordinate values for ${state.dimension}`);
+    if (state.type === "Point") {
+      state.rings = [[coordinate]];
+      return this;
+    }
+    if (!state.currentRing)
+      this.beginRing();
+    state.currentRing.push(coordinate);
+    return this;
+  }
+  /** Ends the current event geometry and appends it to the builder/parent. */
+  endGeometry() {
+    var _a;
+    const state = this.eventStack.pop();
+    if (!state)
+      throw new Error("endGeometry without beginGeometry");
+    const coordinates = state.rings;
+    let geometry;
+    switch (state.type) {
+      case "Point":
+        geometry = { type: "Point", coordinates: ((_a = coordinates[0]) == null ? void 0 : _a[0]) || [] };
+        break;
+      case "LineString":
+        geometry = { type: "LineString", coordinates: coordinates[0] || [] };
+        break;
+      case "MultiPoint":
+        geometry = { type: "MultiPoint", coordinates: coordinates.flat() };
+        break;
+      case "Polygon":
+        geometry = { type: "Polygon", coordinates };
+        break;
+      case "MultiLineString":
+        geometry = { type: "MultiLineString", coordinates };
+        break;
+      case "MultiPolygon":
+        geometry = {
+          type: "MultiPolygon",
+          coordinates: state.polygons.length ? state.polygons : [coordinates]
+        };
+        break;
+      case "GeometryCollection":
+        geometry = { type: "GeometryCollection", geometries: state.children };
+        break;
+    }
+    const parent = this.eventStack[this.eventStack.length - 1];
+    if ((parent == null ? void 0 : parent.type) === "GeometryCollection")
+      parent.children.push(geometry);
+    else
+      this.append(geometry);
+    return this;
+  }
   writeOffset(target, index, value) {
     if (!target)
       return;
@@ -961,7 +1073,7 @@ function makeDenseUnionArray(rows, options, dimension) {
     const geometry = rows[rowIndex];
     const type = (geometry == null ? void 0 : geometry.type) || fallbackType;
     const values = childRows.get(type) || [];
-    typeIds[rowIndex] = getGeometryTypeId(type);
+    typeIds[rowIndex] = getGeometryTypeId(type, dimension);
     valueOffsets[rowIndex] = values.length;
     if (geometry) {
       values.push(geometry);
@@ -969,13 +1081,20 @@ function makeDenseUnionArray(rows, options, dimension) {
       setValidityBit(validity, rowIndex);
     }
   }
-  const children = [...childRows.entries()].sort(([left], [right]) => getGeometryTypeId(left) - getGeometryTypeId(right)).map(([type, values]) => {
+  const children = [...childRows.entries()].sort(([left], [right]) => getGeometryTypeId(left, dimension) - getGeometryTypeId(right, dimension)).map(([type, values]) => {
     const data = type === "GeometryCollection" ? makeGeometryCollectionArray(values, options, dimension) : GeoArrowBuilder.build(values, {
       ...options,
       dimension,
       encoding: getGeoArrowEncodingForGeometry(type)
     }).chunks[0];
-    return { name: type, typeId: getGeometryTypeId(type), data };
+    return {
+      name: type,
+      typeId: getGeometryTypeId(type, dimension),
+      encoding: getGeoArrowEncodingForGeometry(type),
+      dimension,
+      coordinateLayout: options.coordinateLayout || "interleaved",
+      data
+    };
   });
   return {
     kind: "dense-union",
@@ -1071,8 +1190,8 @@ function getBuilderDepth(encoding) {
       return 3;
   }
 }
-function getGeometryTypeId(type) {
-  return [
+function getGeometryTypeId(type, dimension = "xy") {
+  const family = [
     "Point",
     "LineString",
     "Polygon",
@@ -1080,7 +1199,9 @@ function getGeometryTypeId(type) {
     "MultiLineString",
     "MultiPolygon",
     "GeometryCollection"
-  ].indexOf(type) + 1;
+  ].indexOf(type);
+  const dimensionIndex = ["xy", "xyz", "xym", "xyzm"].indexOf(dimension);
+  return family < 0 || dimensionIndex < 0 ? 1 : family * 4 + dimensionIndex + 1;
 }
 function inferRowsDimension(rows) {
   let size = 2;
@@ -1135,6 +1256,46 @@ function getGeoArrowBounds(column) {
   });
   return Number.isFinite(minimumX) ? [minimumX, minimumY, maximumX, maximumY] : null;
 }
+function getGeoArrowRowBounds(column) {
+  const rowCount = getGeoArrowRowCount(column);
+  if (column.encoding === "geoarrow.box") {
+    const result = [];
+    for (const chunk of column.chunks) {
+      for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+        if (chunk.kind !== "struct" || !isGeoArrowValueValid(chunk.validity, rowIndex)) {
+          result.push(null);
+          continue;
+        }
+        const index = (chunk.offset || 0) + rowIndex;
+        const xmin = readPrimitiveNumber(chunk.children["xmin"], index);
+        const ymin = readPrimitiveNumber(chunk.children["ymin"], index);
+        const xmax = readPrimitiveNumber(chunk.children["xmax"], index);
+        const ymax = readPrimitiveNumber(chunk.children["ymax"], index);
+        result.push([xmin, ymin, xmax, ymax].every(Number.isFinite) ? [xmin, ymin, xmax, ymax] : null);
+      }
+    }
+    return result;
+  }
+  const minimumX = new Float64Array(rowCount).fill(Number.POSITIVE_INFINITY);
+  const minimumY = new Float64Array(rowCount).fill(Number.POSITIVE_INFINITY);
+  const maximumX = new Float64Array(rowCount).fill(Number.NEGATIVE_INFINITY);
+  const maximumY = new Float64Array(rowCount).fill(Number.NEGATIVE_INFINITY);
+  visitGeoArrowCoordinates(column, (coordinate, sourceRowIndex) => {
+    const [x, y] = coordinate;
+    if (Number.isFinite(x) && Number.isFinite(y)) {
+      minimumX[sourceRowIndex] = Math.min(minimumX[sourceRowIndex], x);
+      minimumY[sourceRowIndex] = Math.min(minimumY[sourceRowIndex], y);
+      maximumX[sourceRowIndex] = Math.max(maximumX[sourceRowIndex], x);
+      maximumY[sourceRowIndex] = Math.max(maximumY[sourceRowIndex], y);
+    }
+    return coordinate;
+  });
+  const bounds = [];
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    bounds.push(Number.isFinite(minimumX[rowIndex]) ? [minimumX[rowIndex], minimumY[rowIndex], maximumX[rowIndex], maximumY[rowIndex]] : null);
+  }
+  return bounds;
+}
 function getGeoArrowBoxBounds(column) {
   let minimumX = Number.POSITIVE_INFINITY;
   let minimumY = Number.POSITIVE_INFINITY;
@@ -1175,20 +1336,20 @@ function readPrimitiveNumber(array, index) {
   const valueIndex = (array.offset || 0) + index * (array.stride || 1);
   return Number(array.values[valueIndex]);
 }
-function mapGeoArrowCoordinates(column, mapper, options = {}) {
+function mapGeoArrowCoordinates(column, mapper, options = {}, sourceDimension) {
   assertGeoArrowResourceLimits(column, options.limits);
-  const rows = materializeGeoArrowRows(column);
-  let rowIndex = 0;
-  const mappedRows = rows.map((row) => {
-    const mapped = row ? mapGeometryCoordinates(row, (coordinate) => mapper(coordinate, rowIndex)) : null;
-    rowIndex++;
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt") {
+    throw new Error("Coordinate mapping requires native GeoArrow storage");
+  }
+  const dimension = options.dimension || column.dimension;
+  const layout = options.coordinateLayout || column.coordinateLayout || "interleaved";
+  let rowOffset = 0;
+  const chunks = column.chunks.map((chunk) => {
+    const mapped = mapArrayCoordinates(chunk, column.encoding, rowOffset, dimension, layout, mapper, options.coordinateType || "preserve", options.dimension !== void 0, options.coordinateLayout !== void 0, sourceDimension);
+    rowOffset += chunk.length;
     return mapped;
   });
-  const result = makeGeoArrowColumnFromGeometryRows(mappedRows, {
-    dimension: options.dimension || column.dimension,
-    coordinateLayout: options.coordinateLayout || column.coordinateLayout || "interleaved"
-  });
-  return copyColumnMetadata(column, result);
+  return { ...column, dimension, coordinateLayout: layout, chunks };
 }
 function mapGeoArrowCoordinatesInto(target, source, mapper, options = {}) {
   const mapped = mapGeoArrowCoordinates(source, mapper, {
@@ -1233,45 +1394,56 @@ function normalizeGeoArrowUnion(column) {
   return changed ? { ...column, chunks } : column;
 }
 function convertGeoArrowColumn(column, options = {}) {
-  const encoding = options.encoding || column.encoding;
+  const encoding = options.encoding === "native" || !options.encoding ? column.encoding : options.encoding;
   const dimension = options.dimension || column.dimension;
-  const coordinateLayout = options.coordinateLayout || column.coordinateLayout;
-  if (encoding === column.encoding && dimension === column.dimension && coordinateLayout === column.coordinateLayout) {
+  const coordinateLayout = options.coordinateLayout === "preserve" || !options.coordinateLayout ? column.coordinateLayout : options.coordinateLayout;
+  const requestedOffsetType = options.offsetType || "preserve";
+  const currentOffsetType = getColumnOffsetType(column);
+  if (encoding === column.encoding && dimension === column.dimension && coordinateLayout === column.coordinateLayout && (requestedOffsetType === "preserve" || requestedOffsetType === currentOffsetType) && (!options.coordinateType || options.coordinateType === "preserve")) {
     return column;
   }
   if (encoding === "geoarrow.wkb" || encoding === "geoarrow.wkt") {
     throw new Error("Use encodeGeoArrowWKB or encodeGeoArrowWKT for serialized output");
   }
   assertGeoArrowResourceLimits(column, options.limits);
-  const rows = materializeGeoArrowRows(column).map((row) => row ? convertGeometryFamily(row, encoding, column.dimension, dimension) : null);
-  const result = makeGeoArrowColumnFromGeometryRows(rows, {
-    encoding: encoding === "geoarrow.geometry" ? encoding : void 0,
+  const mapped = mapGeoArrowCoordinates(column, (coordinate) => coordinate, {
     dimension,
-    coordinateLayout: coordinateLayout || "interleaved"
+    coordinateLayout: coordinateLayout || void 0,
+    coordinateType: options.coordinateType,
+    limits: options.limits
+  }, column.dimension);
+  const offsetConverted = requestedOffsetType === "preserve" ? mapped : {
+    ...mapped,
+    chunks: mapped.chunks.map((chunk) => convertArrayOffsets(chunk, requestedOffsetType))
+  };
+  if (encoding === column.encoding)
+    return offsetConverted;
+  if (encoding === "geoarrow.geometry")
+    return promoteToDenseUnion(offsetConverted);
+  if (column.encoding === "geoarrow.geometry")
+    return demoteDenseUnion(offsetConverted, encoding);
+  throw new Error(`Rows cannot be represented as ${encoding}`);
+}
+function resizeCoordinate(coordinate, sourceDimension, targetDimension) {
+  const sourceNames = getDimensionNames(sourceDimension);
+  return getDimensionNames(targetDimension).map((name) => {
+    const sourceIndex = sourceNames.indexOf(name);
+    return sourceIndex >= 0 ? coordinate[sourceIndex] ?? 0 : 0;
   });
-  if (result.encoding !== encoding && encoding !== "geoarrow.geometry") {
-    throw new Error(`Rows cannot be represented as ${encoding}`);
-  }
-  return copyColumnMetadata(column, result);
 }
 function rewindGeoArrow(column, options = {}) {
   assertGeoArrowResourceLimits(column, options.limits);
+  if (column.encoding === "geoarrow.wkb" || column.encoding === "geoarrow.wkt") {
+    throw new Error("Rewinding requires native GeoArrow storage");
+  }
   const outerClockwise = (options.outer || "counter-clockwise") === "clockwise";
   let changed = false;
-  const rows = materializeGeoArrowRows(column).map((row) => {
-    if (!row)
-      return null;
-    const rewound = rewindGeometry(row, outerClockwise);
-    changed || (changed = rewound !== row);
-    return rewound;
-  });
-  if (!changed)
-    return column;
-  const result = makeGeoArrowColumnFromGeometryRows(rows, {
-    dimension: column.dimension,
-    coordinateLayout: column.coordinateLayout || "interleaved"
+  const chunks = column.chunks.map((chunk) => {
+    const clone = mapArrayCoordinates(chunk, column.encoding, 0, column.dimension, column.coordinateLayout || "interleaved", (coordinate) => coordinate, "preserve");
+    changed || (changed = rewindArrayRings(clone, column.encoding, outerClockwise));
+    return clone;
   });
-  return copyColumnMetadata(column, result);
+  return changed ? { ...column, chunks } : column;
 }
 function assertGeoArrowResourceLimits(column, options = {}) {
   const rows = getGeoArrowRowCount(column);
@@ -1298,86 +1470,210 @@ function assertGeoArrowResourceLimits(column, options = {}) {
     }
   }
 }
-function mapGeometryCoordinates(geometry, mapper) {
-  if (geometry.type === "GeometryCollection") {
+function mapArrayCoordinates(array, encoding, rowOffset, targetDimension, targetLayout, mapper, coordinateType, forceDimension = false, forceLayout = false, sourceDimension, rowIndicesOverride) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const childRowIndices = collectUnionRowIndices(array, rowOffset);
     return {
-      ...geometry,
-      geometries: geometry.geometries.map((child) => mapGeometryCoordinates(child, mapper))
+      ...array,
+      children: array.children.map((child, childIndex) => {
+        const childEncoding = child.encoding || getEncodingFromChildName2(child.name);
+        const childDimension = forceDimension ? targetDimension : child.dimension || targetDimension;
+        const childLayout = forceLayout ? targetLayout : child.coordinateLayout || targetLayout;
+        return {
+          ...child,
+          data: mapArrayCoordinates(child.data, childEncoding, rowOffset, childDimension, childLayout, mapper, coordinateType, forceDimension, forceLayout, childDimension, childRowIndices[childIndex]),
+          dimension: childDimension,
+          coordinateLayout: childLayout,
+          encoding: childEncoding
+        };
+      })
     };
   }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    return {
+      ...array,
+      child: mapArrayCoordinates(array.child, "geoarrow.geometry", rowOffset, targetDimension, targetLayout, mapper, coordinateType, forceDimension, forceLayout, sourceDimension, rowIndicesOverride)
+    };
+  }
+  const depth = getEncodingDepth2(encoding);
+  const rowIndices = rowIndicesOverride || collectLeafRowIndices(array, depth, rowOffset);
+  return mapNestedArray(array, depth, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension);
+}
+function mapNestedArray(array, depth, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension) {
+  if (depth === 0) {
+    return mapCoordinateLeaf(array, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension);
+  }
+  if (array.kind !== "list")
+    return array;
   return {
-    ...geometry,
-    coordinates: mapCoordinateNesting(geometry.coordinates, mapper)
+    ...array,
+    child: mapNestedArray(array.child, depth - 1, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension)
   };
 }
-function mapCoordinateNesting(value, mapper) {
-  if (value.length === 0)
-    return [];
-  if (typeof value[0] === "number")
-    return [...mapper(value)];
-  return value.map((child) => mapCoordinateNesting(child, mapper));
+function mapCoordinateLeaf(array, rowOffset, targetDimension, targetLayout, mapper, coordinateType, rowIndices, sourceDimension) {
+  const count = array.length;
+  const targetSize = getGeoArrowDimensionSize(targetDimension);
+  const sourceValues = new Array(count);
+  for (let index = 0; index < count; index++) {
+    const coordinate = readCoordinateAt(array, index);
+    const mapped = coordinate ? mapper(sourceDimension ? resizeCoordinate(coordinate, sourceDimension, targetDimension) : coordinate, (rowIndices == null ? void 0 : rowIndices[index]) ?? rowOffset) : new Array(targetSize).fill(0);
+    if (mapped.length !== targetSize) {
+      throw new Error(`Coordinate mapper returned ${mapped.length} values; expected ${targetSize}`);
+    }
+    sourceValues[index] = [...mapped];
+  }
+  const FloatArray = resolveCoordinateConstructor(array, coordinateType);
+  return makeCoordinateLeaf(sourceValues, targetDimension, targetLayout, FloatArray, array.validity);
 }
-function rewindGeometry(geometry, outerClockwise) {
-  if (geometry.type === "GeometryCollection") {
-    const geometries = geometry.geometries.map((child) => rewindGeometry(child, outerClockwise));
-    return geometries.some((child, index) => child !== geometry.geometries[index]) ? { ...geometry, geometries } : geometry;
+function collectLeafRowIndices(array, depth, rowOffset) {
+  const output = new Array(getLeafLength(array, depth)).fill(rowOffset);
+  for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+    if (isGeoArrowValueValid(array.validity, rowIndex)) {
+      assignNestedRowIndices(array, rowIndex, depth, rowOffset + rowIndex, output);
+    }
   }
-  if (geometry.type === "Polygon") {
-    const coordinates = rewindPolygon(geometry.coordinates, outerClockwise);
-    return coordinates === geometry.coordinates ? geometry : { ...geometry, coordinates };
+  return output;
+}
+function assignNestedRowIndices(array, index, depth, rowIndex, output) {
+  if (depth === 0) {
+    if (index >= 0 && index < output.length)
+      output[index] = rowIndex;
+    return;
   }
-  if (geometry.type === "MultiPolygon") {
-    const coordinates = geometry.coordinates.map((polygon) => rewindPolygon(polygon, outerClockwise));
-    return coordinates.every((polygon, index) => polygon === geometry.coordinates[index]) ? geometry : { ...geometry, coordinates };
+  if (array.kind !== "list")
+    return;
+  const [first, last] = getListRange(array, index);
+  for (let childIndex = first; childIndex < last; childIndex++) {
+    assignNestedRowIndices(array.child, childIndex, depth - 1, rowIndex, output);
   }
-  return geometry;
 }
-function rewindPolygon(rings, outerClockwise) {
-  let changed = false;
-  const result = rings.map((ring, ringIndex) => {
-    const shouldBeClockwise = ringIndex === 0 ? outerClockwise : !outerClockwise;
-    const isClockwise = getRingSignedArea(ring) < 0;
-    if (isClockwise === shouldBeClockwise)
-      return ring;
-    changed = true;
-    return [...ring].reverse();
+function collectUnionRowIndices(union, rowOffset) {
+  if (union.kind !== "dense-union")
+    return [];
+  const output = union.children.map((child) => {
+    const encoding = child.encoding || getEncodingFromChildName2(child.name);
+    return new Array(getLeafLength(child.data, getEncodingDepth2(encoding))).fill(rowOffset);
   });
-  return changed ? result : rings;
+  for (let rowIndex = 0; rowIndex < union.length; rowIndex++) {
+    if (!isGeoArrowValueValid(union.validity, rowIndex))
+      continue;
+    const physical = (union.offset || 0) + rowIndex;
+    const childIndex = union.children.findIndex((child2) => child2.typeId === union.typeIds[physical]);
+    if (childIndex < 0)
+      continue;
+    const child = union.children[childIndex];
+    assignUnionRowIndices(child.data, child.encoding || getEncodingFromChildName2(child.name), union.valueOffsets[physical], rowOffset + rowIndex, output[childIndex]);
+  }
+  return output;
+}
+function assignUnionRowIndices(array, encoding, index, rowIndex, output) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const physical = (array.offset || 0) + index;
+    const childIndex = array.children.findIndex((child) => child.typeId === array.typeIds[physical]);
+    if (childIndex >= 0) {
+      const child = array.children[childIndex];
+      assignUnionRowIndices(child.data, child.encoding || getEncodingFromChildName2(child.name), array.valueOffsets[physical], rowIndex, output);
+    }
+    return;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    const [first, last] = getListRange(array, index);
+    if (array.child.kind === "dense-union") {
+      for (let childIndex = first; childIndex < last; childIndex++) {
+        assignUnionRowIndices(array.child, "geoarrow.geometry", childIndex, rowIndex, output);
+      }
+    }
+    return;
+  }
+  assignNestedRowIndices(array, index, getEncodingDepth2(encoding), rowIndex, output);
 }
-function getRingSignedArea(ring) {
-  let area = 0;
-  for (let index = 0; index < ring.length; index++) {
-    const current = ring[index];
-    const next = ring[(index + 1) % ring.length];
-    area += current[0] * next[1] - next[0] * current[1];
+function getLeafLength(array, depth) {
+  let current = array;
+  for (let level = 0; level < depth; level++) {
+    if (current.kind !== "list")
+      return 0;
+    current = current.child;
   }
-  return area / 2;
+  return current.length;
 }
-function convertGeometryFamily(geometry, encoding, sourceDimension, targetDimension) {
-  if (geometry.type === "GeometryCollection") {
-    const geometries = geometry.geometries.map((child) => convertGeometryFamily(child, "geoarrow.geometry", sourceDimension, targetDimension));
-    if (encoding === "geoarrow.geometry" || encoding === "geoarrow.geometrycollection") {
-      return { ...geometry, geometries };
+function resolveCoordinateConstructor(array, coordinateType) {
+  if (coordinateType === "float32")
+    return Float32Array;
+  if (coordinateType === "float64")
+    return Float64Array;
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    return array.child.values instanceof Float32Array ? Float32Array : Float64Array;
+  }
+  if (array.kind === "struct") {
+    const child = array.children["x"];
+    if ((child == null ? void 0 : child.kind) === "primitive" && child.values instanceof Float32Array)
+      return Float32Array;
+  }
+  return Float64Array;
+}
+function makeCoordinateLeaf(coordinates, dimension, layout, FloatArray, validity) {
+  const size = getGeoArrowDimensionSize(dimension);
+  if (layout === "interleaved") {
+    const values = new FloatArray(coordinates.length * size);
+    for (let index = 0; index < coordinates.length; index++) {
+      values.set(coordinates[index], index * size);
     }
-    throw new Error(`${geometry.type} cannot be represented as ${encoding}`);
+    return {
+      kind: "fixed-size-list",
+      length: coordinates.length,
+      size,
+      child: { kind: "primitive", length: values.length, values },
+      validity
+    };
   }
-  const coordinates = mapCoordinateNesting(geometry.coordinates, (coordinate) => resizeCoordinate(coordinate, sourceDimension, targetDimension));
-  if (encoding === "geoarrow.geometry") {
-    return { ...geometry, coordinates };
+  const children = {
+    x: { kind: "primitive", length: coordinates.length, values: new FloatArray(coordinates.length) },
+    y: { kind: "primitive", length: coordinates.length, values: new FloatArray(coordinates.length) }
+  };
+  const names = getDimensionNames(dimension);
+  for (let component = 2; component < names.length; component++) {
+    children[names[component]] = {
+      kind: "primitive",
+      length: coordinates.length,
+      values: new FloatArray(coordinates.length)
+    };
   }
-  const target = encoding.replace("geoarrow.", "");
-  if (geometry.type.toLowerCase() !== target) {
-    throw new Error(`${geometry.type} cannot be represented as ${encoding}`);
+  for (let index = 0; index < coordinates.length; index++) {
+    const coordinate = coordinates[index];
+    for (let component = 0; component < names.length; component++) {
+      const child = children[names[component]];
+      if (child.kind === "primitive")
+        child.values[index] = coordinate[component];
+    }
   }
-  return { ...geometry, coordinates };
+  return { kind: "struct", length: coordinates.length, children, validity };
 }
-function resizeCoordinate(coordinate, sourceDimension, targetDimension) {
-  const sourceNames = getDimensionNames(sourceDimension);
-  const targetNames = getDimensionNames(targetDimension);
-  return targetNames.map((name) => {
-    const sourceIndex = sourceNames.indexOf(name);
-    return sourceIndex >= 0 ? coordinate[sourceIndex] ?? 0 : 0;
-  });
+function readCoordinateAt(array, index) {
+  if (!isGeoArrowValueValid(array.validity, index))
+    return null;
+  if (array.kind === "fixed-size-list") {
+    const logicalIndex = (array.offset || 0) + index;
+    if (array.child.kind !== "primitive")
+      return null;
+    const values = [];
+    for (let component = 0; component < array.size; component++) {
+      const scalarIndex = logicalIndex * array.size + component;
+      values.push(Number(array.child.values[(array.child.offset || 0) + scalarIndex * (array.child.stride || 1)]));
+    }
+    return values;
+  }
+  if (array.kind === "struct") {
+    const logicalIndex = (array.offset || 0) + index;
+    const values = [];
+    for (const name of ["x", "y", "z", "m"]) {
+      const child = array.children[name];
+      if ((child == null ? void 0 : child.kind) === "primitive") {
+        values.push(Number(child.values[(child.offset || 0) + logicalIndex * (child.stride || 1)]));
+      }
+    }
+    return values.length >= 2 ? values : null;
+  }
+  return null;
 }
 function getDimensionNames(dimension) {
   switch (dimension) {
@@ -1391,14 +1687,321 @@ function getDimensionNames(dimension) {
       return ["x", "y", "z", "m"];
   }
 }
-function copyColumnMetadata(source, target) {
+function getEncodingFromChildName2(name) {
+  const normalized = name.replace(/[^a-z]/gi, "").toLowerCase();
+  const encoding = `geoarrow.${normalized}`;
+  if (encoding === "geoarrow.point" || encoding === "geoarrow.linestring" || encoding === "geoarrow.polygon" || encoding === "geoarrow.multipoint" || encoding === "geoarrow.multilinestring" || encoding === "geoarrow.multipolygon" || encoding === "geoarrow.geometrycollection") {
+    return encoding;
+  }
+  throw new Error(`Unknown GeoArrow dense-union child ${name}`);
+}
+function getEncodingDepth2(encoding) {
+  switch (encoding) {
+    case "geoarrow.point":
+      return 0;
+    case "geoarrow.linestring":
+    case "geoarrow.multipoint":
+      return 1;
+    case "geoarrow.polygon":
+    case "geoarrow.multilinestring":
+      return 2;
+    case "geoarrow.multipolygon":
+      return 3;
+    default:
+      return 0;
+  }
+}
+function promoteToDenseUnion(column) {
+  if (column.encoding === "geoarrow.geometry")
+    return column;
+  const chunks = column.chunks.map((chunk) => {
+    const typeId = getCanonicalTypeId(column.encoding, column.dimension);
+    const typeIds = new Int8Array(chunk.length);
+    typeIds.fill(typeId);
+    const valueOffsets = new Int32Array(chunk.length);
+    for (let index = 0; index < chunk.length; index++)
+      valueOffsets[index] = index;
+    return {
+      kind: "dense-union",
+      length: chunk.length,
+      typeIds,
+      valueOffsets,
+      validity: chunk.validity,
+      children: [
+        {
+          name: getGeoArrowGeometryTypeName(column.encoding),
+          typeId,
+          encoding: column.encoding,
+          dimension: column.dimension,
+          coordinateLayout: column.coordinateLayout,
+          data: chunk
+        }
+      ]
+    };
+  });
+  return { ...column, encoding: "geoarrow.geometry", chunks };
+}
+function demoteDenseUnion(column, encoding) {
+  if (encoding === "geoarrow.geometry" || encoding === "geoarrow.geometrycollection")
+    return column;
+  const rows = [];
+  for (const chunk of column.chunks) {
+    if (chunk.kind !== "dense-union")
+      throw new Error("Expected dense-union storage");
+    for (let index = 0; index < chunk.length; index++) {
+      if (!isGeoArrowValueValid(chunk.validity, index)) {
+        rows.push(null);
+        continue;
+      }
+      const physical = (chunk.offset || 0) + index;
+      const child = chunk.children.find((candidate) => candidate.typeId === chunk.typeIds[physical]);
+      const childEncoding = child && (child.encoding || getEncodingFromChildName2(child.name));
+      if (!child || childEncoding !== encoding) {
+        throw new Error(`Rows cannot be represented as ${encoding}`);
+      }
+      const geometry = materializeGeometryRow(child.data, chunk.valueOffsets[physical], childEncoding);
+      rows.push(geometry ? resizeGeometryValue(geometry, child.dimension || column.dimension, column.dimension) : null);
+    }
+  }
+  const built = makeGeoArrowColumnFromGeometryRows(rows, {
+    dimension: column.dimension,
+    coordinateLayout: column.coordinateLayout || "interleaved",
+    offsetType: getColumnOffsetType(column)
+  });
+  return {
+    ...built,
+    encoding,
+    spatialReference: column.spatialReference,
+    edges: column.edges,
+    metadata: column.metadata
+  };
+}
+function resizeGeometryValue(geometry, sourceDimension, targetDimension) {
+  const map = (value) => {
+    if (Array.isArray(value) && (value.length === 0 || typeof value[0] === "number")) {
+      return resizeCoordinate(value, sourceDimension, targetDimension);
+    }
+    return Array.isArray(value) ? value.map(map) : value;
+  };
+  if (geometry.type === "GeometryCollection") {
+    return {
+      type: geometry.type,
+      geometries: geometry.geometries.map((child) => resizeGeometryValue(child, sourceDimension, targetDimension))
+    };
+  }
   return {
-    ...target,
-    spatialReference: source.spatialReference,
-    edges: source.edges,
-    metadata: source.metadata
+    ...geometry,
+    coordinates: map(geometry.coordinates)
   };
 }
+function getCanonicalTypeId(encoding, dimension) {
+  const families = [
+    "point",
+    "linestring",
+    "polygon",
+    "multipoint",
+    "multilinestring",
+    "multipolygon",
+    "geometrycollection"
+  ];
+  const dimensions = ["xy", "xyz", "xym", "xyzm"];
+  const family = encoding.replace("geoarrow.", "");
+  const familyIndex = families.indexOf(family);
+  const dimensionIndex = dimensions.indexOf(dimension);
+  return familyIndex < 0 || dimensionIndex < 0 ? 1 : familyIndex * 4 + dimensionIndex + 1;
+}
+function getColumnOffsetType(column) {
+  for (const chunk of column.chunks) {
+    const found = findOffsetType(chunk);
+    if (found)
+      return found;
+  }
+  return "int32";
+}
+function findOffsetType(array) {
+  switch (array.kind) {
+    case "list":
+    case "serialized":
+      return array.offsets instanceof BigInt64Array ? "int64" : "int32";
+    case "fixed-size-list":
+      return findOffsetType(array.child);
+    case "struct": {
+      for (const child of Object.values(array.children)) {
+        const found = findOffsetType(child);
+        if (found)
+          return found;
+      }
+      return null;
+    }
+    case "dense-union":
+      for (const child of array.children) {
+        const found = findOffsetType(child.data);
+        if (found)
+          return found;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function convertArrayOffsets(array, offsetType) {
+  const toOffsets = (offsets, offsetBase) => {
+    if (offsetType === "int64") {
+      const result2 = new BigInt64Array(offsets.length);
+      for (let index = 0; index < offsets.length; index++)
+        result2[index] = BigInt(offsets[index]);
+      return { offsets: result2, ...offsetBase === void 0 ? {} : { offsetBase } };
+    }
+    const result = new Int32Array(offsets.length);
+    const base = BigInt(offsetBase ?? 0);
+    for (let index = 0; index < offsets.length; index++) {
+      const value = BigInt(offsets[index]) - base;
+      if (value < -2147483648n || value > 2147483647n) {
+        throw new Error("GeoArrow offset cannot be represented as Int32");
+      }
+      result[index] = Number(value);
+    }
+    return { offsets: result, offsetBase: 0 };
+  };
+  switch (array.kind) {
+    case "list":
+      if (array.offsets instanceof (offsetType === "int64" ? BigInt64Array : Int32Array)) {
+        return { ...array, child: convertArrayOffsets(array.child, offsetType) };
+      }
+      return {
+        ...array,
+        ...toOffsets(array.offsets, array.offsetBase),
+        child: convertArrayOffsets(array.child, offsetType)
+      };
+    case "serialized":
+      if (array.offsets instanceof (offsetType === "int64" ? BigInt64Array : Int32Array))
+        return array;
+      return { ...array, ...toOffsets(array.offsets, array.offsetBase) };
+    case "fixed-size-list":
+      return { ...array, child: convertArrayOffsets(array.child, offsetType) };
+    case "struct":
+      return {
+        ...array,
+        children: Object.fromEntries(Object.entries(array.children).map(([name, child]) => [
+          name,
+          convertArrayOffsets(child, offsetType)
+        ]))
+      };
+    case "dense-union":
+      return {
+        ...array,
+        children: array.children.map((child) => ({
+          ...child,
+          data: convertArrayOffsets(child.data, offsetType)
+        }))
+      };
+    default:
+      return array;
+  }
+}
+function getGeoArrowGeometryTypeName(encoding) {
+  return encoding.replace("geoarrow.", "").replace(/^./, (character) => character.toUpperCase());
+}
+function rewindArrayRings(array, encoding, outerClockwise) {
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    let changed2 = false;
+    for (const child of array.children) {
+      if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName2(child.name), outerClockwise))
+        changed2 = true;
+    }
+    return changed2;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    if (array.child.kind !== "dense-union")
+      return false;
+    let changed2 = false;
+    for (const child of array.child.children) {
+      if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName2(child.name), outerClockwise))
+        changed2 = true;
+    }
+    return changed2;
+  }
+  if (encoding !== "geoarrow.polygon" && encoding !== "geoarrow.multipolygon")
+    return false;
+  if (array.kind !== "list" || array.child.kind !== "list")
+    return false;
+  let changed = false;
+  for (let rowIndex = 0; rowIndex < array.length; rowIndex++) {
+    if (!isGeoArrowValueValid(array.validity, rowIndex))
+      continue;
+    const [, rowEnd] = getListRange(array, rowIndex);
+    const rowStart = getListRange(array, rowIndex)[0];
+    if (encoding === "geoarrow.polygon") {
+      const rings = array.child;
+      if (rewindRingGroup(rings, rowStart, rowEnd, outerClockwise))
+        changed = true;
+    } else {
+      const polygons = array.child;
+      for (let polygonIndex = rowStart; polygonIndex < rowEnd; polygonIndex++) {
+        const [ringStart, ringEnd] = getListRange(polygons, polygonIndex);
+        if (rewindRingGroup(polygons.child, ringStart, ringEnd, outerClockwise))
+          changed = true;
+      }
+    }
+  }
+  return changed;
+}
+function rewindRingGroup(rings, firstRing, lastRing, outerClockwise) {
+  if (rings.kind !== "list")
+    return false;
+  const leaf = rings.child;
+  if (leaf.kind !== "fixed-size-list" && leaf.kind !== "struct")
+    return false;
+  let changed = false;
+  for (let ringIndex = firstRing; ringIndex < lastRing; ringIndex++) {
+    const [first, last] = getListRange(rings, ringIndex);
+    const area = getRingArea(leaf, first, last);
+    if (!Number.isFinite(area) || area === 0)
+      continue;
+    const shouldClockwise = ringIndex === firstRing ? outerClockwise : !outerClockwise;
+    if (area < 0 !== shouldClockwise) {
+      reverseCoordinateRange(leaf, first, last);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function getRingArea(leaf, first, last) {
+  let area = 0;
+  for (let index = first; index < last; index++) {
+    const current = readCoordinateAt(leaf, index);
+    const next = readCoordinateAt(leaf, index + 1 < last ? index + 1 : first);
+    if (!current || !next)
+      return Number.NaN;
+    area += current[0] * next[1] - next[0] * current[1];
+  }
+  return area / 2;
+}
+function reverseCoordinateRange(leaf, first, last) {
+  const values = [];
+  for (let index = first; index < last; index++)
+    values.push(readCoordinateAt(leaf, index));
+  values.reverse();
+  for (let index = first; index < last; index++)
+    writeCoordinateAt(leaf, index, values[index - first]);
+}
+function writeCoordinateAt(array, index, coordinate) {
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    const logical = (array.offset || 0) + index;
+    for (let component = 0; component < array.size; component++) {
+      const scalar = (array.child.offset || 0) + logical * array.size + component;
+      array.child.values[scalar] = coordinate[component];
+    }
+  } else if (array.kind === "struct") {
+    const logical = (array.offset || 0) + index;
+    const names = ["x", "y", "z", "m"];
+    for (let component = 0; component < names.length; component++) {
+      const child = array.children[names[component]];
+      if ((child == null ? void 0 : child.kind) === "primitive")
+        child.values[(child.offset || 0) + logical * (child.stride || 1)] = coordinate[component];
+    }
+  }
+}
 function collectCoordinateLeaves(column) {
   const leaves = [];
   for (const chunk of column.chunks)
@@ -1447,6 +2050,7 @@ function getArrayDepth(array) {
 
 // dist/codecs.js
 var import_wkb = require("@math.gl/wkb");
+var import_wkb2 = require("@math.gl/wkb");
 var textEncoder = new TextEncoder();
 var textDecoder = new TextDecoder();
 function decodeGeoArrowWKB(column) {
@@ -1458,9 +2062,38 @@ function decodeGeoArrowWKB(column) {
 function encodeGeoArrowWKB(column) {
   if (column.encoding === "geoarrow.wkb")
     return column;
-  const rows = materializeGeoArrowRows(column);
-  const values = rows.map((row) => row ? (0, import_wkb.writeWKB)(row, column.dimension) : null);
-  return copyMetadata(column, makeSerializedColumn(values, "geoarrow.wkb", column.dimension));
+  const writers = [];
+  const dimensions = [];
+  for (const chunk of column.chunks) {
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      if (!isGeoArrowValueValid(chunk.validity, rowIndex)) {
+        writers.push(null);
+        dimensions.push(column.dimension);
+        continue;
+      }
+      dimensions.push(getPhysicalGeometryDimension(chunk, rowIndex, column.encoding, column.dimension));
+      writers.push((builder) => writePhysicalGeometry(builder, chunk, rowIndex, column.encoding, column.dimension));
+    }
+  }
+  const built = import_wkb2.WKBBuilder.buildGeometryArray(writers, {
+    dimension: column.dimension,
+    dimensionResolver: (index) => dimensions[index] || column.dimension
+  });
+  return copyMetadata(column, {
+    encoding: "geoarrow.wkb",
+    dimension: column.dimension,
+    coordinateLayout: null,
+    chunks: [
+      {
+        kind: "serialized",
+        encoding: "binary",
+        length: writers.length,
+        offsets: built.valueOffsets,
+        values: built.values,
+        ...built.nullBitmap ? { validity: { values: built.nullBitmap } } : {}
+      }
+    ]
+  });
 }
 function decodeGeoArrowWKT(column) {
   if (column.encoding !== "geoarrow.wkt")
@@ -1471,10 +2104,146 @@ function decodeGeoArrowWKT(column) {
 function encodeGeoArrowWKT(column) {
   if (column.encoding === "geoarrow.wkt")
     return column;
-  const rows = materializeGeoArrowRows(column);
-  const values = rows.map((row) => row ? textEncoder.encode((0, import_wkb.formatWKT)(row, column.dimension)) : null);
+  const values = [];
+  for (const chunk of column.chunks) {
+    for (let rowIndex = 0; rowIndex < chunk.length; rowIndex++) {
+      const row = isGeoArrowValueValid(chunk.validity, rowIndex) ? materializeGeometryRow(chunk, rowIndex, column.encoding) : null;
+      values.push(row ? textEncoder.encode((0, import_wkb.formatWKT)(row, column.dimension)) : null);
+    }
+  }
   return copyMetadata(column, makeSerializedColumn(values, "geoarrow.wkt", column.dimension));
 }
+function writePhysicalGeometry(builder, array, rowIndex, encoding, dimension) {
+  const depth = getEncodingDepth3(encoding);
+  if (encoding === "geoarrow.geometry" && array.kind === "dense-union") {
+    const physical = (array.offset || 0) + rowIndex;
+    const typeId = array.typeIds[physical];
+    const child = array.children.find((candidate) => candidate.typeId === typeId);
+    if (!child)
+      throw new Error("Dense-union row references an unknown child");
+    const childDimension = child.dimension || dimension;
+    builder.withDimension(childDimension, () => writePhysicalGeometry(builder, child.data, array.valueOffsets[physical], child.encoding || encodingFromName(child.name), childDimension));
+    return;
+  }
+  if (encoding === "geoarrow.geometrycollection" && array.kind === "list") {
+    const [first, last] = getListRange2(array, rowIndex);
+    builder.beginGeometry("GeometryCollection", last - first);
+    if (array.child.kind !== "dense-union")
+      throw new Error("GeometryCollection requires dense union child");
+    const union = array.child;
+    for (let index = first; index < last; index++) {
+      const physical = (union.offset || 0) + index;
+      const child = union.children.find((candidate) => candidate.typeId === union.typeIds[physical]);
+      if (child) {
+        const childDimension = child.dimension || dimension;
+        builder.withDimension(childDimension, () => writePhysicalGeometry(builder, child.data, union.valueOffsets[physical], child.encoding || encodingFromName(child.name), childDimension));
+      }
+    }
+    return;
+  }
+  if (array.kind !== "list" && depth > 0)
+    throw new Error(`Invalid ${encoding} storage`);
+  const writeCoordinate2 = (leaf, index) => {
+    const coordinate = readPhysicalCoordinate(leaf, index);
+    if (!coordinate)
+      throw new Error("Invalid GeoArrow coordinate storage");
+    if (dimension === "xym")
+      builder.writeCoordinate(coordinate[0], coordinate[1], void 0, coordinate[2]);
+    else if (dimension === "xyzm")
+      builder.writeCoordinate(coordinate[0], coordinate[1], coordinate[2], coordinate[3]);
+    else
+      builder.writeCoordinate(coordinate[0], coordinate[1], coordinate[2]);
+  };
+  const writeSequence = (leaf, first, last) => {
+    for (let index = first; index < last; index++)
+      writeCoordinate2(leaf, index);
+  };
+  if (encoding === "geoarrow.point") {
+    builder.beginPoint();
+    writeCoordinate2(array, rowIndex);
+  } else if (encoding === "geoarrow.linestring" || encoding === "geoarrow.multipoint") {
+    const [first, last] = getListRange2(array, rowIndex);
+    if (encoding === "geoarrow.linestring") {
+      builder.beginLineString(last - first);
+      writeSequence(array.child, first, last);
+    } else {
+      builder.beginMultiPoint(last - first);
+      const leaf = array.child;
+      for (let index = first; index < last; index++) {
+        builder.beginPoint();
+        writeCoordinate2(leaf, index);
+      }
+    }
+  } else if (encoding === "geoarrow.polygon" || encoding === "geoarrow.multilinestring") {
+    const [first, last] = getListRange2(array, rowIndex);
+    const parts = array.child;
+    if (encoding === "geoarrow.polygon")
+      builder.beginPolygon(last - first);
+    else
+      builder.beginMultiLineString(last - first);
+    for (let partIndex = first; partIndex < last; partIndex++) {
+      const [ringFirst, ringLast] = getListRange2(parts, partIndex);
+      const leaf = parts.child;
+      if (encoding === "geoarrow.polygon")
+        builder.beginLinearRing(ringLast - ringFirst);
+      else
+        builder.beginLineString(ringLast - ringFirst);
+      writeSequence(leaf, ringFirst, ringLast);
+    }
+  } else if (encoding === "geoarrow.multipolygon") {
+    const [first, last] = getListRange2(array, rowIndex);
+    const polygons = array.child;
+    builder.beginMultiPolygon(last - first);
+    for (let polygonIndex = first; polygonIndex < last; polygonIndex++) {
+      const [partFirst, partLast] = getListRange2(polygons, polygonIndex);
+      const parts = polygons.child;
+      builder.beginPolygon(partLast - partFirst);
+      for (let partIndex = partFirst; partIndex < partLast; partIndex++) {
+        const [ringFirst, ringLast] = getListRange2(parts, partIndex);
+        builder.beginLinearRing(ringLast - ringFirst);
+        writeSequence(parts.child, ringFirst, ringLast);
+      }
+    }
+  }
+}
+function getPhysicalGeometryDimension(array, rowIndex, encoding, dimension) {
+  if (encoding !== "geoarrow.geometry" || array.kind !== "dense-union")
+    return dimension;
+  const physical = (array.offset || 0) + rowIndex;
+  const child = array.children.find((candidate) => candidate.typeId === array.typeIds[physical]);
+  return (child == null ? void 0 : child.dimension) || dimension;
+}
+function readPhysicalCoordinate(array, index) {
+  if (array.kind === "fixed-size-list" && array.child.kind === "primitive") {
+    const logical = (array.offset || 0) + index;
+    const values = [];
+    for (let component = 0; component < array.size; component++)
+      values.push(Number(array.child.values[(array.child.offset || 0) + (logical * array.size + component) * (array.child.stride || 1)]));
+    return values;
+  }
+  if (array.kind === "struct") {
+    const logical = (array.offset || 0) + index;
+    return ["x", "y", "z", "m"].flatMap((name) => {
+      const child = array.children[name];
+      return (child == null ? void 0 : child.kind) === "primitive" ? [Number(child.values[(child.offset || 0) + logical * (child.stride || 1)])] : [];
+    });
+  }
+  return null;
+}
+function getListRange2(list, index) {
+  const offset = (list.offset || 0) + index;
+  const base = typeof (list.offsetBase ?? 0) === "bigint" ? Number(list.offsetBase) : Number(list.offsetBase ?? 0);
+  return [
+    getGeoArrowOffset(list.offsets, offset) - base,
+    getGeoArrowOffset(list.offsets, offset + 1) - base
+  ];
+}
+function getEncodingDepth3(encoding) {
+  return encoding === "geoarrow.point" ? 0 : encoding === "geoarrow.linestring" || encoding === "geoarrow.multipoint" ? 1 : encoding === "geoarrow.polygon" || encoding === "geoarrow.multilinestring" ? 2 : 3;
+}
+function encodingFromName(name) {
+  return `geoarrow.${name.toLowerCase()}`;
+}
 function normalizeRowsToDimension(rows, dimension) {
   const size = getGeoArrowDimensionSize(dimension);
   const normalizeGeometry = (geometry) => {
@@ -1515,6 +2284,21 @@ function decodeSerializedRows(column, decoder) {
   return rows;
 }
 function getSerializedBytes(array, rowIndex) {
+  var _a;
+  if (array.views) {
+    const viewIndex = ((array.offset || 0) + rowIndex) * 4;
+    const length = array.views[viewIndex];
+    if (length <= 12) {
+      const byteOffset2 = array.views.byteOffset + viewIndex * 4 + 4;
+      return new Uint8Array(array.views.buffer, byteOffset2, length);
+    }
+    const bufferIndex = array.views[viewIndex + 2];
+    const byteOffset = array.views[viewIndex + 3];
+    const data = (_a = array.dataBuffers) == null ? void 0 : _a[bufferIndex];
+    if (!data)
+      throw new Error(`Serialized view references missing data buffer ${bufferIndex}`);
+    return data.subarray(byteOffset, byteOffset + length);
+  }
   const offsetIndex = (array.offset || 0) + rowIndex;
   const baseValue = array.offsetBase ?? 0;
   const base = typeof baseValue === "bigint" ? Number(baseValue) : baseValue;