geolibre-wasm 1.2.1 → 1.4.0

package/README.md

@@ -49,6 +49,33 @@ const meta = JSON.parse(geotiff_info(tiffBytes));
 Classes include `GeoTiffReader` (parse once, read many), `CogBuilder` (encode
 Cloud Optimized GeoTIFFs), and `CogStream` (range-request tiled COG reading).
 
+### Vector data as binary, not GeoJSON
+
+`vector_to_geojson` returns a string, so the consumer pays for `JSON.parse` plus
+a re-encode into typed arrays before anything reaches the GPU. Two binary paths
+skip both steps, reading the same formats through the same reader
+(`geojson`, `topojson`, `gml`, `gpx`, `kml`, `flatgeobuf`, `geopackage`,
+`geoparquet`, `kmz` -- see `vector_formats()`):
+
+```js
+import init, { vector_to_binary, vector_to_arrow_ipc } from "geolibre-wasm";
+await init();
+
+// deck.gl binary attributes: Float64Array positions + Uint32Array indices.
+const b = vector_to_binary(bytes, "geoparquet");
+b.point_positions();          // Float64Array, position_size values per vertex
+b.numeric_column(0);          // Float64Array, one value per feature
+JSON.parse(b.schema_json);    // [{name, type}, ...]
+b.free();
+
+// GeoArrow record batch for apache-arrow, DuckDB-WASM, @geoarrow/deck.gl-layers.
+const ipc = vector_to_arrow_ipc(bytes, "flatgeobuf"); // Uint8Array
+```
+
+Reprojecting variants (`vector_to_binary_reproject`,
+`vector_to_arrow_ipc_reproject`) take `dst_epsg` and `src_epsg`, where `0`
+means "use the layer's own CRS".
+
 ## Tools usage (`./tools`)
 
 ```js

package/geolibre_wasm.d.ts

@@ -314,6 +314,120 @@ export class PmtilesExtractor {
     readonly done: boolean;
 }
 
+/**
+ * A layer's geometry and attributes as flat typed arrays.
+ *
+ * Produced by [`vector_to_binary`]. Every accessor copies into a fresh
+ * JavaScript typed array, so read each one once and keep the reference.
+ */
+export class VectorBinary {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Per line vertex: index into the line feature list.
+     */
+    line_feature_ids(): Uint32Array;
+    /**
+     * Per line feature: its index in the whole layer.
+     */
+    line_feature_index(): Uint32Array;
+    /**
+     * Per line vertex: index into the whole layer.
+     */
+    line_global_feature_ids(): Uint32Array;
+    /**
+     * Vertex offsets delimiting each path; ends at the total vertex count.
+     */
+    line_path_indices(): Uint32Array;
+    /**
+     * Line positions, `position_size` values per vertex.
+     */
+    line_positions(): Float64Array;
+    /**
+     * Field `index` as one `f64` per feature: integers and floats as-is,
+     * booleans as 1/0, everything else (including nulls) as `NaN`.
+     */
+    numeric_column(index: number): Float64Array;
+    /**
+     * Per point vertex: index into the point feature list.
+     */
+    point_feature_ids(): Uint32Array;
+    /**
+     * Per point feature: its index in the whole layer.
+     */
+    point_feature_index(): Uint32Array;
+    /**
+     * Per point vertex: index into the whole layer.
+     */
+    point_global_feature_ids(): Uint32Array;
+    /**
+     * Point positions, `position_size` values per vertex.
+     */
+    point_positions(): Float64Array;
+    /**
+     * Per polygon vertex: index into the polygon feature list.
+     */
+    polygon_feature_ids(): Uint32Array;
+    /**
+     * Per polygon feature: its index in the whole layer.
+     */
+    polygon_feature_index(): Uint32Array;
+    /**
+     * Per polygon vertex: index into the whole layer.
+     */
+    polygon_global_feature_ids(): Uint32Array;
+    /**
+     * Vertex offsets delimiting each whole polygon.
+     */
+    polygon_indices(): Uint32Array;
+    /**
+     * Polygon positions, `position_size` values per vertex.
+     */
+    polygon_positions(): Float64Array;
+    /**
+     * Vertex offsets delimiting each ring (exterior and holes alike).
+     */
+    polygon_primitive_polygon_indices(): Uint32Array;
+    /**
+     * Field `index` as UTF-8 bytes for every feature, concatenated. Split it
+     * with [`Self::text_column_offsets`]. Non-text values are stringified;
+     * nulls are empty.
+     */
+    text_column(index: number): Uint8Array;
+    /**
+     * Byte offsets into [`Self::text_column`], `feature_count + 1` entries.
+     */
+    text_column_offsets(index: number): Uint32Array;
+    /**
+     * Bounds as `[min_x, min_y, max_x, max_y]`, or an empty array when the
+     * layer has no geometry.
+     */
+    readonly bbox: Float64Array;
+    /**
+     * EPSG code of the layer's CRS, if it declares one.
+     */
+    readonly epsg: number | undefined;
+    /**
+     * Number of features in the source layer.
+     */
+    readonly feature_count: number;
+    /**
+     * Number of attribute fields.
+     */
+    readonly field_count: number;
+    /**
+     * Values per vertex in every `positions` array: 2, or 3 when any geometry
+     * carries a Z coordinate.
+     */
+    readonly position_size: number;
+    /**
+     * Attribute schema as JSON: `[{"name":...,"type":...}, ...]`. Field values
+     * themselves come from [`Self::numeric_column`] / [`Self::text_column`].
+     */
+    readonly schema_json: string;
+}
+
 /**
  * Install a panic hook so Rust panics surface as readable `console.error`
  * messages instead of an opaque `RuntimeError: unreachable`.
@@ -417,6 +531,37 @@ export function vector_formats(): string;
  */
 export function vector_info(data: Uint8Array, format: string): string;
 
+/**
+ * Read a vector dataset and return it as a GeoArrow-encoded Arrow IPC stream.
+ *
+ * `format` accepts the same names as [`crate::vector::vector_formats`]. Feed
+ * the bytes to `tableFromIPC` (apache-arrow) or
+ * `insertArrowFromIPCStream` (DuckDB-WASM).
+ */
+export function vector_to_arrow_ipc(data: Uint8Array, format: string): Uint8Array;
+
+/**
+ * Read a vector dataset, reproject it to `dst_epsg`, and return a GeoArrow
+ * Arrow IPC stream. `src_epsg` of `0` uses the layer's own CRS (falling back
+ * to EPSG:4326).
+ */
+export function vector_to_arrow_ipc_reproject(data: Uint8Array, format: string, dst_epsg: number, src_epsg: number): Uint8Array;
+
+/**
+ * Read a vector dataset and return its geometry and attributes as flat typed
+ * arrays — no GeoJSON string, no `JSON.parse`.
+ *
+ * `format` accepts the same names as [`crate::vector::vector_formats`].
+ */
+export function vector_to_binary(data: Uint8Array, format: string): VectorBinary;
+
+/**
+ * Read a vector dataset, reproject it to `dst_epsg`, and return flat typed
+ * arrays. `src_epsg` of `0` uses the layer's own CRS (falling back to
+ * EPSG:4326), matching [`crate::vector::vector_to_geojson_reproject`].
+ */
+export function vector_to_binary_reproject(data: Uint8Array, format: string, dst_epsg: number, src_epsg: number): VectorBinary;
+
 /**
  * Read a vector dataset and return it as a GeoJSON `FeatureCollection` string.
  */
@@ -445,6 +590,7 @@ export interface InitOutput {
     readonly __wbg_cogstream_free: (a: number, b: number) => void;
     readonly __wbg_geotiffreader_free: (a: number, b: number) => void;
     readonly __wbg_pmtilesextractor_free: (a: number, b: number) => void;
+    readonly __wbg_vectorbinary_free: (a: number, b: number) => void;
     readonly cogbuilder_new: (a: number, b: number, c: number) => number;
     readonly cogbuilder_set_bigtiff: (a: number, b: number) => void;
     readonly cogbuilder_set_compression: (a: number, b: number, c: number, d: number) => void;
@@ -525,8 +671,36 @@ export interface InitOutput {
     readonly transform_points_epsg: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly vector_formats: (a: number) => void;
     readonly vector_info: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly vector_to_arrow_ipc: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly vector_to_arrow_ipc_reproject: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly vector_to_binary: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly vector_to_binary_reproject: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly vector_to_geojson: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly vector_to_geojson_reproject: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly vectorbinary_bbox: (a: number, b: number) => void;
+    readonly vectorbinary_epsg: (a: number) => number;
+    readonly vectorbinary_feature_count: (a: number) => number;
+    readonly vectorbinary_field_count: (a: number) => number;
+    readonly vectorbinary_line_feature_ids: (a: number, b: number) => void;
+    readonly vectorbinary_line_feature_index: (a: number, b: number) => void;
+    readonly vectorbinary_line_global_feature_ids: (a: number, b: number) => void;
+    readonly vectorbinary_line_path_indices: (a: number, b: number) => void;
+    readonly vectorbinary_line_positions: (a: number, b: number) => void;
+    readonly vectorbinary_numeric_column: (a: number, b: number, c: number) => void;
+    readonly vectorbinary_point_feature_ids: (a: number, b: number) => void;
+    readonly vectorbinary_point_feature_index: (a: number, b: number) => void;
+    readonly vectorbinary_point_global_feature_ids: (a: number, b: number) => void;
+    readonly vectorbinary_point_positions: (a: number, b: number) => void;
+    readonly vectorbinary_polygon_feature_ids: (a: number, b: number) => void;
+    readonly vectorbinary_polygon_feature_index: (a: number, b: number) => void;
+    readonly vectorbinary_polygon_global_feature_ids: (a: number, b: number) => void;
+    readonly vectorbinary_polygon_indices: (a: number, b: number) => void;
+    readonly vectorbinary_polygon_positions: (a: number, b: number) => void;
+    readonly vectorbinary_polygon_primitive_polygon_indices: (a: number, b: number) => void;
+    readonly vectorbinary_position_size: (a: number) => number;
+    readonly vectorbinary_schema_json: (a: number, b: number) => void;
+    readonly vectorbinary_text_column: (a: number, b: number, c: number) => void;
+    readonly vectorbinary_text_column_offsets: (a: number, b: number, c: number) => void;
     readonly version: (a: number) => void;
     readonly rust_zstd_wasm_shim_calloc: (a: number, b: number) => number;
     readonly rust_zstd_wasm_shim_free: (a: number) => void;

package/geolibre_wasm.js

@@ -1290,6 +1290,431 @@ export class PmtilesExtractor {
 }
 if (Symbol.dispose) PmtilesExtractor.prototype[Symbol.dispose] = PmtilesExtractor.prototype.free;
 
+/**
+ * A layer's geometry and attributes as flat typed arrays.
+ *
+ * Produced by [`vector_to_binary`]. Every accessor copies into a fresh
+ * JavaScript typed array, so read each one once and keep the reference.
+ */
+export class VectorBinary {
+    static __wrap(ptr) {
+        const obj = Object.create(VectorBinary.prototype);
+        obj.__wbg_ptr = ptr;
+        VectorBinaryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VectorBinaryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_vectorbinary_free(ptr, 0);
+    }
+    /**
+     * Bounds as `[min_x, min_y, max_x, max_y]`, or an empty array when the
+     * layer has no geometry.
+     * @returns {Float64Array}
+     */
+    get bbox() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_bbox(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * EPSG code of the layer's CRS, if it declares one.
+     * @returns {number | undefined}
+     */
+    get epsg() {
+        const ret = wasm.vectorbinary_epsg(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
+    /**
+     * Number of features in the source layer.
+     * @returns {number}
+     */
+    get feature_count() {
+        const ret = wasm.vectorbinary_feature_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of attribute fields.
+     * @returns {number}
+     */
+    get field_count() {
+        const ret = wasm.vectorbinary_field_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Per line vertex: index into the line feature list.
+     * @returns {Uint32Array}
+     */
+    line_feature_ids() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_line_feature_ids(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Per line feature: its index in the whole layer.
+     * @returns {Uint32Array}
+     */
+    line_feature_index() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_line_feature_index(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Per line vertex: index into the whole layer.
+     * @returns {Uint32Array}
+     */
+    line_global_feature_ids() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_line_global_feature_ids(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Vertex offsets delimiting each path; ends at the total vertex count.
+     * @returns {Uint32Array}
+     */
+    line_path_indices() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_line_path_indices(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Line positions, `position_size` values per vertex.
+     * @returns {Float64Array}
+     */
+    line_positions() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_line_positions(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Field `index` as one `f64` per feature: integers and floats as-is,
+     * booleans as 1/0, everything else (including nulls) as `NaN`.
+     * @param {number} index
+     * @returns {Float64Array}
+     */
+    numeric_column(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_numeric_column(retptr, this.__wbg_ptr, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Per point vertex: index into the point feature list.
+     * @returns {Uint32Array}
+     */
+    point_feature_ids() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_point_feature_ids(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Per point feature: its index in the whole layer.
+     * @returns {Uint32Array}
+     */
+    point_feature_index() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_point_feature_index(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Per point vertex: index into the whole layer.
+     * @returns {Uint32Array}
+     */
+    point_global_feature_ids() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_point_global_feature_ids(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Point positions, `position_size` values per vertex.
+     * @returns {Float64Array}
+     */
+    point_positions() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_point_positions(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Per polygon vertex: index into the polygon feature list.
+     * @returns {Uint32Array}
+     */
+    polygon_feature_ids() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_polygon_feature_ids(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Per polygon feature: its index in the whole layer.
+     * @returns {Uint32Array}
+     */
+    polygon_feature_index() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_polygon_feature_index(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Per polygon vertex: index into the whole layer.
+     * @returns {Uint32Array}
+     */
+    polygon_global_feature_ids() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_polygon_global_feature_ids(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Vertex offsets delimiting each whole polygon.
+     * @returns {Uint32Array}
+     */
+    polygon_indices() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_polygon_indices(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Polygon positions, `position_size` values per vertex.
+     * @returns {Float64Array}
+     */
+    polygon_positions() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_polygon_positions(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Vertex offsets delimiting each ring (exterior and holes alike).
+     * @returns {Uint32Array}
+     */
+    polygon_primitive_polygon_indices() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_polygon_primitive_polygon_indices(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Values per vertex in every `positions` array: 2, or 3 when any geometry
+     * carries a Z coordinate.
+     * @returns {number}
+     */
+    get position_size() {
+        const ret = wasm.vectorbinary_position_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Attribute schema as JSON: `[{"name":...,"type":...}, ...]`. Field values
+     * themselves come from [`Self::numeric_column`] / [`Self::text_column`].
+     * @returns {string}
+     */
+    get schema_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_schema_json(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Field `index` as UTF-8 bytes for every feature, concatenated. Split it
+     * with [`Self::text_column_offsets`]. Non-text values are stringified;
+     * nulls are empty.
+     * @param {number} index
+     * @returns {Uint8Array}
+     */
+    text_column(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_text_column(retptr, this.__wbg_ptr, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Byte offsets into [`Self::text_column`], `feature_count + 1` entries.
+     * @param {number} index
+     * @returns {Uint32Array}
+     */
+    text_column_offsets(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.vectorbinary_text_column_offsets(retptr, this.__wbg_ptr, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) VectorBinary.prototype[Symbol.dispose] = VectorBinary.prototype.free;
+
 /**
  * Install a panic hook so Rust panics surface as readable `console.error`
  * messages instead of an opaque `RuntimeError: unreachable`.
@@ -1717,6 +2142,131 @@ export function vector_info(data, format) {
     }
 }
 
+/**
+ * Read a vector dataset and return it as a GeoArrow-encoded Arrow IPC stream.
+ *
+ * `format` accepts the same names as [`crate::vector::vector_formats`]. Feed
+ * the bytes to `tableFromIPC` (apache-arrow) or
+ * `insertArrowFromIPCStream` (DuckDB-WASM).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {Uint8Array}
+ */
+export function vector_to_arrow_ipc(data, format) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.vector_to_arrow_ipc(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Read a vector dataset, reproject it to `dst_epsg`, and return a GeoArrow
+ * Arrow IPC stream. `src_epsg` of `0` uses the layer's own CRS (falling back
+ * to EPSG:4326).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @param {number} dst_epsg
+ * @param {number} src_epsg
+ * @returns {Uint8Array}
+ */
+export function vector_to_arrow_ipc_reproject(data, format, dst_epsg, src_epsg) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.vector_to_arrow_ipc_reproject(retptr, ptr0, len0, ptr1, len1, dst_epsg, src_epsg);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Read a vector dataset and return its geometry and attributes as flat typed
+ * arrays — no GeoJSON string, no `JSON.parse`.
+ *
+ * `format` accepts the same names as [`crate::vector::vector_formats`].
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {VectorBinary}
+ */
+export function vector_to_binary(data, format) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.vector_to_binary(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return VectorBinary.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Read a vector dataset, reproject it to `dst_epsg`, and return flat typed
+ * arrays. `src_epsg` of `0` uses the layer's own CRS (falling back to
+ * EPSG:4326), matching [`crate::vector::vector_to_geojson_reproject`].
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @param {number} dst_epsg
+ * @param {number} src_epsg
+ * @returns {VectorBinary}
+ */
+export function vector_to_binary_reproject(data, format, dst_epsg, src_epsg) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.vector_to_binary_reproject(retptr, ptr0, len0, ptr1, len1, dst_epsg, src_epsg);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return VectorBinary.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Read a vector dataset and return it as a GeoJSON `FeatureCollection` string.
  * @param {Uint8Array} data
@@ -1868,6 +2418,9 @@ const GeoTiffReaderFinalization = (typeof FinalizationRegistry === 'undefined')
 const PmtilesExtractorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pmtilesextractor_free(ptr, 1));
+const VectorBinaryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_vectorbinary_free(ptr, 1));
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);

package/geolibre_wasm_bg.wasm.d.ts

@@ -6,6 +6,7 @@ export const __wbg_cogbuilder_free: (a: number, b: number) => void;
 export const __wbg_cogstream_free: (a: number, b: number) => void;
 export const __wbg_geotiffreader_free: (a: number, b: number) => void;
 export const __wbg_pmtilesextractor_free: (a: number, b: number) => void;
+export const __wbg_vectorbinary_free: (a: number, b: number) => void;
 export const cogbuilder_new: (a: number, b: number, c: number) => number;
 export const cogbuilder_set_bigtiff: (a: number, b: number) => void;
 export const cogbuilder_set_compression: (a: number, b: number, c: number, d: number) => void;
@@ -86,8 +87,36 @@ export const transform_bbox_epsg: (a: number, b: number, c: number, d: number, e
 export const transform_points_epsg: (a: number, b: number, c: number, d: number, e: number) => void;
 export const vector_formats: (a: number) => void;
 export const vector_info: (a: number, b: number, c: number, d: number, e: number) => void;
+export const vector_to_arrow_ipc: (a: number, b: number, c: number, d: number, e: number) => void;
+export const vector_to_arrow_ipc_reproject: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const vector_to_binary: (a: number, b: number, c: number, d: number, e: number) => void;
+export const vector_to_binary_reproject: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const vector_to_geojson: (a: number, b: number, c: number, d: number, e: number) => void;
 export const vector_to_geojson_reproject: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const vectorbinary_bbox: (a: number, b: number) => void;
+export const vectorbinary_epsg: (a: number) => number;
+export const vectorbinary_feature_count: (a: number) => number;
+export const vectorbinary_field_count: (a: number) => number;
+export const vectorbinary_line_feature_ids: (a: number, b: number) => void;
+export const vectorbinary_line_feature_index: (a: number, b: number) => void;
+export const vectorbinary_line_global_feature_ids: (a: number, b: number) => void;
+export const vectorbinary_line_path_indices: (a: number, b: number) => void;
+export const vectorbinary_line_positions: (a: number, b: number) => void;
+export const vectorbinary_numeric_column: (a: number, b: number, c: number) => void;
+export const vectorbinary_point_feature_ids: (a: number, b: number) => void;
+export const vectorbinary_point_feature_index: (a: number, b: number) => void;
+export const vectorbinary_point_global_feature_ids: (a: number, b: number) => void;
+export const vectorbinary_point_positions: (a: number, b: number) => void;
+export const vectorbinary_polygon_feature_ids: (a: number, b: number) => void;
+export const vectorbinary_polygon_feature_index: (a: number, b: number) => void;
+export const vectorbinary_polygon_global_feature_ids: (a: number, b: number) => void;
+export const vectorbinary_polygon_indices: (a: number, b: number) => void;
+export const vectorbinary_polygon_positions: (a: number, b: number) => void;
+export const vectorbinary_polygon_primitive_polygon_indices: (a: number, b: number) => void;
+export const vectorbinary_position_size: (a: number) => number;
+export const vectorbinary_schema_json: (a: number, b: number) => void;
+export const vectorbinary_text_column: (a: number, b: number, c: number) => void;
+export const vectorbinary_text_column_offsets: (a: number, b: number, c: number) => void;
 export const version: (a: number) => void;
 export const rust_zstd_wasm_shim_calloc: (a: number, b: number) => number;
 export const rust_zstd_wasm_shim_free: (a: number) => void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "geolibre-wasm",
   "type": "module",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Pure-Rust geospatial toolkit (whitebox_next_gen) compiled to WebAssembly (WASI) for GeoLibre's in-browser tool execution",
   "license": "MIT",
   "repository": {

package/tools.mjs

@@ -132,6 +132,15 @@ async function materializeInput(value) {
   return new Uint8Array(value);
 }
 
+// Build a readable message for a guest trap out of what the tool printed to
+// stderr before aborting. `stdout` here is the shared stdout+stderr capture.
+function describeTrap(argv, err, stdout) {
+  const tool = argv[0] ?? "tool";
+  const tail = stdout.map((s) => s.trimEnd()).filter(Boolean).slice(-12);
+  const detail = tail.length ? `\n${tail.join("\n")}` : "";
+  return `${tool} crashed: ${err.message}${detail}`;
+}
+
 async function exec(argv, inputFiles) {
   const mod = await initTools();
   const inNames = new Set(Object.keys(inputFiles));
@@ -150,7 +159,14 @@ async function exec(argv, inputFiles) {
   const inst = await WebAssembly.instantiate(mod, { wasi_snapshot_preview1: wasi.wasiImport });
   let exitCode = 0;
   try { exitCode = wasi.start(inst); }
-  catch (e) { if (e && e.constructor && e.constructor.name === "WASIProcExit") exitCode = e.code; else throw e; }
+  catch (e) {
+    if (e && e.constructor && e.constructor.name === "WASIProcExit") exitCode = e.code;
+    // A guest trap (a Rust panic aborts to `unreachable`) surfaces as a bare
+    // RuntimeError whose stack is raw wasm-function offsets. The panic message
+    // was already written to stderr, so fold it into the error we rethrow —
+    // otherwise the caller only sees unreadable hex addresses.
+    else throw new Error(describeTrap(argv, e, stdout), { cause: e });
+  }
   // Collect every new file under /work, recursing into subdirectories so tools
   // that write a tree (e.g. raster_to_tiles' {z}/{x}/{y}.png) are surfaced too.
   // Keys are paths relative to /work (nested files use "/" separators).