@mailwoman/resolver-wof-sqlite 9.1.0 → 9.3.0

package/out/extracts.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Multi-extract support for `WOFSQLitePlaceLookup` — opens multiple WOF SQLite distributions on one
+ *   connection via `ATTACH DATABASE`, and routes queries to the right extract based on placetype.
+ *
+ *   ## The FTS5 syntax rule that drove this design
+ *
+ *   The naive `SELECT … FROM pc.place_search WHERE pc.place_search MATCH ?` fails — SQLite parses the
+ *   schema-qualified table on the left of MATCH as "column place_search of table pc". Discovered in
+ *   the spike at PR review time; documented as `_EXTRACT_RULE.md` should it ever bite again.
+ *
+ *   The working form: schema-qualified in FROM, bare table name in MATCH:
+ *
+ *   ```sql
+ *   SELECT … FROM pc.place_search WHERE place_search MATCH ?
+ * ```
+ *
+ *   Identical table names across attached extracts (which is what we have — every extract ships its own
+ *   `place_search` + `place_bbox`) are fine because the bare-name MATCH resolves against FROM
+ *   scope.
+ */
+/**
+ * Derive a SQL-safe schema name from a WOF distribution filename. Used by `ATTACH DATABASE … AS <name>` so each extract
+ * gets a stable, predictable handle.
+ *
+ * Convention strips the `whosonfirst-data-` prefix and the `-latest.db` (or just `.db`) suffix, then replaces `-` with
+ * `_` for SQL identifier safety.
+ *
+ * Examples:
+ *
+ * - `whosonfirst-data-admin-us-latest.db` → `admin_us`
+ * - `whosonfirst-data-postalcode-us-latest.db` → `postalcode_us`
+ * - `whosonfirst-data-admin-latest.db` → `admin`
+ * - `my-custom.db` → `my_custom`
+ *
+ * Callers can override the derived name explicitly via `ExtractConfig.schemaName` when the filename doesn't follow WOF
+ * convention.
+ */
+export declare function deriveSchemaName(path: string): string;
+/**
+ * Per-extract configuration. The simple form is just a path string — the schema name is derived from it. The object
+ * form lets callers override the derived schema name (useful when a filename doesn't follow WOF convention) or attach
+ * an extra hint about which placetypes route here.
+ */
+export interface ExtractConfig {
+    path: string;
+    /**
+     * Override the auto-derived schema name. Useful when the filename doesn't match WOF convention or when you want a
+     * memorable handle. Must be a valid SQLite identifier — `[a-zA-Z_][a-zA-Z0-9_]*`.
+     */
+    schemaName?: string;
+    /**
+     * Optional explicit list of placetypes this extract serves. When set, queries against any listed placetype are routed
+     * to this extract. When omitted, routing falls back to a name-match heuristic: a extract whose `schemaName` contains
+     * the placetype as a substring (e.g. `postalcode_us` for `postalcode` queries) is preferred for that placetype.
+     */
+    placetypes?: readonly string[];
+}
+/**
+ * Resolved post-derivation: paired path + chosen schema name + (possibly empty) placetypes hint. Used internally by
+ * `WOFSQLitePlaceLookup` so the routing logic operates on uniform structures.
+ */
+export interface ResolvedExtract {
+    path: string;
+    schemaName: string;
+    placetypes: readonly string[];
+}
+/**
+ * Normalize the user-provided `databasePath` opt (which may be a single string, an array of strings, or an array of
+ * `ExtractConfig` objects) into a uniform `ResolvedExtract[]`.
+ *
+ * The first extract becomes `main` regardless of its derived schema name — that's the SQLite convention. Subsequent
+ * extracts keep their derived (or override) schema name.
+ */
+export declare function resolveExtracts(input: string | ReadonlyArray<string | ExtractConfig>): ResolvedExtract[];
+/**
+ * Pick the extract to route a query to given the requested placetype(s).
+ *
+ * Routing rules, in order:
+ *
+ * 1. If any extract has explicit `placetypes` that includes the requested placetype, use it.
+ * 2. Otherwise, if a non-main extract's `schemaName` matches the placetype (e.g. `postalcode_us` matches `postalcode`),
+ *    use it.
+ * 3. Otherwise, fall back to `main`.
+ *
+ * This deliberately doesn't UNION across extracts — BM25 scores aren't comparable across separately- indexed corpora,
+ * and the typical mailwoman query has a single placetype anyway. If a caller needs cross-extract results they can issue
+ * two `findPlace` calls.
+ */
+/**
+ * All placetype-matching extracts, in routing order (the country-aware pick chooses among these). Used by the bias
+ * path: a country-less postcode query with proximity hints fans out across every matching extract and merges, because
+ * single-extract routing would hide the cross-country ambiguity the hints exist to resolve ("48026" lives in
+ * postalcode-us AND postalcode-intl).
+ */
+export declare function pickExtractsForPlacetype(extracts: ResolvedExtract[], placetype: string | undefined): ResolvedExtract[];
+export declare function pickExtractForPlacetype(extracts: ResolvedExtract[], placetype: string | undefined, opts?: {
+    /**
+     * #920: the query's country constraint, when the caller has one. With MULTIPLE extracts matching a placetype
+     * (postalcode-us + postalcode-geonames-tail), first-match routing sent every postcode query to the first extract
+     * and starved the rest — a FI postcode could never reach the tail extract. When `country` is given and a matching
+     * extract's probed country set contains it, that extract wins; extracts without the country are skipped; the
+     * placetype-match order remains the tiebreak when no extract claims the country (or none was probed).
+     */
+    country?: string;
+    /**
+     * Per-schema probed country sets (see `WOFSQLitePlaceLookup`'s construction probe).
+     */
+    countriesBySchema?: ReadonlyMap<string, ReadonlySet<string>>;
+}): ResolvedExtract;
+//# sourceMappingURL=extracts.d.ts.map

