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

package/dist/kernels.js

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 import { getGeoArrowDimensionSize } from "./types.js";
 import { makeGeoArrowColumnFromGeometryRows } from "./builder.js";
-import { getGeoArrowRowCount, getGeoArrowVertexCount, isGeoArrowValueValid, materializeGeoArrowRows, visitGeoArrowCoordinates } from "./layout.js";
+import { getGeoArrowRowCount, getGeoArrowVertexCount, isGeoArrowValueValid, visitGeoArrowCoordinates, getListRange, materializeGeometryRow } from "./layout.js";
 /** Returns XY bounds, or null when the column contains no finite coordinates. */
 export function getGeoArrowBounds(column) {
     if (column.encoding === 'geoarrow.box')
@@ -25,6 +25,49 @@ export function getGeoArrowBounds(column) {
     });
     return Number.isFinite(minimumX) ? [minimumX, minimumY, maximumX, maximumY] : null;
 }
+/** Computes exact XY bounds for each logical row without materializing geometry values. */
+export 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;
@@ -66,22 +109,20 @@ function readPrimitiveNumber(array, index) {
     return Number(array.values[valueIndex]);
 }
 /** Maps every coordinate into newly allocated physical buffers while preserving column semantics. */
-export function mapGeoArrowCoordinates(column, mapper, options = {}) {
+export 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 !== undefined, options.coordinateLayout !== undefined, 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 };
 }
 /**
  * Maps coordinates and copies the result into caller-provided destination buffers.
@@ -137,48 +178,65 @@ export function normalizeGeoArrowUnion(column) {
 }
 /** Converts between concrete/mixed encodings, dimensions, and coordinate layouts. */
 export 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;
+    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) {
+        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 : undefined,
+    const mapped = mapGeoArrowCoordinates(column, coordinate => coordinate, {
         dimension,
-        coordinateLayout: coordinateLayout || 'interleaved'
+        coordinateLayout: coordinateLayout || undefined,
+        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);
 }
 /** Rewinds polygon rings without changing non-polygon rows. */
 export 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;
 }
 /** Throws when a column exceeds configured work or output limits. */
 export function assertGeoArrowResourceLimits(column, options = {}) {
@@ -206,90 +264,218 @@ export function assertGeoArrowResourceLimits(column, options = {}) {
         }
     }
 }
-function mapGeometryCoordinates(geometry, mapper) {
-    if (geometry.type === 'GeometryCollection') {
+/** Directly clones a physical array while rewriting only coordinate leaves. */
+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 {
+            ...array,
+            children: array.children.map((child, childIndex) => {
+                const childEncoding = child.encoding || getEncodingFromChildName(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 {
-            ...geometry,
-            geometries: geometry.geometries.map(child => mapGeometryCoordinates(child, mapper))
+            ...array,
+            child: mapArrayCoordinates(array.child, 'geoarrow.geometry', rowOffset, targetDimension, targetLayout, mapper, coordinateType, forceDimension, forceLayout, sourceDimension, rowIndicesOverride)
         };
     }
+    const depth = getEncodingDepth(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?.[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;
+/** Fills one row-index entry per coordinate in a concrete nested array. */
+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 || getEncodingFromChildName(child.name);
+        return new Array(getLeafLength(child.data, getEncodingDepth(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(child => child.typeId === union.typeIds[physical]);
+        if (childIndex < 0)
+            continue;
+        const child = union.children[childIndex];
+        assignUnionRowIndices(child.data, child.encoding || getEncodingFromChildName(child.name), union.valueOffsets[physical], rowOffset + rowIndex, output[childIndex]);
+    }
+    return 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 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 || getEncodingFromChildName(child.name), array.valueOffsets[physical], rowIndex, output);
+        }
+        return;
     }
-    return area / 2;
+    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, getEncodingDepth(encoding), rowIndex, output);
 }
-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 getLeafLength(array, depth) {
+    let current = array;
+    for (let level = 0; level < depth; level++) {
+        if (current.kind !== 'list')
+            return 0;
+        current = current.child;
+    }
+    return current.length;
+}
+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?.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?.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) {
@@ -303,13 +489,330 @@ function getDimensionNames(dimension) {
             return ['x', 'y', 'z', 'm'];
     }
 }
-function copyColumnMetadata(source, target) {
+function getEncodingFromChildName(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 getEncodingDepth(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 || getEncodingFromChildName(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: 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 result = new BigInt64Array(offsets.length);
+            for (let index = 0; index < offsets.length; index++)
+                result[index] = BigInt(offsets[index]);
+            return { offsets: result, ...(offsetBase === undefined ? {} : { 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 changed = false;
+        for (const child of array.children) {
+            if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName(child.name), outerClockwise))
+                changed = true;
+        }
+        return changed;
+    }
+    if (encoding === 'geoarrow.geometrycollection' && array.kind === 'list') {
+        if (array.child.kind !== 'dense-union')
+            return false;
+        let changed = false;
+        for (const child of array.child.children) {
+            if (rewindArrayRings(child.data, child.encoding || getEncodingFromChildName(child.name), outerClockwise))
+                changed = true;
+        }
+        return changed;
+    }
+    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?.kind === 'primitive')
+                child.values[(child.offset || 0) + logical * (child.stride || 1)] = coordinate[component];
+        }
+    }
 }
 function collectCoordinateLeaves(column) {
     const leaves = [];