whitebox-wasm 0.2.0 → 0.4.0

package/README.md

@@ -1,8 +1,15 @@
 # whitebox-wasm
 
-**Pure-Rust GeoTIFF decoding compiled to WebAssembly.** No GDAL, no PROJ, no
-native libraries, no server. Decode GeoTIFF / BigTIFF / COG entirely in the
-browser, Node, Deno, or any Wasm host.
+**Pure-Rust geospatial toolkit compiled to WebAssembly.** No GDAL, no PROJ, no
+native libraries, no server. Work with raster, vector, and LiDAR data entirely
+in the browser, Node, Deno, or any Wasm host:
+
+- **Raster** - read/write GeoTIFF / BigTIFF / COG, stats, range-request streaming
+- **Projections** - full EPSG + user-defined CRS to WGS84 lon/lat
+- **Vector** - read GeoJSON, TopoJSON, GML, GPX, KML, FlatGeobuf, GeoPackage, KMZ -> GeoJSON, with reprojection
+- **LiDAR** - read LAS / LAZ / PLY point clouds (xyz, classification, intensity)
+- **Analysis** - convex hull, Moran's I spatial autocorrelation
+- **Tools** - the full WhiteboxTools suite (733 tools) via `whitebox-wasm/tools`
 
 This wraps `wbgeotiff`, the shared GeoTIFF engine from the original
 [**whitebox_next_gen**](https://github.com/jblindsay/whitebox_next_gen) project
@@ -132,6 +139,74 @@ window). Requires a tiled COG on a server that supports HTTP range requests.
 
 JSON-returning functions report failures as `{"ok":false,"error":"..."}`; class methods throw on error.
 
+## Vector
+
+```js
+import init, { vector_to_geojson, vector_info, vector_to_geojson_reproject } from "whitebox-wasm";
+await init();
+const bytes = new Uint8Array(await (await fetch("data.fgb")).arrayBuffer());
+const geojson = JSON.parse(vector_to_geojson(bytes, "flatgeobuf"));
+const meta = JSON.parse(vector_info(bytes, "flatgeobuf")); // { features, geometry, epsg, fields, bbox }
+const wgs84 = vector_to_geojson_reproject(bytes, "flatgeobuf", 4326, 0); // dst, src(0=auto)
+```
+
+- `vector_formats()` -> supported formats (geojson, topojson, gml, gpx, kml, flatgeobuf, geopackage, kmz)
+- `vector_to_geojson(data, format)` -> GeoJSON string
+- `vector_to_geojson_reproject(data, format, dst_epsg, src_epsg)` -> reprojected GeoJSON (`src_epsg=0` uses the layer CRS, or 4326)
+- `vector_info(data, format)` -> JSON `{name, features, geometry, epsg, fields, bbox}`
+
+## LiDAR
+
+```js
+import init, { lidar_info, lidar_read_xyz } from "whitebox-wasm";
+await init();
+const las = new Uint8Array(await (await fetch("cloud.laz")).arrayBuffer());
+const meta = JSON.parse(lidar_info(las, "laz")); // { points, epsg, point_format, bounds }
+const xyz = lidar_read_xyz(las, "laz");          // Float64Array [x0,y0,z0, x1,y1,z1, ...]
+```
+
+- `lidar_formats()`, `lidar_info(data, format)` (header-only count/bounds for LAS/LAZ)
+- `lidar_read_xyz` -> `Float64Array`; `lidar_read_classification` -> `Uint8Array`; `lidar_read_intensity` -> `Uint16Array`
+
+## Analysis
+
+- `convex_hull(points_xy)` -> hull ring `Float64Array` (input `[x0,y0,x1,y1,...]`)
+- `morans_i(points_xy, values, distance_threshold)` -> JSON global spatial autocorrelation `{morans_i, expected, variance, z_score, p_value, n}`
+
+## Tools (the full WhiteboxTools suite)
+
+The `whitebox-wasm/tools` subpath runs the complete **WhiteboxTools** algorithm
+suite (**733 tools** - slope, filters, hydrology, geomorphometry, vector ops,
+...). The tools are path-based, so they run through an in-memory WASI filesystem
+(bundled `whitebox-cli.wasm`); raster outputs are Cloud Optimized GeoTIFFs.
+
+```js
+import { runTool, listTools } from "whitebox-wasm/tools";
+
+console.log((await listTools()).length);  // 733
+
+// raster: slope -> a COG
+const { files } = await runTool("slope", {
+  args: ["--input=/work/dem.tif", "--output=/work/slope.tif", "--units=degrees"],
+  input: { "dem.tif": demBytes },         // Uint8Array, placed under /work
+});
+const slopeCog = files["slope.tif"];      // Uint8Array (tiled, Deflate, overviews)
+
+// vector: convex hull -> GeoJSON
+const hull = await runTool("minimum_convex_hull", {
+  args: ["--input=/work/in.geojson", "--output=/work/hull.geojson"],
+  input: { "in.geojson": geojsonBytes },
+});
+```
+
+- `listTools()` -> `string[]` of tool ids
+- `runTool(id, { args, input })` -> `{ exitCode, stdout, files }` (`files` = outputs the tool wrote)
+- `initTools(source?)` -> compile the runner; in Node pass the wasm bytes (browsers/bundlers omit it)
+
+Needs the `@bjorn3/browser_wasi_shim` peer (declared as a dependency). The
+`whitebox-cli.wasm` (~5 MB gzipped) is only fetched the first time you call a
+tool, so the rest of the library stays lightweight.
+
 ## Limits
 
 WebAssembly is 32-bit, so linear memory is capped at ~4 GiB. `geotiff_info` is
