@geolith/glx 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,4 @@
+geolith .glx
+Copyright 2026 Vinayak Kulkarni
+
+This product is licensed under the Apache License, Version 2.0 (see LICENSE).

package/README.md

@@ -1,3 +1,81 @@
-# Temporary Holding Version
+# @geolith/glx
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Reads [`.glx`](https://github.com/geolith/glx) geocoding files from object
+storage or HTTP: search, autocomplete, structured search, reverse geocoding,
+nearby and place lookup.
+
+A `.glx` file is a single-file geocoding index, as a `.pmtiles` file is for map
+tiles. The reader keeps a small part of the file in memory and reads the rest
+with byte-range requests, so the file can stay in R2, S3 or behind any HTTP
+server. The reader is the same Rust code that the geolith search server runs,
+built to WebAssembly, so both give the same answers.
+
+Documentation: [docs.geolith.app/glx](https://docs.geolith.app/glx).
+Format: [spec/v1/spec.md](https://github.com/geolith/glx/blob/main/spec/v1/spec.md).
+
+## Install
+
+```sh
+npm install @geolith/glx
+```
+
+ESM only. Node 26 or later, Cloudflare Workers, or a modern browser.
+
+## Use it in a Cloudflare Worker (R2)
+
+```ts
+import wasm from '@geolith/glx/glx.wasm';
+import { GlxFile, R2Source, init } from '@geolith/glx';
+
+init(wasm);
+
+export default {
+  async fetch(request: Request, env: { GLX: R2Bucket }): Promise<Response> {
+    const file = await GlxFile.open(new R2Source(env.GLX, 'planet.glx'));
+    const text = new URL(request.url).searchParams.get('text') ?? '';
+    const { collection } = await file.search({ text });
+    return Response.json(collection);
+  },
+};
+```
+
+Open the file once per isolate and reuse the `GlxFile`: opening reads the
+header and the small in-memory sections.
+
+## Use it over HTTP (Node or the browser)
+
+```ts
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { FetchSource, GlxFile, init } from '@geolith/glx';
+
+init(
+  await readFile(fileURLToPath(import.meta.resolve('@geolith/glx/glx.wasm'))),
+);
+
+const file = await GlxFile.open(
+  new FetchSource('https://example.com/planet.glx'),
+);
+const { collection } = await file.reverse({
+  lon: 77.2295,
+  lat: 28.6129,
+  radiusKm: 1,
+});
+```
+
+The server must answer `Range` requests. In the browser, fetch the `.wasm`
+bytes (for example with a bundler `?url` import) and pass them to `init`.
+`FileSource` reads a local `File` or `Blob`.
+
+## Exports
+
+| Export                         | What                                                              |
+| ------------------------------ | ----------------------------------------------------------------- |
+| `@geolith/glx`                 | `init`, `GlxFile`, `R2Source`, `FetchSource`, `FileSource`, types |
+| `@geolith/glx/glx.wasm`        | The reader                                                        |
+| `@geolith/glx/glx-parser.wasm` | The reader with the trained query parser (larger; same API)       |
+
+## License
+
+Apache-2.0. See [LICENSE](https://github.com/geolith/glx/blob/main/LICENSE)
+and NOTICE.

package/dist/index.d.ts

@@ -0,0 +1,260 @@
+/**
+ * Merges byte spans `[offset, length]` into at most `count` ranges. The pair
+ * with the smallest gap merges first; a merge whose range would pass
+ * `maxBytes` is not made, so more than `count` ranges can remain.
+ */
+export declare function coalesce(spans: readonly (readonly [number, number])[], count: number, maxBytes: number): [number, number][];
+/** An invalid query, rejected before any read. */
+export declare class GlxQueryError extends Error {
+  readonly name = "GlxQueryError";
+}
+/** Where a `.glx` file's bytes come from. */
+interface Source {
+  /** Names the file, for logs and cache keys. */
+  readonly key: string;
+  /** The bytes `[offset, offset + length)`. */
+  getBytes(offset: number, length: number): Promise<Uint8Array>;
+}
+/** The part of a Cloudflare R2 bucket binding that a source needs. */
+interface R2BucketLike {
+  get(key: string, options: {
+    range: {
+      offset: number;
+      length: number;
+    };
+  }): Promise<{
+    arrayBuffer(): Promise<ArrayBuffer>;
+  } | null>;
+}
+/** How a wave of reads is sent. */
+interface ReadOptions {
+  /** Most ranges one wave is merged into. Default 3. */
+  maxRanges?: number;
+  /** A merge that would make a range longer than this is not made. Default 4 MiB. */
+  maxRangeBytes?: number;
+  /**
+   * Copies of each range sent at once; the first answer wins, which cuts
+   * the slow tail of object storage. Used only while ranges × copies fits in
+   * six concurrent reads. Default 2.
+   */
+  hedge?: number;
+}
+/** Read limits for one query; unset fields keep the reader's default. */
+interface Budget {
+  /** Posting bytes one search may walk (default 16 MiB). */
+  walkBytes?: number;
+  /** Document-block bytes one search may read (default 12 MiB). */
+  recordBytes?: number;
+  /** Read waves one search may take (default 16). */
+  maxWaves?: number;
+  /**
+   * Record blocks one record wave may ask for beyond the first page
+   * (default 512). Smaller reads far fewer bytes; answers can change for
+   * searches that then reach the wave or record budget.
+   */
+  recordWaveBlocks?: number;
+}
+/** A layer of the index: the seven layers the `.glx` format codes. */
+type Layer = 'venue' | 'address' | 'street' | 'locality' | 'county' | 'region' | 'country';
+/** Filters shared by every query. */
+interface Filters {
+  /** Results wanted, 1 to 40. Default 10. */
+  size?: number;
+  /** Layers to search; empty or unset means all. */
+  layers?: readonly Layer[];
+  /** ISO 3166-1 alpha-2 codes, any case; empty or unset means all. */
+  countries?: readonly string[];
+}
+/** A point, in degrees. */
+interface Point {
+  lon: number;
+  lat: number;
+}
+/** Options of {@link GlxFile.search} and {@link GlxFile.autocomplete}. */
+interface SearchParams extends Filters {
+  text: string;
+  /** Places near this point rank higher. */
+  focus?: Point;
+  budget?: Budget;
+}
+/** Fields of {@link GlxFile.structured}; at least one must be set. */
+interface StructuredParams extends Filters {
+  address?: string;
+  neighbourhood?: string;
+  borough?: string;
+  locality?: string;
+  county?: string;
+  region?: string;
+  postalcode?: string;
+  /** A two-letter code becomes a country filter; other text is searched. */
+  country?: string;
+  focus?: Point;
+  budget?: Budget;
+}
+/** Options of {@link GlxFile.reverse} and {@link GlxFile.nearby}. */
+interface NearbyParams extends Filters, Point {
+  /** Radius in kilometres, greater than 0. */
+  radiusKm: number;
+}
+/** A ring of `[lon, lat]` points, closed. */
+type Ring = Array<[number, number]>;
+/** A feature's geometry: its point, or its outline when asked for. */
+type Geometry = {
+  type: 'Point';
+  coordinates: [number, number];
+} | {
+  type: 'Polygon';
+  coordinates: Ring[];
+} | {
+  type: 'MultiPolygon';
+  coordinates: Ring[][];
+};
+/** A Pelias GeoJSON feature. */
+interface Feature {
+  type: 'Feature';
+  geometry: Geometry;
+  properties: Properties;
+  /** The outline's box, `[west, south, east, north]`, when it has one. */
+  bbox?: [number, number, number, number];
+}
+/** Options of {@link GlxFile.place}. */
+interface PlaceOptions {
+  /** Return each place's outline as its geometry when it has one. */
+  geometry?: boolean;
+}
+/** Properties of a {@link Feature}. */
+interface Properties {
+  id: string;
+  /** `geolith:<layer>:<id>`. */
+  gid: string;
+  layer: string;
+  source: 'geolith';
+  name: string;
+  label: string;
+  importance: number;
+  street?: string;
+  postalcode?: string;
+  country_code?: string;
+  country?: string;
+  region?: string;
+  county?: string;
+  locality?: string;
+  /** Share of the query's words the place contains (text searches). */
+  confidence?: number;
+  /** Kilometres from the focus or query point. */
+  distance?: number;
+  /** The place's point, when its geometry is its outline. */
+  center?: [number, number];
+}
+/** How a result list was ranked. */
+type Ranking = 'importance' | 'importance+distance';
+/** A Pelias `FeatureCollection`. */
+interface FeatureCollection {
+  type: 'FeatureCollection';
+  geocoding: {
+    version: string;
+    attribution: string;
+    query: Record<string, unknown>;
+    engine: {
+      name: string;
+      version: string;
+    };
+  };
+  features: Feature[];
+  bbox?: [number, number, number, number];
+}
+/** What one query read. */
+interface QueryStats {
+  /** Waves of parallel reads. */
+  waves: number;
+  /** Range reads the reader asked for. */
+  reads: number;
+  /** Bytes the reader received. */
+  bytes: number;
+}
+/** A collection and what it cost to read. */
+interface Answer {
+  collection: FeatureCollection;
+  stats: QueryStats;
+}
+/** A gid split into its parts. */
+interface Gid {
+  layer: string;
+  /** Record id, as a decimal string. */
+  id: string;
+}
+/** One wave step from the wasm reader. */
+type WasmStep = {
+  fetch: [number, number][];
+} | {
+  done: Feature[];
+  distanceRanked: boolean;
+};
+/** Largest `size`. */
+export declare const MAX_SIZE = 40;
+/** `size` when unset. */
+export declare const DEFAULT_SIZE = 10;
+/** Every layer of the index, in the order the `.glx` format codes them (1 to 7). */
+export declare const LAYERS: readonly Layer[];
+/**
+ * One `.glx` file. Open it once per isolate with {@link GlxFile.open}; every
+ * query then reads only the byte ranges it needs from the {@link Source}.
+ */
+export declare class GlxFile {
+  #private;
+  private constructor();
+  /**
+   * Reads the header and the boot sections (dictionary root, spatial
+   * directory, id directory) and opens the index. Call `init` (the wasm
+   * module) first.
+   */
+  static open(source: Source, read?: ReadOptions): Promise<GlxFile>;
+  /** Places in the file. */
+  get places(): number;
+  /** Forward geocoding: places matching free text. */
+  search(params: SearchParams): Promise<Answer>;
+  /** Search as you type: the last word may be unfinished. */
+  autocomplete(params: SearchParams): Promise<Answer>;
+  /** Structured geocoding: the fields are joined and searched. */
+  structured(params: StructuredParams): Promise<Answer>;
+  /** Reverse geocoding: places nearest to a point within `radiusKm`. */
+  reverse(params: NearbyParams): Promise<Answer>;
+  /** Places around a point within `radiusKm`, nearest first. */
+  nearby(params: NearbyParams): Promise<Answer>;
+  /**
+   * Places by gid (`geolith:<layer>:<id>`), in the asked order. A gid whose
+   * layer does not match the place's is left out. With `geometry`, a place
+   * with an outline returns it as its geometry (`Polygon` or
+   * `MultiPolygon`), its point in `properties.center` and its box in `bbox`.
+   */
+  place(gids: readonly string[], options?: PlaceOptions): Promise<Answer>;
+}
+/** Reads a `.glx` file over HTTP range requests. */
+export declare class FetchSource implements Source {
+  #private;
+  readonly key: string;
+  /** `init` is merged into every request (headers, for example). */
+  constructor(url: string, init?: RequestInit);
+  getBytes(offset: number, length: number): Promise<Uint8Array>;
+}
+/** Reads a `.glx` file from a browser `Blob` or `File`, for example one a user dropped on a page. */
+export declare class FileSource implements Source {
+  #private;
+  readonly key: string;
+  /** `key` is the file's name when `blob` is a `File`, else `blob.glx`. */
+  constructor(blob: Blob);
+  getBytes(offset: number, length: number): Promise<Uint8Array>;
+}
+/** Reads a `.glx` file from a Cloudflare R2 bucket binding. */
+export declare class R2Source implements Source {
+  #private;
+  readonly key: string;
+  constructor(bucket: R2BucketLike, key: string);
+  getBytes(offset: number, length: number): Promise<Uint8Array>;
+}
+/**
+ * Loads the wasm reader once per isolate: pass the compiled module (a
+ * Worker's wasm import) or the `.wasm` bytes.
+ */
+export declare function init(module: WebAssembly.Module | BufferSource): void;
+export type { Answer, Budget, Feature, FeatureCollection, Filters, Geometry, Gid, Layer, NearbyParams, PlaceOptions, Point, Properties, QueryStats, R2BucketLike, Ranking, ReadOptions, Ring, SearchParams, Source, StructuredParams, WasmStep };

package/dist/index.js

@@ -0,0 +1,732 @@
+// src/wasm/glx.js
+/**
+* The in-memory index of one `.glx` file.
+*/
+var Engine = class {
+	__destroy_into_raw() {
+		const ptr = this.__wbg_ptr;
+		this.__wbg_ptr = 0;
+		EngineFinalization.unregister(this);
+		return ptr;
+	}
+	free() {
+		const ptr = this.__destroy_into_raw();
+		wasm.__wbg_engine_free(ptr, 0);
+	}
+	/**
+	* Starts a search for the places nearest to a point. `options` is
+	* JSON: `lon`, `lat`, `radiusKm`, `size`, optional `layers` and
+	* `countries`.
+	*
+	* # Errors
+	* When the options do not parse.
+	* @param {string} options_json
+	* @returns {Query}
+	*/
+	nearby(options_json) {
+		const ptr0 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		const len0 = WASM_VECTOR_LEN;
+		const ret = wasm.engine_nearby(this.__wbg_ptr, ptr0, len0);
+		if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+		return Query.__wrap(ret[0]);
+	}
+	/**
+	* Opens the index. It lives as long as the isolate.
+	*
+	* # Errors
+	* When the bytes do not decode.
+	* @param {Uint8Array | number[]} header
+	* @param {Uint8Array | number[]} boot
+	*/
+	constructor(header, boot) {
+		let ptr0, len0, ptr1, len1;
+		try {
+			ptr0 = passArray8ToWasm0(header, wasm.__wbindgen_malloc);
+			len0 = WASM_VECTOR_LEN;
+			ptr1 = passArray8ToWasm0(boot, wasm.__wbindgen_malloc);
+			len1 = WASM_VECTOR_LEN;
+		} catch (e) {
+			if (ptr1) wasm.__wbindgen_free(ptr1, len1 * 1, 1);
+			if (ptr0) wasm.__wbindgen_free(ptr0, len0 * 1, 1);
+			throw e;
+		}
+		const ret = wasm.engine_new(ptr0, len0, ptr1, len1);
+		if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+		this.__wbg_ptr = ret[0];
+		EngineFinalization.register(this, this.__wbg_ptr, this);
+		return this;
+	}
+	/**
+	* Starts a lookup of places by id. `ids_json` is a JSON array of ids
+	* as decimal strings (ids pass the 53-bit JavaScript number range).
+	* With `shapes`, each place with an outline returns it as its
+	* geometry, read in the same wave as the records.
+	*
+	* # Errors
+	* When the ids do not parse.
+	* @param {string} ids_json
+	* @param {boolean} shapes
+	* @returns {Query}
+	*/
+	place(ids_json, shapes) {
+		const val2 = +shapes;
+		const ptr0 = passStringToWasm0(ids_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		const len0 = WASM_VECTOR_LEN;
+		const ret = wasm.engine_place(this.__wbg_ptr, ptr0, len0, val2);
+		if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+		return Query.__wrap(ret[0]);
+	}
+	/**
+	* Places in the file.
+	* @returns {number}
+	*/
+	places() {
+		return wasm.engine_places(this.__wbg_ptr);
+	}
+	/**
+	* Starts a ranked text search. `options` is JSON: `text`, `size`,
+	* optional `autocomplete`, `layers`, `countries`, `focus` (`[lon,
+	* lat]`) and `budget` (`walkBytes`, `recordBytes`, `maxWaves`).
+	*
+	* # Errors
+	* When the options do not parse.
+	* @param {string} options_json
+	* @returns {Query}
+	*/
+	search(options_json) {
+		const ptr0 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		const len0 = WASM_VECTOR_LEN;
+		const ret = wasm.engine_search(this.__wbg_ptr, ptr0, len0);
+		if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+		return Query.__wrap(ret[0]);
+	}
+};
+if (Symbol.dispose) Engine.prototype[Symbol.dispose] = Engine.prototype.free;
+/**
+* One query in progress.
+*/
+var Query = class Query {
+	static __wrap(ptr) {
+		const obj = Object.create(Query.prototype);
+		obj.__wbg_ptr = ptr;
+		QueryFinalization.register(obj, obj.__wbg_ptr, obj);
+		return obj;
+	}
+	__destroy_into_raw() {
+		const ptr = this.__wbg_ptr;
+		this.__wbg_ptr = 0;
+		QueryFinalization.unregister(this);
+		return ptr;
+	}
+	free() {
+		const ptr = this.__destroy_into_raw();
+		wasm.__wbg_query_free(ptr, 0);
+	}
+	/**
+	* Bytes fetched so far.
+	* @returns {number}
+	*/
+	bytes() {
+		return wasm.query_bytes(this.__wbg_ptr);
+	}
+	/**
+	* Range reads so far.
+	* @returns {number}
+	*/
+	reads() {
+		return wasm.query_reads(this.__wbg_ptr) >>> 0;
+	}
+	/**
+	* Next step as JSON.
+	* @returns {string}
+	*/
+	step() {
+		let deferred1_0;
+		let deferred1_1;
+		try {
+			const ret = wasm.query_step(this.__wbg_ptr);
+			deferred1_0 = ret[0];
+			deferred1_1 = ret[1];
+			return getStringFromWasm0(ret[0], ret[1]);
+		} finally {
+			wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+		}
+	}
+	/**
+	* Hands back the bytes of a span from the last `step()`.
+	* @param {number} offset
+	* @param {Uint8Array | number[]} bytes
+	*/
+	supply(offset, bytes) {
+		const val2 = +offset;
+		const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+		const len0 = WASM_VECTOR_LEN;
+		wasm.query_supply(this.__wbg_ptr, val2, ptr0, len0);
+	}
+	/**
+	* Waves so far.
+	* @returns {number}
+	*/
+	waves() {
+		return wasm.query_waves(this.__wbg_ptr) >>> 0;
+	}
+};
+if (Symbol.dispose) Query.prototype[Symbol.dispose] = Query.prototype.free;
+/**
+* `[offset, length]` of the boot bytes, from the header bytes.
+*
+* # Errors
+* When the bytes are not a `.glx` version 1 header, or the file lacks a
+* record feature this reader needs.
+* @param {Uint8Array | number[]} header
+* @returns {Float64Array}
+*/
+function bootSpan(header) {
+	const ptr0 = passArray8ToWasm0(header, wasm.__wbindgen_malloc);
+	const len0 = WASM_VECTOR_LEN;
+	const ret = wasm.bootSpan(ptr0, len0);
+	if (ret[3]) throw takeFromExternrefTable0(ret[2]);
+	var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+	wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+	return v2;
+}
+/**
+* A Pelias `FeatureCollection` around `features` (a JSON array), with
+* `query` (a JSON object) and the engine's name and version.
+*
+* # Errors
+* When `query` or `features` is not valid JSON.
+* @param {string} query
+* @param {string} features
+* @param {string} name
+* @param {string} version
+* @returns {string}
+*/
+function collection(query, features, name, version) {
+	let deferred6_0;
+	let deferred6_1;
+	try {
+		let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3;
+		try {
+			ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+			len0 = WASM_VECTOR_LEN;
+			ptr1 = passStringToWasm0(features, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+			len1 = WASM_VECTOR_LEN;
+			ptr2 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+			len2 = WASM_VECTOR_LEN;
+			ptr3 = passStringToWasm0(version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+			len3 = WASM_VECTOR_LEN;
+		} catch (e) {
+			if (ptr3) wasm.__wbindgen_free(ptr3, len3 * 1, 1);
+			if (ptr2) wasm.__wbindgen_free(ptr2, len2 * 1, 1);
+			if (ptr1) wasm.__wbindgen_free(ptr1, len1 * 1, 1);
+			if (ptr0) wasm.__wbindgen_free(ptr0, len0 * 1, 1);
+			throw e;
+		}
+		const ret = wasm.collection(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+		var ptr5 = ret[0];
+		var len5 = ret[1];
+		if (ret[3]) {
+			ptr5 = 0;
+			len5 = 0;
+			throw takeFromExternrefTable0(ret[2]);
+		}
+		deferred6_0 = ptr5;
+		deferred6_1 = len5;
+		return getStringFromWasm0(ptr5, len5);
+	} finally {
+		wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+	}
+}
+/**
+* Header length in bytes.
+* @returns {number}
+*/
+function headerLength() {
+	return wasm.headerLength() >>> 0;
+}
+function __wbg_get_imports() {
+	return {
+		__proto__: null,
+		"./glx_bg.js": {
+			__proto__: null,
+			__wbg_Error_208446807d0d1e30: function(arg0, arg1) {
+				return Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbg___wbindgen_throw_4c88d8bf264fd984: function(arg0, arg1) {
+				throw new Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbindgen_init_externref_table: function() {
+				const table = wasm.__wbindgen_externrefs;
+				table.set(0, void 0);
+				table.set(1024, void 0);
+				table.set(1025, null);
+				table.set(1026, true);
+				table.set(1027, false);
+			}
+		}
+	};
+}
+const EngineFinalization = typeof FinalizationRegistry === "undefined" ? {
+	register: () => {},
+	unregister: () => {}
+} : new FinalizationRegistry((ptr) => wasm.__wbg_engine_free(ptr, 1));
+const QueryFinalization = typeof FinalizationRegistry === "undefined" ? {
+	register: () => {},
+	unregister: () => {}
+} : new FinalizationRegistry((ptr) => wasm.__wbg_query_free(ptr, 1));
+function getArrayF64FromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+	if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+	return cachedFloat64ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return decodeText(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+	if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+	return cachedUint8ArrayMemory0;
+}
+function passArray8ToWasm0(arg, malloc) {
+	const ptr = malloc(arg.length * 1, 1) >>> 0;
+	getUint8ArrayMemory0().set(arg, ptr / 1);
+	WASM_VECTOR_LEN = arg.length;
+	return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+	if (realloc === void 0) {
+		const buf = cachedTextEncoder.encode(arg);
+		const ptr = malloc(buf.length, 1) >>> 0;
+		getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+		WASM_VECTOR_LEN = buf.length;
+		return ptr;
+	}
+	let len = arg.length;
+	let ptr = malloc(len, 1) >>> 0;
+	const mem = getUint8ArrayMemory0();
+	let offset = 0;
+	for (; offset < len; offset++) {
+		const code = arg.charCodeAt(offset);
+		if (code > 127) break;
+		mem[ptr + offset] = code;
+	}
+	if (offset !== len) {
+		if (offset !== 0) arg = arg.slice(offset);
+		ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+		const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+		const ret = cachedTextEncoder.encodeInto(arg, view);
+		offset += ret.written;
+		ptr = realloc(ptr, len, offset, 1) >>> 0;
+	}
+	WASM_VECTOR_LEN = offset;
+	return ptr;
+}
+function takeFromExternrefTable0(idx) {
+	const value = wasm.__wbindgen_externrefs.get(idx);
+	wasm.__externref_table_dealloc(idx);
+	return value;
+}
+let cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(bytes) {
+	numBytesDecoded += bytes.length;
+	if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+		cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+		cachedTextDecoder.decode();
+		numBytesDecoded = bytes.length;
+	}
+	return cachedTextDecoder.decode(bytes);
+}
+const cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) cachedTextEncoder.encodeInto = function(arg, view) {
+	const buf = cachedTextEncoder.encode(arg);
+	view.set(buf);
+	return {
+		read: arg.length,
+		written: buf.length
+	};
+};
+let WASM_VECTOR_LEN = 0;
+let wasm;
+function __wbg_finalize_init(instance, module) {
+	wasm = instance.exports;
+	cachedFloat64ArrayMemory0 = null;
+	cachedUint8ArrayMemory0 = null;
+	wasm.__wbindgen_start();
+	return wasm;
+}
+function initSync(module) {
+	if (wasm !== void 0) return wasm;
+	if (module !== void 0) {
+		if (Object.getPrototypeOf(module) === Object.prototype) ({module} = module);
+		else console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+	}
+	const imports = __wbg_get_imports();
+	if (!(module instanceof WebAssembly.Module)) module = new WebAssembly.Module(module);
+	return __wbg_finalize_init(new WebAssembly.Instance(module, imports), module);
+}
+// src/coalesce.ts
+/**
+* Merges byte spans `[offset, length]` into at most `count` ranges. The pair
+* with the smallest gap merges first; a merge whose range would pass
+* `maxBytes` is not made, so more than `count` ranges can remain.
+*/
+function coalesce(spans, count, maxBytes) {
+	const ranges = [...spans].sort((a, b) => a[0] - b[0]).map(([offset, length]) => [offset, offset + length]);
+	const out = [];
+	for (const range of ranges) {
+		const last = out.at(-1);
+		if (last && range[0] <= last[1]) last[1] = Math.max(last[1], range[1]);
+		else out.push(range);
+	}
+	while (out.length > count) {
+		let best = -1;
+		let bestGap = Infinity;
+		for (let i = 0; i + 1 < out.length; i++) {
+			const [start] = out[i];
+			const [nextStart, nextEnd] = out[i + 1];
+			if (nextEnd - start > maxBytes) continue;
+			const gap = nextStart - out[i][1];
+			if (gap < bestGap) {
+				best = i;
+				bestGap = gap;
+			}
+		}
+		if (best < 0) break;
+		out[best][1] = out[best + 1][1];
+		out.splice(best + 1, 1);
+	}
+	return out.map(([start, end]) => [start, end - start]);
+}
+// src/error.ts
+/** An invalid query, rejected before any read. */
+var GlxQueryError = class extends Error {
+	name = "GlxQueryError";
+};
+// src/gid.ts
+/** Parses `geolith:<layer>:<id>` gids; at least one, at most `max`. */
+function parseGids(gids, max) {
+	const parsed = gids.map((gid) => gid.trim()).filter((gid) => gid !== "").map(parseGid);
+	if (parsed.length === 0) throw new GlxQueryError("missing param ids");
+	if (parsed.length > max) throw new GlxQueryError(`ids holds more than ${max} gids`);
+	return parsed;
+}
+function parseGid(gid) {
+	const match = /^geolith:([^:]+):(-?\d+)$/.exec(gid);
+	if (match === null) throw new GlxQueryError(`gid '${gid}' is not a geolith gid`);
+	const [, layer, id] = match;
+	return {
+		layer,
+		id
+	};
+}
+// src/glxfile.ts
+/** Engine name and version written into every response. */
+const ENGINE = {
+	name: "geolith-glx",
+	version: "0.1.0"
+};
+/** Largest `size`. */
+const MAX_SIZE = 40;
+/** `size` when unset. */
+const DEFAULT_SIZE = 10;
+/** Every layer of the index, in the order the `.glx` format codes them (1 to 7). */
+const LAYERS = [
+	"venue",
+	"address",
+	"street",
+	"locality",
+	"county",
+	"region",
+	"country"
+];
+/**
+* One `.glx` file. Open it once per isolate with {@link GlxFile.open}; every
+* query then reads only the byte ranges it needs from the {@link Source}.
+*/
+var GlxFile = class GlxFile {
+	#source;
+	#engine;
+	#read;
+	constructor(source, engine, read) {
+		this.#source = source;
+		this.#engine = engine;
+		this.#read = read;
+	}
+	/**
+	* Reads the header and the boot sections (dictionary root, spatial
+	* directory, id directory) and opens the index. Call `init` (the wasm
+	* module) first.
+	*/
+	static async open(source, read = {}) {
+		const header = await source.getBytes(0, headerLength());
+		const span = bootSpan(header);
+		const boot = await source.getBytes(span[0] ?? 0, span[1] ?? 0);
+		return new GlxFile(source, new Engine(header, boot), {
+			maxRanges: read.maxRanges ?? 3,
+			maxRangeBytes: read.maxRangeBytes ?? 4194304,
+			hedge: read.hedge ?? 2
+		});
+	}
+	/** Places in the file. */
+	get places() {
+		return this.#engine.places();
+	}
+	/** Forward geocoding: places matching free text. */
+	search(params) {
+		return this.#text(params, false);
+	}
+	/** Search as you type: the last word may be unfinished. */
+	autocomplete(params) {
+		return this.#text(params, true);
+	}
+	/** Structured geocoding: the fields are joined and searched. */
+	async structured(params) {
+		const fields = [
+			params.address,
+			params.neighbourhood,
+			params.borough,
+			params.locality,
+			params.county,
+			params.region,
+			params.postalcode,
+			params.country
+		].filter((field) => field !== void 0 && field.trim() !== "");
+		let countries = params.countries;
+		let words = fields;
+		const country = params.country?.trim();
+		if (country !== void 0 && /^[a-z]{2}$/i.test(country)) {
+			countries = [country];
+			words = fields.filter((field) => field.trim() !== country);
+		}
+		const text = words.join(" ");
+		if (text.trim() === "") throw new GlxQueryError("set at least one of address, locality, region, postalcode or country");
+		return this.#text({
+			...params,
+			text,
+			...countries ? { countries } : {}
+		}, false, { fields });
+	}
+	/** Reverse geocoding: places nearest to a point within `radiusKm`. */
+	reverse(params) {
+		return this.nearby(params);
+	}
+	/** Places around a point within `radiusKm`, nearest first. */
+	async nearby(params) {
+		checkPoint(params);
+		if (!(params.radiusKm > 0)) throw new GlxQueryError("radiusKm must be greater than 0");
+		const size = checkSize(params.size);
+		const query = this.#engine.nearby(JSON.stringify({
+			lon: params.lon,
+			lat: params.lat,
+			radiusKm: params.radiusKm,
+			size,
+			...limits(params)
+		}));
+		const { features, stats } = await this.#run(query);
+		return {
+			collection: this.#collection({
+				"point.lat": params.lat,
+				"point.lon": params.lon,
+				"boundary.circle.radius": params.radiusKm,
+				size
+			}, features),
+			stats
+		};
+	}
+	/**
+	* Places by gid (`geolith:<layer>:<id>`), in the asked order. A gid whose
+	* layer does not match the place's is left out. With `geometry`, a place
+	* with an outline returns it as its geometry (`Polygon` or
+	* `MultiPolygon`), its point in `properties.center` and its box in `bbox`.
+	*/
+	async place(gids, options = {}) {
+		const parsed = parseGids(gids, 40);
+		const query = this.#engine.place(JSON.stringify(parsed.map((gid) => gid.id)), options.geometry === true);
+		const { features, stats } = await this.#run(query);
+		const kept = features.filter((feature) => parsed.some((gid) => gid.id === feature.properties.id && gid.layer === feature.properties.layer));
+		const ids = parsed.map((gid) => ({
+			source: "geolith",
+			layer: gid.layer,
+			id: gid.id
+		}));
+		return {
+			collection: this.#collection({
+				ids,
+				size: parsed.length
+			}, kept),
+			stats
+		};
+	}
+	async #text(params, autocomplete, echo = { text: params.text }) {
+		if (params.text.trim() === "") throw new GlxQueryError("missing param text");
+		const size = checkSize(params.size);
+		if (params.focus) checkPoint(params.focus);
+		const query = this.#engine.search(JSON.stringify({
+			text: params.text,
+			autocomplete,
+			size,
+			...limits(params),
+			...params.focus ? { focus: [params.focus.lon, params.focus.lat] } : {},
+			budget: { ...params.budget }
+		}));
+		const { features, stats, distanceRanked } = await this.#run(query);
+		const ranking = distanceRanked ? "importance+distance" : "importance";
+		return {
+			collection: this.#collection({
+				...echo,
+				size,
+				ranking
+			}, features),
+			stats
+		};
+	}
+	/** Drives a query to the end, reading each wave from the source. */
+	async #run(query) {
+		try {
+			return await this.#drive(query);
+		} finally {
+			query.free();
+		}
+	}
+	/**
+	* Steps the query until it is done. Waves run one after another: the
+	* query names the next wave's ranges only after it has the last one's bytes.
+	*/
+	async #drive(query) {
+		const step = JSON.parse(query.step());
+		if ("done" in step) return {
+			features: step.done,
+			distanceRanked: step.distanceRanked,
+			stats: {
+				waves: query.waves(),
+				reads: query.reads(),
+				bytes: query.bytes()
+			}
+		};
+		const parts = await this.#wave(step.fetch);
+		step.fetch.forEach(([offset], index) => query.supply(offset, parts[index]));
+		return this.#drive(query);
+	}
+	/** Reads one wave in at most `maxRanges` merged, hedged range reads. */
+	async #wave(spans) {
+		const { maxRanges, maxRangeBytes, hedge } = this.#read;
+		const ranges = coalesce(spans, maxRanges, maxRangeBytes);
+		const copies = ranges.length * hedge <= 6 ? hedge : 1;
+		const bytes = await Promise.all(ranges.map(([offset, length]) => Promise.any(Array.from({ length: copies }, () => this.#source.getBytes(offset, length)))));
+		return spans.map(([offset, length]) => {
+			const at = ranges.findIndex(([start, size]) => offset >= start && offset + length <= start + size);
+			const start = offset - ranges[at][0];
+			return bytes[at].subarray(start, start + length);
+		});
+	}
+	#collection(query, features) {
+		return JSON.parse(collection(JSON.stringify(query), JSON.stringify(features), ENGINE.name, ENGINE.version));
+	}
+};
+function checkSize(size) {
+	const value = size ?? 10;
+	if (!Number.isInteger(value) || value < 1 || value > 40) throw new GlxQueryError(`size must be between 1 and 40`);
+	return value;
+}
+function checkPoint({ lon, lat }) {
+	if (!(lat >= -90 && lat <= 90)) throw new GlxQueryError("latitude must be between -90 and 90");
+	if (!(lon >= -180 && lon <= 180)) throw new GlxQueryError("longitude must be between -180 and 180");
+}
+function limits({ layers, countries }) {
+	for (const country of countries ?? []) if (!/^[a-z]{2}$/i.test(country)) throw new GlxQueryError(`country '${country}' is not a two-letter code`);
+	return {
+		layers: [...layers ?? []],
+		countries: [...countries ?? []]
+	};
+}
+// src/source.ts
+/** Reads a `.glx` file over HTTP range requests. */
+var FetchSource = class {
+	key;
+	#url;
+	#init;
+	/** `init` is merged into every request (headers, for example). */
+	constructor(url, init = {}) {
+		this.key = url;
+		this.#url = url;
+		this.#init = init;
+	}
+	async getBytes(offset, length) {
+		const headers = new Headers(this.#init.headers);
+		headers.set("range", `bytes=${offset}-${offset + length - 1}`);
+		const response = await fetch(this.#url, {
+			...this.#init,
+			headers
+		});
+		if (response.status !== 206) throw new Error(`${this.#url}: range request answered ${response.status}`);
+		const bytes = new Uint8Array(await response.arrayBuffer());
+		if (bytes.length !== length) throw new Error(`${this.#url}: asked ${length} bytes at ${offset}, got ${bytes.length}`);
+		return bytes;
+	}
+};
+/** Reads a `.glx` file from a browser `Blob` or `File`, for example one a user dropped on a page. */
+var FileSource = class {
+	key;
+	#blob;
+	/** `key` is the file's name when `blob` is a `File`, else `blob.glx`. */
+	constructor(blob) {
+		this.key = blob instanceof File ? blob.name : "blob.glx";
+		this.#blob = blob;
+	}
+	async getBytes(offset, length) {
+		const bytes = new Uint8Array(await this.#blob.slice(offset, offset + length).arrayBuffer());
+		if (bytes.length !== length) throw new Error(`${this.key}: asked ${length} bytes at ${offset}, got ${bytes.length}`);
+		return bytes;
+	}
+};
+/** Reads a `.glx` file from a Cloudflare R2 bucket binding. */
+var R2Source = class {
+	key;
+	#bucket;
+	constructor(bucket, key) {
+		this.key = key;
+		this.#bucket = bucket;
+	}
+	async getBytes(offset, length) {
+		const object = await this.#bucket.get(this.key, { range: {
+			offset,
+			length
+		} });
+		if (object === null) throw new Error(`R2 object ${this.key} is missing`);
+		const bytes = new Uint8Array(await object.arrayBuffer());
+		if (bytes.length !== length) throw new Error(`${this.key}: asked ${length} bytes at ${offset}, got ${bytes.length}`);
+		return bytes;
+	}
+};
+// src/index.ts
+/**
+* `@geolith/glx`: reads a `.glx` geocoding file from object storage or HTTP,
+* as `pmtiles` reads a `.pmtiles` file. The reader is the same Rust code the
+* geolith search server runs, built to WebAssembly, so both answer alike.
+*
+* ```ts
+* import wasm from '@geolith/glx/glx.wasm';
+* import { GlxFile, R2Source, init } from '@geolith/glx';
+*
+* init(wasm);
+* const file = await GlxFile.open(new R2Source(env.GLX, 'planet.glx'));
+* const { collection } = await file.search({ text: 'india gate' });
+* ```
+*/
+/**
+* Loads the wasm reader once per isolate: pass the compiled module (a
+* Worker's wasm import) or the `.wasm` bytes.
+*/
+function init(module) {
+	initSync({ module });
+}
+export { DEFAULT_SIZE, FetchSource, FileSource, GlxFile, GlxQueryError, LAYERS, MAX_SIZE, R2Source, coalesce, init };

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "@geolith/glx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Reads .glx geocoding files from R2 or HTTP range requests: search, autocomplete, structured, reverse, nearby and place lookup.",
+  "keywords": [
+    "autocomplete",
+    "cloudflare-workers",
+    "geocoder",
+    "geocoding",
+    "glx",
+    "openstreetmap",
+    "overture-maps",
+    "r2",
+    "range-requests",
+    "reverse-geocoding",
+    "search",
+    "wasm",
+    "webassembly"
+  ],
+  "homepage": "https://docs.geolith.app/glx",
+  "bugs": {
+    "url": "https://github.com/geolith/glx/issues"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Vinayak Kulkarni",
+    "email": "inbox.vinayak@gmail.com",
+    "url": "https://vinayakkulkarni.dev"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/geolith/glx.git",
+    "directory": "packages/js"
+  },
+  "files": [
+    "dist",
+    "NOTICE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./glx.wasm": "./dist/glx_bg.wasm",
+    "./glx-parser.wasm": "./dist/glx_parser_bg.wasm",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "wasm": "node scripts/wasm.ts",
+    "fixture": "cargo run --manifest-path ../../Cargo.toml --example fixture -- test/fixture.glx",
+    "build": "pnpm wasm && tsdown",
+    "test": "pnpm wasm && pnpm fixture && vitest run",
+    "typecheck": "pnpm wasm && tsc --noEmit",
+    "lint": "oxlint src test scripts",
+    "prepublishOnly": "pnpm build"
+  },
+  "devDependencies": {
+    "@types/node": "26.6.6",
+    "oxlint": "1.91.0",
+    "tsdown": "0.23.5",
+    "typescript": "7.0.2",
+    "vitest": "5.1.0"
+  },
+  "engines": {
+    "node": ">=26"
+  },
+  "packageManager": "pnpm@12.16.1+sha512.091d1dee7927575661b25dab3c2ae31cafc1c54d6b71ed6a6600cf0c1cb10434a447eae14015f1b23e2e6bedeed79df94a932e2164d2832280dce3fb32f656d1"
+}