package/out/extracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extracts.d.ts","sourceRoot":"","sources":["../lib/extracts.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYrD;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;CAC7B;AAOD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC,MAAM,GAAG,aAAa,CAAC,GAAG,eAAe,EAAE,CA0CxG;AAED;;;;;;;;;;;;;GAaG;AACH;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,eAAe,EAAE,EAC3B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC3B,eAAe,EAAE,CAuBnB;AAED,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,eAAe,EAAE,EAC3B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,IAAI,CAAC,EAAE;IACN;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;OAEG;IACH,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,CAAA;CAC5D,GACC,eAAe,CAmCjB"}

package/out/{sharding.js → extracts.js}

@@ -1,16 +1,17 @@
+import { basename } from "path-ts";
 /**
  * @copyright Sister Software
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Multi-shard support for `WOFSqlitePlaceLookup` — opens multiple WOF SQLite distributions on one
- *   connection via `ATTACH DATABASE`, and routes queries to the right shard based on placetype.
+ *   Multi-extract support for `WOFSQLitePlaceLookup` — opens multiple WOF SQLite distributions on one
+ *   connection via `ATTACH DATABASE`, and routes queries to the right extract based on placetype.
  *
  *   ## The FTS5 syntax rule that drove this design
  *
  *   The naive `SELECT … FROM pc.place_search WHERE pc.place_search MATCH ?` fails — SQLite parses the
  *   schema-qualified table on the left of MATCH as "column place_search of table pc". Discovered in
- *   the spike at PR review time; documented as `_SHARD_RULE.md` should it ever bite again.
+ *   the spike at PR review time; documented as `_EXTRACT_RULE.md` should it ever bite again.
  *
  *   The working form: schema-qualified in FROM, bare table name in MATCH:
  *
@@ -18,13 +19,12 @@
  *   SELECT … FROM pc.place_search WHERE place_search MATCH ?
  * ```
  *
- *   Identical table names across attached shards (which is what we have — every shard ships its own
+ *   Identical table names across attached extracts (which is what we have — every extract ships its own
  *   `place_search` + `place_bbox`) are fine because the bare-name MATCH resolves against FROM
  *   scope.
  */