@@ -147,5 +222,5 @@ decoded in-browser). For such data, read metadata only or process server-side.
 ## License
 
 Dual-licensed under MIT or Apache-2.0, at your option. Includes the vendored
-`wbgeotiff` and `wbprojection` crates (Copyright John Lindsay, Whitebox
+`wbgeotiff`, `wbprojection`, `wbvector`, `wblidar`, `wbtopology`, `wbspatialstats`, and `wbhdf` crates (Copyright John Lindsay, Whitebox
 Geospatial Inc.), used under the same dual license.

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whitebox-wasm",
   "type": "module",
-  "description": "WebAssembly bindings for the pure-Rust Whitebox GeoTIFF engine",
-  "version": "0.2.0",
+  "description": "Pure-Rust geospatial toolkit (raster, vector, LiDAR, projections) compiled to WebAssembly",
+  "version": "0.4.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
@@ -11,7 +11,10 @@
   "files": [
     "whitebox_wasm_bg.wasm",
     "whitebox_wasm.js",
-    "whitebox_wasm.d.ts"
+    "whitebox_wasm.d.ts",
+    "whitebox-cli.wasm",
+    "tools.mjs",
+    "tools.d.ts"
   ],
   "main": "whitebox_wasm.js",
   "homepage": "https://github.com/opengeos/whitebox-wasm",
@@ -20,10 +23,23 @@
     "./snippets/*"
   ],
   "keywords": [
-    "geotiff",
+    "geospatial",
     "wasm",
     "gis",
-    "raster",
-    "webassembly"
-  ]
+    "geotiff",
+    "lidar"
+  ],
+  "dependencies": {
+    "@bjorn3/browser_wasi_shim": "^0.4.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./whitebox_wasm.d.ts",
+      "default": "./whitebox_wasm.js"
+    },
+    "./tools": {
+      "types": "./tools.d.ts",
+      "default": "./tools.mjs"
+    }
+  }
 }

package/tools.d.ts

@@ -0,0 +1,26 @@
+/** Result of running a tool. */
+export interface ToolResult {
+  /** Process exit code (0 = success). */
+  exitCode: number;
+  /** Captured stdout/stderr lines. */
+  stdout: string[];
+  /** New files the tool wrote, keyed by filename (e.g. the --output path's basename). */
+  files: Record<string, Uint8Array>;
+}
+
+export interface RunToolOptions {
+  /** CLI args, e.g. ["--input=/work/dem.tif", "--output=/work/out.tif", "--units=degrees"]. */
+  args?: string[];
+  /** Input files placed under /work, keyed by filename. */
+  input?: Record<string, Uint8Array>;
+}
+
+/** Compile the WASI tool runner once. Omit `source` in browsers/bundlers; pass
+ *  the wasm bytes or a URL/Response in Node. */
+export function initTools(source?: URL | Response | BufferSource | string): Promise<WebAssembly.Module>;
+
+/** List every available tool id. */
+export function listTools(): Promise<string[]>;
+
+/** Run one tool over an in-memory filesystem. */
+export function runTool(tool: string, opts?: RunToolOptions): Promise<ToolResult>;

package/tools.mjs

