geolibre-wasm 0.5.3 → 0.7.0

package/README.md

@@ -65,10 +65,87 @@ const { exitCode, stdout, files } = await runTool("slope", {
 const slopeCog = files["slope.tif"]; // Uint8Array (Cloud Optimized GeoTIFF)
 ```
 
+COG subsets can be extracted from a local file or an HTTP source. HTTP sources
+use byte-range requests and do not download the full object:
+
+```js
+const { files } = await runTool("extract_cog_subset", {
+  args: [
+    "--url=https://example.com/scene.cog.tif",
+    "--bbox=-122.55,37.70,-122.35,37.84",
+    "--bbox_crs=4326",
+    "--output_crs=3857",
+    "--resolution=10",
+    "--nodata=-9999",
+    "--output=/work/subset.tif",
+  ],
+});
+const subsetCog = files["subset.tif"];
+```
+
+WMS subsets can be requested from a GetMap endpoint that supports GeoTIFF
+responses:
+
+```js
+const { files } = await runTool("extract_wms_subset", {
+  args: [
+    "--url=https://example.com/geoserver/wms",
+    "--layers=workspace:layer",
+    "--bbox=-122.55,37.70,-122.35,37.84",
+    "--bbox_crs=4326",
+    "--resolution=0.0001",
+    "--format=image/geotiff",
+    "--output=/work/wms_subset.tif",
+  ],
+});
+```
+
+XYZ tile subsets can be mosaicked from raster tiles and written as an RGB COG:
+
+```js
+const { files } = await runTool("extract_xyz_tile_subset", {
+  args: [
+    "--url=https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+    "--zoom=10",
+    "--bbox=-122.55,37.70,-122.35,37.84",
+    "--bbox_crs=4326",
+    "--width=512",
+    "--height=512",
+    "--output=/work/xyz_subset.tif",
+  ],
+});
+```
+
+For a local COG, upload/provide bytes through `input` and point `--input` at
+the `/work` path:
+
+```js
+const { files } = await runTool("extract_cog_subset", {
+  args: [
+    "--input=/work/local.cog.tif",
+    "--bbox=-122.55,37.70,-122.35,37.84",
+    "--bbox_crs=4326",
+    "--output=/work/subset.tif",
+  ],
+  input: { "local.cog.tif": localCogBytes },
+});
+```
+
 Inputs are placed under `/work` (keyed by filename); any file a tool writes is
 returned in `files`. Raster outputs are Cloud Optimized GeoTIFFs; vector outputs
 are GeoJSON.
 
+When `output_crs` is set, `resolution` is interpreted in output CRS units and
+the subset is reprojected with nearest-neighbor resampling. Without
+`output_crs`, the output usually stays on the source COG grid. Sources with
+user-defined projection strings that cannot be written as EPSG metadata, such as
+the NLCD sample, default to `bbox_crs` output so GIS viewers can place the
+result. Outputs are Deflate-compressed by default. `nodata` overrides the output
+nodata metadata and is used to fill pixels introduced during reprojection.
+The subset writer preserves the source sample type for supported COG types
+(`uint8`, `float32`, and `float64`); palette-indexed `uint8` rasters retain
+their source ColorMap.
+
 ## API
 
 | Export | Description |
@@ -77,6 +154,9 @@ are GeoJSON.
 | `listTools(): Promise<string[]>` | Every available tool id. |
 | `listManifests(): Promise<ToolManifest[]>` | All tool manifests (parameter schemas), for building UIs offline. |
 | `runTool(tool, { args?, input? }): Promise<ToolResult>` | Run one tool over the in-memory filesystem. |
+| `extractCogSubset(source, opts): Promise<Uint8Array>` | Extract a local or HTTP COG subset directly. |
+| `extractWmsSubset(url, opts): Promise<Uint8Array>` | Request a WMS GeoTIFF subset and encode it as a COG. |
+| `extractXyzTileSubset(url, opts): Promise<Uint8Array>` | Mosaic XYZ raster tiles and encode them as an RGB COG. |
 
 `ToolResult` is `{ exitCode: number, stdout: string[], files: Record<string, Uint8Array> }`.
 

package/geolibre_wasm.d.ts

@@ -79,6 +79,14 @@ export class CogBuilder {
 export class CogStream {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Reproject a bbox from `bbox_epsg` into this COG's dataset CRS.
+     *
+     * The COG projection string is preferred over its EPSG tag when available,
+     * because some user-defined projected GeoTIFFs expose only their geographic
+     * base EPSG code.
+     */
+    bbox_to_dataset_crs(bbox_epsg: number, bbox: Float64Array): Float64Array;
     /**
      * Bounding box `[min_x, min_y, max_x, max_y]` in the dataset CRS, or empty.
      */
@@ -115,6 +123,14 @@ export class CogStream {
      * Parse a COG's tile layout from front-of-file header bytes.
      */
     constructor(header_bytes: Uint8Array);
+    /**
+     * Reproject x,y coordinate pairs from this COG's dataset CRS to an EPSG CRS.
+     */
+    points_from_dataset_crs(dst_epsg: number, xy: Float64Array): Float64Array;
+    /**
+     * Reproject x,y coordinate pairs from an EPSG CRS into this COG's dataset CRS.
+     */
+    points_to_dataset_crs(src_epsg: number, xy: Float64Array): Float64Array;
     /**
      * `[offset, length]` byte range of the tile at `(col, row)` on `level`.
      */
@@ -128,6 +144,10 @@ export class CogStream {
      * EPSG code of the full-resolution level, if any.
      */
     readonly epsg: number | undefined;
+    /**
+     * True when the COG CRS is represented by a user-defined projection string.
+     */
+    readonly has_projection_string: boolean;
     /**
      * No-data sentinel, if declared.
      */
@@ -242,6 +262,58 @@ export class GeoTiffReader {
     readonly width: number;
 }
 
+export class PmtilesExtractor {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Hand back the bytes of one `wanted_json()` range, identified by its
+     * offset. Ranges may be fed in any order.
+     */
+    feed(offset: number, bytes: Uint8Array): void;
+    /**
+     * Assemble the extracted archive. Consumes the extractor's buffers; the
+     * returned `Uint8Array` is a complete `.pmtiles` file.
+     */
+    finish(): Uint8Array;
+    /**
+     * Source archive header as JSON (`{}` until the first feed): zooms,
+     * bounds, tile type/compression, tile counts. Lets a UI validate the
+     * request and describe the source before committing to the download.
+     */
+    header_json(): string;
+    /**
+     * Plan an extraction of `min_zoom..=max_zoom` tiles intersecting the
+     * WGS84 bbox. Zooms are clamped to what the source archive contains once
+     * its header arrives; `min_zoom` 0 keeps the basemap usable zoomed out.
+     */
+    constructor(min_lon: number, min_lat: number, max_lon: number, max_lat: number, min_zoom: number, max_zoom: number);
+    /**
+     * Progress as JSON: `{"phase":"header|directories|data|done",
+     * "tiles_selected":n,"blobs_total":n,"data_bytes_total":n,
+     * "data_bytes_received":n,"estimated_output_bytes":n}`.
+     */
+    progress_json(): string;
+    /**
+     * Coalesce tile-data requests whose byte gap is at most this (default
+     * 65,536). Larger values trade overfetch for fewer HTTP round-trips.
+     */
+    set_max_range_gap(max_gap: number): void;
+    /**
+     * Cap on addressed tiles (default 2,000,000). Raise for huge desktop
+     * extracts; lower to fail fast in memory-constrained embeds.
+     */
+    set_max_tiles(max_tiles: number): void;
+    /**
+     * Outstanding byte ranges the host should fetch, as a JSON array of
+     * `{"offset":n,"length":n}`. Empty array when nothing is outstanding.
+     */
+    wanted_json(): string;
+    /**
+     * True once every needed range has been fed; `finish()` is then valid.
+     */
+    readonly done: boolean;
+}
+
 /**
  * Install a panic hook so Rust panics surface as readable `console.error`
  * messages instead of an opaque `RuntimeError: unreachable`.
@@ -319,6 +391,20 @@ export function lidar_read_xyz(data: Uint8Array, format: string): Float64Array;
  */
 export function morans_i(points_xy: Float64Array, values: Float64Array, distance_threshold: number): string;
 
+/**
+ * Reproject a bbox between two EPSG CRSs.
+ *
+ * Input and output order is `[min_x, min_y, max_x, max_y]`. The bbox edges are
+ * densified so projected extrema that fall along an edge are preserved better
+ * than a corner-only transform.
+ */
+export function transform_bbox_epsg(src_epsg: number, dst_epsg: number, bbox: Float64Array): Float64Array;
+
+/**
+ * Reproject x,y coordinate pairs between two EPSG CRSs.
+ */
+export function transform_points_epsg(src_epsg: number, dst_epsg: number, xy: Float64Array): Float64Array;
+
 /**
  * Vector formats this build can read from memory (comma-separated).
  */
@@ -358,6 +444,7 @@ export interface InitOutput {
     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;
+    readonly __wbg_pmtilesextractor_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;
@@ -370,6 +457,7 @@ export interface InitOutput {
     readonly cogbuilder_write_f32: (a: number, b: number, c: number, d: number) => void;
     readonly cogbuilder_write_f64: (a: number, b: number, c: number, d: number) => void;
     readonly cogbuilder_write_u8: (a: number, b: number, c: number, d: number) => void;
+    readonly cogstream_bbox_to_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cogstream_bounding_box: (a: number, b: number) => void;
     readonly cogstream_bounds_lonlat: (a: number, b: number) => void;
     readonly cogstream_center: (a: number, b: number) => void;
@@ -377,10 +465,13 @@ export interface InitOutput {
     readonly cogstream_decode_tile_f64: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly cogstream_epsg: (a: number) => number;
     readonly cogstream_geo_transform: (a: number, b: number) => void;
+    readonly cogstream_has_projection_string: (a: number) => number;
     readonly cogstream_levels_json: (a: number, b: number) => void;
     readonly cogstream_new: (a: number, b: number, c: number) => void;
     readonly cogstream_nodata: (a: number, b: number) => void;
     readonly cogstream_num_levels: (a: number) => number;
+    readonly cogstream_points_from_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly cogstream_points_to_dataset_crs: (a: number, b: number, c: number, d: number, e: number) => void;
     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;
@@ -421,6 +512,17 @@ export interface InitOutput {
     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 pmtilesextractor_done: (a: number) => number;
+    readonly pmtilesextractor_feed: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly pmtilesextractor_finish: (a: number, b: number) => void;
+    readonly pmtilesextractor_header_json: (a: number, b: number) => void;
+    readonly pmtilesextractor_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly pmtilesextractor_progress_json: (a: number, b: number) => void;
+    readonly pmtilesextractor_set_max_range_gap: (a: number, b: number, c: number) => void;
+    readonly pmtilesextractor_set_max_tiles: (a: number, b: number, c: number) => void;
+    readonly pmtilesextractor_wanted_json: (a: number, b: number) => void;
+    readonly transform_bbox_epsg: (a: number, b: number, c: number, d: number, e: number) => void;
+    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_geojson: (a: number, b: number, c: number, d: number, e: number) => void;

package/geolibre_wasm.js

@@ -218,6 +218,36 @@ export class CogStream {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_cogstream_free(ptr, 0);
     }
+    /**
+     * Reproject a bbox from `bbox_epsg` into this COG's dataset CRS.
+     *
+     * The COG projection string is preferred over its EPSG tag when available,
+     * because some user-defined projected GeoTIFFs expose only their geographic
+     * base EPSG code.
+     * @param {number} bbox_epsg
+     * @param {Float64Array} bbox
+     * @returns {Float64Array}
+     */
+    bbox_to_dataset_crs(bbox_epsg, bbox) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(bbox, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.cogstream_bbox_to_dataset_crs(retptr, this.__wbg_ptr, bbox_epsg, 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);
+        }
+    }
     /**
      * Bounding box `[min_x, min_y, max_x, max_y]` in the dataset CRS, or empty.
      * @returns {Float64Array}
@@ -340,6 +370,14 @@ export class CogStream {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * True when the COG CRS is represented by a user-defined projection string.
+     * @returns {boolean}
+     */
+    get has_projection_string() {
+        const ret = wasm.cogstream_has_projection_string(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * JSON array describing every level: `[{level,width,height,tile_width,
      * tile_height,tiles_x,tiles_y,bands,bits_per_sample,sample_format,compression}]`.
@@ -407,6 +445,58 @@ export class CogStream {
         const ret = wasm.cogstream_num_levels(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Reproject x,y coordinate pairs from this COG's dataset CRS to an EPSG CRS.
+     * @param {number} dst_epsg
+     * @param {Float64Array} xy
+     * @returns {Float64Array}
+     */
+    points_from_dataset_crs(dst_epsg, xy) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(xy, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.cogstream_points_from_dataset_crs(retptr, this.__wbg_ptr, dst_epsg, 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);
+        }
+    }
+    /**
+     * Reproject x,y coordinate pairs from an EPSG CRS into this COG's dataset CRS.
+     * @param {number} src_epsg
+     * @param {Float64Array} xy
+     * @returns {Float64Array}
+     */
+    points_to_dataset_crs(src_epsg, xy) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(xy, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.cogstream_points_to_dataset_crs(retptr, this.__wbg_ptr, src_epsg, 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);
+        }
+    }
     /**
      * `[offset, length]` byte range of the tile at `(col, row)` on `level`.
      * @param {number} level
@@ -981,6 +1071,225 @@ export class GeoTiffReader {
 }
 if (Symbol.dispose) GeoTiffReader.prototype[Symbol.dispose] = GeoTiffReader.prototype.free;
 
+export class PmtilesExtractor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PmtilesExtractorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pmtilesextractor_free(ptr, 0);
+    }
+    /**
+     * True once every needed range has been fed; `finish()` is then valid.
+     * @returns {boolean}
+     */
+    get done() {
+        const ret = wasm.pmtilesextractor_done(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Hand back the bytes of one `wanted_json()` range, identified by its
+     * offset. Ranges may be fed in any order.
+     * @param {number} offset
+     * @param {Uint8Array} bytes
+     */
+    feed(offset, bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.pmtilesextractor_feed(retptr, this.__wbg_ptr, offset, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Assemble the extracted archive. Consumes the extractor's buffers; the
+     * returned `Uint8Array` is a complete `.pmtiles` file.
+     * @returns {Uint8Array}
+     */
+    finish() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pmtilesextractor_finish(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * Source archive header as JSON (`{}` until the first feed): zooms,
+     * bounds, tile type/compression, tile counts. Lets a UI validate the
+     * request and describe the source before committing to the download.
+     * @returns {string}
+     */
+    header_json() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pmtilesextractor_header_json(retptr, this.__wbg_ptr);
+            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 ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Plan an extraction of `min_zoom..=max_zoom` tiles intersecting the
+     * WGS84 bbox. Zooms are clamped to what the source archive contains once
+     * its header arrives; `min_zoom` 0 keeps the basemap usable zoomed out.
+     * @param {number} min_lon
+     * @param {number} min_lat
+     * @param {number} max_lon
+     * @param {number} max_lat
+     * @param {number} min_zoom
+     * @param {number} max_zoom
+     */
+    constructor(min_lon, min_lat, max_lon, max_lat, min_zoom, max_zoom) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pmtilesextractor_new(retptr, min_lon, min_lat, max_lon, max_lat, min_zoom, max_zoom);
+            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);
+            }
+            this.__wbg_ptr = r0;
+            PmtilesExtractorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Progress as JSON: `{"phase":"header|directories|data|done",
+     * "tiles_selected":n,"blobs_total":n,"data_bytes_total":n,
+     * "data_bytes_received":n,"estimated_output_bytes":n}`.
+     * @returns {string}
+     */
+    progress_json() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pmtilesextractor_progress_json(retptr, this.__wbg_ptr);
+            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 ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Coalesce tile-data requests whose byte gap is at most this (default
+     * 65,536). Larger values trade overfetch for fewer HTTP round-trips.
+     * @param {number} max_gap
+     */
+    set_max_range_gap(max_gap) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pmtilesextractor_set_max_range_gap(retptr, this.__wbg_ptr, max_gap);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Cap on addressed tiles (default 2,000,000). Raise for huge desktop
+     * extracts; lower to fail fast in memory-constrained embeds.
+     * @param {number} max_tiles
+     */
+    set_max_tiles(max_tiles) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pmtilesextractor_set_max_tiles(retptr, this.__wbg_ptr, max_tiles);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Outstanding byte ranges the host should fetch, as a JSON array of
+     * `{"offset":n,"length":n}`. Empty array when nothing is outstanding.
+     * @returns {string}
+     */
+    wanted_json() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pmtilesextractor_wanted_json(retptr, this.__wbg_ptr);
+            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 ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) PmtilesExtractor.prototype[Symbol.dispose] = PmtilesExtractor.prototype.free;
+
 /**
  * Install a panic hook so Rust panics surface as readable `console.error`
  * messages instead of an opaque `RuntimeError: unreachable`.
@@ -1290,6 +1599,66 @@ export function morans_i(points_xy, values, distance_threshold) {
     }
 }
 
+/**
+ * Reproject a bbox between two EPSG CRSs.
+ *
+ * Input and output order is `[min_x, min_y, max_x, max_y]`. The bbox edges are
+ * densified so projected extrema that fall along an edge are preserved better
+ * than a corner-only transform.
+ * @param {number} src_epsg
+ * @param {number} dst_epsg
+ * @param {Float64Array} bbox
+ * @returns {Float64Array}
+ */
+export function transform_bbox_epsg(src_epsg, dst_epsg, bbox) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF64ToWasm0(bbox, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.transform_bbox_epsg(retptr, src_epsg, dst_epsg, 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);
+    }
+}
+
+/**
+ * Reproject x,y coordinate pairs between two EPSG CRSs.
+ * @param {number} src_epsg
+ * @param {number} dst_epsg
+ * @param {Float64Array} xy
+ * @returns {Float64Array}
+ */
+export function transform_points_epsg(src_epsg, dst_epsg, xy) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF64ToWasm0(xy, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.transform_points_epsg(retptr, src_epsg, dst_epsg, 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);
+    }
+}
+
 /**
  * Vector formats this build can read from memory (comma-separated).
  * @returns {string}
@@ -1496,6 +1865,9 @@ const CogStreamFinalization = (typeof FinalizationRegistry === 'undefined')
 const GeoTiffReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_geotiffreader_free(ptr, 1));
+const PmtilesExtractorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pmtilesextractor_free(ptr, 1));
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);