-import { basename } from "node:path";
 /**
- * Derive a SQL-safe schema name from a WOF distribution filename. Used by `ATTACH DATABASE … AS <name>` so each shard
+ * Derive a SQL-safe schema name from a WOF distribution filename. Used by `ATTACH DATABASE … AS <name>` so each extract
  * gets a stable, predictable handle.
  *
  * Convention strips the `whosonfirst-data-` prefix and the `-latest.db` (or just `.db`) suffix, then replaces `-` with
@@ -37,7 +37,7 @@ import { basename } from "node:path";
  * - `whosonfirst-data-admin-latest.db` → `admin`
  * - `my-custom.db` → `my_custom`
  *
- * Callers can override the derived name explicitly via `ShardConfig.schemaName` when the filename doesn't follow WOF
+ * Callers can override the derived name explicitly via `ExtractConfig.schemaName` when the filename doesn't follow WOF
  * convention.
  */
 export function deriveSchemaName(path) {
@@ -57,15 +57,15 @@ export function deriveSchemaName(path) {
 const SQLITE_IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/u;
 /**
  * Normalize the user-provided `databasePath` opt (which may be a single string, an array of strings, or an array of
- * `ShardConfig` objects) into a uniform `ResolvedShard[]`.
+ * `ExtractConfig` objects) into a uniform `ResolvedExtract[]`.
  *
- * The first shard becomes `main` regardless of its derived schema name — that's the SQLite convention. Subsequent
- * shards keep their derived (or override) schema name.
+ * The first extract becomes `main` regardless of its derived schema name — that's the SQLite convention. Subsequent
+ * extracts keep their derived (or override) schema name.
  */
-export function resolveShards(input) {
+export function resolveExtracts(input) {
     const list = typeof input === "string" ? [input] : input;
     if (!list.length)
-        throw new Error("resolveShards: at least one shard is required");
+        throw new Error("resolveExtracts: at least one extract is required");
     const seen = new Set();
     const out = [];
     for (let i = 0; i < list.length; i++) {
@@ -73,16 +73,16 @@ export function resolveShards(input) {
         const cfg = typeof entry === "string" ? { path: entry } : entry;
         const derived = cfg.schemaName ?? deriveSchemaName(cfg.path);
         if (!SQLITE_IDENT_RE.test(derived)) {
-            throw new Error(`resolveShards: schema name ${JSON.stringify(derived)} is not a valid SQLite identifier ` +
+            throw new Error(`resolveExtracts: schema name ${JSON.stringify(derived)} is not a valid SQLite identifier ` +
                 `(derived from path ${JSON.stringify(cfg.path)}). Pass an explicit ` +
                 `{ path, schemaName } to override.`);
         }
-        // The first shard is always main per SQLite semantics — its derived name is informational
-        // only. Subsequent shards must have unique non-main names.
+        // The first extract is always main per SQLite semantics — its derived name is informational
+        // only. Subsequent extracts must have unique non-main names.
         const schemaName = i === 0 ? "main" : derived;
         if (i > 0 && (schemaName === "main" || seen.has(schemaName))) {
-            throw new Error(`resolveShards: schema name ${JSON.stringify(schemaName)} collides ` +
-                `(either with "main" or another shard). Pass an explicit { path, schemaName }.`);
+            throw new Error(`resolveExtracts: schema name ${JSON.stringify(schemaName)} collides ` +
+                `(either with "main" or another extract). Pass an explicit { path, schemaName }.`);
         }
         seen.add(schemaName);
         out.push({
@@ -94,35 +94,35 @@ export function resolveShards(input) {
     return out;
 }
 /**
- * Pick the shard to route a query to given the requested placetype(s).
+ * Pick the extract to route a query to given the requested placetype(s).
  *
  * Routing rules, in order:
  *
- * 1. If any shard has explicit `placetypes` that includes the requested placetype, use it.
- * 2. Otherwise, if a non-main shard's `schemaName` matches the placetype (e.g. `postalcode_us` matches `postalcode`), use
- *    it.
+ * 1. If any extract has explicit `placetypes` that includes the requested placetype, use it.
+ * 2. Otherwise, if a non-main extract's `schemaName` matches the placetype (e.g. `postalcode_us` matches `postalcode`),
+ *    use it.
  * 3. Otherwise, fall back to `main`.
  *
- * This deliberately doesn't UNION across shards — BM25 scores aren't comparable across separately- indexed corpora, and
- * the typical mailwoman query has a single placetype anyway. If a caller needs cross-shard results they can issue two
- * `findPlace` calls.
+ * This deliberately doesn't UNION across extracts — BM25 scores aren't comparable across separately- indexed corpora,
+ * and the typical mailwoman query has a single placetype anyway. If a caller needs cross-extract results they can issue
+ * two `findPlace` calls.
  */
 /**
- * All placetype-matching shards, in routing order (the country-aware pick chooses among these). Used by the bias path:
- * a country-less postcode query with proximity hints fans out across every matching shard and merges, because
- * single-shard routing would hide the cross-country ambiguity the hints exist to resolve ("48026" lives in
+ * All placetype-matching extracts, in routing order (the country-aware pick chooses among these). Used by the bias
+ * path: a country-less postcode query with proximity hints fans out across every matching extract and merges, because
+ * single-extract routing would hide the cross-country ambiguity the hints exist to resolve ("48026" lives in
  * postalcode-us AND postalcode-intl).
  */
-export function pickShardsForPlacetype(shards, placetype) {
+export function pickExtractsForPlacetype(extracts, placetype) {
     if (!placetype)
-        return [shards[0]];
+        return [extracts[0]];
     const matches = [];
-    for (const s of shards) {
+    for (const s of extracts) {
         if (s.placetypes.includes(placetype)) {
             matches.push(s);
         }
     }
-    for (const s of shards) {
+    for (const s of extracts) {
         if (s.schemaName === "main" || matches.includes(s))
             continue;
         if (s.schemaName === placetype ||
@@ -131,18 +131,18 @@ export function pickShardsForPlacetype(shards, placetype) {
             matches.push(s);
         }
     }
-    return matches.length ? matches : [shards[0]];
+    return matches.length ? matches : [extracts[0]];
 }
-export function pickShardForPlacetype(shards, placetype, opts) {
+export function pickExtractForPlacetype(extracts, placetype, opts) {
     if (!placetype)
-        return shards[0];
+        return extracts[0];
     const matches = [];
-    for (const s of shards) {
+    for (const s of extracts) {
         if (s.placetypes.includes(placetype)) {
             matches.push(s);
         }
     }
-    for (const s of shards) {
+    for (const s of extracts) {
         if (s.schemaName === "main" || matches.includes(s))
             continue;
         // Substring match: `postalcode_us` matches `postalcode`. Conservative — requires the
@@ -155,7 +155,7 @@ export function pickShardForPlacetype(shards, placetype, opts) {
         }
     }
     if (!matches.length)
-        return shards[0];
+        return extracts[0];
     if (opts?.country && opts.countriesBySchema) {
         for (const s of matches) {
             if (opts.countriesBySchema.get(s.schemaName)?.has(opts.country))
@@ -164,4 +164,4 @@ export function pickShardForPlacetype(shards, placetype, opts) {
     }
     return matches[0];
 }
-//# sourceMappingURL=sharding.js.map
+//# sourceMappingURL=extracts.js.map

package/out/extracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extracts.js","sourceRoot":"","sources":["../lib/extracts.ts"],"names":[],"mappings":"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"}

package/out/{fst-autocomplete.d.ts → fst/autocomplete.d.ts}

@@ -3,20 +3,20 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   FST-based autocomplete. Prefix walk + BFS expansion to collect ranked place suggestions. O(depth
- *   × branching) — the FST IS the autocomplete index.
+ *   FST-based autocomplete — mailwoman vocabulary over `@mailwoman/ancestrie`'s generic algorithm
+ *   (#1728 phase 2). The #587 behavior — prefix walk + BFS expansion, partial-last-token completion,
+ *   per-branch capping, dedupe — lives in ancestrie's `autocomplete`; this module contributes only
+ *   the storage adapter ({@link FSTMatcher} → `AncestrieReaderLike`) and the mapping back to
+ *   mailwoman's suggestion shape (name, placetype, referential/encyclopedic, WOF ids).
  *
- *   Two query shapes are handled (the FST is a trie over normalized WORD tokens):
- *
- *   - COMPLETE tokens ("new york") — `walk` lands on a state; collect its accepting entries + BFS a
- *       couple tokens past it for nearby completions. This is the CLI's "complete a place word"
- *       path.
- *   - A PARTIAL last token ("new yor", "chic") — `walk` fails (there is no "yor" edge, only "york"). So
- *       walk the complete prefix, then complete the partial token by prefix-filtering the
- *       continuation edges (`token.startsWith(partial)`). This is what a char-level typeahead
- *       needs; without it "new yor" returns nothing useful. (#587)
+ *   THE BYTES DO NOT MIGRATE. The shipped artifacts are `FST\0` v1–v5 (`fst-serialize.ts`), not
+ *   ancestrie's `ANCT`: ancestrie entries are id-keyed with one record per id, while an FST place row
+ *   is per-(surface, place) — `crossCountryBranches` is a property of the SURFACE, so the same wofID
+ *   legitimately carries different values under different aliases and cannot be represented id-keyed.
+ *   The matcher, both deserializers, and the serializer therefore stay here; what migrated is the
+ *   ALGORITHM, which is the half that drifts (the #861 share-the-function rule).
  */
-import type { FSTMatcher } from "./fst-matcher.ts";
+import type { FSTMatcher } from "#fst/matcher";
 export interface AutocompleteResult {
     query: string;
     normalizedTokens: string[];
@@ -56,4 +56,4 @@ export interface AutocompleteOpts {
  * Autocomplete from the current prefix. Returns suggestions ranked referential-descending.
  */
 export declare function autocomplete(fst: FSTMatcher, query: string, opts?: AutocompleteOpts): AutocompleteResult;
-//# sourceMappingURL=fst-autocomplete.d.ts.map
+//# sourceMappingURL=autocomplete.d.ts.map

package/out/fst/autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../lib/fst/autocomplete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAWH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAI9C,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,sBAAsB,EAAE,CAAA;CACrC;AAED,MAAM,WAAW,sBAAsB;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,EAAE,MAAM,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAChC,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACtB;AAyED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,kBAAkB,CA+B5G"}

package/out/fst/autocomplete.js

@@ -0,0 +1,113 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   FST-based autocomplete — mailwoman vocabulary over `@mailwoman/ancestrie`'s generic algorithm
+ *   (#1728 phase 2). The #587 behavior — prefix walk + BFS expansion, partial-last-token completion,
+ *   per-branch capping, dedupe — lives in ancestrie's `autocomplete`; this module contributes only
+ *   the storage adapter ({@link FSTMatcher} → `AncestrieReaderLike`) and the mapping back to
+ *   mailwoman's suggestion shape (name, placetype, referential/encyclopedic, WOF ids).
+ *
+ *   THE BYTES DO NOT MIGRATE. The shipped artifacts are `FST\0` v1–v5 (`fst-serialize.ts`), not
+ *   ancestrie's `ANCT`: ancestrie entries are id-keyed with one record per id, while an FST place row
+ *   is per-(surface, place) — `crossCountryBranches` is a property of the SURFACE, so the same wofID
+ *   legitimately carries different values under different aliases and cannot be represented id-keyed.
+ *   The matcher, both deserializers, and the serializer therefore stay here; what migrated is the
+ *   ALGORITHM, which is the half that drifts (the #861 share-the-function rule).
+ */
+import { autocomplete as ancestrieAutocomplete } from "@mailwoman/ancestrie";
+import { normalizeTokens } from "#fst/matcher";
+/**
+ * Max accepting entries collected per BFS branch — keeps one dense branch from starving the search.
+ */
+const PER_BRANCH = 4;
+/**
+ * The top-`k` entries by REFERENTIAL likelihood (descending). Avoids sorting/allocating when `entries` is small — and
+ * that shortcut is part of the observable contract: at or under `k` the INSERTION order is served, which decides
+ * suggestion order among referential ties.
+ */
+function topByReferential(entries, k) {
+    if (entries.length <= k)
+        return [...entries];
+    return [...entries].toSorted((a, b) => b.referential - a.referential).slice(0, k);
+}
+/**
+ * {@link FSTMatcher} presented through ancestrie's storage interface. Records carry the {@link PlaceEntry} itself as the
+ * payload, so the entry that WINS the algorithm's shallowest-depth rule is the entry whose fields the suggestion
+ * reports — a side lookup keyed on id could pick a different surface's row (`crossCountryBranches` differs per
+ * surface).
+ */
+class FSTReader {
+    #fst;
+    /**
+     * Parent chains of the entries this reader has served, id-keyed. A place's chain is identical across its surfaces (it
+     * is place-row data), so last-write-wins is safe. The algorithm asks {@link FSTReader.ancestorsOf} only for ids it
+     * just received from {@link FSTReader.entriesAt}, so serving from this memo answers every real call without an
+     * artifact-wide id index.
+     */
+    #chains = new Map();
+    constructor(fst) {
+        this.#fst = fst;
+    }
+    walk(tokens) {
+        return this.#fst.walk([...tokens]);
+    }
+    continuations(stateID) {
+        // Insertion order, verbatim — BFS visit order under the suggestion budget depends on it.
+        return this.#fst.continuations(stateID).map((c) => ({
+            token: c.token,
+            targetState: c.targetState,
+            entryCount: c.acceptingCount,
+        }));
+    }
+    entriesAt(stateID, limit) {
+        const places = this.#fst.accepting(stateID);
+        const selected = limit === undefined ? places : topByReferential(places, limit);
+        return selected.map((entry) => {
+            this.#chains.set(entry.wofID, entry.parentChain);
+            return {
+                id: entry.wofID,
+                rank: entry.referential,
+                parentIDs: entry.parentChain,
+                payload: entry,
+            };
+        });
+    }
+    ancestorsOf(id) {
+        return this.#chains.get(id) ?? [];
+    }
+}
+/**
+ * Autocomplete from the current prefix. Returns suggestions ranked referential-descending.
+ */
+export function autocomplete(fst, query, opts = {}) {
+    const normalizedTokens = normalizeTokens(query);
+    const result = ancestrieAutocomplete(new FSTReader(fst), normalizedTokens, {
+        ...(opts.maxSuggestions === undefined ? {} : { maxSuggestions: opts.maxSuggestions }),
+        ...(opts.maxExpansionDepth === undefined ? {} : { maxExpansionDepth: opts.maxExpansionDepth }),
+        perBranchLimit: PER_BRANCH,
+        // The dedupe key is the DISPLAY name, not the token path: two surfaces of one name must still collapse. (#587)
+        ...(opts.dedupeByName ? { dedupe: (s) => s.payload.name.toLowerCase() } : {}),
+    });
+    return {
+        query,
+        normalizedTokens,
+        depth: result.depth,
+        suggestions: result.suggestions.map((s) => {
+            // Every record this adapter serves carries its entry; the assertion documents the invariant.
+            const entry = s.payload;
+            return {
+                name: entry.name,
+                placetype: entry.placetype,
+                referential: entry.referential,
+                ...(entry.encyclopedic === undefined ? {} : { encyclopedic: entry.encyclopedic }),
+                wofID: s.id,
+                parentChain: s.parentIDs,
+                matchDepth: s.matchDepth,
+                completionTokens: s.completionTokens,
+            };
+        }),
+    };
+}
+//# sourceMappingURL=autocomplete.js.map

package/out/fst/autocomplete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.js","sourceRoot":"","sources":["../../lib/fst/autocomplete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AASH,OAAO,EAAE,YAAY,IAAI,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AAG5E,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAyC9C;;GAEG;AACH,MAAM,UAAU,GAAG,CAAC,CAAA;AAEpB;;;;GAIG;AACH,SAAS,gBAAgB,CAAC,OAA8B,EAAE,CAAS;IAClE,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC;QAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAA;IAE5C,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAClF,CAAC;AAED;;;;;GAKG;AACH,MAAM,SAAS;IACL,IAAI,CAAY;IAEzB;;;;;OAKG;IACM,OAAO,GAAG,IAAI,GAAG,EAAoB,CAAA;IAE9C,YAAY,GAAe;QAC1B,IAAI,CAAC,IAAI,GAAG,GAAG,CAAA;IAChB,CAAC;IAED,IAAI,CAAC,MAAyB;QAC7B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAA;IACnC,CAAC;IAED,aAAa,CAAC,OAAe;QAC5B,yFAAyF;QACzF,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACnD,KAAK,EAAE,CAAC,CAAC,KAAK;YACd,WAAW,EAAE,CAAC,CAAC,WAAW;YAC1B,UAAU,EAAE,CAAC,CAAC,cAAc;SAC5B,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,SAAS,CAAC,OAAe,EAAE,KAAc;QACxC,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;QAC3C,MAAM,QAAQ,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QAE/E,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YAC7B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;YAEhD,OAAO;gBACN,EAAE,EAAE,KAAK,CAAC,KAAK;gBACf,IAAI,EAAE,KAAK,CAAC,WAAW;gBACvB,SAAS,EAAE,KAAK,CAAC,WAAW;gBAC5B,OAAO,EAAE,KAAK;aACd,CAAA;QACF,CAAC,CAAC,CAAA;IACH,CAAC;IAED,WAAW,CAAC,EAAU;QACrB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,CAAA;IAClC,CAAC;CACD;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,GAAe,EAAE,KAAa,EAAE,OAAyB,EAAE;IACvF,MAAM,gBAAgB,GAAG,eAAe,CAAC,KAAK,CAAC,CAAA;IAE/C,MAAM,MAAM,GAAG,qBAAqB,CAAa,IAAI,SAAS,CAAC,GAAG,CAAC,EAAE,gBAAgB,EAAE;QACtF,GAAG,CAAC,IAAI,CAAC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC;QACrF,GAAG,CAAC,IAAI,CAAC,iBAAiB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC9F,cAAc,EAAE,UAAU;QAC1B,+GAA+G;QAC/G,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAkC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC/G,CAAC,CAAA;IAEF,OAAO;QACN,KAAK;QACL,gBAAgB;QAChB,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACzC,6FAA6F;YAC7F,MAAM,KAAK,GAAG,CAAC,CAAC,OAAQ,CAAA;YAExB,OAAO;gBACN,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,WAAW,EAAE,KAAK,CAAC,WAAW;gBAC9B,GAAG,CAAC,KAAK,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,CAAC;gBACjF,KAAK,EAAE,CAAC,CAAC,EAAE;gBACX,WAAW,EAAE,CAAC,CAAC,SAAS;gBACxB,UAAU,EAAE,CAAC,CAAC,UAAU;gBACxB,gBAAgB,EAAE,CAAC,CAAC,gBAAgB;aACpC,CAAA;QACF,CAAC,CAAC;KACF,CAAA;AACF,CAAC"}

package/out/{fst-builder.d.ts → fst/builder.d.ts}

@@ -10,11 +10,11 @@
  *   Build pipeline: open WOF DB → query spr + names → normalize names → insert into trie → attach
  *   PlaceEntry at terminals → return FSTMatcher.
  */
-import { FSTMatcher } from "./fst-matcher.ts";
-import type { BuildFSTOpts, BuildFSTResult, FSTProvenance } from "./fst-types.ts";
-export declare function buildFSTFromWOF(opts: BuildFSTOpts): {
+import { FSTMatcher } from "#fst/matcher";
+import type { BuildFSTOpts, BuildFSTResult, FSTProvenance } from "#fst/types";
+export declare function buildFSTFromWOF(opts: BuildFSTOpts): Promise<{
     matcher: FSTMatcher;
     provenance: FSTProvenance;
     result: BuildFSTResult;
-};
-//# sourceMappingURL=fst-builder.d.ts.map
+}>;
+//# sourceMappingURL=builder.d.ts.map

package/out/fst/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../lib/fst/builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,EAAE,UAAU,EAAmB,MAAM,cAAc,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAA2B,MAAM,YAAY,CAAA;AAuCtG,wBAAsB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC;IAClE,OAAO,EAAE,UAAU,CAAA;IACnB,UAAU,EAAE,aAAa,CAAA;IACzB,MAAM,EAAE,cAAc,CAAA;CACtB,CAAC,CAyTD"}

package/out/{fst-builder.js → fst/builder.js}

@@ -10,10 +10,12 @@
  *   Build pipeline: open WOF DB → query spr + names → normalize names → insert into trie → attach
  *   PlaceEntry at terminals → return FSTMatcher.
  */
-import { DatabaseSync } from "node:sqlite";
-import { readWOFSourceIdentity } from "./fst-freshness.js";
-import { FSTMatcher, normalizeTokens } from "./fst-matcher.js";
-import { loadImportanceSplit } from "./place-importance-schema.js";
+import { DatabaseClient } from "@mailwoman/sqlite/client";
+import { resolvePath } from "path-ts";
+import { readWOFSourceIdentity } from "#fst/freshness";
+import { FSTMatcher, normalizeTokens } from "#fst/matcher";
+import { loadImportanceSplit } from "#place-importance-schema";
+import { allRows, getRow } from "#sqlite-utils";
 const DEFAULT_PLACETYPES = [
     "country",
     "region",
@@ -30,13 +32,14 @@ const DEFAULT_LANGUAGES = ["eng", ""];
  * down, so both read paths bind the same shape.
  */
 const ANCESTOR_CHUNK = 500;
-export function buildFSTFromWOF(opts) {
+export async function buildFSTFromWOF(opts) {
     const countries = opts.countries ?? DEFAULT_COUNTRIES;
     const placetypes = opts.placetypes ?? DEFAULT_PLACETYPES;
     const languages = opts.languages ?? DEFAULT_LANGUAGES;
     const progress = opts.onProgress ?? (() => { });
-    progress("open", opts.dbPath);
-    const db = new DatabaseSync(opts.dbPath, { open: true });
+    const dbPath = resolvePath(opts.dbPath);
+    progress("open", dbPath);
+    using db = new DatabaseClient(dbPath, { open: true });
     // Phase 1: Load all matching SPR rows.
     progress("spr", `Loading places for countries=[${countries}], placetypes=[${placetypes}]`);
     const placeholders = (arr) => arr.map(() => "?").join(",");
@@ -45,7 +48,7 @@ export function buildFSTFromWOF(opts) {
 		 WHERE is_current = 1
 		   AND country IN (${placeholders(countries)})
 		   AND placetype IN (${placeholders(placetypes)})`);
-    const sprRows = sprStmt.all(...countries, ...placetypes);
+    const sprRows = allRows(sprStmt, ...countries, ...placetypes);
     progress("spr", `Loaded ${sprRows.length} places`);
     // Phase 2: Build a lookup for parent chain resolution.
     const sprByID = new Map();
@@ -63,15 +66,13 @@ export function buildFSTFromWOF(opts) {
         const orphanIDs = sprRows.filter((row) => row.parent_id <= 0).map((row) => row.id);
         for (let i = 0; i < orphanIDs.length; i += ANCESTOR_CHUNK) {
             const chunk = orphanIDs.slice(i, i + ANCESTOR_CHUNK);
-            const rows = db
-                .prepare(`SELECT DISTINCT id, ancestor_id FROM ancestors
+            const rows = allRows(db.prepare(`SELECT DISTINCT id, ancestor_id FROM ancestors
 					 WHERE id IN (${chunk.map(() => "?").join(",")}) AND ancestor_placetype IN ('country', 'region', 'county')
 					 ORDER BY id, CASE ancestor_placetype
 					   WHEN 'county' THEN 1
 					   WHEN 'region' THEN 2
 					   WHEN 'country' THEN 3
-					 END`)
-                .all(...chunk);
+					 END`), ...chunk);
             for (const row of rows) {
                 let chain = ancestorsByID.get(row.id);
                 if (!chain) {
@@ -101,7 +102,7 @@ export function buildFSTFromWOF(opts) {
             chain.push(current);
             let parentRow = sprByID.get(current);
             if (!parentRow) {
-                const fetched = parentStmt.get(current);
+                const fetched = getRow(parentStmt, current);
                 if (!fetched)
                     break;
                 parentRow = fetched;
@@ -130,18 +131,18 @@ export function buildFSTFromWOF(opts) {
         ")");
     // Phase 4: Load names for matching places.
     progress("names", "Loading name variants");
-    const placeIds = sprRows.map((r) => r.id);
+    const placeIDs = sprRows.map((r) => r.id);
     const namesByPlace = new Map();
     const allLanguages = languages.includes("*");
-    for (let i = 0; i < placeIds.length; i += 500) {
-        const chunk = placeIds.slice(i, i + 500);
+    for (let i = 0; i < placeIDs.length; i += 500) {
+        const chunk = placeIDs.slice(i, i + 500);
         const idPlaceholders = chunk.map(() => "?").join(",");
         const nameStmt = allLanguages
             ? db.prepare(`SELECT id, name, language, privateuse FROM names WHERE id IN (${idPlaceholders})`)
             : db.prepare(`SELECT id, name, language, privateuse FROM names WHERE id IN (${idPlaceholders}) AND language IN (${languages.map(() => "?").join(",")})`);
-        const nameRows = (allLanguages
-            ? nameStmt.all(...chunk)
-            : nameStmt.all(...chunk, ...languages));
+        const nameRows = allLanguages
+            ? allRows(nameStmt, ...chunk)
+            : allRows(nameStmt, ...chunk, ...languages);
         for (const row of nameRows) {
             const existing = namesByPlace.get(row.id) ?? [];
             if (!existing.includes(row.name)) {
@@ -235,7 +236,6 @@ export function buildFSTFromWOF(opts) {
             }
         }
     }
-    db.close();
     progress("done", `Built trie: ${nodes.length} states, ${insertCount} name insertions` +
         (excludedCount > 0 ? ` (${excludedCount} degenerate surfaces excluded)` : ""));
     const edgeCount = nodes.reduce((sum, n) => sum + n.edges.size, 0);
@@ -246,8 +246,8 @@ export function buildFSTFromWOF(opts) {
     // and is free whenever the `.md5` sidecar is current, which the admin build already writes.
     // `sourceIdentity` lets a caller that already knows the digest (or is building from something that
     // is not a file at all) supply it instead.
-    progress("stamp", `Reading source identity for ${opts.dbPath}`);
-    const source = opts.sourceIdentity ?? readWOFSourceIdentity(opts.dbPath);
+    progress("stamp", `Reading source identity for ${dbPath}`);
+    const source = opts.sourceIdentity ?? (await readWOFSourceIdentity(dbPath));
     const provenance = {
         builtAt: new Date().toISOString(),
         countries,
@@ -258,7 +258,7 @@ export function buildFSTFromWOF(opts) {
         importanceMatches: split.referential.size,
         encyclopedicMatches: split.encyclopedic.size,
         importanceSource: split.source,
-        sourceDB: opts.dbPath,
+        sourceDB: dbPath,
         sourceDBMD5: source.md5,
         sourceDBBytes: source.bytes,
         ...(excludeSurfaces !== undefined || excludeAllTokensOf !== undefined
@@ -276,4 +276,4 @@ export function buildFSTFromWOF(opts) {
         },
     };
 }
-//# sourceMappingURL=fst-builder.js.map
+//# sourceMappingURL=builder.js.map