@@ -0,0 +1,83 @@
+// whitebox-wasm/tools - run the WhiteboxTools (wbtools_oss) algorithm suite from
+// JavaScript. The tools are the WASI binary `whitebox-cli.wasm` (733 path-based
+// tools); this module executes them through a WASI shim with an in-memory
+// filesystem, so they run in browsers, Node, Deno, and bundlers without a real
+// disk. Raster outputs are Cloud Optimized GeoTIFFs.
+//
+//   import { runTool, listTools } from "whitebox-wasm/tools";
+//   const { files } = await runTool("slope", {
+//     args: ["--input=/work/dem.tif", "--output=/work/slope.tif", "--units=degrees"],
+//     input: { "dem.tif": demBytes },   // Uint8Array, placed under /work
+//   });
+//   const slopeCog = files["slope.tif"];  // Uint8Array
+import { WASI, File, OpenFile, ConsoleStdout, PreopenDirectory } from "@bjorn3/browser_wasi_shim";
+
+let _module = null;
+
+/**
+ * Compile the WASI tool runner once. In browsers/bundlers it loads the bundled
+ * `whitebox-cli.wasm` relative to this module. In Node (no fetch of file URLs),
+ * pass the wasm bytes or a URL/Response explicitly.
+ * @param {URL|Response|BufferSource|string} [source]
+ * @returns {Promise<WebAssembly.Module>}
+ */
+export async function initTools(source) {
+  if (_module) return _module;
+  if (!source) source = new URL("./whitebox-cli.wasm", import.meta.url);
+  if (source instanceof Uint8Array || source instanceof ArrayBuffer) {
+    _module = await WebAssembly.compile(source);
+  } else if (source instanceof Response) {
+    _module = await WebAssembly.compileStreaming(source);
+  } else {
+    _module = await WebAssembly.compileStreaming(fetch(source));
+  }
+  return _module;
+}
+
+async function exec(argv, inputFiles) {
+  const mod = await initTools();
+  const inNames = new Set(Object.keys(inputFiles));
+  const contents = new Map(
+    Object.entries(inputFiles).map(([k, v]) => [k, new File(new Uint8Array(v))]));
+  const work = new PreopenDirectory("/work", contents);
+  const stdout = [];
+  const fds = [
+    new OpenFile(new File(new Uint8Array())),
+    ConsoleStdout.lineBuffered((s) => stdout.push(s)),
+    ConsoleStdout.lineBuffered((s) => stdout.push(s)),
+    work,
+  ];
+  const wasi = new WASI(["whitebox", ...argv], [], fds, { debug: false });
+  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; }
+  const files = {};
+  for (const [name, entry] of work.dir.contents) {
+    if (entry.data && !inNames.has(name)) files[name] = entry.data;
+  }
+  return { exitCode, stdout, files };
+}
+
+/**
+ * List every available tool id (733 of them).
+ * @returns {Promise<string[]>}
+ */
+export async function listTools() {
+  const { stdout } = await exec(["list"], {});
+  return stdout.map((s) => s.trim()).filter((s) => s && !/tools:$/.test(s));
+}
+
+/**
+ * Run one tool over an in-memory filesystem.
+ * @param {string} tool  tool id, e.g. "slope" (see {@link listTools})
+ * @param {object} [opts]
+ * @param {string[]} [opts.args]  CLI args, e.g. ["--input=/work/dem.tif","--output=/work/out.tif","--units=degrees"]
+ * @param {Object<string, Uint8Array>} [opts.input]  files placed under /work (key = filename)
+ * @returns {Promise<{exitCode:number, stdout:string[], files:Object<string,Uint8Array>}>}
+ *   `files` contains any new files the tool wrote (e.g. the --output path).
+ */
+export async function runTool(tool, opts = {}) {
+  const { args = [], input = {} } = opts;
+  return exec([tool, ...args], input);
+}

package/whitebox_wasm.d.ts

@@ -248,6 +248,12 @@ export class GeoTiffReader {
  */
 export function __start(): void;
 
+/**
+ * Convex hull of a 2D point set. Input is `[x0,y0,x1,y1,...]`; output is the
+ * hull ring as `[x0,y0,...]` (closed). Needs at least 3 points.
+ */
+export function convex_hull(points_xy: Float64Array): Float64Array;
+
 /**
  * Decode only a GeoTIFF's header and return its metadata as JSON. O(header)
  * memory, so it works on multi-gigabyte rasters that whole-image reads cannot
@@ -270,6 +276,75 @@ export function geotiff_read_band_f64(data: Uint8Array, band: number): Float64Ar
  */
 export function geotiff_stats(data: Uint8Array): string;
 
+/**
+ * LiDAR formats this build can read from memory.
+ */
+export function lidar_formats(): string;
+
+/**
+ * Read a LiDAR file's metadata as JSON. For LAS/LAZ this is header-only (count,
+ * bounds, CRS, point format, COPC flag) and never decodes points:
+ * `{"ok":true,"format","points","epsg"|null,"point_format"|null,
+ *   "bounds":[min_x,min_y,min_z,max_x,max_y,max_z]|null,"copc":bool}`.
+ */
+export function lidar_info(data: Uint8Array, format: string): string;
+
+/**
+ * Read per-point classification codes as a `Uint8Array` (length `point_count`).
+ */
+export function lidar_read_classification(data: Uint8Array, format: string): Uint8Array;
+
+/**
+ * Read per-point intensity as a `Uint16Array` (length `point_count`).
+ */
+export function lidar_read_intensity(data: Uint8Array, format: string): Uint16Array;
+
+/**
+ * Read all point coordinates as an interleaved `Float64Array`
+ * `[x0,y0,z0, x1,y1,z1, ...]` (length `3 * point_count`).
+ *
+ * Guarded against 32-bit memory blowup; very large clouds return a clean error
+ * (read the header with `lidar_info`, or downsample on your side).
+ */
+export function lidar_read_xyz(data: Uint8Array, format: string): Float64Array;
+
+/**
+ * Global Moran's I spatial autocorrelation for point data, using a binary
+ * distance-band spatial weights matrix (neighbors within `distance_threshold`).
+ *
+ * `points_xy` is `[x0,y0,...]`, `values` is one value per point. Returns JSON:
+ * `{"ok":true,"morans_i","expected","variance","z_score","p_value","n"}`.
+ *
+ * Builds neighbors in O(n^2); intended for up to a few thousand points.
+ */
+export function morans_i(points_xy: Float64Array, values: Float64Array, distance_threshold: number): string;
+
+/**
+ * Vector formats this build can read from memory (comma-separated).
+ */
+export function vector_formats(): string;
+
+/**
+ * Read a vector dataset and return metadata as JSON:
+ * `{"ok":true,"name","features","geometry","epsg"|null,"fields":[...],
+ *   "bbox":[min_x,min_y,max_x,max_y]|null}`.
+ */
+export function vector_info(data: Uint8Array, format: string): string;
+
+/**
+ * Read a vector dataset and return it as a GeoJSON `FeatureCollection` string.
+ */
+export function vector_to_geojson(data: Uint8Array, format: string): string;
+
+/**
+ * Read a vector dataset, reproject it to `dst_epsg`, and return GeoJSON.
+ * Uses the bundled pure-Rust projection engine (full EPSG support).
+ *
+ * `src_epsg` overrides the source CRS: pass `0` to use the layer's own CRS, or
+ * fall back to EPSG:4326 if it declares none (GeoJSON is WGS84 by RFC 7946).
+ */
+export function vector_to_geojson_reproject(data: Uint8Array, format: string, dst_epsg: number, src_epsg: number): string;
+
 /**
  * Semantic version of this crate, exposed for runtime feature detection.
  */
@@ -279,6 +354,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __start: () => void;
     readonly __wbg_cogbuilder_free: (a: number, b: number) => void;
     readonly __wbg_cogstream_free: (a: number, b: number) => void;
     readonly __wbg_geotiffreader_free: (a: number, b: number) => void;
@@ -307,6 +383,7 @@ export interface InitOutput {
     readonly cogstream_num_levels: (a: number) => number;
     readonly cogstream_tile_range: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cogstream_tiles_for_window: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly convex_hull: (a: number, b: number, c: number) => void;
     readonly geotiff_info: (a: number, b: number, c: number) => void;
     readonly geotiff_read_band_f64: (a: number, b: number, c: number, d: number) => void;
     readonly geotiff_stats: (a: number, b: number, c: number) => void;
@@ -338,8 +415,25 @@ export interface InitOutput {
     readonly geotiffreader_stats_json: (a: number, b: number) => void;
     readonly geotiffreader_value_transform: (a: number, b: number) => void;
     readonly geotiffreader_width: (a: number) => number;
+    readonly lidar_formats: (a: number) => void;
+    readonly lidar_info: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly lidar_read_classification: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly lidar_read_intensity: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly lidar_read_xyz: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly morans_i: (a: number, b: number, c: number, d: number, e: number, f: 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_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 version: (a: number) => void;
-    readonly __start: () => void;
+    readonly rust_zstd_wasm_shim_calloc: (a: number, b: number) => number;
+    readonly rust_zstd_wasm_shim_free: (a: number) => void;
+    readonly rust_zstd_wasm_shim_malloc: (a: number) => number;
+    readonly rust_zstd_wasm_shim_memcmp: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memcpy: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => void;
     readonly __wbindgen_export: (a: number, b: number, c: number) => void;
     readonly __wbindgen_export2: (a: number, b: number) => number;
     readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;

package/whitebox_wasm.js

@@ -989,6 +989,33 @@ export function __start() {
     wasm.__start();
 }
 
+/**
+ * Convex hull of a 2D point set. Input is `[x0,y0,x1,y1,...]`; output is the
+ * hull ring as `[x0,y0,...]` (closed). Needs at least 3 points.
+ * @param {Float64Array} points_xy
+ * @returns {Float64Array}
+ */
+export function convex_hull(points_xy) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF64ToWasm0(points_xy, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.convex_hull(retptr, ptr0, len0);
+        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 v2 = getArrayF64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 8, 8);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Decode only a GeoTIFF's header and return its metadata as JSON. O(header)
  * memory, so it works on multi-gigabyte rasters that whole-image reads cannot
@@ -1071,6 +1098,332 @@ export function geotiff_stats(data) {
     }
 }
 
+/**
+ * LiDAR formats this build can read from memory.
+ * @returns {string}
+ */
+export function lidar_formats() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.lidar_formats(retptr);
+        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);
+    }
+}
+
+/**
+ * Read a LiDAR file's metadata as JSON. For LAS/LAZ this is header-only (count,
+ * bounds, CRS, point format, COPC flag) and never decodes points:
+ * `{"ok":true,"format","points","epsg"|null,"point_format"|null,
+ *   "bounds":[min_x,min_y,min_z,max_x,max_y,max_z]|null,"copc":bool}`.
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {string}
+ */
+export function lidar_info(data, format) {
+    let deferred4_0;
+    let deferred4_1;
+    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.lidar_info(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);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Read per-point classification codes as a `Uint8Array` (length `point_count`).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {Uint8Array}
+ */
+export function lidar_read_classification(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.lidar_read_classification(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 per-point intensity as a `Uint16Array` (length `point_count`).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {Uint16Array}
+ */
+export function lidar_read_intensity(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.lidar_read_intensity(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 = getArrayU16FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 2, 2);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Read all point coordinates as an interleaved `Float64Array`
+ * `[x0,y0,z0, x1,y1,z1, ...]` (length `3 * point_count`).
+ *
+ * Guarded against 32-bit memory blowup; very large clouds return a clean error
+ * (read the header with `lidar_info`, or downsample on your side).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {Float64Array}
+ */
+export function lidar_read_xyz(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.lidar_read_xyz(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 = getArrayF64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 8, 8);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Global Moran's I spatial autocorrelation for point data, using a binary
+ * distance-band spatial weights matrix (neighbors within `distance_threshold`).
+ *
+ * `points_xy` is `[x0,y0,...]`, `values` is one value per point. Returns JSON:
+ * `{"ok":true,"morans_i","expected","variance","z_score","p_value","n"}`.
+ *
+ * Builds neighbors in O(n^2); intended for up to a few thousand points.
+ * @param {Float64Array} points_xy
+ * @param {Float64Array} values
+ * @param {number} distance_threshold
+ * @returns {string}
+ */
+export function morans_i(points_xy, values, distance_threshold) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF64ToWasm0(points_xy, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(values, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.morans_i(retptr, ptr0, len0, ptr1, len1, distance_threshold);
+        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);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Vector formats this build can read from memory (comma-separated).
+ * @returns {string}
+ */
+export function vector_formats() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.vector_formats(retptr);
+        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);
+    }
+}
+
+/**
+ * Read a vector dataset and return metadata as JSON:
+ * `{"ok":true,"name","features","geometry","epsg"|null,"fields":[...],
+ *   "bbox":[min_x,min_y,max_x,max_y]|null}`.
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {string}
+ */
+export function vector_info(data, format) {
+    let deferred4_0;
+    let deferred4_1;
+    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_info(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);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Read a vector dataset and return it as a GeoJSON `FeatureCollection` string.
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @returns {string}
+ */
+export function vector_to_geojson(data, format) {
+    let deferred4_0;
+    let deferred4_1;
+    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_geojson(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);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Read a vector dataset, reproject it to `dst_epsg`, and return GeoJSON.
+ * Uses the bundled pure-Rust projection engine (full EPSG support).
+ *
+ * `src_epsg` overrides the source CRS: pass `0` to use the layer's own CRS, or
+ * fall back to EPSG:4326 if it declares none (GeoJSON is WGS84 by RFC 7946).
+ * @param {Uint8Array} data
+ * @param {string} format
+ * @param {number} dst_epsg
+ * @param {number} src_epsg
+ * @returns {string}
+ */
+export function vector_to_geojson_reproject(data, format, dst_epsg, src_epsg) {
+    let deferred4_0;
+    let deferred4_1;
+    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_geojson_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);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Semantic version of this crate, exposed for runtime feature detection.
  * @returns {string}